From 50a29f7c213d4a906839dfd625b6280663348781 Mon Sep 17 00:00:00 2001
From: Robin Voetter <robin@voetter.nl>
Date: Mon, 26 Jul 2021 02:37:11 +0200
Subject: [PATCH 01/96] Add @select

@select(
    comptime T: type,
    pred: std.meta.Vector(len, bool),
    a: std.meta.Vector(len, T),
    b: std.meta.Vector(len, T)
) std.meta.Vector(len, T)

Constructs a vector from a & b, based on the values in the predicate vector. For indices where the predicate value is true, the corresponding
element from the a vector is selected, and otherwise from b.
---
 doc/langref.html.in      |  10 ++++
 src/AstGen.zig           |  10 ++++
 src/BuiltinFn.zig        |   8 +++
 src/Sema.zig             |   7 +++
 src/Zir.zig              |  13 ++++
 src/stage1/all_types.hpp |  20 +++++++
 src/stage1/astgen.cpp    |  51 ++++++++++++++++
 src/stage1/codegen.cpp   |  10 ++++
 src/stage1/ir.cpp        | 124 ++++++++++++++++++++++++++++++++++++++-
 src/stage1/ir_print.cpp  |  32 ++++++++++
 test/behavior.zig        |   1 +
 test/behavior/select.zig |  25 ++++++++
 12 files changed, 309 insertions(+), 2 deletions(-)
 create mode 100644 test/behavior/select.zig

diff --git a/doc/langref.html.in b/doc/langref.html.in
index 9e98bb0114..a805f9a2ac 100644
--- a/doc/langref.html.in
+++ b/doc/langref.html.in
@@ -7125,6 +7125,7 @@ fn func(y: *i32) void {
       an integer or an enum.
       </p>
       {#header_close#}
+
       {#header_open|@bitCast#}
       <pre>{#syntax#}@bitCast(comptime DestType: type, value: anytype) DestType{#endsyntax#}</pre>
       <p>
@@ -8177,6 +8178,15 @@ test "@wasmMemoryGrow" {
       a calling function, the returned address will apply to the calling function.
       </p>
       {#header_close#}
+
+      {#header_open|@select#}
+      <pre>{#syntax#}@select(comptime T: type, pred: std.meta.Vector(len, bool), a: std.meta.Vector(len, T), b: std.meta.Vector(len, T)) std.meta.Vector(len, T){#endsyntax#}</pre>
+      <p>
+      Selects values element-wise from {#syntax#}a{#endsyntax#} or {#syntax#}b{#endsyntax#} based on {#syntax#}pred{#endsyntax#}. If {#syntax#}pred[i]{#endsyntax#} is {#syntax#}true{#endsyntax#}, the corresponding element in the result will be {#syntax#}a[i]{#endsyntax#} and otherwise {#syntax#}b[i]{#endsyntax#}.
+      </p>
+      {#see_also|SIMD|Vectors#}
+      {#header_close#}
+
       {#header_open|@setAlignStack#}
       <pre>{#syntax#}@setAlignStack(comptime alignment: u29){#endsyntax#}</pre>
       <p>
diff --git a/src/AstGen.zig b/src/AstGen.zig
index a00b43288b..656b960c2f 100644
--- a/src/AstGen.zig
+++ b/src/AstGen.zig
@@ -2090,6 +2090,7 @@ fn unusedResultExpr(gz: *GenZir, scope: *Scope, statement: ast.Node.Index) Inner
             .splat,
             .reduce,
             .shuffle,
+            .select,
             .atomic_load,
             .atomic_rmw,
             .atomic_store,
@@ -7375,6 +7376,15 @@ fn builtinCall(
             });
             return rvalue(gz, rl, result, node);
         },
+        .select => {
+            const result = try gz.addPlNode(.select, node, Zir.Inst.Select{
+                .elem_type = try typeExpr(gz, scope, params[0]),
+                .pred = try expr(gz, scope, .none, params[1]),
+                .a = try expr(gz, scope, .none, params[2]),
+                .b = try expr(gz, scope, .none, params[3]),
+            });
+            return rvalue(gz, rl, result, node);
+        },
         .async_call => {
             const result = try gz.addPlNode(.builtin_async_call, node, Zir.Inst.AsyncCall{
                 .frame_buffer = try expr(gz, scope, .none, params[0]),
diff --git a/src/BuiltinFn.zig b/src/BuiltinFn.zig
index 3964512838..07371b3192 100644
--- a/src/BuiltinFn.zig
+++ b/src/BuiltinFn.zig
@@ -69,6 +69,7 @@ pub const Tag = enum {
     ptr_to_int,
     rem,
     return_address,
+    select,
     set_align_stack,
     set_cold,
     set_eval_branch_quota,
@@ -601,6 +602,13 @@ pub const list = list: {
                 .param_count = 0,
             },
         },
+        .{
+            "@select",
+            .{
+                .tag = .select,
+                .param_count = 4,
+            },
+        },
         .{
             "@setAlignStack",
             .{
diff --git a/src/Sema.zig b/src/Sema.zig
index 3df512596f..6f8975d086 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -338,6 +338,7 @@ pub fn analyzeBody(
             .splat                        => try sema.zirSplat(block, inst),
             .reduce                       => try sema.zirReduce(block, inst),
             .shuffle                      => try sema.zirShuffle(block, inst),
+            .select                       => try sema.zirSelect(block, inst),
             .atomic_load                  => try sema.zirAtomicLoad(block, inst),
             .atomic_rmw                   => try sema.zirAtomicRmw(block, inst),
             .atomic_store                 => try sema.zirAtomicStore(block, inst),
@@ -6099,6 +6100,12 @@ fn zirShuffle(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) CompileErr
     return sema.mod.fail(&block.base, src, "TODO: Sema.zirShuffle", .{});
 }
 
+fn zirSelect(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
+    const inst_data = sema.code.instructions.items(.data)[inst].pl_node;
+    const src = inst_data.src();
+    return sema.mod.fail(&block.base, src, "TODO: Sema.zirSelect", .{});
+}
+
 fn zirAtomicLoad(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
     const inst_data = sema.code.instructions.items(.data)[inst].pl_node;
     const src = inst_data.src();
diff --git a/src/Zir.zig b/src/Zir.zig
index 00f66ef507..003b43d9e0 100644
--- a/src/Zir.zig
+++ b/src/Zir.zig
@@ -890,6 +890,9 @@ pub const Inst = struct {
         /// Implements the `@shuffle` builtin.
         /// Uses the `pl_node` union field with payload `Shuffle`.
         shuffle,
+        /// Implements the `@select` builtin.
+        /// Uses the `pl_node` union field with payload `Select`.
+        select,
         /// Implements the `@atomicLoad` builtin.
         /// Uses the `pl_node` union field with payload `Bin`.
         atomic_load,
@@ -1181,6 +1184,7 @@ pub const Inst = struct {
                 .splat,
                 .reduce,
                 .shuffle,
+                .select,
                 .atomic_load,
                 .atomic_rmw,
                 .atomic_store,
@@ -1451,6 +1455,7 @@ pub const Inst = struct {
                 .splat = .pl_node,
                 .reduce = .pl_node,
                 .shuffle = .pl_node,
+                .select = .pl_node,
                 .atomic_load = .pl_node,
                 .atomic_rmw = .pl_node,
                 .atomic_store = .pl_node,
@@ -2725,6 +2730,13 @@ pub const Inst = struct {
         mask: Ref,
     };
 
+    pub const Select = struct {
+        elem_type: Ref,
+        pred: Ref,
+        a: Ref,
+        b: Ref,
+    };
+
     pub const AsyncCall = struct {
         frame_buffer: Ref,
         result_ptr: Ref,
@@ -2935,6 +2947,7 @@ const Writer = struct {
             .cmpxchg_strong,
             .cmpxchg_weak,
             .shuffle,
+            .select,
             .atomic_rmw,
             .atomic_store,
             .mul_add,
diff --git a/src/stage1/all_types.hpp b/src/stage1/all_types.hpp
index ee06c15cf0..b4b2740dec 100644
--- a/src/stage1/all_types.hpp
+++ b/src/stage1/all_types.hpp
@@ -1755,6 +1755,7 @@ enum BuiltinFnId {
     BuiltinFnIdIntToEnum,
     BuiltinFnIdVectorType,
     BuiltinFnIdShuffle,
+    BuiltinFnIdSelect,
     BuiltinFnIdSplat,
     BuiltinFnIdSetCold,
     BuiltinFnIdSetRuntimeSafety,
@@ -2544,6 +2545,7 @@ enum Stage1ZirInstId : uint8_t {
     Stage1ZirInstIdBoolToInt,
     Stage1ZirInstIdVectorType,
     Stage1ZirInstIdShuffleVector,
+    Stage1ZirInstIdSelect,
     Stage1ZirInstIdSplat,
     Stage1ZirInstIdBoolNot,
     Stage1ZirInstIdMemset,
@@ -2664,6 +2666,7 @@ enum Stage1AirInstId : uint8_t {
     Stage1AirInstIdReduce,
     Stage1AirInstIdTruncate,
     Stage1AirInstIdShuffleVector,
+    Stage1AirInstIdSelect,
     Stage1AirInstIdSplat,
     Stage1AirInstIdBoolNot,
     Stage1AirInstIdMemset,
@@ -4295,6 +4298,23 @@ struct Stage1AirInstShuffleVector {
     Stage1AirInst *mask; // This is in zig-format, not llvm format
 };
 
+struct Stage1ZirInstSelect {
+    Stage1ZirInst base;
+
+    Stage1ZirInst *scalar_type;
+    Stage1ZirInst *pred; // This is in zig-format, not llvm format
+    Stage1ZirInst *a;
+    Stage1ZirInst *b;
+};
+
+struct Stage1AirInstSelect {
+    Stage1AirInst base;
+
+    Stage1AirInst *pred;  // This is in zig-format, not llvm format
+    Stage1AirInst *a;
+    Stage1AirInst *b;
+};
+
 struct Stage1ZirInstSplat {
     Stage1ZirInst base;
 
diff --git a/src/stage1/astgen.cpp b/src/stage1/astgen.cpp
index cc8ccefad7..e8f68c82bb 100644
--- a/src/stage1/astgen.cpp
+++ b/src/stage1/astgen.cpp
@@ -196,6 +196,8 @@ void destroy_instruction_src(Stage1ZirInst *inst) {
             return heap::c_allocator.destroy(reinterpret_cast<Stage1ZirInstVectorType *>(inst));
         case Stage1ZirInstIdShuffleVector:
             return heap::c_allocator.destroy(reinterpret_cast<Stage1ZirInstShuffleVector *>(inst));
+        case Stage1ZirInstIdSelect:
+            return heap::c_allocator.destroy(reinterpret_cast<Stage1ZirInstSelect *>(inst));
         case Stage1ZirInstIdSplat:
             return heap::c_allocator.destroy(reinterpret_cast<Stage1ZirInstSplat *>(inst));
         case Stage1ZirInstIdBoolNot:
@@ -651,6 +653,10 @@ static constexpr Stage1ZirInstId ir_inst_id(Stage1ZirInstShuffleVector *) {
     return Stage1ZirInstIdShuffleVector;
 }
 
+static constexpr Stage1ZirInstId ir_inst_id(Stage1ZirInstSelect *) {
+    return Stage1ZirInstIdSelect;
+}
+
 static constexpr Stage1ZirInstId ir_inst_id(Stage1ZirInstSplat *) {
     return Stage1ZirInstIdSplat;
 }
@@ -2037,6 +2043,22 @@ static Stage1ZirInst *ir_build_shuffle_vector(Stage1AstGen *ag, Scope *scope, As
     return &instruction->base;
 }
 
+static Stage1ZirInst *ir_build_select(Stage1AstGen *ag, Scope *scope, AstNode *source_node,
+    Stage1ZirInst *scalar_type, Stage1ZirInst *pred, Stage1ZirInst *a, Stage1ZirInst *b)
+{
+    Stage1ZirInstSelect *instruction = ir_build_instruction<Stage1ZirInstSelect>(ag, scope, source_node);
+    instruction->scalar_type = scalar_type;
+    instruction->pred = pred;
+    instruction->a = a;
+    instruction->b = b;
+
+    ir_ref_instruction(pred, ag->current_basic_block);
+    ir_ref_instruction(a, ag->current_basic_block);
+    ir_ref_instruction(b, ag->current_basic_block);
+
+    return &instruction->base;
+}
+
 static Stage1ZirInst *ir_build_splat_src(Stage1AstGen *ag, Scope *scope, AstNode *source_node,
     Stage1ZirInst *len, Stage1ZirInst *scalar)
 {
@@ -4619,6 +4641,35 @@ static Stage1ZirInst *astgen_builtin_fn_call(Stage1AstGen *ag, Scope *scope, Ast
                     arg0_value, arg1_value, arg2_value, arg3_value);
                 return ir_lval_wrap(ag, scope, shuffle_vector, lval, result_loc);
             }
+        case BuiltinFnIdSelect:
+            {
+                // Used for the type expr
+                Scope *comptime_scope = create_comptime_scope(ag->codegen, node, scope);
+
+                AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
+                Stage1ZirInst *arg0_value = astgen_node(ag, arg0_node, comptime_scope);
+                if (arg0_value == ag->codegen->invalid_inst_src)
+                    return arg0_value;
+
+                AstNode *arg1_node = node->data.fn_call_expr.params.at(1);
+                Stage1ZirInst *arg1_value = astgen_node(ag, arg1_node, scope);
+                if (arg0_value == ag->codegen->invalid_inst_src)
+                    return arg1_value;
+
+                AstNode *arg2_node = node->data.fn_call_expr.params.at(2);
+                Stage1ZirInst *arg2_value = astgen_node(ag, arg2_node, scope);
+                if (arg1_value == ag->codegen->invalid_inst_src)
+                    return arg2_value;
+
+                AstNode *arg3_node = node->data.fn_call_expr.params.at(3);
+                Stage1ZirInst *arg3_value = astgen_node(ag, arg3_node, scope);
+                if (arg2_value == ag->codegen->invalid_inst_src)
+                    return arg3_value;
+
+                Stage1ZirInst *select = ir_build_select(ag, scope, node,
+                    arg0_value, arg1_value, arg2_value, arg3_value);
+                return ir_lval_wrap(ag, scope, select, lval, result_loc);
+            }
         case BuiltinFnIdSplat:
             {
                 AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
diff --git a/src/stage1/codegen.cpp b/src/stage1/codegen.cpp
index 562327d500..fc2651c8f7 100644
--- a/src/stage1/codegen.cpp
+++ b/src/stage1/codegen.cpp
@@ -5162,6 +5162,13 @@ static LLVMValueRef ir_render_shuffle_vector(CodeGen *g, Stage1Air *executable,
         llvm_mask_value, "");
 }
 
+static LLVMValueRef ir_render_select(CodeGen *g, Stage1Air *executable, Stage1AirInstSelect *instruction) {
+    LLVMValueRef pred = ir_llvm_value(g, instruction->pred);
+    LLVMValueRef a = ir_llvm_value(g, instruction->a);
+    LLVMValueRef b = ir_llvm_value(g, instruction->b);
+    return LLVMBuildSelect(g->builder, pred, a, b, "");
+}
+
 static LLVMValueRef ir_render_splat(CodeGen *g, Stage1Air *executable, Stage1AirInstSplat *instruction) {
     ZigType *result_type = instruction->base.value->type;
     ir_assert(result_type->id == ZigTypeIdVector, &instruction->base);
@@ -7015,6 +7022,8 @@ static LLVMValueRef ir_render_instruction(CodeGen *g, Stage1Air *executable, Sta
             return ir_render_spill_end(g, executable, (Stage1AirInstSpillEnd *)instruction);
         case Stage1AirInstIdShuffleVector:
             return ir_render_shuffle_vector(g, executable, (Stage1AirInstShuffleVector *) instruction);
+        case Stage1AirInstIdSelect:
+            return ir_render_select(g, executable, (Stage1AirInstSelect *) instruction);
         case Stage1AirInstIdSplat:
             return ir_render_splat(g, executable, (Stage1AirInstSplat *) instruction);
         case Stage1AirInstIdVectorExtractElem:
@@ -8920,6 +8929,7 @@ static void define_builtin_fns(CodeGen *g) {
     create_builtin_fn(g, BuiltinFnIdCompileLog, "compileLog", SIZE_MAX);
     create_builtin_fn(g, BuiltinFnIdVectorType, "Vector", 2);
     create_builtin_fn(g, BuiltinFnIdShuffle, "shuffle", 4);
+    create_builtin_fn(g, BuiltinFnIdSelect, "select", 4);
     create_builtin_fn(g, BuiltinFnIdSplat, "splat", 2);
     create_builtin_fn(g, BuiltinFnIdSetCold, "setCold", 1);
     create_builtin_fn(g, BuiltinFnIdSetRuntimeSafety, "setRuntimeSafety", 1);
diff --git a/src/stage1/ir.cpp b/src/stage1/ir.cpp
index a6d1ff3007..9a2e50fef7 100644
--- a/src/stage1/ir.cpp
+++ b/src/stage1/ir.cpp
@@ -355,6 +355,8 @@ void destroy_instruction_gen(Stage1AirInst *inst) {
             return heap::c_allocator.destroy(reinterpret_cast<Stage1AirInstTruncate *>(inst));
         case Stage1AirInstIdShuffleVector:
             return heap::c_allocator.destroy(reinterpret_cast<Stage1AirInstShuffleVector *>(inst));
+        case Stage1AirInstIdSelect:
+            return heap::c_allocator.destroy(reinterpret_cast<Stage1AirInstSelect *>(inst));
         case Stage1AirInstIdSplat:
             return heap::c_allocator.destroy(reinterpret_cast<Stage1AirInstSplat *>(inst));
         case Stage1AirInstIdBoolNot:
@@ -901,6 +903,10 @@ static constexpr Stage1AirInstId ir_inst_id(Stage1AirInstShuffleVector *) {
     return Stage1AirInstIdShuffleVector;
 }
 
+static constexpr Stage1AirInstId ir_inst_id(Stage1AirInstSelect *) {
+    return Stage1AirInstIdSelect;
+}
+
 static constexpr Stage1AirInstId ir_inst_id(Stage1AirInstSplat *) {
     return Stage1AirInstIdSplat;
 }
@@ -1756,6 +1762,22 @@ static Stage1AirInst *ir_build_shuffle_vector_gen(IrAnalyze *ira, Scope *scope,
     return &inst->base;
 }
 
+static Stage1AirInst *ir_build_select_gen(IrAnalyze *ira, Scope *scope, AstNode *source_node,
+        ZigType *result_type, Stage1AirInst *pred, Stage1AirInst *a, Stage1AirInst *b)
+{
+    Stage1AirInstSelect *inst = ir_build_inst_gen<Stage1AirInstSelect>(&ira->new_irb, scope, source_node);
+    inst->base.value->type = result_type;
+    inst->pred = pred;
+    inst->a = a;
+    inst->b = b;
+
+    ir_ref_inst_gen(pred);
+    ir_ref_inst_gen(a);
+    ir_ref_inst_gen(b);
+
+    return &inst->base;
+}
+
 static Stage1AirInst *ir_build_splat_gen(IrAnalyze *ira, Scope *scope, AstNode *source_node, ZigType *result_type,
     Stage1AirInst *scalar)
 {
@@ -20318,6 +20340,100 @@ static Stage1AirInst *ir_analyze_instruction_shuffle_vector(IrAnalyze *ira, Stag
     return ir_analyze_shuffle_vector(ira, instruction->base.scope, instruction->base.source_node, scalar_type, a, b, mask);
 }
 
+static Stage1AirInst *ir_analyze_instruction_select(IrAnalyze *ira, Stage1ZirInstSelect *instruction) {
+    Error err;
+
+    ZigType *scalar_type = ir_resolve_vector_elem_type(ira, instruction->scalar_type->child);
+    if (type_is_invalid(scalar_type))
+        return ira->codegen->invalid_inst_gen;
+
+    if ((err = ir_validate_vector_elem_type(ira, instruction->base.source_node, scalar_type)))
+        return ira->codegen->invalid_inst_gen;
+
+    Stage1AirInst *pred = instruction->pred->child;
+    if (type_is_invalid(pred->value->type))
+        return ira->codegen->invalid_inst_gen;
+
+    Stage1AirInst *a = instruction->a->child;
+    if (type_is_invalid(a->value->type))
+        return ira->codegen->invalid_inst_gen;
+
+    Stage1AirInst *b = instruction->b->child;
+    if (type_is_invalid(b->value->type))
+        return ira->codegen->invalid_inst_gen;
+
+    if (pred->value->type->id != ZigTypeIdVector) {
+        ir_add_error(ira, pred,
+                buf_sprintf("expected vector type, found '%s'",
+                    buf_ptr(&pred->value->type->name)));
+        return ira->codegen->invalid_inst_gen;
+    }
+
+    uint32_t pred_len = pred->value->type->data.vector.len;
+    pred = ir_implicit_cast(ira, pred, get_vector_type(ira->codegen, pred_len,
+                ira->codegen->builtin_types.entry_bool));
+    if (type_is_invalid(pred->value->type))
+        return ira->codegen->invalid_inst_gen;
+
+    if (a->value->type->id != ZigTypeIdVector) {
+        ir_add_error(ira, a,
+                buf_sprintf("expected vector type, found '%s'",
+                    buf_ptr(&a->value->type->name)));
+        return ira->codegen->invalid_inst_gen;
+    }
+
+    if (b->value->type->id != ZigTypeIdVector) {
+        ir_add_error(ira, b,
+                buf_sprintf("expected vector type, found '%s'",
+                    buf_ptr(&b->value->type->name)));
+        return ira->codegen->invalid_inst_gen;
+    }
+
+    ZigType *result_type = get_vector_type(ira->codegen, pred_len, scalar_type);
+
+    a = ir_implicit_cast(ira, a, result_type);
+    if (type_is_invalid(a->value->type))
+        return ira->codegen->invalid_inst_gen;
+
+    b = ir_implicit_cast(ira, b, result_type);
+    if (type_is_invalid(a->value->type))
+        return ira->codegen->invalid_inst_gen;
+
+    if (instr_is_comptime(pred) && instr_is_comptime(a) && instr_is_comptime(b)) {
+        ZigValue *pred_val = ir_resolve_const(ira, pred, UndefBad);
+        if (pred_val == nullptr)
+            return ira->codegen->invalid_inst_gen;
+
+        ZigValue *a_val = ir_resolve_const(ira, a, UndefBad);
+        if (a_val == nullptr)
+            return ira->codegen->invalid_inst_gen;
+
+        ZigValue *b_val = ir_resolve_const(ira, b, UndefBad);
+        if (b_val == nullptr)
+            return ira->codegen->invalid_inst_gen;
+
+        expand_undef_array(ira->codegen, a_val);
+        expand_undef_array(ira->codegen, b_val);
+
+        Stage1AirInst *result = ir_const(ira, instruction->base.scope, instruction->base.source_node, result_type);
+        result->value->data.x_array.data.s_none.elements = ira->codegen->pass1_arena->allocate<ZigValue>(pred_len);
+
+        for (uint64_t i = 0; i < pred_len; i += 1) {
+            ZigValue *dst_elem_val = &result->value->data.x_array.data.s_none.elements[i];
+            ZigValue *pred_elem_val = &pred_val->data.x_array.data.s_none.elements[i];
+            ZigValue *a_elem_val = &a_val->data.x_array.data.s_none.elements[i];
+            ZigValue *b_elem_val = &b_val->data.x_array.data.s_none.elements[i];
+            ZigValue *result_elem_val = pred_elem_val->data.x_bool ? a_elem_val : b_elem_val;
+            copy_const_val(ira->codegen, dst_elem_val, result_elem_val);
+        }
+
+        result->value->special = ConstValSpecialStatic;
+        return result;
+    }
+
+    return ir_build_select_gen(ira, instruction->base.scope, instruction->base.source_node, result_type, pred, a, b);
+}
+
 static Stage1AirInst *ir_analyze_instruction_splat(IrAnalyze *ira, Stage1ZirInstSplat *instruction) {
     Error err;
 
@@ -24595,7 +24711,9 @@ static Stage1AirInst *ir_analyze_instruction_base(IrAnalyze *ira, Stage1ZirInst
             return ir_analyze_instruction_vector_type(ira, (Stage1ZirInstVectorType *)instruction);
         case Stage1ZirInstIdShuffleVector:
             return ir_analyze_instruction_shuffle_vector(ira, (Stage1ZirInstShuffleVector *)instruction);
-         case Stage1ZirInstIdSplat:
+        case Stage1ZirInstIdSelect:
+            return ir_analyze_instruction_select(ira, (Stage1ZirInstSelect *)instruction);
+        case Stage1ZirInstIdSplat:
             return ir_analyze_instruction_splat(ira, (Stage1ZirInstSplat *)instruction);
         case Stage1ZirInstIdBoolNot:
             return ir_analyze_instruction_bool_not(ira, (Stage1ZirInstBoolNot *)instruction);
@@ -24931,6 +25049,7 @@ bool ir_inst_gen_has_side_effects(Stage1AirInst *instruction) {
         case Stage1AirInstIdUnionTag:
         case Stage1AirInstIdTruncate:
         case Stage1AirInstIdShuffleVector:
+        case Stage1AirInstIdSelect:
         case Stage1AirInstIdSplat:
         case Stage1AirInstIdBoolNot:
         case Stage1AirInstIdReturnAddress:
@@ -25084,6 +25203,7 @@ bool ir_inst_src_has_side_effects(Stage1ZirInst *instruction) {
         case Stage1ZirInstIdTruncate:
         case Stage1ZirInstIdVectorType:
         case Stage1ZirInstIdShuffleVector:
+        case Stage1ZirInstIdSelect:
         case Stage1ZirInstIdSplat:
         case Stage1ZirInstIdBoolNot:
         case Stage1ZirInstIdSlice:
@@ -25751,7 +25871,7 @@ static Error ir_resolve_lazy_recurse_array(AstNode *source_node, ZigValue *val,
 
 static Error ir_resolve_lazy_recurse(AstNode *source_node, ZigValue *val) {
     Error err;
-    if ((err = ir_resolve_lazy_raw(source_node, val))) 
+    if ((err = ir_resolve_lazy_raw(source_node, val)))
         return err;
     assert(val->special != ConstValSpecialRuntime);
     assert(val->special != ConstValSpecialLazy);
diff --git a/src/stage1/ir_print.cpp b/src/stage1/ir_print.cpp
index bec9521bc2..e83da8565c 100644
--- a/src/stage1/ir_print.cpp
+++ b/src/stage1/ir_print.cpp
@@ -93,6 +93,8 @@ const char* ir_inst_src_type_str(Stage1ZirInstId id) {
             return "SrcInvalid";
         case Stage1ZirInstIdShuffleVector:
             return "SrcShuffle";
+        case Stage1ZirInstIdSelect:
+            return "SrcSelect";
         case Stage1ZirInstIdSplat:
             return "SrcSplat";
         case Stage1ZirInstIdDeclVar:
@@ -379,6 +381,8 @@ const char* ir_inst_gen_type_str(Stage1AirInstId id) {
             return "GenInvalid";
         case Stage1AirInstIdShuffleVector:
             return "GenShuffle";
+        case Stage1AirInstIdSelect:
+            return "GenSelect";
         case Stage1AirInstIdSplat:
             return "GenSplat";
         case Stage1AirInstIdDeclVar:
@@ -1722,6 +1726,28 @@ static void ir_print_shuffle_vector(IrPrintGen *irp, Stage1AirInstShuffleVector
     fprintf(irp->f, ")");
 }
 
+static void ir_print_select(IrPrintSrc *irp, Stage1ZirInstSelect *instruction) {
+    fprintf(irp->f, "@select(");
+    ir_print_other_inst_src(irp, instruction->scalar_type);
+    fprintf(irp->f, ", ");
+    ir_print_other_inst_src(irp, instruction->pred);
+    fprintf(irp->f, ", ");
+    ir_print_other_inst_src(irp, instruction->a);
+    fprintf(irp->f, ", ");
+    ir_print_other_inst_src(irp, instruction->b);
+    fprintf(irp->f, ")");
+}
+
+static void ir_print_select(IrPrintGen *irp, Stage1AirInstSelect *instruction) {
+    fprintf(irp->f, "@select(");
+    ir_print_other_inst_gen(irp, instruction->pred);
+    fprintf(irp->f, ", ");
+    ir_print_other_inst_gen(irp, instruction->a);
+    fprintf(irp->f, ", ");
+    ir_print_other_inst_gen(irp, instruction->b);
+    fprintf(irp->f, ")");
+}
+
 static void ir_print_splat_src(IrPrintSrc *irp, Stage1ZirInstSplat *instruction) {
     fprintf(irp->f, "@splat(");
     ir_print_other_inst_src(irp, instruction->len);
@@ -2836,6 +2862,9 @@ static void ir_print_inst_src(IrPrintSrc *irp, Stage1ZirInst *instruction, bool
         case Stage1ZirInstIdShuffleVector:
             ir_print_shuffle_vector(irp, (Stage1ZirInstShuffleVector *)instruction);
             break;
+        case Stage1ZirInstIdSelect:
+            ir_print_select(irp, (Stage1ZirInstSelect *)instruction);
+            break;
         case Stage1ZirInstIdSplat:
             ir_print_splat_src(irp, (Stage1ZirInstSplat *)instruction);
             break;
@@ -3178,6 +3207,9 @@ static void ir_print_inst_gen(IrPrintGen *irp, Stage1AirInst *instruction, bool
         case Stage1AirInstIdShuffleVector:
             ir_print_shuffle_vector(irp, (Stage1AirInstShuffleVector *)instruction);
             break;
+        case Stage1AirInstIdSelect:
+            ir_print_select(irp, (Stage1AirInstSelect *)instruction);
+            break;
         case Stage1AirInstIdSplat:
             ir_print_splat_gen(irp, (Stage1AirInstSplat *)instruction);
             break;
diff --git a/test/behavior.zig b/test/behavior.zig
index 0055638335..8459e499d7 100644
--- a/test/behavior.zig
+++ b/test/behavior.zig
@@ -118,6 +118,7 @@ test {
         _ = @import("behavior/ref_var_in_if_after_if_2nd_switch_prong.zig");
         _ = @import("behavior/reflection.zig");
         _ = @import("behavior/shuffle.zig");
+        _ = @import("behavior/select.zig");
         _ = @import("behavior/sizeof_and_typeof.zig");
         _ = @import("behavior/slice.zig");
         _ = @import("behavior/slice_sentinel_comptime.zig");
diff --git a/test/behavior/select.zig b/test/behavior/select.zig
new file mode 100644
index 0000000000..5c69094413
--- /dev/null
+++ b/test/behavior/select.zig
@@ -0,0 +1,25 @@
+const std = @import("std");
+const builtin = @import("builtin");
+const mem = std.mem;
+const expect = std.testing.expect;
+const Vector = std.meta.Vector;
+
+test "@select" {
+    const S = struct {
+        fn doTheTest() !void {
+            var a: Vector(4, bool) = [4]bool{ true, false, true, false };
+            var b: Vector(4, i32) = [4]i32{ -1, 4, 999, -31 };
+            var c: Vector(4, i32) = [4]i32{ -5, 1, 0, 1234 };
+            var abc = @select(i32, a, b, c);
+            try expect(mem.eql(i32, &@as([4]i32, abc), &[4]i32{ -1, 1, 999, 1234 }));
+
+            var x: Vector(4, bool) = [4]bool{ false, false, false, true };
+            var y: Vector(4, f32) = [4]f32{ 0.001, 33.4, 836, -3381.233 };
+            var z: Vector(4, f32) = [4]f32{ 0.0, 312.1, -145.9, 9993.55 };
+            var xyz = @select(f32, x, y, z);
+            try expect(mem.eql(f32, &@as([4]f32, xyz), &[4]f32{ 0.0, 312.1, -145.9, -3381.233 }));
+        }
+    };
+    try S.doTheTest();
+    comptime try S.doTheTest();
+}

From cdeea3b0943b070d49d8d8d0855f9a38843e3ecc Mon Sep 17 00:00:00 2001
From: Robin Voetter <robin@voetter.nl>
Date: Sun, 25 Jul 2021 05:34:11 +0200
Subject: [PATCH 02/96] minimum/maximum builtins

---
 doc/langref.html.in               |  22 ++++++
 src/AstGen.zig                    |  21 ++++++
 src/BuiltinFn.zig                 |  16 ++++
 src/Sema.zig                      |  14 ++++
 src/Zir.zig                       |  12 +++
 src/stage1/all_types.hpp          |   4 +
 src/stage1/astgen.cpp             |  30 ++++++++
 src/stage1/bigfloat.cpp           |  24 ++++++
 src/stage1/bigfloat.hpp           |   3 +
 src/stage1/bigint.cpp             |  20 +++++
 src/stage1/bigint.hpp             |   2 +
 src/stage1/codegen.cpp            |  26 +++++++
 src/stage1/ir.cpp                 | 120 ++++++++++++++++++++++++++++++
 src/stage1/ir_print.cpp           |   4 +
 src/zig_llvm.cpp                  |  30 ++++++++
 src/zig_llvm.h                    |   9 +++
 test/behavior.zig                 |   1 +
 test/behavior/maximum_minimum.zig |  58 +++++++++++++++
 18 files changed, 416 insertions(+)
 create mode 100644 test/behavior/maximum_minimum.zig

diff --git a/doc/langref.html.in b/doc/langref.html.in
index a805f9a2ac..38b91468e2 100644
--- a/doc/langref.html.in
+++ b/doc/langref.html.in
@@ -7988,6 +7988,17 @@ test "@hasDecl" {
       </p>
       {#header_close#}
 
+      {#header_open|@maximum#}
+      <pre>{#syntax#}@maximum(a: T, b: T) T{#endsyntax#}</pre>
+      <p>
+      Returns the maximum value of {#syntax#}a{#endsyntax#} and {#syntax#}b{#endsyntax#}. This builtin accepts integers, floats, and vectors of either. In the latter case, the operation is performed element wise.
+      </p>
+      <p>
+      NaNs are handled as follows: if one of the operands of a (pairwise) operation is NaN, the other operand is returned. If both operands are NaN, NaN is returned.
+      </p>
+      {#see_also|@minimum|SIMD|Vectors#}
+      {#header_close#}
+
       {#header_open|@memcpy#}
       <pre>{#syntax#}@memcpy(noalias dest: [*]u8, noalias source: [*]const u8, byte_count: usize){#endsyntax#}</pre>
       <p>
@@ -8025,6 +8036,17 @@ mem.copy(u8, dest[0..byte_count], source[0..byte_count]);{#endsyntax#}</pre>
 mem.set(u8, dest, c);{#endsyntax#}</pre>
       {#header_close#}
 
+      {#header_open|@minimum#}
+      <pre>{#syntax#}@minimum(a: T, b: T) T{#endsyntax#}</pre>
+      <p>
+      Returns the minimum value of {#syntax#}a{#endsyntax#} and {#syntax#}b{#endsyntax#}. This builtin accepts integers, floats, and vectors of either. In the latter case, the operation is performed element wise.
+      </p>
+      <p>
+      NaNs are handled as follows: if one of the operands of a (pairwise) operation is NaN, the other operand is returned. If both operands are NaN, NaN is returned.
+      </p>
+      {#see_also|@maximum|SIMD|Vectors#}
+      {#header_close#}
+
       {#header_open|@wasmMemorySize#}
       <pre>{#syntax#}@wasmMemorySize(index: u32) u32{#endsyntax#}</pre>
       <p>
diff --git a/src/AstGen.zig b/src/AstGen.zig
index 656b960c2f..34f906fab1 100644
--- a/src/AstGen.zig
+++ b/src/AstGen.zig
@@ -2098,8 +2098,10 @@ fn unusedResultExpr(gz: *GenZir, scope: *Scope, statement: ast.Node.Index) Inner
             .builtin_call,
             .field_ptr_type,
             .field_parent_ptr,
+            .maximum,
             .memcpy,
             .memset,
+            .minimum,
             .builtin_async_call,
             .c_import,
             .@"resume",
@@ -7227,6 +7229,25 @@ fn builtinCall(
             return rvalue(gz, rl, result, node);
         },
 
+        .maximum => {
+            const a = try expr(gz, scope, .none, params[0]);
+            const b = try expr(gz, scope, .none, params[1]);
+            const result = try gz.addPlNode(.maximum, node, Zir.Inst.Bin{
+                .lhs = a,
+                .rhs = b,
+            });
+            return rvalue(gz, rl, result, node);
+        },
+        .minimum => {
+            const a = try expr(gz, scope, .none, params[0]);
+            const b = try expr(gz, scope, .none, params[1]);
+            const result = try gz.addPlNode(.minimum, node, Zir.Inst.Bin{
+                .lhs = a,
+                .rhs = b,
+            });
+            return rvalue(gz, rl, result, node);
+        },
+
         .add_with_overflow => return overflowArithmetic(gz, scope, rl, node, params, .add_with_overflow),
         .sub_with_overflow => return overflowArithmetic(gz, scope, rl, node, params, .sub_with_overflow),
         .mul_with_overflow => return overflowArithmetic(gz, scope, rl, node, params, .mul_with_overflow),
diff --git a/src/BuiltinFn.zig b/src/BuiltinFn.zig
index 07371b3192..8f23ec86d7 100644
--- a/src/BuiltinFn.zig
+++ b/src/BuiltinFn.zig
@@ -57,8 +57,10 @@ pub const Tag = enum {
     int_to_error,
     int_to_float,
     int_to_ptr,
+    maximum,
     memcpy,
     memset,
+    minimum,
     wasm_memory_size,
     wasm_memory_grow,
     mod,
@@ -518,6 +520,13 @@ pub const list = list: {
                 .param_count = 2,
             },
         },
+        .{
+            "@maximum",
+            .{
+                .tag = .maximum,
+                .param_count = 2,
+            },
+        },
         .{
             "@memcpy",
             .{
@@ -532,6 +541,13 @@ pub const list = list: {
                 .param_count = 3,
             },
         },
+        .{
+            "@minimum",
+            .{
+                .tag = .minimum,
+                .param_count = 2,
+            },
+        },
         .{
             "@wasmMemorySize",
             .{
diff --git a/src/Sema.zig b/src/Sema.zig
index 6f8975d086..67cfc09b53 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -346,8 +346,10 @@ pub fn analyzeBody(
             .builtin_call                 => try sema.zirBuiltinCall(block, inst),
             .field_ptr_type               => try sema.zirFieldPtrType(block, inst),
             .field_parent_ptr             => try sema.zirFieldParentPtr(block, inst),
+            .maximum                      => try sema.zirMaximum(block, inst),
             .memcpy                       => try sema.zirMemcpy(block, inst),
             .memset                       => try sema.zirMemset(block, inst),
+            .minimum                      => try sema.zirMinimum(block, inst),
             .builtin_async_call           => try sema.zirBuiltinAsyncCall(block, inst),
             .@"resume"                    => try sema.zirResume(block, inst),
             .@"await"                     => try sema.zirAwait(block, inst, false),
@@ -6148,6 +6150,12 @@ fn zirFieldParentPtr(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) Com
     return sema.mod.fail(&block.base, src, "TODO: Sema.zirFieldParentPtr", .{});
 }
 
+fn zirMaximum(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
+    const inst_data = sema.code.instructions.items(.data)[inst].pl_node;
+    const src = inst_data.src();
+    return sema.mod.fail(&block.base, src, "TODO: Sema.zirMaximum", .{});
+}
+
 fn zirMemcpy(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
     const inst_data = sema.code.instructions.items(.data)[inst].pl_node;
     const src = inst_data.src();
@@ -6160,6 +6168,12 @@ fn zirMemset(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) CompileErro
     return sema.mod.fail(&block.base, src, "TODO: Sema.zirMemset", .{});
 }
 
+fn zirMinimum(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
+    const inst_data = sema.code.instructions.items(.data)[inst].pl_node;
+    const src = inst_data.src();
+    return sema.mod.fail(&block.base, src, "TODO: Sema.zirMinimum", .{});
+}
+
 fn zirBuiltinAsyncCall(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
     const inst_data = sema.code.instructions.items(.data)[inst].pl_node;
     const src = inst_data.src();
diff --git a/src/Zir.zig b/src/Zir.zig
index 003b43d9e0..2b88a3415d 100644
--- a/src/Zir.zig
+++ b/src/Zir.zig
@@ -915,12 +915,18 @@ pub const Inst = struct {
         /// Implements the `@fieldParentPtr` builtin.
         /// Uses the `pl_node` union field with payload `FieldParentPtr`.
         field_parent_ptr,
+        /// Implements the `@maximum` builtin.
+        /// Uses the `pl_node` union field with payload `Bin`
+        maximum,
         /// Implements the `@memcpy` builtin.
         /// Uses the `pl_node` union field with payload `Memcpy`.
         memcpy,
         /// Implements the `@memset` builtin.
         /// Uses the `pl_node` union field with payload `Memset`.
         memset,
+        /// Implements the `@minimum` builtin.
+        /// Uses the `pl_node` union field with payload `Bin`
+        minimum,
         /// Implements the `@asyncCall` builtin.
         /// Uses the `pl_node` union field with payload `AsyncCall`.
         builtin_async_call,
@@ -1192,8 +1198,10 @@ pub const Inst = struct {
                 .builtin_call,
                 .field_ptr_type,
                 .field_parent_ptr,
+                .maximum,
                 .memcpy,
                 .memset,
+                .minimum,
                 .builtin_async_call,
                 .c_import,
                 .@"resume",
@@ -1463,8 +1471,10 @@ pub const Inst = struct {
                 .builtin_call = .pl_node,
                 .field_ptr_type = .bin,
                 .field_parent_ptr = .pl_node,
+                .maximum = .pl_node,
                 .memcpy = .pl_node,
                 .memset = .pl_node,
+                .minimum = .pl_node,
                 .builtin_async_call = .pl_node,
                 .c_import = .pl_node,
 
@@ -3020,6 +3030,8 @@ const Writer = struct {
             .bitcast,
             .bitcast_result_ptr,
             .vector_type,
+            .maximum,
+            .minimum,
             => try self.writePlNodeBin(stream, inst),
 
             .@"export" => try self.writePlNodeExport(stream, inst),
diff --git a/src/stage1/all_types.hpp b/src/stage1/all_types.hpp
index b4b2740dec..a72faa15ce 100644
--- a/src/stage1/all_types.hpp
+++ b/src/stage1/all_types.hpp
@@ -1796,6 +1796,8 @@ enum BuiltinFnId {
     BuiltinFnIdWasmMemoryGrow,
     BuiltinFnIdSrc,
     BuiltinFnIdReduce,
+    BuiltinFnIdMaximum,
+    BuiltinFnIdMinimum,
 };
 
 struct BuiltinFnEntry {
@@ -2938,6 +2940,8 @@ enum IrBinOp {
     IrBinOpRemMod,
     IrBinOpArrayCat,
     IrBinOpArrayMult,
+    IrBinOpMaximum,
+    IrBinOpMinimum,
 };
 
 struct Stage1ZirInstBinOp {
diff --git a/src/stage1/astgen.cpp b/src/stage1/astgen.cpp
index e8f68c82bb..a5afe32d8b 100644
--- a/src/stage1/astgen.cpp
+++ b/src/stage1/astgen.cpp
@@ -4686,6 +4686,21 @@ static Stage1ZirInst *astgen_builtin_fn_call(Stage1AstGen *ag, Scope *scope, Ast
                     arg0_value, arg1_value);
                 return ir_lval_wrap(ag, scope, splat, lval, result_loc);
             }
+        case BuiltinFnIdMaximum:
+            {
+                AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
+                Stage1ZirInst *arg0_value = astgen_node(ag, arg0_node, scope);
+                if (arg0_value == ag->codegen->invalid_inst_src)
+                    return arg0_value;
+
+                AstNode *arg1_node = node->data.fn_call_expr.params.at(1);
+                Stage1ZirInst *arg1_value = astgen_node(ag, arg1_node, scope);
+                if (arg1_value == ag->codegen->invalid_inst_src)
+                    return arg1_value;
+
+                Stage1ZirInst *bin_op = ir_build_bin_op(ag, scope, node, IrBinOpMaximum, arg0_value, arg1_value, true);
+                return ir_lval_wrap(ag, scope, bin_op, lval, result_loc);
+            }
         case BuiltinFnIdMemcpy:
             {
                 AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
@@ -4726,6 +4741,21 @@ static Stage1ZirInst *astgen_builtin_fn_call(Stage1AstGen *ag, Scope *scope, Ast
                 Stage1ZirInst *ir_memset = ir_build_memset_src(ag, scope, node, arg0_value, arg1_value, arg2_value);
                 return ir_lval_wrap(ag, scope, ir_memset, lval, result_loc);
             }
+        case BuiltinFnIdMinimum:
+            {
+                AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
+                Stage1ZirInst *arg0_value = astgen_node(ag, arg0_node, scope);
+                if (arg0_value == ag->codegen->invalid_inst_src)
+                    return arg0_value;
+
+                AstNode *arg1_node = node->data.fn_call_expr.params.at(1);
+                Stage1ZirInst *arg1_value = astgen_node(ag, arg1_node, scope);
+                if (arg1_value == ag->codegen->invalid_inst_src)
+                    return arg1_value;
+
+                Stage1ZirInst *bin_op = ir_build_bin_op(ag, scope, node, IrBinOpMinimum, arg0_value, arg1_value, true);
+                return ir_lval_wrap(ag, scope, bin_op, lval, result_loc);
+            }
         case BuiltinFnIdWasmMemorySize:
             {
                 AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
diff --git a/src/stage1/bigfloat.cpp b/src/stage1/bigfloat.cpp
index 56bf2637e3..e5f21e34ea 100644
--- a/src/stage1/bigfloat.cpp
+++ b/src/stage1/bigfloat.cpp
@@ -191,6 +191,30 @@ void bigfloat_sqrt(BigFloat *dest, const BigFloat *op) {
     f128M_sqrt(&op->value, &dest->value);
 }
 
+void bigfloat_min(BigFloat *dest, const BigFloat *op1, const BigFloat *op2) {
+    if (bigfloat_is_nan(op1)) {
+        bigfloat_init_bigfloat(dest, op2);
+    } else if (bigfloat_is_nan(op2)) {
+        bigfloat_init_bigfloat(dest, op1);
+    } else if (f128M_lt(&op1->value, &op2->value)) {
+        bigfloat_init_bigfloat(dest, op1);
+    } else {
+        bigfloat_init_bigfloat(dest, op2);
+    }
+}
+
+void bigfloat_max(BigFloat *dest, const BigFloat *op1, const BigFloat *op2) {
+    if (bigfloat_is_nan(op1)) {
+        bigfloat_init_bigfloat(dest, op2);
+    } else if (bigfloat_is_nan(op2)) {
+        bigfloat_init_bigfloat(dest, op1);
+    } else if (f128M_lt(&op1->value, &op2->value)) {
+        bigfloat_init_bigfloat(dest, op2);
+    } else {
+        bigfloat_init_bigfloat(dest, op1);
+    }
+}
+
 bool bigfloat_is_nan(const BigFloat *op) {
     return f128M_isSignalingNaN(&op->value);
 }
diff --git a/src/stage1/bigfloat.hpp b/src/stage1/bigfloat.hpp
index 52e92d20f4..ffaff320e9 100644
--- a/src/stage1/bigfloat.hpp
+++ b/src/stage1/bigfloat.hpp
@@ -45,9 +45,12 @@ void bigfloat_div_floor(BigFloat *dest, const BigFloat *op1, const BigFloat *op2
 void bigfloat_rem(BigFloat *dest, const BigFloat *op1, const BigFloat *op2);
 void bigfloat_mod(BigFloat *dest, const BigFloat *op1, const BigFloat *op2);
 void bigfloat_sqrt(BigFloat *dest, const BigFloat *op);
+void bigfloat_min(BigFloat *dest, const BigFloat *op1, const BigFloat *op2);
+void bigfloat_max(BigFloat *dest, const BigFloat *op1, const BigFloat *op2);
 void bigfloat_append_buf(Buf *buf, const BigFloat *op);
 Cmp bigfloat_cmp(const BigFloat *op1, const BigFloat *op2);
 
+
 bool bigfloat_is_nan(const BigFloat *op);
 
 // convenience functions
diff --git a/src/stage1/bigint.cpp b/src/stage1/bigint.cpp
index 3ab6d08d79..5c8efad698 100644
--- a/src/stage1/bigint.cpp
+++ b/src/stage1/bigint.cpp
@@ -448,6 +448,26 @@ bool mul_u64_overflow(uint64_t op1, uint64_t op2, uint64_t *result) {
 }
 #endif
 
+void bigint_max(BigInt* dest, const BigInt *op1, const BigInt *op2) {
+    switch (bigint_cmp(op1, op2)) {
+        case CmpEQ:
+        case CmpLT:
+            return bigint_init_bigint(dest, op2);
+        case CmpGT:
+            return bigint_init_bigint(dest, op1);
+    }
+}
+
+void bigint_min(BigInt* dest, const BigInt *op1, const BigInt *op2) {
+    switch (bigint_cmp(op1, op2)) {
+        case CmpEQ:
+        case CmpLT:
+            return bigint_init_bigint(dest, op1);
+        case CmpGT:
+            return bigint_init_bigint(dest, op2);
+    }
+}
+
 void bigint_add(BigInt *dest, const BigInt *op1, const BigInt *op2) {
     if (op1->digit_count == 0) {
         return bigint_init_bigint(dest, op2);
diff --git a/src/stage1/bigint.hpp b/src/stage1/bigint.hpp
index 67f3ca1368..53e07f9284 100644
--- a/src/stage1/bigint.hpp
+++ b/src/stage1/bigint.hpp
@@ -56,6 +56,8 @@ bool bigint_fits_in_bits(const BigInt *bn, size_t bit_count, bool is_signed);
 void bigint_write_twos_complement(const BigInt *big_int, uint8_t *buf, size_t bit_count, bool is_big_endian);
 void bigint_read_twos_complement(BigInt *dest, const uint8_t *buf, size_t bit_count, bool is_big_endian,
         bool is_signed);
+void bigint_max(BigInt* dest, const BigInt *op1, const BigInt *op2);
+void bigint_min(BigInt* dest, const BigInt *op1, const BigInt *op2);
 void bigint_add(BigInt *dest, const BigInt *op1, const BigInt *op2);
 void bigint_add_wrap(BigInt *dest, const BigInt *op1, const BigInt *op2, size_t bit_count, bool is_signed);
 void bigint_sub(BigInt *dest, const BigInt *op1, const BigInt *op2);
diff --git a/src/stage1/codegen.cpp b/src/stage1/codegen.cpp
index fc2651c8f7..d1bea6990a 100644
--- a/src/stage1/codegen.cpp
+++ b/src/stage1/codegen.cpp
@@ -3248,6 +3248,30 @@ static LLVMValueRef ir_render_bin_op(CodeGen *g, Stage1Air *executable,
         case IrBinOpRemMod:
             return gen_rem(g, want_runtime_safety, ir_want_fast_math(g, &bin_op_instruction->base),
                     op1_value, op2_value, operand_type, RemKindMod);
+        case IrBinOpMaximum:
+            if (scalar_type->id == ZigTypeIdFloat) {
+                return ZigLLVMBuildMaxNum(g->builder, op1_value, op2_value, "");
+            } else if (scalar_type->id == ZigTypeIdInt) {
+                if (scalar_type->data.integral.is_signed) {
+                    return ZigLLVMBuildSMax(g->builder, op1_value, op2_value, "");
+                } else {
+                    return ZigLLVMBuildUMax(g->builder, op1_value, op2_value, "");
+                }
+            } else {
+                zig_unreachable();
+            }
+        case IrBinOpMinimum:
+            if (scalar_type->id == ZigTypeIdFloat) {
+                return ZigLLVMBuildMinNum(g->builder, op1_value, op2_value, "");
+            } else if (scalar_type->id == ZigTypeIdInt) {
+                if (scalar_type->data.integral.is_signed) {
+                    return ZigLLVMBuildSMin(g->builder, op1_value, op2_value, "");
+                } else {
+                    return ZigLLVMBuildUMin(g->builder, op1_value, op2_value, "");
+                }
+            } else {
+                zig_unreachable();
+            }
     }
     zig_unreachable();
 }
@@ -8990,6 +9014,8 @@ static void define_builtin_fns(CodeGen *g) {
     create_builtin_fn(g, BuiltinFnIdWasmMemoryGrow, "wasmMemoryGrow", 2);
     create_builtin_fn(g, BuiltinFnIdSrc, "src", 0);
     create_builtin_fn(g, BuiltinFnIdReduce, "reduce", 2);
+    create_builtin_fn(g, BuiltinFnIdMaximum, "maximum", 2);
+    create_builtin_fn(g, BuiltinFnIdMinimum, "minimum", 2);
 }
 
 static const char *bool_to_str(bool b) {
diff --git a/src/stage1/ir.cpp b/src/stage1/ir.cpp
index 9a2e50fef7..e9bb7b1d15 100644
--- a/src/stage1/ir.cpp
+++ b/src/stage1/ir.cpp
@@ -3311,6 +3311,108 @@ static void float_mod(ZigValue *out_val, ZigValue *op1, ZigValue *op2) {
     }
 }
 
+static void float_max(ZigValue *out_val, ZigValue *op1, ZigValue *op2) {
+    assert(op1->type == op2->type);
+    out_val->type = op1->type;
+    if (op1->type->id == ZigTypeIdComptimeFloat) {
+        bigfloat_max(&out_val->data.x_bigfloat, &op1->data.x_bigfloat, &op2->data.x_bigfloat);
+    } else if (op1->type->id == ZigTypeIdFloat) {
+        switch (op1->type->data.floating.bit_count) {
+            case 16:
+                if (zig_f16_isNaN(op1->data.x_f16)) {
+                    out_val->data.x_f16 = op2->data.x_f16;
+                } else if (zig_f16_isNaN(op2->data.x_f16)) {
+                    out_val->data.x_f16 = op1->data.x_f16;
+                } else {
+                    out_val->data.x_f16 = f16_lt(op1->data.x_f16, op2->data.x_f16) ? op2->data.x_f16 : op1->data.x_f16;
+                }
+                return;
+            case 32:
+                if (op1->data.x_f32 != op1->data.x_f32) {
+                    out_val->data.x_f32 = op2->data.x_f32;
+                } else if (op2->data.x_f32 != op2->data.x_f32) {
+                    out_val->data.x_f32 = op1->data.x_f32;
+                } else {
+                    out_val->data.x_f32 = op1->data.x_f32 > op2->data.x_f32 ? op1->data.x_f32 : op2->data.x_f32;
+                }
+                return;
+            case 64:
+                if (op1->data.x_f64 != op1->data.x_f64) {
+                    out_val->data.x_f64 = op2->data.x_f64;
+                } else if (op2->data.x_f64 != op2->data.x_f64) {
+                    out_val->data.x_f64 = op1->data.x_f64;
+                } else {
+                    out_val->data.x_f64 = op1->data.x_f64 > op2->data.x_f64 ? op1->data.x_f64 : op2->data.x_f64;
+                }
+                return;
+            case 128:
+                if (zig_f128_isNaN(&op1->data.x_f128)) {
+                    out_val->data.x_f128 = op2->data.x_f128;
+                } else if (zig_f128_isNaN(&op2->data.x_f128)) {
+                    out_val->data.x_f128 = op1->data.x_f128;
+                } else {
+                    out_val->data.x_f128 = f128M_lt(&op1->data.x_f128, &op2->data.x_f128) ? op2->data.x_f128 : op1->data.x_f128;
+                }
+                return;
+            default:
+                zig_unreachable();
+        }
+    } else {
+        zig_unreachable();
+    }
+}
+
+static void float_min(ZigValue *out_val, ZigValue *op1, ZigValue *op2) {
+    assert(op1->type == op2->type);
+    out_val->type = op1->type;
+    if (op1->type->id == ZigTypeIdComptimeFloat) {
+        bigfloat_min(&out_val->data.x_bigfloat, &op1->data.x_bigfloat, &op2->data.x_bigfloat);
+    } else if (op1->type->id == ZigTypeIdFloat) {
+        switch (op1->type->data.floating.bit_count) {
+            case 16:
+                if (zig_f16_isNaN(op1->data.x_f16)) {
+                    out_val->data.x_f16 = op2->data.x_f16;
+                } else if (zig_f16_isNaN(op2->data.x_f16)) {
+                    out_val->data.x_f16 = op1->data.x_f16;
+                } else {
+                    out_val->data.x_f16 = f16_lt(op1->data.x_f16, op2->data.x_f16) ? op1->data.x_f16 : op2->data.x_f16;
+                }
+                return;
+            case 32:
+                if (op1->data.x_f32 != op1->data.x_f32) {
+                    out_val->data.x_f32 = op2->data.x_f32;
+                } else if (op2->data.x_f32 != op2->data.x_f32) {
+                    out_val->data.x_f32 = op1->data.x_f32;
+                } else {
+                    out_val->data.x_f32 = op1->data.x_f32 < op2->data.x_f32 ? op1->data.x_f32 : op2->data.x_f32;
+                }
+                return;
+            case 64:
+                if (op1->data.x_f64 != op1->data.x_f64) {
+                    out_val->data.x_f64 = op2->data.x_f64;
+                } else if (op2->data.x_f64 != op2->data.x_f64) {
+                    out_val->data.x_f64 = op1->data.x_f64;
+                } else {
+                    out_val->data.x_f64 = op1->data.x_f32 < op2->data.x_f64 ? op1->data.x_f64 : op2->data.x_f64;
+                }
+                return;
+            case 128:
+                if (zig_f128_isNaN(&op1->data.x_f128)) {
+                    out_val->data.x_f128 = op2->data.x_f128;
+                } else if (zig_f128_isNaN(&op2->data.x_f128)) {
+                    out_val->data.x_f128 = op1->data.x_f128;
+                } else {
+                    out_val->data.x_f128 = f128M_lt(&op1->data.x_f128, &op2->data.x_f128) ? op1->data.x_f128 : op2->data.x_f128;
+                }
+                return;
+            default:
+                zig_unreachable();
+        }
+    } else {
+        zig_unreachable();
+    }
+}
+
 static void float_negate(ZigValue *out_val, ZigValue *op) {
     out_val->type = op->type;
     if (op->type->id == ZigTypeIdComptimeFloat) {
@@ -9704,6 +9806,20 @@ static ErrorMsg *ir_eval_math_op_scalar(IrAnalyze *ira, Scope *scope, AstNode *s
                 float_mod(out_val, op1_val, op2_val);
             }
             break;
+        case IrBinOpMaximum:
+            if (is_int) {
+                bigint_max(&out_val->data.x_bigint, &op1_val->data.x_bigint, &op2_val->data.x_bigint);
+            } else {
+                float_max(out_val, op1_val, op2_val);
+            }
+            break;
+        case IrBinOpMinimum:
+            if (is_int) {
+                bigint_min(&out_val->data.x_bigint, &op1_val->data.x_bigint, &op2_val->data.x_bigint);
+            } else {
+                float_min(out_val, op1_val, op2_val);
+            }
+            break;
     }
 
     if (type_entry->id == ZigTypeIdInt) {
@@ -9904,6 +10020,8 @@ static bool ok_float_op(IrBinOp op) {
         case IrBinOpRemRem:
         case IrBinOpRemMod:
         case IrBinOpRemUnspecified:
+        case IrBinOpMaximum:
+        case IrBinOpMinimum:
             return true;
 
         case IrBinOpBoolOr:
@@ -10894,6 +11012,8 @@ static Stage1AirInst *ir_analyze_instruction_bin_op(IrAnalyze *ira, Stage1ZirIns
         case IrBinOpRemUnspecified:
         case IrBinOpRemRem:
         case IrBinOpRemMod:
+        case IrBinOpMaximum:
+        case IrBinOpMinimum:
             return ir_analyze_bin_op_math(ira, bin_op_instruction);
         case IrBinOpArrayCat:
             return ir_analyze_array_cat(ira, bin_op_instruction);
diff --git a/src/stage1/ir_print.cpp b/src/stage1/ir_print.cpp
index e83da8565c..96e924b768 100644
--- a/src/stage1/ir_print.cpp
+++ b/src/stage1/ir_print.cpp
@@ -733,6 +733,10 @@ static const char *ir_bin_op_id_str(IrBinOp op_id) {
             return "++";
         case IrBinOpArrayMult:
             return "**";
+        case IrBinOpMaximum:
+            return "@maximum";
+        case IrBinOpMinimum:
+            return "@minimum";
     }
     zig_unreachable();
 }
diff --git a/src/zig_llvm.cpp b/src/zig_llvm.cpp
index d5d6f9f670..d0bc24ed1b 100644
--- a/src/zig_llvm.cpp
+++ b/src/zig_llvm.cpp
@@ -458,6 +458,36 @@ LLVMValueRef ZigLLVMBuildMemSet(LLVMBuilderRef B, LLVMValueRef Ptr, LLVMValueRef
     return wrap(call_inst);
 }
 
+LLVMValueRef ZigLLVMBuildMaxNum(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, const char *name) {
+    CallInst *call_inst = unwrap(B)->CreateMaxNum(unwrap(LHS), unwrap(RHS), name);
+    return wrap(call_inst);
+}
+
+LLVMValueRef ZigLLVMBuildMinNum(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, const char *name) {
+    CallInst *call_inst = unwrap(B)->CreateMinNum(unwrap(LHS), unwrap(RHS), name);
+    return wrap(call_inst);
+}
+
+LLVMValueRef ZigLLVMBuildUMax(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, const char *name) {
+    CallInst *call_inst = unwrap(B)->CreateBinaryIntrinsic(Intrinsic::umax, unwrap(LHS), unwrap(RHS), nullptr, name);
+    return wrap(call_inst);
+}
+
+LLVMValueRef ZigLLVMBuildUMin(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, const char *name) {
+    CallInst *call_inst = unwrap(B)->CreateBinaryIntrinsic(Intrinsic::umin, unwrap(LHS), unwrap(RHS), nullptr, name);
+    return wrap(call_inst);
+}
+
+LLVMValueRef ZigLLVMBuildSMax(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, const char *name) {
+    CallInst *call_inst = unwrap(B)->CreateBinaryIntrinsic(Intrinsic::smax, unwrap(LHS), unwrap(RHS), nullptr, name);
+    return wrap(call_inst);
+}
+
+LLVMValueRef ZigLLVMBuildSMin(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, const char *name) {
+    CallInst *call_inst = unwrap(B)->CreateBinaryIntrinsic(Intrinsic::smin, unwrap(LHS), unwrap(RHS), nullptr, name);
+    return wrap(call_inst);
+}
+
 void ZigLLVMFnSetSubprogram(LLVMValueRef fn, ZigLLVMDISubprogram *subprogram) {
     assert( isa<Function>(unwrap(fn)) );
     Function *unwrapped_function = reinterpret_cast<Function*>(unwrap(fn));
diff --git a/src/zig_llvm.h b/src/zig_llvm.h
index a771491138..f49c2662c6 100644
--- a/src/zig_llvm.h
+++ b/src/zig_llvm.h
@@ -129,6 +129,14 @@ ZIG_EXTERN_C LLVMValueRef ZigLLVMBuildMemCpy(LLVMBuilderRef B, LLVMValueRef Dst,
 ZIG_EXTERN_C LLVMValueRef ZigLLVMBuildMemSet(LLVMBuilderRef B, LLVMValueRef Ptr, LLVMValueRef Val, LLVMValueRef Size,
         unsigned Align, bool isVolatile);
 
+ZIG_EXTERN_C LLVMValueRef ZigLLVMBuildMaxNum(LLVMBuilderRef builder, LLVMValueRef LHS, LLVMValueRef RHS, const char* name);
+ZIG_EXTERN_C LLVMValueRef ZigLLVMBuildMinNum(LLVMBuilderRef builder, LLVMValueRef LHS, LLVMValueRef RHS, const char* name);
+
+ZIG_EXTERN_C LLVMValueRef ZigLLVMBuildUMax(LLVMBuilderRef builder, LLVMValueRef LHS, LLVMValueRef RHS, const char* name);
+ZIG_EXTERN_C LLVMValueRef ZigLLVMBuildUMin(LLVMBuilderRef builder, LLVMValueRef LHS, LLVMValueRef RHS, const char* name);
+ZIG_EXTERN_C LLVMValueRef ZigLLVMBuildSMax(LLVMBuilderRef builder, LLVMValueRef LHS, LLVMValueRef RHS, const char* name);
+ZIG_EXTERN_C LLVMValueRef ZigLLVMBuildSMin(LLVMBuilderRef builder, LLVMValueRef LHS, LLVMValueRef RHS, const char* name);
+
 ZIG_EXTERN_C LLVMValueRef ZigLLVMBuildCmpXchg(LLVMBuilderRef builder, LLVMValueRef ptr, LLVMValueRef cmp,
         LLVMValueRef new_val, LLVMAtomicOrdering success_ordering,
         LLVMAtomicOrdering failure_ordering, bool is_weak);
@@ -142,6 +150,7 @@ ZIG_EXTERN_C LLVMValueRef ZigLLVMBuildLShrExact(LLVMBuilderRef builder, LLVMValu
 ZIG_EXTERN_C LLVMValueRef ZigLLVMBuildAShrExact(LLVMBuilderRef builder, LLVMValueRef LHS, LLVMValueRef RHS,
         const char *name);
 
+
 ZIG_EXTERN_C struct ZigLLVMDIType *ZigLLVMCreateDebugPointerType(struct ZigLLVMDIBuilder *dibuilder,
         struct ZigLLVMDIType *pointee_type, uint64_t size_in_bits, uint64_t align_in_bits, const char *name);
 
diff --git a/test/behavior.zig b/test/behavior.zig
index 8459e499d7..101ee2ce53 100644
--- a/test/behavior.zig
+++ b/test/behavior.zig
@@ -105,6 +105,7 @@ test {
         _ = @import("behavior/inttoptr.zig");
         _ = @import("behavior/ir_block_deps.zig");
         _ = @import("behavior/math.zig");
+        _ = @import("behavior/maximum_minimum.zig");
         _ = @import("behavior/merge_error_sets.zig");
         _ = @import("behavior/misc.zig");
         _ = @import("behavior/muladd.zig");
diff --git a/test/behavior/maximum_minimum.zig b/test/behavior/maximum_minimum.zig
new file mode 100644
index 0000000000..5fef818f2b
--- /dev/null
+++ b/test/behavior/maximum_minimum.zig
@@ -0,0 +1,58 @@
+const std = @import("std");
+const builtin = @import("builtin");
+const mem = std.mem;
+const expect = std.testing.expect;
+const expectEqual = std.testing.expectEqual;
+const Vector = std.meta.Vector;
+
+test "@maximum" {
+    const S = struct {
+        fn doTheTest() !void {
+            try expectEqual(@as(i32, 10), @maximum(@as(i32, -3), @as(i32, 10)));
+            try expectEqual(@as(f32, 3.2), @maximum(@as(f32, 3.2), @as(f32, 0.68)));
+
+            var a: Vector(4, i32) = [4]i32{ 2147483647, -2, 30, 40 };
+            var b: Vector(4, i32) = [4]i32{ 1, 2147483647, 3, 4 };
+            var x = @maximum(a, b);
+            try expect(mem.eql(i32, &@as([4]i32, x), &[4]i32{ 2147483647, 2147483647, 30, 40 }));
+
+            var c: Vector(4, f32) = [4]f32{ 0, 0.4, -2.4, 7.8 };
+            var d: Vector(4, f32) = [4]f32{ -0.23, 0.42, -0.64, 0.9 };
+            var y = @maximum(c, d);
+            try expect(mem.eql(f32, &@as([4]f32, y), &[4]f32{ 0, 0.42, -0.64, 7.8 }));
+
+            var e: Vector(2, f32) = [2]f32{ 0, std.math.qnan_f32 };
+            var f: Vector(2, f32) = [2]f32{ std.math.qnan_f32, 0 };
+            var z = @maximum(e, f);
+            try expect(mem.eql(f32, &@as([2]f32, z), &[2]f32{ 0, 0 }));
+        }
+    };
+    try S.doTheTest();
+    comptime try S.doTheTest();
+}
+
+test "@minimum" {
+    const S = struct {
+        fn doTheTest() !void {
+            try expectEqual(@as(i32, -3), @minimum(@as(i32, -3), @as(i32, 10)));
+            try expectEqual(@as(f32, 0.68), @minimum(@as(f32, 3.2), @as(f32, 0.68)));
+
+            var a: Vector(4, i32) = [4]i32{ 2147483647, -2, 30, 40 };
+            var b: Vector(4, i32) = [4]i32{ 1, 2147483647, 3, 4 };
+            var x = @minimum(a, b);
+            try expect(mem.eql(i32, &@as([4]i32, x), &[4]i32{ 1, -2, 3, 4 }));
+
+            var c: Vector(4, f32) = [4]f32{ 0, 0.4, -2.4, 7.8 };
+            var d: Vector(4, f32) = [4]f32{ -0.23, 0.42, -0.64, 0.9 };
+            var y = @minimum(c, d);
+            try expect(mem.eql(f32, &@as([4]f32, y), &[4]f32{ -0.23, 0.4, -2.4, 0.9 }));
+
+            var e: Vector(2, f32) = [2]f32{ 0, std.math.qnan_f32 };
+            var f: Vector(2, f32) = [2]f32{ std.math.qnan_f32, 0 };
+            var z = @maximum(e, f);
+            try expect(mem.eql(f32, &@as([2]f32, z), &[2]f32{ 0, 0 }));
+        }
+    };
+    try S.doTheTest();
+    comptime try S.doTheTest();
+}

From 31a59c229cb39b9ffd1ee3397a1ce87c36b91477 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Mon, 26 Jul 2021 19:12:34 -0700
Subject: [PATCH 03/96] stage2: improvements towards `zig test`

 * Add AIR instruction: struct_field_val
   - This is part of an effort to eliminate the AIR instruction `ref`.
   - It's implemented for C backend and LLVM backend so far.
 * Rename `resolvePossiblyUndefinedValue` to `resolveMaybeUndefVal` just
   to save some columns on long lines.
 * Sema: add `fieldVal` alongside `fieldPtr` (renamed from
   `namedFieldPtr`). This is part of an effort to eliminate the AIR
   instruction `ref`. The idea is to avoid unnecessary loads, stores,
   stack usage, and IR instructions, by paying a DRY cost.

LLVM backend improvements:

 * internal linkage vs exported linkage is implemented, along with
   aliases. There is an issue with incremental updates due to missing
   LLVM API for deleting aliases; see the relevant comment in this commit.
   - `updateDeclExports` is hooked up to the LLVM backend now.
 * Fix usage of `Type.tag() == .noreturn` rather than calling `isNoReturn()`.
 * Properly mark global variables as mutable/constant.
 * Fix llvm type generation of function pointers
 * Fix codegen for calls of function pointers
 * Implement llvm type generation of error unions and error sets.
 * Implement AIR instructions: addwrap, subwrap, mul, mulwrap, div,
   bit_and, bool_and, bit_or, bool_or, xor, struct_field_ptr,
   struct_field_val, unwrap_errunion_err, add for floats, sub for
   floats.

After this commit, `zig test` on a file with `test "example" {}`
correctly generates and executes a test binary. However the
`test_functions` slice is undefined and just happens to be going into
the .bss section, causing the length to be 0. The next step towards
`zig test` will be replacing the `test_functions` Decl Value with the
set of test function pointers, before it is sent to linker/codegen.
---
 src/Air.zig                   |   7 +-
 src/Liveness.zig              |   4 +-
 src/Module.zig                |   4 +-
 src/Sema.zig                  | 386 ++++++++++++++++++++++++++++------
 src/codegen.zig               |   9 +
 src/codegen/c.zig             |  25 ++-
 src/codegen/llvm.zig          | 362 ++++++++++++++++++++++++-------
 src/codegen/llvm/bindings.zig | 133 +++++++++++-
 src/codegen/wasm.zig          |   2 +-
 src/link/Coff.zig             |  14 +-
 src/link/Elf.zig              |   7 +-
 src/link/MachO.zig            |   6 +
 src/link/Wasm.zig             |  10 +-
 src/print_air.zig             |   7 +-
 14 files changed, 808 insertions(+), 168 deletions(-)

diff --git a/src/Air.zig b/src/Air.zig
index 9451f8b763..8cb7b943e3 100644
--- a/src/Air.zig
+++ b/src/Air.zig
@@ -247,6 +247,9 @@ pub const Inst = struct {
         /// Given a pointer to a struct and a field index, returns a pointer to the field.
         /// Uses the `ty_pl` field, payload is `StructField`.
         struct_field_ptr,
+        /// Given a byval struct and a field index, returns the field byval.
+        /// Uses the `ty_pl` field, payload is `StructField`.
+        struct_field_val,
         /// Given a slice value, return the length.
         /// Result type is always usize.
         /// Uses the `ty_op` field.
@@ -376,7 +379,8 @@ pub const SwitchBr = struct {
 };
 
 pub const StructField = struct {
-    struct_ptr: Inst.Ref,
+    /// Whether this is a pointer or byval is determined by the AIR tag.
+    struct_operand: Inst.Ref,
     field_index: u32,
 };
 
@@ -448,6 +452,7 @@ pub fn typeOfIndex(air: Air, inst: Air.Inst.Index) Type {
         .constant,
         .varptr,
         .struct_field_ptr,
+        .struct_field_val,
         => return air.getRefType(datas[inst].ty_pl.ty),
 
         .not,
diff --git a/src/Liveness.zig b/src/Liveness.zig
index c6617e9b29..a4c6d8c016 100644
--- a/src/Liveness.zig
+++ b/src/Liveness.zig
@@ -320,9 +320,9 @@ fn analyzeInst(
             }
             return extra_tombs.finish();
         },
-        .struct_field_ptr => {
+        .struct_field_ptr, .struct_field_val => {
             const extra = a.air.extraData(Air.StructField, inst_datas[inst].ty_pl.payload).data;
-            return trackOperands(a, new_set, inst, main_tomb, .{ extra.struct_ptr, .none, .none });
+            return trackOperands(a, new_set, inst, main_tomb, .{ extra.struct_operand, .none, .none });
         },
         .br => {
             const br = inst_datas[inst].br;
diff --git a/src/Module.zig b/src/Module.zig
index 8ebb1c203c..99f314c5cb 100644
--- a/src/Module.zig
+++ b/src/Module.zig
@@ -3702,8 +3702,8 @@ pub fn analyzeExport(
         else => return mod.fail(scope, src, "unable to export type '{}'", .{exported_decl.ty}),
     }
 
-    try mod.decl_exports.ensureCapacity(mod.gpa, mod.decl_exports.count() + 1);
-    try mod.export_owners.ensureCapacity(mod.gpa, mod.export_owners.count() + 1);
+    try mod.decl_exports.ensureUnusedCapacity(mod.gpa, 1);
+    try mod.export_owners.ensureUnusedCapacity(mod.gpa, 1);
 
     const new_export = try mod.gpa.create(Export);
     errdefer mod.gpa.destroy(new_export);
diff --git a/src/Sema.zig b/src/Sema.zig
index 67cfc09b53..46a41426c8 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -655,7 +655,7 @@ fn resolveDefinedValue(
     src: LazySrcLoc,
     air_ref: Air.Inst.Ref,
 ) CompileError!?Value {
-    if (try sema.resolvePossiblyUndefinedValue(block, src, air_ref)) |val| {
+    if (try sema.resolveMaybeUndefVal(block, src, air_ref)) |val| {
         if (val.isUndef()) {
             return sema.failWithUseOfUndef(block, src);
         }
@@ -664,7 +664,7 @@ fn resolveDefinedValue(
     return null;
 }
 
-fn resolvePossiblyUndefinedValue(
+fn resolveMaybeUndefVal(
     sema: *Sema,
     block: *Scope.Block,
     src: LazySrcLoc,
@@ -1293,7 +1293,7 @@ fn zirIndexablePtrLen(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) Co
         };
         return sema.mod.failWithOwnedErrorMsg(&block.base, msg);
     }
-    const result_ptr = try sema.namedFieldPtr(block, src, array_ptr, "len", src);
+    const result_ptr = try sema.fieldPtr(block, src, array_ptr, "len", src);
     const result_ptr_src = array_ptr_src;
     return sema.analyzeLoad(block, src, result_ptr, result_ptr_src);
 }
@@ -1789,7 +1789,7 @@ fn zirCompileLog(
 
         const arg = sema.resolveInst(arg_ref);
         const arg_ty = sema.typeOf(arg);
-        if (try sema.resolvePossiblyUndefinedValue(block, src, arg)) |val| {
+        if (try sema.resolveMaybeUndefVal(block, src, arg)) |val| {
             try writer.print("@as({}, {})", .{ arg_ty, val });
         } else {
             try writer.print("@as({}, [runtime value])", .{arg_ty});
@@ -2579,7 +2579,7 @@ fn zirErrorToInt(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) Compile
     const op_coerced = try sema.coerce(block, Type.initTag(.anyerror), op, operand_src);
     const result_ty = Type.initTag(.u16);
 
-    if (try sema.resolvePossiblyUndefinedValue(block, src, op_coerced)) |val| {
+    if (try sema.resolveMaybeUndefVal(block, src, op_coerced)) |val| {
         if (val.isUndef()) {
             return sema.addConstUndef(result_ty);
         }
@@ -2759,7 +2759,7 @@ fn zirEnumToInt(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) CompileE
         return sema.addConstant(int_tag_ty, opv);
     }
 
-    if (try sema.resolvePossiblyUndefinedValue(block, operand_src, enum_tag)) |enum_tag_val| {
+    if (try sema.resolveMaybeUndefVal(block, operand_src, enum_tag)) |enum_tag_val| {
         if (enum_tag_val.castTag(.enum_field_index)) |enum_field_payload| {
             const field_index = enum_field_payload.data;
             switch (enum_tag_ty.tag()) {
@@ -2806,7 +2806,7 @@ fn zirIntToEnum(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) CompileE
         return mod.fail(&block.base, dest_ty_src, "expected enum, found {}", .{dest_ty});
     }
 
-    if (try sema.resolvePossiblyUndefinedValue(block, operand_src, operand)) |int_val| {
+    if (try sema.resolveMaybeUndefVal(block, operand_src, operand)) |int_val| {
         if (dest_ty.isNonexhaustiveEnum()) {
             return sema.addConstant(dest_ty, int_val);
         }
@@ -3309,16 +3309,16 @@ fn zirFieldVal(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) CompileEr
     const inst_data = sema.code.instructions.items(.data)[inst].pl_node;
     const src = inst_data.src();
     const field_name_src: LazySrcLoc = .{ .node_offset_field_name = inst_data.src_node };
+    const lhs_src: LazySrcLoc = src; // TODO
     const extra = sema.code.extraData(Zir.Inst.Field, inst_data.payload_index).data;
     const field_name = sema.code.nullTerminatedString(extra.field_name_start);
     const object = sema.resolveInst(extra.lhs);
-    const object_ptr = if (sema.typeOf(object).zigTypeTag() == .Pointer)
-        object
-    else
-        try sema.analyzeRef(block, src, object);
-    const result_ptr = try sema.namedFieldPtr(block, src, object_ptr, field_name, field_name_src);
-    const result_ptr_src = src;
-    return sema.analyzeLoad(block, src, result_ptr, result_ptr_src);
+    if (sema.typeOf(object).isSinglePointer()) {
+        const result_ptr = try sema.fieldPtr(block, src, object, field_name, field_name_src);
+        return sema.analyzeLoad(block, src, result_ptr, lhs_src);
+    } else {
+        return sema.fieldVal(block, src, object, field_name, field_name_src);
+    }
 }
 
 fn zirFieldPtr(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
@@ -3331,7 +3331,7 @@ fn zirFieldPtr(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) CompileEr
     const extra = sema.code.extraData(Zir.Inst.Field, inst_data.payload_index).data;
     const field_name = sema.code.nullTerminatedString(extra.field_name_start);
     const object_ptr = sema.resolveInst(extra.lhs);
-    return sema.namedFieldPtr(block, src, object_ptr, field_name, field_name_src);
+    return sema.fieldPtr(block, src, object_ptr, field_name, field_name_src);
 }
 
 fn zirFieldValNamed(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
@@ -3344,9 +3344,7 @@ fn zirFieldValNamed(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) Comp
     const extra = sema.code.extraData(Zir.Inst.FieldNamed, inst_data.payload_index).data;
     const object = sema.resolveInst(extra.lhs);
     const field_name = try sema.resolveConstString(block, field_name_src, extra.field_name);
-    const object_ptr = try sema.analyzeRef(block, src, object);
-    const result_ptr = try sema.namedFieldPtr(block, src, object_ptr, field_name, field_name_src);
-    return sema.analyzeLoad(block, src, result_ptr, src);
+    return sema.fieldVal(block, src, object, field_name, field_name_src);
 }
 
 fn zirFieldPtrNamed(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
@@ -3359,7 +3357,7 @@ fn zirFieldPtrNamed(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) Comp
     const extra = sema.code.extraData(Zir.Inst.FieldNamed, inst_data.payload_index).data;
     const object_ptr = sema.resolveInst(extra.lhs);
     const field_name = try sema.resolveConstString(block, field_name_src, extra.field_name);
-    return sema.namedFieldPtr(block, src, object_ptr, field_name, field_name_src);
+    return sema.fieldPtr(block, src, object_ptr, field_name, field_name_src);
 }
 
 fn zirIntCast(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
@@ -4691,8 +4689,8 @@ fn zirBitwise(
         return sema.mod.fail(&block.base, src, "invalid operands to binary bitwise expression: '{s}' and '{s}'", .{ @tagName(lhs_ty.zigTypeTag()), @tagName(rhs_ty.zigTypeTag()) });
     }
 
-    if (try sema.resolvePossiblyUndefinedValue(block, lhs_src, casted_lhs)) |lhs_val| {
-        if (try sema.resolvePossiblyUndefinedValue(block, rhs_src, casted_rhs)) |rhs_val| {
+    if (try sema.resolveMaybeUndefVal(block, lhs_src, casted_lhs)) |lhs_val| {
+        if (try sema.resolveMaybeUndefVal(block, rhs_src, casted_rhs)) |rhs_val| {
             if (lhs_val.isUndef() or rhs_val.isUndef()) {
                 return sema.addConstUndef(resolved_type);
             }
@@ -4823,8 +4821,8 @@ fn analyzeArithmetic(
         return sema.mod.fail(&block.base, src, "invalid operands to binary expression: '{s}' and '{s}'", .{ @tagName(lhs_ty.zigTypeTag()), @tagName(rhs_ty.zigTypeTag()) });
     }
 
-    if (try sema.resolvePossiblyUndefinedValue(block, lhs_src, casted_lhs)) |lhs_val| {
-        if (try sema.resolvePossiblyUndefinedValue(block, rhs_src, casted_rhs)) |rhs_val| {
+    if (try sema.resolveMaybeUndefVal(block, lhs_src, casted_lhs)) |lhs_val| {
+        if (try sema.resolveMaybeUndefVal(block, rhs_src, casted_rhs)) |rhs_val| {
             if (lhs_val.isUndef() or rhs_val.isUndef()) {
                 return sema.addConstUndef(resolved_type);
             }
@@ -5038,8 +5036,8 @@ fn zirCmp(
         if (!is_equality_cmp) {
             return mod.fail(&block.base, src, "{s} operator not allowed for errors", .{@tagName(op)});
         }
-        if (try sema.resolvePossiblyUndefinedValue(block, lhs_src, lhs)) |lval| {
-            if (try sema.resolvePossiblyUndefinedValue(block, rhs_src, rhs)) |rval| {
+        if (try sema.resolveMaybeUndefVal(block, lhs_src, lhs)) |lval| {
+            if (try sema.resolveMaybeUndefVal(block, rhs_src, rhs)) |rval| {
                 if (lval.isUndef() or rval.isUndef()) {
                     return sema.addConstUndef(Type.initTag(.bool));
                 }
@@ -5085,8 +5083,8 @@ fn zirCmp(
     const casted_lhs = try sema.coerce(block, resolved_type, lhs, lhs_src);
     const casted_rhs = try sema.coerce(block, resolved_type, rhs, rhs_src);
 
-    if (try sema.resolvePossiblyUndefinedValue(block, lhs_src, casted_lhs)) |lhs_val| {
-        if (try sema.resolvePossiblyUndefinedValue(block, rhs_src, casted_rhs)) |rhs_val| {
+    if (try sema.resolveMaybeUndefVal(block, lhs_src, casted_lhs)) |lhs_val| {
+        if (try sema.resolveMaybeUndefVal(block, rhs_src, casted_rhs)) |rhs_val| {
             if (lhs_val.isUndef() or rhs_val.isUndef()) {
                 return sema.addConstUndef(resolved_type);
             }
@@ -5759,7 +5757,7 @@ fn zirStructInit(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index, is_ref:
     if (is_comptime) {
         const values = try sema.arena.alloc(Value, field_inits.len);
         for (field_inits) |field_init, i| {
-            values[i] = (sema.resolvePossiblyUndefinedValue(block, src, field_init) catch unreachable).?;
+            values[i] = (sema.resolveMaybeUndefVal(block, src, field_init) catch unreachable).?;
         }
         return sema.addConstant(struct_ty, try Value.Tag.@"struct".create(sema.arena, values.ptr));
     }
@@ -6234,7 +6232,7 @@ fn zirVarExtended(
         const init_ref = @intToEnum(Zir.Inst.Ref, sema.code.extra[extra_index]);
         extra_index += 1;
         const init_air_inst = sema.resolveInst(init_ref);
-        break :blk (try sema.resolvePossiblyUndefinedValue(block, init_src, init_air_inst)) orelse
+        break :blk (try sema.resolveMaybeUndefVal(block, init_src, init_air_inst)) orelse
             return sema.failWithNeededComptime(block, init_src);
     } else Value.initTag(.unreachable_value);
 
@@ -6565,7 +6563,177 @@ fn emitBackwardBranch(sema: *Sema, block: *Scope.Block, src: LazySrcLoc) !void {
     }
 }
 
-fn namedFieldPtr(
+fn fieldVal(
+    sema: *Sema,
+    block: *Scope.Block,
+    src: LazySrcLoc,
+    object: Air.Inst.Ref,
+    field_name: []const u8,
+    field_name_src: LazySrcLoc,
+) CompileError!Air.Inst.Ref {
+    // When editing this function, note that there is corresponding logic to be edited
+    // in `fieldPtr`. This function takes a value and returns a value.
+
+    const mod = sema.mod;
+    const arena = sema.arena;
+    const object_src = src; // TODO better source location
+    const object_ty = sema.typeOf(object);
+
+    switch (object_ty.zigTypeTag()) {
+        .Array => {
+            if (mem.eql(u8, field_name, "len")) {
+                return sema.addConstant(
+                    Type.initTag(.comptime_int),
+                    try Value.Tag.int_u64.create(arena, object_ty.arrayLen()),
+                );
+            } else {
+                return mod.fail(
+                    &block.base,
+                    field_name_src,
+                    "no member named '{s}' in '{}'",
+                    .{ field_name, object_ty },
+                );
+            }
+        },
+        .Pointer => switch (object_ty.ptrSize()) {
+            .Slice => {
+                if (mem.eql(u8, field_name, "ptr")) {
+                    const buf = try arena.create(Type.Payload.ElemType);
+                    const result_ty = object_ty.slicePtrFieldType(buf);
+                    if (try sema.resolveMaybeUndefVal(block, object_src, object)) |val| {
+                        if (val.isUndef()) return sema.addConstUndef(result_ty);
+                        return mod.fail(
+                            &block.base,
+                            field_name_src,
+                            "TODO implement comptime slice ptr",
+                            .{},
+                        );
+                    }
+                    try sema.requireRuntimeBlock(block, src);
+                    return block.addTyOp(.slice_ptr, result_ty, object);
+                } else if (mem.eql(u8, field_name, "len")) {
+                    const result_ty = Type.initTag(.usize);
+                    if (try sema.resolveMaybeUndefVal(block, object_src, object)) |val| {
+                        if (val.isUndef()) return sema.addConstUndef(result_ty);
+                        return sema.addConstant(
+                            result_ty,
+                            try Value.Tag.int_u64.create(arena, val.sliceLen()),
+                        );
+                    }
+                    try sema.requireRuntimeBlock(block, src);
+                    return block.addTyOp(.slice_len, result_ty, object);
+                } else {
+                    return mod.fail(
+                        &block.base,
+                        field_name_src,
+                        "no member named '{s}' in '{}'",
+                        .{ field_name, object_ty },
+                    );
+                }
+            },
+            .One => {
+                const elem_ty = object_ty.elemType();
+                if (elem_ty.zigTypeTag() == .Array) {
+                    if (mem.eql(u8, field_name, "len")) {
+                        return sema.addConstant(
+                            Type.initTag(.comptime_int),
+                            try Value.Tag.int_u64.create(arena, elem_ty.arrayLen()),
+                        );
+                    } else {
+                        return mod.fail(
+                            &block.base,
+                            field_name_src,
+                            "no member named '{s}' in '{}'",
+                            .{ field_name, object_ty },
+                        );
+                    }
+                }
+            },
+            .Many, .C => {},
+        },
+        .Type => {
+            const val = (try sema.resolveDefinedValue(block, object_src, object)).?;
+            const child_type = try val.toType(arena);
+            switch (child_type.zigTypeTag()) {
+                .ErrorSet => {
+                    // TODO resolve inferred error sets
+                    const name: []const u8 = if (child_type.castTag(.error_set)) |payload| blk: {
+                        const error_set = payload.data;
+                        // TODO this is O(N). I'm putting off solving this until we solve inferred
+                        // error sets at the same time.
+                        const names = error_set.names_ptr[0..error_set.names_len];
+                        for (names) |name| {
+                            if (mem.eql(u8, field_name, name)) {
+                                break :blk name;
+                            }
+                        }
+                        return mod.fail(&block.base, src, "no error named '{s}' in '{}'", .{
+                            field_name, child_type,
+                        });
+                    } else (try mod.getErrorValue(field_name)).key;
+
+                    return sema.addConstant(
+                        child_type,
+                        try Value.Tag.@"error".create(arena, .{ .name = name }),
+                    );
+                },
+                .Struct, .Opaque, .Union => {
+                    if (child_type.getNamespace()) |namespace| {
+                        if (try sema.namespaceLookupRef(block, src, namespace, field_name)) |inst| {
+                            return sema.analyzeLoad(block, src, inst, src);
+                        }
+                    }
+                    // TODO add note: declared here
+                    const kw_name = switch (child_type.zigTypeTag()) {
+                        .Struct => "struct",
+                        .Opaque => "opaque",
+                        .Union => "union",
+                        else => unreachable,
+                    };
+                    return mod.fail(&block.base, src, "{s} '{}' has no member named '{s}'", .{
+                        kw_name, child_type, field_name,
+                    });
+                },
+                .Enum => {
+                    if (child_type.getNamespace()) |namespace| {
+                        if (try sema.namespaceLookupRef(block, src, namespace, field_name)) |inst| {
+                            return sema.analyzeLoad(block, src, inst, src);
+                        }
+                    }
+                    const field_index = child_type.enumFieldIndex(field_name) orelse {
+                        const msg = msg: {
+                            const msg = try mod.errMsg(
+                                &block.base,
+                                src,
+                                "enum '{}' has no member named '{s}'",
+                                .{ child_type, field_name },
+                            );
+                            errdefer msg.destroy(sema.gpa);
+                            try mod.errNoteNonLazy(
+                                child_type.declSrcLoc(),
+                                msg,
+                                "enum declared here",
+                                .{},
+                            );
+                            break :msg msg;
+                        };
+                        return mod.failWithOwnedErrorMsg(&block.base, msg);
+                    };
+                    const field_index_u32 = @intCast(u32, field_index);
+                    const enum_val = try Value.Tag.enum_field_index.create(arena, field_index_u32);
+                    return sema.addConstant(child_type, enum_val);
+                },
+                else => return mod.fail(&block.base, src, "type '{}' has no members", .{child_type}),
+            }
+        },
+        .Struct => return sema.structFieldVal(block, src, object, field_name, field_name_src, object_ty),
+        .Union => return sema.unionFieldVal(block, src, object, field_name, field_name_src, object_ty),
+        else => {},
+    }
+    return mod.fail(&block.base, src, "type '{}' does not support field access", .{object_ty});
+}
+
+fn fieldPtr(
     sema: *Sema,
     block: *Scope.Block,
     src: LazySrcLoc,
@@ -6573,23 +6741,25 @@ fn namedFieldPtr(
     field_name: []const u8,
     field_name_src: LazySrcLoc,
 ) CompileError!Air.Inst.Ref {
+    // When editing this function, note that there is corresponding logic to be edited
+    // in `fieldVal`. This function takes a pointer and returns a pointer.
+
     const mod = sema.mod;
     const arena = sema.arena;
-
     const object_ptr_src = src; // TODO better source location
     const object_ptr_ty = sema.typeOf(object_ptr);
-    const elem_ty = switch (object_ptr_ty.zigTypeTag()) {
+    const object_ty = switch (object_ptr_ty.zigTypeTag()) {
         .Pointer => object_ptr_ty.elemType(),
         else => return mod.fail(&block.base, object_ptr_src, "expected pointer, found '{}'", .{object_ptr_ty}),
     };
-    switch (elem_ty.zigTypeTag()) {
+    switch (object_ty.zigTypeTag()) {
         .Array => {
             if (mem.eql(u8, field_name, "len")) {
                 return sema.addConstant(
                     Type.initTag(.single_const_pointer_to_comptime_int),
                     try Value.Tag.ref_val.create(
                         arena,
-                        try Value.Tag.int_u64.create(arena, elem_ty.arrayLen()),
+                        try Value.Tag.int_u64.create(arena, object_ty.arrayLen()),
                     ),
                 );
             } else {
@@ -6597,33 +6767,33 @@ fn namedFieldPtr(
                     &block.base,
                     field_name_src,
                     "no member named '{s}' in '{}'",
-                    .{ field_name, elem_ty },
+                    .{ field_name, object_ty },
                 );
             }
         },
         .Pointer => {
-            const ptr_child = elem_ty.elemType();
+            const ptr_child = object_ty.elemType();
             if (ptr_child.isSlice()) {
                 if (mem.eql(u8, field_name, "ptr")) {
                     return mod.fail(
                         &block.base,
                         field_name_src,
                         "cannot obtain reference to pointer field of slice '{}'",
-                        .{elem_ty},
+                        .{object_ty},
                     );
                 } else if (mem.eql(u8, field_name, "len")) {
                     return mod.fail(
                         &block.base,
                         field_name_src,
                         "cannot obtain reference to length field of slice '{}'",
-                        .{elem_ty},
+                        .{object_ty},
                     );
                 } else {
                     return mod.fail(
                         &block.base,
                         field_name_src,
                         "no member named '{s}' in '{}'",
-                        .{ field_name, elem_ty },
+                        .{ field_name, object_ty },
                     );
                 }
             } else switch (ptr_child.zigTypeTag()) {
@@ -6641,7 +6811,7 @@ fn namedFieldPtr(
                             &block.base,
                             field_name_src,
                             "no member named '{s}' in '{}'",
-                            .{ field_name, elem_ty },
+                            .{ field_name, object_ty },
                         );
                     }
                 },
@@ -6684,7 +6854,7 @@ fn namedFieldPtr(
                 },
                 .Struct, .Opaque, .Union => {
                     if (child_type.getNamespace()) |namespace| {
-                        if (try sema.analyzeNamespaceLookup(block, src, namespace, field_name)) |inst| {
+                        if (try sema.namespaceLookupRef(block, src, namespace, field_name)) |inst| {
                             return inst;
                         }
                     }
@@ -6701,7 +6871,7 @@ fn namedFieldPtr(
                 },
                 .Enum => {
                     if (child_type.getNamespace()) |namespace| {
-                        if (try sema.analyzeNamespaceLookup(block, src, namespace, field_name)) |inst| {
+                        if (try sema.namespaceLookupRef(block, src, namespace, field_name)) |inst| {
                             return inst;
                         }
                     }
@@ -6734,20 +6904,20 @@ fn namedFieldPtr(
                 else => return mod.fail(&block.base, src, "type '{}' has no members", .{child_type}),
             }
         },
-        .Struct => return sema.analyzeStructFieldPtr(block, src, object_ptr, field_name, field_name_src, elem_ty),
-        .Union => return sema.analyzeUnionFieldPtr(block, src, object_ptr, field_name, field_name_src, elem_ty),
+        .Struct => return sema.structFieldPtr(block, src, object_ptr, field_name, field_name_src, object_ty),
+        .Union => return sema.unionFieldPtr(block, src, object_ptr, field_name, field_name_src, object_ty),
         else => {},
     }
-    return mod.fail(&block.base, src, "type '{}' does not support field access", .{elem_ty});
+    return mod.fail(&block.base, src, "type '{}' does not support field access", .{object_ty});
 }
 
-fn analyzeNamespaceLookup(
+fn namespaceLookup(
     sema: *Sema,
     block: *Scope.Block,
     src: LazySrcLoc,
     namespace: *Scope.Namespace,
     decl_name: []const u8,
-) CompileError!?Air.Inst.Ref {
+) CompileError!?*Decl {
     const mod = sema.mod;
     const gpa = sema.gpa;
     if (try sema.lookupInNamespace(namespace, decl_name)) |decl| {
@@ -6762,12 +6932,23 @@ fn analyzeNamespaceLookup(
             };
             return mod.failWithOwnedErrorMsg(&block.base, msg);
         }
-        return try sema.analyzeDeclRef(block, src, decl);
+        return decl;
     }
     return null;
 }
 
-fn analyzeStructFieldPtr(
+fn namespaceLookupRef(
+    sema: *Sema,
+    block: *Scope.Block,
+    src: LazySrcLoc,
+    namespace: *Scope.Namespace,
+    decl_name: []const u8,
+) CompileError!?Air.Inst.Ref {
+    const decl = (try sema.namespaceLookup(block, src, namespace, decl_name)) orelse return null;
+    return try sema.analyzeDeclRef(block, src, decl);
+}
+
+fn structFieldPtr(
     sema: *Sema,
     block: *Scope.Block,
     src: LazySrcLoc,
@@ -6803,14 +6984,52 @@ fn analyzeStructFieldPtr(
         .data = .{ .ty_pl = .{
             .ty = try sema.addType(ptr_field_ty),
             .payload = try sema.addExtra(Air.StructField{
-                .struct_ptr = struct_ptr,
+                .struct_operand = struct_ptr,
                 .field_index = @intCast(u32, field_index),
             }),
         } },
     });
 }
 
-fn analyzeUnionFieldPtr(
+fn structFieldVal(
+    sema: *Sema,
+    block: *Scope.Block,
+    src: LazySrcLoc,
+    struct_byval: Air.Inst.Ref,
+    field_name: []const u8,
+    field_name_src: LazySrcLoc,
+    unresolved_struct_ty: Type,
+) CompileError!Air.Inst.Ref {
+    assert(unresolved_struct_ty.zigTypeTag() == .Struct);
+
+    const struct_ty = try sema.resolveTypeFields(block, src, unresolved_struct_ty);
+    const struct_obj = struct_ty.castTag(.@"struct").?.data;
+
+    const field_index = struct_obj.fields.getIndex(field_name) orelse
+        return sema.failWithBadFieldAccess(block, struct_obj, field_name_src, field_name);
+    const field = struct_obj.fields.values()[field_index];
+
+    if (try sema.resolveMaybeUndefVal(block, src, struct_byval)) |struct_val| {
+        if (struct_val.isUndef()) return sema.addConstUndef(field.ty);
+
+        const field_values = struct_val.castTag(.@"struct").?.data;
+        return sema.addConstant(field.ty, field_values[field_index]);
+    }
+
+    try sema.requireRuntimeBlock(block, src);
+    return block.addInst(.{
+        .tag = .struct_field_val,
+        .data = .{ .ty_pl = .{
+            .ty = try sema.addType(field.ty),
+            .payload = try sema.addExtra(Air.StructField{
+                .struct_operand = struct_byval,
+                .field_index = @intCast(u32, field_index),
+            }),
+        } },
+    });
+}
+
+fn unionFieldPtr(
     sema: *Sema,
     block: *Scope.Block,
     src: LazySrcLoc,
@@ -6847,6 +7066,37 @@ fn analyzeUnionFieldPtr(
     return mod.fail(&block.base, src, "TODO implement runtime union field access", .{});
 }
 
+fn unionFieldVal(
+    sema: *Sema,
+    block: *Scope.Block,
+    src: LazySrcLoc,
+    union_byval: Air.Inst.Ref,
+    field_name: []const u8,
+    field_name_src: LazySrcLoc,
+    unresolved_union_ty: Type,
+) CompileError!Air.Inst.Ref {
+    assert(unresolved_union_ty.zigTypeTag() == .Union);
+
+    const union_ty = try sema.resolveTypeFields(block, src, unresolved_union_ty);
+    const union_obj = union_ty.cast(Type.Payload.Union).?.data;
+
+    const field_index = union_obj.fields.getIndex(field_name) orelse
+        return sema.failWithBadUnionFieldAccess(block, union_obj, field_name_src, field_name);
+
+    const field = union_obj.fields.values()[field_index];
+
+    if (try sema.resolveMaybeUndefVal(block, src, union_byval)) |union_val| {
+        if (union_val.isUndef()) return sema.addConstUndef(field.ty);
+
+        // TODO detect inactive union field and emit compile error
+        const active_val = union_val.castTag(.@"union").?.data.val;
+        return sema.addConstant(field.ty, active_val);
+    }
+
+    try sema.requireRuntimeBlock(block, src);
+    return sema.mod.fail(&block.base, src, "TODO implement runtime union field access", .{});
+}
+
 fn elemPtr(
     sema: *Sema,
     block: *Scope.Block,
@@ -6973,7 +7223,7 @@ fn coerce(
     const arena = sema.arena;
 
     // undefined to anything
-    if (try sema.resolvePossiblyUndefinedValue(block, inst_src, inst)) |val| {
+    if (try sema.resolveMaybeUndefVal(block, inst_src, inst)) |val| {
         if (val.isUndef() or inst_ty.zigTypeTag() == .Undefined) {
             return sema.addConstant(dest_type, val);
         }
@@ -7207,8 +7457,8 @@ fn storePtr(
     if ((try sema.typeHasOnePossibleValue(block, src, elem_ty)) != null)
         return;
 
-    if (try sema.resolvePossiblyUndefinedValue(block, src, ptr)) |ptr_val| blk: {
-        const const_val = (try sema.resolvePossiblyUndefinedValue(block, src, value)) orelse
+    if (try sema.resolveMaybeUndefVal(block, src, ptr)) |ptr_val| blk: {
+        const const_val = (try sema.resolveMaybeUndefVal(block, src, value)) orelse
             return sema.mod.fail(&block.base, src, "cannot store runtime value in compile time variable", .{});
 
         if (ptr_val.tag() == .int_u64)
@@ -7252,7 +7502,7 @@ fn bitcast(
     inst: Air.Inst.Ref,
     inst_src: LazySrcLoc,
 ) CompileError!Air.Inst.Ref {
-    if (try sema.resolvePossiblyUndefinedValue(block, inst_src, inst)) |val| {
+    if (try sema.resolveMaybeUndefVal(block, inst_src, inst)) |val| {
         // Keep the comptime Value representation; take the new type.
         return sema.addConstant(dest_type, val);
     }
@@ -7358,7 +7608,7 @@ fn analyzeRef(
     const operand_ty = sema.typeOf(operand);
     const ptr_type = try Module.simplePtrType(sema.arena, operand_ty, false, .One);
 
-    if (try sema.resolvePossiblyUndefinedValue(block, src, operand)) |val| {
+    if (try sema.resolveMaybeUndefVal(block, src, operand)) |val| {
         return sema.addConstant(ptr_type, try Value.Tag.ref_val.create(sema.arena, val));
     }
 
@@ -7395,7 +7645,7 @@ fn analyzeSliceLen(
     src: LazySrcLoc,
     slice_inst: Air.Inst.Ref,
 ) CompileError!Air.Inst.Ref {
-    if (try sema.resolvePossiblyUndefinedValue(block, src, slice_inst)) |slice_val| {
+    if (try sema.resolveMaybeUndefVal(block, src, slice_inst)) |slice_val| {
         if (slice_val.isUndef()) {
             return sema.addConstUndef(Type.initTag(.usize));
         }
@@ -7413,7 +7663,7 @@ fn analyzeIsNull(
     invert_logic: bool,
 ) CompileError!Air.Inst.Ref {
     const result_ty = Type.initTag(.bool);
-    if (try sema.resolvePossiblyUndefinedValue(block, src, operand)) |opt_val| {
+    if (try sema.resolveMaybeUndefVal(block, src, operand)) |opt_val| {
         if (opt_val.isUndef()) {
             return sema.addConstUndef(result_ty);
         }
@@ -7442,7 +7692,7 @@ fn analyzeIsNonErr(
     if (ot == .ErrorSet) return Air.Inst.Ref.bool_false;
     assert(ot == .ErrorUnion);
     const result_ty = Type.initTag(.bool);
-    if (try sema.resolvePossiblyUndefinedValue(block, src, operand)) |err_union| {
+    if (try sema.resolveMaybeUndefVal(block, src, operand)) |err_union| {
         if (err_union.isUndef()) {
             return sema.addConstUndef(result_ty);
         }
@@ -7567,8 +7817,8 @@ fn cmpNumeric(
         });
     }
 
-    if (try sema.resolvePossiblyUndefinedValue(block, lhs_src, lhs)) |lhs_val| {
-        if (try sema.resolvePossiblyUndefinedValue(block, rhs_src, rhs)) |rhs_val| {
+    if (try sema.resolveMaybeUndefVal(block, lhs_src, lhs)) |lhs_val| {
+        if (try sema.resolveMaybeUndefVal(block, rhs_src, rhs)) |rhs_val| {
             if (lhs_val.isUndef() or rhs_val.isUndef()) {
                 return sema.addConstUndef(Type.initTag(.bool));
             }
@@ -7635,7 +7885,7 @@ fn cmpNumeric(
     var dest_float_type: ?Type = null;
 
     var lhs_bits: usize = undefined;
-    if (try sema.resolvePossiblyUndefinedValue(block, lhs_src, lhs)) |lhs_val| {
+    if (try sema.resolveMaybeUndefVal(block, lhs_src, lhs)) |lhs_val| {
         if (lhs_val.isUndef())
             return sema.addConstUndef(Type.initTag(.bool));
         const is_unsigned = if (lhs_is_float) x: {
@@ -7670,7 +7920,7 @@ fn cmpNumeric(
     }
 
     var rhs_bits: usize = undefined;
-    if (try sema.resolvePossiblyUndefinedValue(block, rhs_src, rhs)) |rhs_val| {
+    if (try sema.resolveMaybeUndefVal(block, rhs_src, rhs)) |rhs_val| {
         if (rhs_val.isUndef())
             return sema.addConstUndef(Type.initTag(.bool));
         const is_unsigned = if (rhs_is_float) x: {
@@ -7725,7 +7975,7 @@ fn wrapOptional(
     inst: Air.Inst.Ref,
     inst_src: LazySrcLoc,
 ) !Air.Inst.Ref {
-    if (try sema.resolvePossiblyUndefinedValue(block, inst_src, inst)) |val| {
+    if (try sema.resolveMaybeUndefVal(block, inst_src, inst)) |val| {
         return sema.addConstant(dest_type, val);
     }
 
@@ -7743,7 +7993,7 @@ fn wrapErrorUnion(
     const inst_ty = sema.typeOf(inst);
     const dest_err_set_ty = dest_type.errorUnionSet();
     const dest_payload_ty = dest_type.errorUnionPayload();
-    if (try sema.resolvePossiblyUndefinedValue(block, inst_src, inst)) |val| {
+    if (try sema.resolveMaybeUndefVal(block, inst_src, inst)) |val| {
         if (inst_ty.zigTypeTag() != .ErrorSet) {
             _ = try sema.coerce(block, dest_payload_ty, inst, inst_src);
         } else switch (dest_err_set_ty.tag()) {
@@ -7956,7 +8206,7 @@ fn getBuiltin(
     const mod = sema.mod;
     const std_pkg = mod.main_pkg.table.get("std").?;
     const std_file = (mod.importPkg(std_pkg) catch unreachable).file;
-    const opt_builtin_inst = try sema.analyzeNamespaceLookup(
+    const opt_builtin_inst = try sema.namespaceLookupRef(
         block,
         src,
         std_file.root_decl.?.namespace,
@@ -7964,7 +8214,7 @@ fn getBuiltin(
     );
     const builtin_inst = try sema.analyzeLoad(block, src, opt_builtin_inst.?, src);
     const builtin_ty = try sema.analyzeAsType(block, src, builtin_inst);
-    const opt_ty_inst = try sema.analyzeNamespaceLookup(
+    const opt_ty_inst = try sema.namespaceLookupRef(
         block,
         src,
         builtin_ty.getNamespace().?,
@@ -8320,5 +8570,5 @@ fn isComptimeKnown(
     src: LazySrcLoc,
     inst: Air.Inst.Ref,
 ) !bool {
-    return (try sema.resolvePossiblyUndefinedValue(block, src, inst)) != null;
+    return (try sema.resolveMaybeUndefVal(block, src, inst)) != null;
 }
diff --git a/src/codegen.zig b/src/codegen.zig
index c2504f26a8..4924b68ca3 100644
--- a/src/codegen.zig
+++ b/src/codegen.zig
@@ -851,6 +851,7 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
                     .ret             => try self.airRet(inst),
                     .store           => try self.airStore(inst),
                     .struct_field_ptr=> try self.airStructFieldPtr(inst),
+                    .struct_field_val=> try self.airStructFieldVal(inst),
                     .switch_br       => try self.airSwitch(inst),
                     .varptr          => try self.airVarPtr(inst),
                     .slice_ptr       => try self.airSlicePtr(inst),
@@ -1501,6 +1502,14 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
             //return self.finishAir(inst, result, .{ extra.struct_ptr, .none, .none });
         }
 
+        fn airStructFieldVal(self: *Self, inst: Air.Inst.Index) !void {
+            const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+            const extra = self.air.extraData(Air.StructField, ty_pl.payload).data;
+            _ = extra;
+            return self.fail("TODO implement codegen struct_field_val", .{});
+            //return self.finishAir(inst, result, .{ extra.struct_ptr, .none, .none });
+        }
+
         fn armOperandShouldBeRegister(self: *Self, mcv: MCValue) !bool {
             return switch (mcv) {
                 .none => unreachable,
diff --git a/src/codegen/c.zig b/src/codegen/c.zig
index 705c5c2ad1..fa254af293 100644
--- a/src/codegen/c.zig
+++ b/src/codegen/c.zig
@@ -935,6 +935,7 @@ fn genBody(o: *Object, body: []const Air.Inst.Index) error{ AnalysisFail, OutOfM
             .wrap_optional    => try airWrapOptional(o, inst),
             .ref              => try airRef(o, inst),
             .struct_field_ptr => try airStructFieldPtr(o, inst),
+            .struct_field_val => try airStructFieldVal(o, inst),
             .varptr           => try airVarPtr(o, inst),
             .slice_ptr        => try airSliceField(o, inst, ".ptr;\n"),
             .slice_len        => try airSliceField(o, inst, ".len;\n"),
@@ -1660,8 +1661,8 @@ fn airStructFieldPtr(o: *Object, inst: Air.Inst.Index) !CValue {
     const ty_pl = o.air.instructions.items(.data)[inst].ty_pl;
     const extra = o.air.extraData(Air.StructField, ty_pl.payload).data;
     const writer = o.writer();
-    const struct_ptr = try o.resolveInst(extra.struct_ptr);
-    const struct_ptr_ty = o.air.typeOf(extra.struct_ptr);
+    const struct_ptr = try o.resolveInst(extra.struct_operand);
+    const struct_ptr_ty = o.air.typeOf(extra.struct_operand);
     const struct_obj = struct_ptr_ty.elemType().castTag(.@"struct").?.data;
     const field_name = struct_obj.fields.keys()[extra.field_index];
 
@@ -1680,6 +1681,26 @@ fn airStructFieldPtr(o: *Object, inst: Air.Inst.Index) !CValue {
     return local;
 }
 
+fn airStructFieldVal(o: *Object, inst: Air.Inst.Index) !CValue {
+    if (o.liveness.isUnused(inst))
+        return CValue.none;
+
+    const ty_pl = o.air.instructions.items(.data)[inst].ty_pl;
+    const extra = o.air.extraData(Air.StructField, ty_pl.payload).data;
+    const writer = o.writer();
+    const struct_byval = try o.resolveInst(extra.struct_operand);
+    const struct_ty = o.air.typeOf(extra.struct_operand);
+    const struct_obj = struct_ty.castTag(.@"struct").?.data;
+    const field_name = struct_obj.fields.keys()[extra.field_index];
+
+    const inst_ty = o.air.typeOfIndex(inst);
+    const local = try o.allocLocal(inst_ty, .Const);
+    try writer.writeAll(" = ");
+    try o.writeCValue(writer, struct_byval);
+    try writer.print(".{};\n", .{fmtIdent(field_name)});
+    return local;
+}
+
 // *(E!T) -> E NOT *E
 fn airUnwrapErrUnionErr(o: *Object, inst: Air.Inst.Index) !CValue {
     if (o.liveness.isUnused(inst))
diff --git a/src/codegen/llvm.zig b/src/codegen/llvm.zig
index 4224591b0b..1b3c36fc69 100644
--- a/src/codegen/llvm.zig
+++ b/src/codegen/llvm.zig
@@ -350,19 +350,21 @@ pub const Object = struct {
         air: Air,
         liveness: Liveness,
     ) !void {
+        const decl = func.owner_decl;
+
         var dg: DeclGen = .{
             .context = self.context,
             .object = self,
             .module = module,
-            .decl = func.owner_decl,
+            .decl = decl,
             .err_msg = null,
             .gpa = module.gpa,
         };
 
-        const llvm_func = try dg.resolveLLVMFunction(func.owner_decl);
+        const llvm_func = try dg.resolveLlvmFunction(decl);
 
         // This gets the LLVM values from the function and stores them in `dg.args`.
-        const fn_param_len = func.owner_decl.ty.fnParamLen();
+        const fn_param_len = decl.ty.fnParamLen();
         var args = try dg.gpa.alloc(*const llvm.Value, fn_param_len);
 
         for (args) |*arg, i| {
@@ -400,13 +402,16 @@ pub const Object = struct {
 
         fg.genBody(air.getMainBody()) catch |err| switch (err) {
             error.CodegenFail => {
-                func.owner_decl.analysis = .codegen_failure;
-                try module.failed_decls.put(module.gpa, func.owner_decl, dg.err_msg.?);
+                decl.analysis = .codegen_failure;
+                try module.failed_decls.put(module.gpa, decl, dg.err_msg.?);
                 dg.err_msg = null;
                 return;
             },
             else => |e| return e,
         };
+
+        const decl_exports = module.decl_exports.get(decl) orelse &[0]*Module.Export{};
+        try self.updateDeclExports(module, decl, decl_exports);
     }
 
     pub fn updateDecl(self: *Object, module: *Module, decl: *Module.Decl) !void {
@@ -428,6 +433,38 @@ pub const Object = struct {
             else => |e| return e,
         };
     }
+
+    pub fn updateDeclExports(
+        self: *Object,
+        module: *const Module,
+        decl: *const Module.Decl,
+        exports: []const *Module.Export,
+    ) !void {
+        const llvm_fn = self.llvm_module.getNamedFunction(decl.name).?;
+        const is_extern = decl.val.tag() == .extern_fn;
+        if (is_extern or exports.len != 0) {
+            llvm_fn.setLinkage(.External);
+            llvm_fn.setUnnamedAddr(.False);
+        } else {
+            llvm_fn.setLinkage(.Internal);
+            llvm_fn.setUnnamedAddr(.True);
+        }
+        // TODO LLVM C API does not support deleting aliases. We need to
+        // patch it to support this or figure out how to wrap the C++ API ourselves.
+        // Until then we iterate over existing aliases and make them point
+        // to the correct decl, or otherwise add a new alias. Old aliases are leaked.
+        for (exports) |exp| {
+            if (self.llvm_module.getNamedGlobalAlias(exp.options.name.ptr, exp.options.name.len)) |alias| {
+                alias.setAliasee(llvm_fn);
+            } else {
+                const exp_name_z = try module.gpa.dupeZ(u8, exp.options.name);
+                defer module.gpa.free(exp_name_z);
+
+                const alias = self.llvm_module.addAlias(llvm_fn.typeOf(), llvm_fn, exp_name_z);
+                _ = alias;
+            }
+        }
+    }
 };
 
 pub const DeclGen = struct {
@@ -461,21 +498,19 @@ pub const DeclGen = struct {
             _ = func_payload;
             @panic("TODO llvm backend genDecl function pointer");
         } else if (decl.val.castTag(.extern_fn)) |extern_fn| {
-            _ = try self.resolveLLVMFunction(extern_fn.data);
+            _ = try self.resolveLlvmFunction(extern_fn.data);
         } else {
             _ = try self.resolveGlobalDecl(decl);
         }
     }
 
     /// If the llvm function does not exist, create it
-    fn resolveLLVMFunction(self: *DeclGen, func: *Module.Decl) !*const llvm.Value {
-        // TODO: do we want to store this in our own datastructure?
-        if (self.llvmModule().getNamedFunction(func.name)) |llvm_fn| return llvm_fn;
+    fn resolveLlvmFunction(self: *DeclGen, decl: *Module.Decl) !*const llvm.Value {
+        if (self.llvmModule().getNamedFunction(decl.name)) |llvm_fn| return llvm_fn;
 
-        assert(func.has_tv);
-        const zig_fn_type = func.ty;
+        assert(decl.has_tv);
+        const zig_fn_type = decl.ty;
         const return_type = zig_fn_type.fnReturnType();
-
         const fn_param_len = zig_fn_type.fnParamLen();
 
         const fn_param_types = try self.gpa.alloc(Type, fn_param_len);
@@ -495,9 +530,17 @@ pub const DeclGen = struct {
             @intCast(c_uint, fn_param_len),
             .False,
         );
-        const llvm_fn = self.llvmModule().addFunction(func.name, fn_type);
+        const llvm_fn = self.llvmModule().addFunction(decl.name, fn_type);
 
-        if (return_type.tag() == .noreturn) {
+        const is_extern = decl.val.tag() == .extern_fn;
+        if (!is_extern) {
+            llvm_fn.setLinkage(.Internal);
+            llvm_fn.setUnnamedAddr(.True);
+        }
+
+        // TODO: calling convention, linkage, tsan, etc. see codegen.cpp `make_fn_llvm_value`.
+
+        if (return_type.isNoReturn()) {
             self.addFnAttr(llvm_fn, "noreturn");
         }
 
@@ -505,7 +548,6 @@ pub const DeclGen = struct {
     }
 
     fn resolveGlobalDecl(self: *DeclGen, decl: *Module.Decl) error{ OutOfMemory, CodegenFail }!*const llvm.Value {
-        // TODO: do we want to store this in our own datastructure?
         if (self.llvmModule().getNamedGlobal(decl.name)) |val| return val;
 
         assert(decl.has_tv);
@@ -515,9 +557,11 @@ pub const DeclGen = struct {
         const global = self.llvmModule().addGlobal(llvm_type, decl.name);
         const init_val = if (decl.val.castTag(.variable)) |payload| init_val: {
             const variable = payload.data;
-            global.setGlobalConstant(.False);
             break :init_val variable.init;
-        } else decl.val;
+        } else init_val: {
+            global.setGlobalConstant(.True);
+            break :init_val decl.val;
+        };
 
         const llvm_init = try self.genTypedValue(.{ .ty = decl.ty, .val = init_val }, null);
         llvm.setInitializer(global, llvm_init);
@@ -602,12 +646,13 @@ pub const DeclGen = struct {
                     llvm_param.* = try self.llvmType(t.fnParamType(i));
                 }
                 const is_var_args = t.fnIsVarArgs();
-                return llvm.functionType(
+                const llvm_fn_ty = llvm.functionType(
                     ret_ty,
                     llvm_params.ptr,
                     @intCast(c_uint, llvm_params.len),
                     llvm.Bool.fromBool(is_var_args),
                 );
+                return llvm_fn_ty.pointerType(0);
             },
             .ComptimeInt => unreachable,
             .ComptimeFloat => unreachable,
@@ -717,6 +762,42 @@ pub const DeclGen = struct {
                     return self.todo("implement const of optional pointer", .{});
                 }
             },
+            .Fn => {
+                const fn_decl = if (tv.val.castTag(.extern_fn)) |extern_fn|
+                    extern_fn.data
+                else if (tv.val.castTag(.function)) |func_payload|
+                    func_payload.data.owner_decl
+                else
+                    unreachable;
+
+                return self.resolveLlvmFunction(fn_decl);
+            },
+            .ErrorSet => {
+                const llvm_ty = try self.llvmType(tv.ty);
+                switch (tv.val.tag()) {
+                    .@"error" => {
+                        const err_name = tv.val.castTag(.@"error").?.data.name;
+                        const kv = try self.module.getErrorValue(err_name);
+                        return llvm_ty.constInt(kv.value, .False);
+                    },
+                    else => {
+                        // In this case we are rendering an error union which has a 0 bits payload.
+                        return llvm_ty.constNull();
+                    },
+                }
+            },
+            .ErrorUnion => {
+                const error_type = tv.ty.errorUnionSet();
+                const payload_type = tv.ty.errorUnionPayload();
+                const sub_val = tv.val.castTag(.error_union).?.data;
+
+                if (!payload_type.hasCodeGenBits()) {
+                    // We use the error type directly as the type.
+                    return self.genTypedValue(.{ .ty = error_type, .val = sub_val }, fg);
+                }
+
+                return self.todo("implement error union const of type '{}'", .{tv.ty});
+            },
             else => return self.todo("implement const of type '{}'", .{tv.ty}),
         }
     }
@@ -801,8 +882,17 @@ pub const FuncGen = struct {
         for (body) |inst| {
             const opt_value: ?*const llvm.Value = switch (air_tags[inst]) {
                 // zig fmt: off
-                .add => try self.airAdd(inst),
-                .sub => try self.airSub(inst),
+                .add     => try self.airAdd(inst, false),
+                .addwrap => try self.airAdd(inst, true),
+                .sub     => try self.airSub(inst, false),
+                .subwrap => try self.airSub(inst, true),
+                .mul     => try self.airMul(inst, false),
+                .mulwrap => try self.airMul(inst, true),
+                .div     => try self.airDiv(inst),
+
+                .bit_and, .bool_and => try self.airAnd(inst),
+                .bit_or, .bool_or   => try self.airOr(inst),
+                .xor                => try self.airXor(inst),
 
                 .cmp_eq  => try self.airCmp(inst, .eq),
                 .cmp_gt  => try self.airCmp(inst, .gt),
@@ -825,10 +915,12 @@ pub const FuncGen = struct {
                 .bitcast    => try self.airBitCast(inst),
                 .block      => try self.airBlock(inst),
                 .br         => try self.airBr(inst),
+                .switch_br  => try self.airSwitchBr(inst),
                 .breakpoint => try self.airBreakpoint(inst),
                 .call       => try self.airCall(inst),
                 .cond_br    => try self.airCondBr(inst),
                 .intcast    => try self.airIntCast(inst),
+                .floatcast  => try self.airFloatCast(inst),
                 .ptrtoint   => try self.airPtrToInt(inst),
                 .load       => try self.airLoad(inst),
                 .loop       => try self.airLoop(inst),
@@ -840,6 +932,9 @@ pub const FuncGen = struct {
                 .slice_ptr  => try self.airSliceField(inst, 0),
                 .slice_len  => try self.airSliceField(inst, 1),
 
+                .struct_field_ptr => try self.airStructFieldPtr(inst),
+                .struct_field_val => try self.airStructFieldVal(inst),
+
                 .slice_elem_val     => try self.airSliceElemVal(inst, false),
                 .ptr_slice_elem_val => try self.airSliceElemVal(inst, true),
 
@@ -851,12 +946,18 @@ pub const FuncGen = struct {
                 .unwrap_errunion_err         => try self.airErrUnionErr(inst, false),
                 .unwrap_errunion_err_ptr     => try self.airErrUnionErr(inst, true),
 
+                .wrap_optional         => try self.airWrapOptional(inst),
+                .wrap_errunion_payload => try self.airWrapErrUnionPayload(inst),
+                .wrap_errunion_err     => try self.airWrapErrUnionErr(inst),
+
+                .constant => unreachable,
+                .const_ty => unreachable,
+                .ref => unreachable, // TODO eradicate this instruction
                 .unreach  => self.airUnreach(inst),
                 .dbg_stmt => blk: {
                     // TODO: implement debug info
                     break :blk null;
                 },
-                else => |tag| return self.todo("implement AIR instruction: {}", .{tag}),
                 // zig fmt: on
             };
             if (opt_value) |val| try self.func_inst_table.putNoClobber(self.gpa, inst, val);
@@ -867,47 +968,32 @@ pub const FuncGen = struct {
         const pl_op = self.air.instructions.items(.data)[inst].pl_op;
         const extra = self.air.extraData(Air.Call, pl_op.payload);
         const args = @bitCast([]const Air.Inst.Ref, self.air.extra[extra.end..][0..extra.data.args_len]);
+        const zig_fn_type = self.air.typeOf(pl_op.operand);
+        const return_type = zig_fn_type.fnReturnType();
+        const llvm_fn = try self.resolveInst(pl_op.operand);
 
-        if (self.air.value(pl_op.operand)) |func_value| {
-            const fn_decl = if (func_value.castTag(.extern_fn)) |extern_fn|
-                extern_fn.data
-            else if (func_value.castTag(.function)) |func_payload|
-                func_payload.data.owner_decl
-            else
-                unreachable;
+        const llvm_param_vals = try self.gpa.alloc(*const llvm.Value, args.len);
+        defer self.gpa.free(llvm_param_vals);
 
-            assert(fn_decl.has_tv);
-            const zig_fn_type = fn_decl.ty;
-            const llvm_fn = try self.dg.resolveLLVMFunction(fn_decl);
-
-            const llvm_param_vals = try self.gpa.alloc(*const llvm.Value, args.len);
-            defer self.gpa.free(llvm_param_vals);
-
-            for (args) |arg, i| {
-                llvm_param_vals[i] = try self.resolveInst(arg);
-            }
-
-            // TODO: LLVMBuildCall2 handles opaque function pointers, according to llvm docs
-            //       Do we need that?
-            const call = self.builder.buildCall(
-                llvm_fn,
-                llvm_param_vals.ptr,
-                @intCast(c_uint, args.len),
-                "",
-            );
-
-            const return_type = zig_fn_type.fnReturnType();
-            if (return_type.tag() == .noreturn) {
-                _ = self.builder.buildUnreachable();
-            }
-
-            // No need to store the LLVM value if the return type is void or noreturn
-            if (!return_type.hasCodeGenBits()) return null;
-
-            return call;
-        } else {
-            return self.todo("implement calling runtime known function pointer", .{});
+        for (args) |arg, i| {
+            llvm_param_vals[i] = try self.resolveInst(arg);
         }
+
+        const call = self.builder.buildCall(
+            llvm_fn,
+            llvm_param_vals.ptr,
+            @intCast(c_uint, args.len),
+            "",
+        );
+
+        if (return_type.isNoReturn()) {
+            _ = self.builder.buildUnreachable();
+        }
+
+        // No need to store the LLVM value if the return type is void or noreturn
+        if (!return_type.hasCodeGenBits()) return null;
+
+        return call;
     }
 
     fn airRet(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
@@ -1026,6 +1112,11 @@ pub const FuncGen = struct {
         return null;
     }
 
+    fn airSwitchBr(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+        _ = inst;
+        return self.todo("implement llvm codegen for switch_br", .{});
+    }
+
     fn airLoop(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
         const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
         const loop = self.air.extraData(Air.Block, ty_pl.payload);
@@ -1082,10 +1173,32 @@ pub const FuncGen = struct {
         };
 
         const indices: [1]*const llvm.Value = .{rhs};
-        const ptr = self.builder.buildInBoundsGEP(base_ptr, &indices, 1, "");
+        const ptr = self.builder.buildInBoundsGEP(base_ptr, &indices, indices.len, "");
         return self.builder.buildLoad(ptr, "");
     }
 
+    fn airStructFieldPtr(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+        if (self.liveness.isUnused(inst))
+            return null;
+
+        const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+        const struct_field = self.air.extraData(Air.StructField, ty_pl.payload).data;
+        const struct_ptr = try self.resolveInst(struct_field.struct_operand);
+        const field_index = @intCast(c_uint, struct_field.field_index);
+        return self.builder.buildStructGEP(struct_ptr, field_index, "");
+    }
+
+    fn airStructFieldVal(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+        if (self.liveness.isUnused(inst))
+            return null;
+
+        const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
+        const struct_field = self.air.extraData(Air.StructField, ty_pl.payload).data;
+        const struct_byval = try self.resolveInst(struct_field.struct_operand);
+        const field_index = @intCast(c_uint, struct_field.field_index);
+        return self.builder.buildExtractValue(struct_byval, field_index, "");
+    }
+
     fn airNot(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
         if (self.liveness.isUnused(inst))
             return null;
@@ -1321,7 +1434,7 @@ pub const FuncGen = struct {
 
         _ = operand;
         _ = operand_is_ptr;
-        return self.todo("implement 'airErrUnionPayload' for type {}", .{self.air.typeOf(ty_op.operand)});
+        return self.todo("implement llvm codegen for 'airErrUnionPayload' for type {}", .{self.air.typeOf(ty_op.operand)});
     }
 
     fn airErrUnionErr(
@@ -1332,42 +1445,123 @@ pub const FuncGen = struct {
         if (self.liveness.isUnused(inst))
             return null;
 
-        _ = operand_is_ptr;
-        return self.todo("implement 'airErrUnionErr'", .{});
+        const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+        const operand = try self.resolveInst(ty_op.operand);
+        const operand_ty = self.air.typeOf(ty_op.operand);
+
+        const payload_ty = operand_ty.errorUnionPayload();
+        if (!payload_ty.hasCodeGenBits()) {
+            if (!operand_is_ptr) return operand;
+            return self.builder.buildLoad(operand, "");
+        }
+        return self.todo("implement llvm codegen for 'airErrUnionErr'", .{});
     }
 
-    fn airAdd(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+    fn airWrapOptional(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
         if (self.liveness.isUnused(inst))
             return null;
+
+        return self.todo("implement llvm codegen for 'airWrapOptional'", .{});
+    }
+
+    fn airWrapErrUnionPayload(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+        if (self.liveness.isUnused(inst))
+            return null;
+
+        return self.todo("implement llvm codegen for 'airWrapErrUnionPayload'", .{});
+    }
+
+    fn airWrapErrUnionErr(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+        if (self.liveness.isUnused(inst))
+            return null;
+
+        return self.todo("implement llvm codegen for 'airWrapErrUnionErr'", .{});
+    }
+
+    fn airAdd(self: *FuncGen, inst: Air.Inst.Index, wrap: bool) !?*const llvm.Value {
+        if (self.liveness.isUnused(inst))
+            return null;
+
         const bin_op = self.air.instructions.items(.data)[inst].bin_op;
         const lhs = try self.resolveInst(bin_op.lhs);
         const rhs = try self.resolveInst(bin_op.rhs);
         const inst_ty = self.air.typeOfIndex(inst);
 
-        if (!inst_ty.isInt())
-            return self.todo("implement 'airAdd' for type {}", .{inst_ty});
-
-        return if (inst_ty.isSignedInt())
-            self.builder.buildNSWAdd(lhs, rhs, "")
-        else
-            self.builder.buildNUWAdd(lhs, rhs, "");
+        if (inst_ty.isFloat()) return self.builder.buildFAdd(lhs, rhs, "");
+        if (wrap) return self.builder.buildAdd(lhs, rhs, "");
+        if (inst_ty.isSignedInt()) return self.builder.buildNSWAdd(lhs, rhs, "");
+        return self.builder.buildNUWAdd(lhs, rhs, "");
     }
 
-    fn airSub(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+    fn airSub(self: *FuncGen, inst: Air.Inst.Index, wrap: bool) !?*const llvm.Value {
         if (self.liveness.isUnused(inst))
             return null;
+
         const bin_op = self.air.instructions.items(.data)[inst].bin_op;
         const lhs = try self.resolveInst(bin_op.lhs);
         const rhs = try self.resolveInst(bin_op.rhs);
         const inst_ty = self.air.typeOfIndex(inst);
 
-        if (!inst_ty.isInt())
-            return self.todo("implement 'airSub' for type {}", .{inst_ty});
+        if (inst_ty.isFloat()) return self.builder.buildFSub(lhs, rhs, "");
+        if (wrap) return self.builder.buildSub(lhs, rhs, "");
+        if (inst_ty.isSignedInt()) return self.builder.buildNSWSub(lhs, rhs, "");
+        return self.builder.buildNUWSub(lhs, rhs, "");
+    }
 
-        return if (inst_ty.isSignedInt())
-            self.builder.buildNSWSub(lhs, rhs, "")
-        else
-            self.builder.buildNUWSub(lhs, rhs, "");
+    fn airMul(self: *FuncGen, inst: Air.Inst.Index, wrap: bool) !?*const llvm.Value {
+        if (self.liveness.isUnused(inst))
+            return null;
+
+        const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+        const lhs = try self.resolveInst(bin_op.lhs);
+        const rhs = try self.resolveInst(bin_op.rhs);
+        const inst_ty = self.air.typeOfIndex(inst);
+
+        if (inst_ty.isFloat()) return self.builder.buildFMul(lhs, rhs, "");
+        if (wrap) return self.builder.buildMul(lhs, rhs, "");
+        if (inst_ty.isSignedInt()) return self.builder.buildNSWMul(lhs, rhs, "");
+        return self.builder.buildNUWMul(lhs, rhs, "");
+    }
+
+    fn airDiv(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+        if (self.liveness.isUnused(inst))
+            return null;
+
+        const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+        const lhs = try self.resolveInst(bin_op.lhs);
+        const rhs = try self.resolveInst(bin_op.rhs);
+        const inst_ty = self.air.typeOfIndex(inst);
+
+        if (inst_ty.isFloat()) return self.builder.buildFDiv(lhs, rhs, "");
+        if (inst_ty.isSignedInt()) return self.builder.buildSDiv(lhs, rhs, "");
+        return self.builder.buildUDiv(lhs, rhs, "");
+    }
+
+    fn airAnd(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+        if (self.liveness.isUnused(inst))
+            return null;
+        const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+        const lhs = try self.resolveInst(bin_op.lhs);
+        const rhs = try self.resolveInst(bin_op.rhs);
+        return self.builder.buildAnd(lhs, rhs, "");
+    }
+
+    fn airOr(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+        if (self.liveness.isUnused(inst))
+            return null;
+        const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+        const lhs = try self.resolveInst(bin_op.lhs);
+        const rhs = try self.resolveInst(bin_op.rhs);
+        return self.builder.buildOr(lhs, rhs, "");
+    }
+
+    fn airXor(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+        if (self.liveness.isUnused(inst))
+            return null;
+        const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+        const lhs = try self.resolveInst(bin_op.lhs);
+        const rhs = try self.resolveInst(bin_op.rhs);
+        return self.builder.buildXor(lhs, rhs, "");
     }
 
     fn airIntCast(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
@@ -1384,6 +1578,14 @@ pub const FuncGen = struct {
         return self.builder.buildIntCast2(operand, try self.dg.llvmType(inst_ty), llvm.Bool.fromBool(signed), "");
     }
 
+    fn airFloatCast(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+        if (self.liveness.isUnused(inst))
+            return null;
+
+        // TODO split floatcast AIR into float_widen and float_shorten
+        return self.todo("implement 'airFloatCast'", .{});
+    }
+
     fn airPtrToInt(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
         if (self.liveness.isUnused(inst))
             return null;
@@ -1474,8 +1676,8 @@ pub const FuncGen = struct {
 
     fn airBreakpoint(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
         _ = inst;
-        const llvn_fn = self.getIntrinsic("llvm.debugtrap");
-        _ = self.builder.buildCall(llvn_fn, undefined, 0, "");
+        const llvm_fn = self.getIntrinsic("llvm.debugtrap");
+        _ = self.builder.buildCall(llvm_fn, undefined, 0, "");
         return null;
     }
 
diff --git a/src/codegen/llvm/bindings.zig b/src/codegen/llvm/bindings.zig
index 3b76361030..9ef6d7e1ac 100644
--- a/src/codegen/llvm/bindings.zig
+++ b/src/codegen/llvm/bindings.zig
@@ -82,6 +82,24 @@ pub const Value = opaque {
 
     pub const setGlobalConstant = LLVMSetGlobalConstant;
     extern fn LLVMSetGlobalConstant(GlobalVar: *const Value, IsConstant: Bool) void;
+
+    pub const setLinkage = LLVMSetLinkage;
+    extern fn LLVMSetLinkage(Global: *const Value, Linkage: Linkage) void;
+
+    pub const setUnnamedAddr = LLVMSetUnnamedAddr;
+    extern fn LLVMSetUnnamedAddr(Global: *const Value, HasUnnamedAddr: Bool) void;
+
+    pub const deleteGlobal = LLVMDeleteGlobal;
+    extern fn LLVMDeleteGlobal(GlobalVar: *const Value) void;
+
+    pub const getNextGlobalAlias = LLVMGetNextGlobalAlias;
+    extern fn LLVMGetNextGlobalAlias(GA: *const Value) *const Value;
+
+    pub const getAliasee = LLVMAliasGetAliasee;
+    extern fn LLVMAliasGetAliasee(Alias: *const Value) *const Value;
+
+    pub const setAliasee = LLVMAliasSetAliasee;
+    extern fn LLVMAliasSetAliasee(Alias: *const Value, Aliasee: *const Value) void;
 };
 
 pub const Type = opaque {
@@ -145,6 +163,27 @@ pub const Module = opaque {
 
     pub const dump = LLVMDumpModule;
     extern fn LLVMDumpModule(M: *const Module) void;
+
+    pub const getFirstGlobalAlias = LLVMGetFirstGlobalAlias;
+    extern fn LLVMGetFirstGlobalAlias(M: *const Module) *const Value;
+
+    pub const getLastGlobalAlias = LLVMGetLastGlobalAlias;
+    extern fn LLVMGetLastGlobalAlias(M: *const Module) *const Value;
+
+    pub const addAlias = LLVMAddAlias;
+    extern fn LLVMAddAlias(
+        M: *const Module,
+        Ty: *const Type,
+        Aliasee: *const Value,
+        Name: [*:0]const u8,
+    ) *const Value;
+
+    pub const getNamedGlobalAlias = LLVMGetNamedGlobalAlias;
+    extern fn LLVMGetNamedGlobalAlias(
+        M: *const Module,
+        Name: [*]const u8,
+        NameLen: usize,
+    ) ?*const Value;
 };
 
 pub const lookupIntrinsicID = LLVMLookupIntrinsicID;
@@ -252,18 +291,60 @@ pub const Builder = opaque {
     pub const buildNot = LLVMBuildNot;
     extern fn LLVMBuildNot(*const Builder, V: *const Value, Name: [*:0]const u8) *const Value;
 
+    pub const buildFAdd = LLVMBuildFAdd;
+    extern fn LLVMBuildFAdd(*const Builder, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
+
+    pub const buildAdd = LLVMBuildAdd;
+    extern fn LLVMBuildAdd(*const Builder, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
+
     pub const buildNSWAdd = LLVMBuildNSWAdd;
     extern fn LLVMBuildNSWAdd(*const Builder, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
 
     pub const buildNUWAdd = LLVMBuildNUWAdd;
     extern fn LLVMBuildNUWAdd(*const Builder, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
 
+    pub const buildFSub = LLVMBuildFSub;
+    extern fn LLVMBuildFSub(*const Builder, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
+
+    pub const buildSub = LLVMBuildSub;
+    extern fn LLVMBuildSub(*const Builder, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
+
     pub const buildNSWSub = LLVMBuildNSWSub;
     extern fn LLVMBuildNSWSub(*const Builder, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
 
     pub const buildNUWSub = LLVMBuildNUWSub;
     extern fn LLVMBuildNUWSub(*const Builder, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
 
+    pub const buildFMul = LLVMBuildFMul;
+    extern fn LLVMBuildFMul(*const Builder, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
+
+    pub const buildMul = LLVMBuildMul;
+    extern fn LLVMBuildMul(*const Builder, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
+
+    pub const buildNSWMul = LLVMBuildNSWMul;
+    extern fn LLVMBuildNSWMul(*const Builder, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
+
+    pub const buildNUWMul = LLVMBuildNUWMul;
+    extern fn LLVMBuildNUWMul(*const Builder, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
+
+    pub const buildUDiv = LLVMBuildUDiv;
+    extern fn LLVMBuildUDiv(*const Builder, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
+
+    pub const buildSDiv = LLVMBuildSDiv;
+    extern fn LLVMBuildSDiv(*const Builder, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
+
+    pub const buildFDiv = LLVMBuildFDiv;
+    extern fn LLVMBuildFDiv(*const Builder, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
+
+    pub const buildAnd = LLVMBuildAnd;
+    extern fn LLVMBuildAnd(*const Builder, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
+
+    pub const buildOr = LLVMBuildOr;
+    extern fn LLVMBuildOr(*const Builder, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
+
+    pub const buildXor = LLVMBuildXor;
+    extern fn LLVMBuildXor(*const Builder, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
+
     pub const buildIntCast2 = LLVMBuildIntCast2;
     extern fn LLVMBuildIntCast2(*const Builder, Val: *const Value, DestTy: *const Type, IsSigned: Bool, Name: [*:0]const u8) *const Value;
 
@@ -279,6 +360,16 @@ pub const Builder = opaque {
         Name: [*:0]const u8,
     ) *const Value;
 
+    pub const buildInBoundsGEP2 = LLVMBuildInBoundsGEP2;
+    extern fn LLVMBuildInBoundsGEP2(
+        B: *const Builder,
+        Ty: *const Type,
+        Pointer: *const Value,
+        Indices: [*]const *const Value,
+        NumIndices: c_uint,
+        Name: [*:0]const u8,
+    ) *const Value;
+
     pub const buildICmp = LLVMBuildICmp;
     extern fn LLVMBuildICmp(*const Builder, Op: IntPredicate, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
 
@@ -292,10 +383,28 @@ pub const Builder = opaque {
     extern fn LLVMBuildPhi(*const Builder, Ty: *const Type, Name: [*:0]const u8) *const Value;
 
     pub const buildExtractValue = LLVMBuildExtractValue;
-    extern fn LLVMBuildExtractValue(*const Builder, AggVal: *const Value, Index: c_uint, Name: [*:0]const u8) *const Value;
+    extern fn LLVMBuildExtractValue(
+        *const Builder,
+        AggVal: *const Value,
+        Index: c_uint,
+        Name: [*:0]const u8,
+    ) *const Value;
 
     pub const buildPtrToInt = LLVMBuildPtrToInt;
-    extern fn LLVMBuildPtrToInt(*const Builder, Val: *const Value, DestTy: *const Type, Name: [*:0]const u8) *const Value;
+    extern fn LLVMBuildPtrToInt(
+        *const Builder,
+        Val: *const Value,
+        DestTy: *const Type,
+        Name: [*:0]const u8,
+    ) *const Value;
+
+    pub const buildStructGEP = LLVMBuildStructGEP;
+    extern fn LLVMBuildStructGEP(
+        B: *const Builder,
+        Pointer: *const Value,
+        Idx: c_uint,
+        Name: [*:0]const u8,
+    ) *const Value;
 };
 
 pub const IntPredicate = enum(c_int) {
@@ -715,3 +824,23 @@ extern fn ZigLLVMWriteImportLibrary(
     output_lib_path: [*c]const u8,
     kill_at: bool,
 ) bool;
+
+pub const Linkage = enum(c_uint) {
+    External,
+    AvailableExternally,
+    LinkOnceAny,
+    LinkOnceODR,
+    LinkOnceODRAutoHide,
+    WeakAny,
+    WeakODR,
+    Appending,
+    Internal,
+    Private,
+    DLLImport,
+    DLLExport,
+    ExternalWeak,
+    Ghost,
+    Common,
+    LinkerPrivate,
+    LinkerPrivateWeak,
+};
diff --git a/src/codegen/wasm.zig b/src/codegen/wasm.zig
index ca0d53988d..bf9010fbff 100644
--- a/src/codegen/wasm.zig
+++ b/src/codegen/wasm.zig
@@ -1306,7 +1306,7 @@ pub const Context = struct {
     fn airStructFieldPtr(self: *Context, inst: Air.Inst.Index) InnerError!WValue {
         const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
         const extra = self.air.extraData(Air.StructField, ty_pl.payload);
-        const struct_ptr = self.resolveInst(extra.data.struct_ptr);
+        const struct_ptr = self.resolveInst(extra.data.struct_operand);
 
         return WValue{ .local = struct_ptr.multi_value.index + @intCast(u32, extra.data.field_index) };
     }
diff --git a/src/link/Coff.zig b/src/link/Coff.zig
index 0bae2cc6cc..0c9e513742 100644
--- a/src/link/Coff.zig
+++ b/src/link/Coff.zig
@@ -777,8 +777,18 @@ pub fn freeDecl(self: *Coff, decl: *Module.Decl) void {
     self.offset_table_free_list.append(self.base.allocator, decl.link.coff.offset_table_index) catch {};
 }
 
-pub fn updateDeclExports(self: *Coff, module: *Module, decl: *Module.Decl, exports: []const *Module.Export) !void {
-    if (self.llvm_object) |_| return;
+pub fn updateDeclExports(
+    self: *Coff,
+    module: *Module,
+    decl: *Module.Decl,
+    exports: []const *Module.Export,
+) !void {
+    if (build_options.skip_non_native and builtin.object_format != .coff) {
+        @panic("Attempted to compile for object format that was disabled by build configuration");
+    }
+    if (build_options.have_llvm) {
+        if (self.llvm_object) |llvm_object| return llvm_object.updateDeclExports(module, decl, exports);
+    }
 
     for (exports) |exp| {
         if (exp.options.section) |section_name| {
diff --git a/src/link/Elf.zig b/src/link/Elf.zig
index c95af23026..502575f3c8 100644
--- a/src/link/Elf.zig
+++ b/src/link/Elf.zig
@@ -2716,7 +2716,12 @@ pub fn updateDeclExports(
     decl: *Module.Decl,
     exports: []const *Module.Export,
 ) !void {
-    if (self.llvm_object) |_| return;
+    if (build_options.skip_non_native and builtin.object_format != .elf) {
+        @panic("Attempted to compile for object format that was disabled by build configuration");
+    }
+    if (build_options.have_llvm) {
+        if (self.llvm_object) |llvm_object| return llvm_object.updateDeclExports(module, decl, exports);
+    }
 
     const tracy = trace(@src());
     defer tracy.end();
diff --git a/src/link/MachO.zig b/src/link/MachO.zig
index 21f4e9c33c..1f2e0616ba 100644
--- a/src/link/MachO.zig
+++ b/src/link/MachO.zig
@@ -3785,6 +3785,12 @@ pub fn updateDeclExports(
     decl: *Module.Decl,
     exports: []const *Module.Export,
 ) !void {
+    if (build_options.skip_non_native and builtin.object_format != .macho) {
+        @panic("Attempted to compile for object format that was disabled by build configuration");
+    }
+    if (build_options.have_llvm) {
+        if (self.llvm_object) |llvm_object| return llvm_object.updateDeclExports(module, decl, exports);
+    }
     const tracy = trace(@src());
     defer tracy.end();
 
diff --git a/src/link/Wasm.zig b/src/link/Wasm.zig
index 2ed6576033..23d0543494 100644
--- a/src/link/Wasm.zig
+++ b/src/link/Wasm.zig
@@ -330,10 +330,12 @@ pub fn updateDeclExports(
     decl: *const Module.Decl,
     exports: []const *Module.Export,
 ) !void {
-    _ = self;
-    _ = module;
-    _ = decl;
-    _ = exports;
+    if (build_options.skip_non_native and builtin.object_format != .wasm) {
+        @panic("Attempted to compile for object format that was disabled by build configuration");
+    }
+    if (build_options.have_llvm) {
+        if (self.llvm_object) |llvm_object| return llvm_object.updateDeclExports(module, decl, exports);
+    }
 }
 
 pub fn freeDecl(self: *Wasm, decl: *Module.Decl) void {
diff --git a/src/print_air.zig b/src/print_air.zig
index 2c756670ad..c20a6995e5 100644
--- a/src/print_air.zig
+++ b/src/print_air.zig
@@ -171,7 +171,8 @@ const Writer = struct {
             .loop,
             => try w.writeBlock(s, inst),
 
-            .struct_field_ptr => try w.writeStructFieldPtr(s, inst),
+            .struct_field_ptr => try w.writeStructField(s, inst),
+            .struct_field_val => try w.writeStructField(s, inst),
             .varptr => try w.writeVarPtr(s, inst),
             .constant => try w.writeConstant(s, inst),
             .assembly => try w.writeAssembly(s, inst),
@@ -233,11 +234,11 @@ const Writer = struct {
         try s.writeAll("}");
     }
 
-    fn writeStructFieldPtr(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
+    fn writeStructField(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
         const ty_pl = w.air.instructions.items(.data)[inst].ty_pl;
         const extra = w.air.extraData(Air.StructField, ty_pl.payload);
 
-        try w.writeOperand(s, inst, 0, extra.data.struct_ptr);
+        try w.writeOperand(s, inst, 0, extra.data.struct_operand);
         try s.print(", {d}", .{extra.data.field_index});
     }
 

From ba71b96fe6c0e01b8445a2f7bd49541a07c360db Mon Sep 17 00:00:00 2001
From: Jarred Sumner <jarred@jarredsumner.com>
Date: Mon, 26 Jul 2021 18:42:28 -0700
Subject: [PATCH 04/96] Add zld.id to list of files to skip

---
 lib/std/build.zig | 1 +
 1 file changed, 1 insertion(+)

diff --git a/lib/std/build.zig b/lib/std/build.zig
index 36a71d5061..cf592f2016 100644
--- a/lib/std/build.zig
+++ b/lib/std/build.zig
@@ -2802,6 +2802,7 @@ pub const LibExeObjStep = struct {
                         mem.eql(u8, entry.name, "llvm-ar.id") or
                         mem.eql(u8, entry.name, "libs.txt") or
                         mem.eql(u8, entry.name, "builtin.zig") or
+                        mem.eql(u8, entry.name, "zld.id") or
                         mem.eql(u8, entry.name, "lld.id")) continue;
 
                     _ = try src_dir.updateFile(entry.name, dest_dir, entry.name, .{});

From a8e964eadd3496330043985cacaaee7db92886c6 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Tue, 27 Jul 2021 14:06:42 -0700
Subject: [PATCH 05/96] stage2: `zig test` now works with the LLVM backend

Frontend improvements:

 * When compiling in `zig test` mode, put a task on the work queue to
   analyze the main package root file. Normally, start code does
   `_ = import("root");` to make Zig analyze the user's code, however in
   the case of `zig test`, the root source file is the test runner.
   Without this change, no tests are picked up.
 * In the main pipeline, once semantic analysis is finished, if there
   are no compile errors, populate the `test_functions` Decl with the
   set of test functions picked up from semantic analysis.
 * Value: add `array` and `slice` Tags.

LLVM backend improvements:

 * Fix incremental updates of globals. Previously the
   value of a global would not get replaced with a new value.
 * Fix LLVM type of arrays. They were incorrectly sending
   the ABI size as the element count.
 * Remove the FuncGen parameter from genTypedValue. This function is for
   generating global constants and there is no function available when
   it is being called.
   - The `ref_val` case is now commented out. I'd like to eliminate
     `ref_val` as one of the possible Value Tags. Instead it should
     always be done via `decl_ref`.
 * Implement constant value generation for slices, arrays, and structs.
 * Constant value generation for functions supports the `decl_ref` tag.
---
 src/Compilation.zig           |  34 ++++-----
 src/Module.zig                | 135 ++++++++++++++++++++++++++++++----
 src/codegen/llvm.zig          | 134 ++++++++++++++++++++++-----------
 src/codegen/llvm/bindings.zig |  16 +++-
 src/type.zig                  |  22 ++++++
 src/value.zig                 |  73 ++++++++++++++++--
 6 files changed, 332 insertions(+), 82 deletions(-)

diff --git a/src/Compilation.zig b/src/Compilation.zig
index a34d0cd198..00cdba85a4 100644
--- a/src/Compilation.zig
+++ b/src/Compilation.zig
@@ -1709,7 +1709,9 @@ pub fn update(self: *Compilation) !void {
         // in the start code, but when using the stage1 backend that won't happen,
         // so in order to run AstGen on the root source file we put it into the
         // import_table here.
-        if (use_stage1) {
+        // Likewise, in the case of `zig test`, the test runner is the root source file,
+        // and so there is nothing to import the main file.
+        if (use_stage1 or self.bin_file.options.is_test) {
             _ = try module.importPkg(module.main_pkg);
         }
 
@@ -1725,6 +1727,9 @@ pub fn update(self: *Compilation) !void {
 
         if (!use_stage1) {
             try self.work_queue.writeItem(.{ .analyze_pkg = std_pkg });
+            if (self.bin_file.options.is_test) {
+                try self.work_queue.writeItem(.{ .analyze_pkg = module.main_pkg });
+            }
         }
     }
 
@@ -2053,24 +2058,7 @@ pub fn performAllTheWork(self: *Compilation) error{ TimerUnsupported, OutOfMemor
                 assert(decl.has_tv);
                 assert(decl.ty.hasCodeGenBits());
 
-                self.bin_file.updateDecl(module, decl) catch |err| switch (err) {
-                    error.OutOfMemory => return error.OutOfMemory,
-                    error.AnalysisFail => {
-                        decl.analysis = .codegen_failure;
-                        continue;
-                    },
-                    else => {
-                        try module.failed_decls.ensureUnusedCapacity(gpa, 1);
-                        module.failed_decls.putAssumeCapacityNoClobber(decl, try Module.ErrorMsg.create(
-                            gpa,
-                            decl.srcLoc(),
-                            "unable to codegen: {s}",
-                            .{@errorName(err)},
-                        ));
-                        decl.analysis = .codegen_failure_retryable;
-                        continue;
-                    },
-                };
+                try module.linkerUpdateDecl(decl);
             },
         },
         .codegen_func => |func| switch (func.owner_decl.analysis) {
@@ -2396,6 +2384,14 @@ pub fn performAllTheWork(self: *Compilation) error{ TimerUnsupported, OutOfMemor
             };
         },
     };
+
+    if (self.bin_file.options.is_test and self.totalErrorCount() == 0) {
+        // The `test_functions` decl has been intentionally postponed until now,
+        // at which point we must populate it with the list of test functions that
+        // have been discovered and not filtered out.
+        const mod = self.bin_file.options.module.?;
+        try mod.populateTestFunctions();
+    }
 }
 
 const AstGenSrc = union(enum) {
diff --git a/src/Module.zig b/src/Module.zig
index 99f314c5cb..4ddce33655 100644
--- a/src/Module.zig
+++ b/src/Module.zig
@@ -112,6 +112,8 @@ compile_log_text: ArrayListUnmanaged(u8) = .{},
 
 emit_h: ?*GlobalEmitH,
 
+test_functions: std.AutoArrayHashMapUnmanaged(*Decl, void) = .{},
+
 /// A `Module` has zero or one of these depending on whether `-femit-h` is enabled.
 pub const GlobalEmitH = struct {
     /// Where to put the output.
@@ -282,6 +284,7 @@ pub const Decl = struct {
     pub fn destroy(decl: *Decl, module: *Module) void {
         const gpa = module.gpa;
         log.debug("destroy {*} ({s})", .{ decl, decl.name });
+        _ = module.test_functions.swapRemove(decl);
         if (decl.deletion_flag) {
             assert(module.deletion_set.swapRemove(decl));
         }
@@ -3319,6 +3322,7 @@ fn scanDecl(iter: *ScanDeclIter, decl_sub_index: usize, flags: u4) SemaError!voi
                 // the test name filter.
                 if (!mod.comp.bin_file.options.is_test) break :blk false;
                 if (decl_pkg != mod.main_pkg) break :blk false;
+                try mod.test_functions.put(gpa, new_decl, {});
                 break :blk true;
             },
             else => blk: {
@@ -3326,6 +3330,7 @@ fn scanDecl(iter: *ScanDeclIter, decl_sub_index: usize, flags: u4) SemaError!voi
                 if (!mod.comp.bin_file.options.is_test) break :blk false;
                 if (decl_pkg != mod.main_pkg) break :blk false;
                 // TODO check the name against --test-filter
+                try mod.test_functions.put(gpa, new_decl, {});
                 break :blk true;
             },
         };
@@ -3765,17 +3770,38 @@ pub fn createAnonymousDeclNamed(
     scope: *Scope,
     typed_value: TypedValue,
     name: [:0]u8,
+) !*Decl {
+    return mod.createAnonymousDeclFromDeclNamed(scope.ownerDecl().?, typed_value, name);
+}
+
+pub fn createAnonymousDecl(mod: *Module, scope: *Scope, typed_value: TypedValue) !*Decl {
+    return mod.createAnonymousDeclFromDecl(scope.ownerDecl().?, typed_value);
+}
+
+pub fn createAnonymousDeclFromDecl(mod: *Module, owner_decl: *Decl, tv: TypedValue) !*Decl {
+    const name_index = mod.getNextAnonNameIndex();
+    const name = try std.fmt.allocPrintZ(mod.gpa, "{s}__anon_{d}", .{
+        owner_decl.name, name_index,
+    });
+    return mod.createAnonymousDeclFromDeclNamed(owner_decl, tv, name);
+}
+
+/// Takes ownership of `name` even if it returns an error.
+pub fn createAnonymousDeclFromDeclNamed(
+    mod: *Module,
+    owner_decl: *Decl,
+    typed_value: TypedValue,
+    name: [:0]u8,
 ) !*Decl {
     errdefer mod.gpa.free(name);
 
-    const scope_decl = scope.ownerDecl().?;
-    const namespace = scope_decl.namespace;
+    const namespace = owner_decl.namespace;
     try namespace.anon_decls.ensureUnusedCapacity(mod.gpa, 1);
 
-    const new_decl = try mod.allocateNewDecl(namespace, scope_decl.src_node);
+    const new_decl = try mod.allocateNewDecl(namespace, owner_decl.src_node);
 
     new_decl.name = name;
-    new_decl.src_line = scope_decl.src_line;
+    new_decl.src_line = owner_decl.src_line;
     new_decl.ty = typed_value.ty;
     new_decl.val = typed_value.val;
     new_decl.has_tv = true;
@@ -3796,15 +3822,6 @@ pub fn createAnonymousDeclNamed(
     return new_decl;
 }
 
-pub fn createAnonymousDecl(mod: *Module, scope: *Scope, typed_value: TypedValue) !*Decl {
-    const scope_decl = scope.ownerDecl().?;
-    const name_index = mod.getNextAnonNameIndex();
-    const name = try std.fmt.allocPrintZ(mod.gpa, "{s}__anon_{d}", .{
-        scope_decl.name, name_index,
-    });
-    return mod.createAnonymousDeclNamed(scope, typed_value, name);
-}
-
 pub fn getNextAnonNameIndex(mod: *Module) usize {
     return @atomicRmw(usize, &mod.next_anon_name_index, .Add, 1, .Monotonic);
 }
@@ -4801,3 +4818,95 @@ pub fn processExports(mod: *Module) !void {
         };
     }
 }
+
+pub fn populateTestFunctions(mod: *Module) !void {
+    const gpa = mod.gpa;
+    const builtin_pkg = mod.main_pkg.table.get("builtin").?;
+    const builtin_file = (mod.importPkg(builtin_pkg) catch unreachable).file;
+    const builtin_namespace = builtin_file.root_decl.?.namespace;
+    const decl = builtin_namespace.decls.get("test_functions").?;
+    var buf: Type.Payload.ElemType = undefined;
+    const tmp_test_fn_ty = decl.ty.slicePtrFieldType(&buf).elemType();
+
+    const array_decl = d: {
+        // Add mod.test_functions to an array decl then make the test_functions
+        // decl reference it as a slice.
+        var new_decl_arena = std.heap.ArenaAllocator.init(gpa);
+        errdefer new_decl_arena.deinit();
+        const arena = &new_decl_arena.allocator;
+
+        const test_fn_vals = try arena.alloc(Value, mod.test_functions.count());
+        const array_decl = try mod.createAnonymousDeclFromDecl(decl, .{
+            .ty = try Type.Tag.array.create(arena, .{
+                .len = test_fn_vals.len,
+                .elem_type = try tmp_test_fn_ty.copy(arena),
+            }),
+            .val = try Value.Tag.array.create(arena, test_fn_vals),
+        });
+        for (mod.test_functions.keys()) |test_decl, i| {
+            const test_name_slice = mem.sliceTo(test_decl.name, 0);
+            const test_name_decl = n: {
+                var name_decl_arena = std.heap.ArenaAllocator.init(gpa);
+                errdefer name_decl_arena.deinit();
+                const bytes = try name_decl_arena.allocator.dupe(u8, test_name_slice);
+                const test_name_decl = try mod.createAnonymousDeclFromDecl(array_decl, .{
+                    .ty = try Type.Tag.array_u8.create(&name_decl_arena.allocator, bytes.len),
+                    .val = try Value.Tag.bytes.create(&name_decl_arena.allocator, bytes),
+                });
+                try test_name_decl.finalizeNewArena(&name_decl_arena);
+                break :n test_name_decl;
+            };
+            try mod.linkerUpdateDecl(test_name_decl);
+
+            const field_vals = try arena.create([3]Value);
+            field_vals.* = .{
+                try Value.Tag.slice.create(arena, .{
+                    .ptr = try Value.Tag.decl_ref.create(arena, test_name_decl),
+                    .len = try Value.Tag.int_u64.create(arena, test_name_slice.len),
+                }), // name
+                try Value.Tag.decl_ref.create(arena, test_decl), // func
+                Value.initTag(.null_value), // async_frame_size
+            };
+            test_fn_vals[i] = try Value.Tag.@"struct".create(arena, field_vals);
+        }
+
+        try array_decl.finalizeNewArena(&new_decl_arena);
+        break :d array_decl;
+    };
+    try mod.linkerUpdateDecl(array_decl);
+
+    {
+        var arena_instance = decl.value_arena.?.promote(gpa);
+        defer decl.value_arena.?.* = arena_instance.state;
+        const arena = &arena_instance.allocator;
+
+        decl.ty = try Type.Tag.const_slice.create(arena, try tmp_test_fn_ty.copy(arena));
+        decl.val = try Value.Tag.slice.create(arena, .{
+            .ptr = try Value.Tag.decl_ref.create(arena, array_decl),
+            .len = try Value.Tag.int_u64.create(arena, mod.test_functions.count()),
+        });
+    }
+    try mod.linkerUpdateDecl(decl);
+}
+
+pub fn linkerUpdateDecl(mod: *Module, decl: *Decl) !void {
+    mod.comp.bin_file.updateDecl(mod, decl) catch |err| switch (err) {
+        error.OutOfMemory => return error.OutOfMemory,
+        error.AnalysisFail => {
+            decl.analysis = .codegen_failure;
+            return;
+        },
+        else => {
+            const gpa = mod.gpa;
+            try mod.failed_decls.ensureUnusedCapacity(gpa, 1);
+            mod.failed_decls.putAssumeCapacityNoClobber(decl, try ErrorMsg.create(
+                gpa,
+                decl.srcLoc(),
+                "unable to codegen: {s}",
+                .{@errorName(err)},
+            ));
+            decl.analysis = .codegen_failure_retryable;
+            return;
+        },
+    };
+}
diff --git a/src/codegen/llvm.zig b/src/codegen/llvm.zig
index 1b3c36fc69..2468b1dbde 100644
--- a/src/codegen/llvm.zig
+++ b/src/codegen/llvm.zig
@@ -500,7 +500,18 @@ pub const DeclGen = struct {
         } else if (decl.val.castTag(.extern_fn)) |extern_fn| {
             _ = try self.resolveLlvmFunction(extern_fn.data);
         } else {
-            _ = try self.resolveGlobalDecl(decl);
+            const global = try self.resolveGlobalDecl(decl);
+            assert(decl.has_tv);
+            const init_val = if (decl.val.castTag(.variable)) |payload| init_val: {
+                const variable = payload.data;
+                break :init_val variable.init;
+            } else init_val: {
+                global.setGlobalConstant(.True);
+                break :init_val decl.val;
+            };
+
+            const llvm_init = try self.genTypedValue(.{ .ty = decl.ty, .val = init_val });
+            llvm.setInitializer(global, llvm_init);
         }
     }
 
@@ -548,25 +559,11 @@ pub const DeclGen = struct {
     }
 
     fn resolveGlobalDecl(self: *DeclGen, decl: *Module.Decl) error{ OutOfMemory, CodegenFail }!*const llvm.Value {
-        if (self.llvmModule().getNamedGlobal(decl.name)) |val| return val;
-
-        assert(decl.has_tv);
-
+        const llvm_module = self.object.llvm_module;
+        if (llvm_module.getNamedGlobal(decl.name)) |val| return val;
         // TODO: remove this redundant `llvmType`, it is also called in `genTypedValue`.
         const llvm_type = try self.llvmType(decl.ty);
-        const global = self.llvmModule().addGlobal(llvm_type, decl.name);
-        const init_val = if (decl.val.castTag(.variable)) |payload| init_val: {
-            const variable = payload.data;
-            break :init_val variable.init;
-        } else init_val: {
-            global.setGlobalConstant(.True);
-            break :init_val decl.val;
-        };
-
-        const llvm_init = try self.genTypedValue(.{ .ty = decl.ty, .val = init_val }, null);
-        llvm.setInitializer(global, llvm_init);
-
-        return global;
+        return llvm_module.addGlobal(llvm_type, decl.name);
     }
 
     fn llvmType(self: *DeclGen, t: Type) error{ OutOfMemory, CodegenFail }!*const llvm.Type {
@@ -596,7 +593,8 @@ pub const DeclGen = struct {
             },
             .Array => {
                 const elem_type = try self.llvmType(t.elemType());
-                return elem_type.arrayType(@intCast(c_uint, t.abiSize(self.module.getTarget())));
+                const total_len = t.arrayLen() + @boolToInt(t.sentinel() != null);
+                return elem_type.arrayType(@intCast(c_uint, total_len));
             },
             .Optional => {
                 if (!t.isPtrLikeOptional()) {
@@ -674,8 +672,7 @@ pub const DeclGen = struct {
         }
     }
 
-    // TODO: figure out a way to remove the FuncGen argument
-    fn genTypedValue(self: *DeclGen, tv: TypedValue, fg: ?*FuncGen) error{ OutOfMemory, CodegenFail }!*const llvm.Value {
+    fn genTypedValue(self: *DeclGen, tv: TypedValue) error{ OutOfMemory, CodegenFail }!*const llvm.Value {
         const llvm_type = try self.llvmType(tv.ty);
 
         if (tv.val.isUndef())
@@ -711,20 +708,36 @@ pub const DeclGen = struct {
                         usize_type.constNull(),
                     };
 
-                    // TODO: consider using buildInBoundsGEP2 for opaque pointers
-                    return fg.?.builder.buildInBoundsGEP(val, &indices, 2, "");
+                    return val.constInBoundsGEP(&indices, indices.len);
                 },
                 .ref_val => {
-                    const elem_value = tv.val.castTag(.ref_val).?.data;
-                    const elem_type = tv.ty.castPointer().?.data;
-                    const alloca = fg.?.buildAlloca(try self.llvmType(elem_type));
-                    _ = fg.?.builder.buildStore(try self.genTypedValue(.{ .ty = elem_type, .val = elem_value }, fg), alloca);
-                    return alloca;
+                    //const elem_value = tv.val.castTag(.ref_val).?.data;
+                    //const elem_type = tv.ty.castPointer().?.data;
+                    //const alloca = fg.?.buildAlloca(try self.llvmType(elem_type));
+                    //_ = fg.?.builder.buildStore(try self.genTypedValue(.{ .ty = elem_type, .val = elem_value }, fg), alloca);
+                    //return alloca;
+                    // TODO eliminate the ref_val Value Tag
+                    return self.todo("implement const of pointer tag ref_val", .{});
                 },
                 .variable => {
                     const variable = tv.val.castTag(.variable).?.data;
                     return self.resolveGlobalDecl(variable.owner_decl);
                 },
+                .slice => {
+                    const slice = tv.val.castTag(.slice).?.data;
+                    var buf: Type.Payload.ElemType = undefined;
+                    const fields: [2]*const llvm.Value = .{
+                        try self.genTypedValue(.{
+                            .ty = tv.ty.slicePtrFieldType(&buf),
+                            .val = slice.ptr,
+                        }),
+                        try self.genTypedValue(.{
+                            .ty = Type.initTag(.usize),
+                            .val = slice.len,
+                        }),
+                    };
+                    return self.context.constStruct(&fields, fields.len, .False);
+                },
                 else => |tag| return self.todo("implement const of pointer type '{}' ({})", .{ tv.ty, tag }),
             },
             .Array => {
@@ -734,10 +747,28 @@ pub const DeclGen = struct {
                         return self.todo("handle other sentinel values", .{});
                     } else false;
 
-                    return self.context.constString(payload.data.ptr, @intCast(c_uint, payload.data.len), llvm.Bool.fromBool(!zero_sentinel));
-                } else {
-                    return self.todo("handle more array values", .{});
+                    return self.context.constString(
+                        payload.data.ptr,
+                        @intCast(c_uint, payload.data.len),
+                        llvm.Bool.fromBool(!zero_sentinel),
+                    );
                 }
+                if (tv.val.castTag(.array)) |payload| {
+                    const gpa = self.gpa;
+                    const elem_ty = tv.ty.elemType();
+                    const elem_vals = payload.data;
+                    const llvm_elems = try gpa.alloc(*const llvm.Value, elem_vals.len);
+                    defer gpa.free(llvm_elems);
+                    for (elem_vals) |elem_val, i| {
+                        llvm_elems[i] = try self.genTypedValue(.{ .ty = elem_ty, .val = elem_val });
+                    }
+                    const llvm_elem_ty = try self.llvmType(elem_ty);
+                    return llvm_elem_ty.constArray(
+                        llvm_elems.ptr,
+                        @intCast(c_uint, llvm_elems.len),
+                    );
+                }
+                return self.todo("handle more array values", .{});
             },
             .Optional => {
                 if (!tv.ty.isPtrLikeOptional()) {
@@ -750,26 +781,25 @@ pub const DeclGen = struct {
                             llvm_child_type.constNull(),
                             self.context.intType(1).constNull(),
                         };
-                        return self.context.constStruct(&optional_values, 2, .False);
+                        return self.context.constStruct(&optional_values, optional_values.len, .False);
                     } else {
                         var optional_values: [2]*const llvm.Value = .{
-                            try self.genTypedValue(.{ .ty = child_type, .val = tv.val }, fg),
+                            try self.genTypedValue(.{ .ty = child_type, .val = tv.val }),
                             self.context.intType(1).constAllOnes(),
                         };
-                        return self.context.constStruct(&optional_values, 2, .False);
+                        return self.context.constStruct(&optional_values, optional_values.len, .False);
                     }
                 } else {
                     return self.todo("implement const of optional pointer", .{});
                 }
             },
             .Fn => {
-                const fn_decl = if (tv.val.castTag(.extern_fn)) |extern_fn|
-                    extern_fn.data
-                else if (tv.val.castTag(.function)) |func_payload|
-                    func_payload.data.owner_decl
-                else
-                    unreachable;
-
+                const fn_decl = switch (tv.val.tag()) {
+                    .extern_fn => tv.val.castTag(.extern_fn).?.data,
+                    .function => tv.val.castTag(.function).?.data.owner_decl,
+                    .decl_ref => tv.val.castTag(.decl_ref).?.data,
+                    else => unreachable,
+                };
                 return self.resolveLlvmFunction(fn_decl);
             },
             .ErrorSet => {
@@ -793,11 +823,29 @@ pub const DeclGen = struct {
 
                 if (!payload_type.hasCodeGenBits()) {
                     // We use the error type directly as the type.
-                    return self.genTypedValue(.{ .ty = error_type, .val = sub_val }, fg);
+                    return self.genTypedValue(.{ .ty = error_type, .val = sub_val });
                 }
 
                 return self.todo("implement error union const of type '{}'", .{tv.ty});
             },
+            .Struct => {
+                const fields_len = tv.ty.structFieldCount();
+                const field_vals = tv.val.castTag(.@"struct").?.data;
+                const gpa = self.gpa;
+                const llvm_fields = try gpa.alloc(*const llvm.Value, fields_len);
+                defer gpa.free(llvm_fields);
+                for (llvm_fields) |*llvm_field, i| {
+                    llvm_field.* = try self.genTypedValue(.{
+                        .ty = tv.ty.structFieldType(i),
+                        .val = field_vals[i],
+                    });
+                }
+                return self.context.constStruct(
+                    llvm_fields.ptr,
+                    @intCast(c_uint, llvm_fields.len),
+                    .False,
+                );
+            },
             else => return self.todo("implement const of type '{}'", .{tv.ty}),
         }
     }
@@ -869,7 +917,7 @@ pub const FuncGen = struct {
 
     fn resolveInst(self: *FuncGen, inst: Air.Inst.Ref) !*const llvm.Value {
         if (self.air.value(inst)) |val| {
-            return self.dg.genTypedValue(.{ .ty = self.air.typeOf(inst), .val = val }, self);
+            return self.dg.genTypedValue(.{ .ty = self.air.typeOf(inst), .val = val });
         }
         const inst_index = Air.refToIndex(inst).?;
         if (self.func_inst_table.get(inst_index)) |value| return value;
diff --git a/src/codegen/llvm/bindings.zig b/src/codegen/llvm/bindings.zig
index 9ef6d7e1ac..d63a75d8bd 100644
--- a/src/codegen/llvm/bindings.zig
+++ b/src/codegen/llvm/bindings.zig
@@ -49,7 +49,12 @@ pub const Context = opaque {
     extern fn LLVMConstStringInContext(C: *const Context, Str: [*]const u8, Length: c_uint, DontNullTerminate: Bool) *const Value;
 
     pub const constStruct = LLVMConstStructInContext;
-    extern fn LLVMConstStructInContext(C: *const Context, ConstantVals: [*]*const Value, Count: c_uint, Packed: Bool) *const Value;
+    extern fn LLVMConstStructInContext(
+        C: *const Context,
+        ConstantVals: [*]const *const Value,
+        Count: c_uint,
+        Packed: Bool,
+    ) *const Value;
 
     pub const createBasicBlock = LLVMCreateBasicBlockInContext;
     extern fn LLVMCreateBasicBlockInContext(C: *const Context, Name: [*:0]const u8) *const BasicBlock;
@@ -100,6 +105,13 @@ pub const Value = opaque {
 
     pub const setAliasee = LLVMAliasSetAliasee;
     extern fn LLVMAliasSetAliasee(Alias: *const Value, Aliasee: *const Value) void;
+
+    pub const constInBoundsGEP = LLVMConstInBoundsGEP;
+    extern fn LLVMConstInBoundsGEP(
+        ConstantVal: *const Value,
+        ConstantIndices: [*]const *const Value,
+        NumIndices: c_uint,
+    ) *const Value;
 };
 
 pub const Type = opaque {
@@ -113,7 +125,7 @@ pub const Type = opaque {
     extern fn LLVMConstInt(IntTy: *const Type, N: c_ulonglong, SignExtend: Bool) *const Value;
 
     pub const constArray = LLVMConstArray;
-    extern fn LLVMConstArray(ElementTy: *const Type, ConstantVals: ?[*]*const Value, Length: c_uint) *const Value;
+    extern fn LLVMConstArray(ElementTy: *const Type, ConstantVals: [*]*const Value, Length: c_uint) *const Value;
 
     pub const getUndef = LLVMGetUndef;
     extern fn LLVMGetUndef(Ty: *const Type) *const Value;
diff --git a/src/type.zig b/src/type.zig
index 731c69b806..4dd1a15fdd 100644
--- a/src/type.zig
+++ b/src/type.zig
@@ -1526,6 +1526,8 @@ pub const Type = extern union {
             .var_args_param => unreachable,
 
             .@"struct" => {
+                const s = self.castTag(.@"struct").?.data;
+                assert(s.status == .have_layout);
                 @panic("TODO abiSize struct");
             },
             .enum_simple, .enum_full, .enum_nonexhaustive => {
@@ -2768,6 +2770,26 @@ pub const Type = extern union {
         }
     }
 
+    pub fn structFieldCount(ty: Type) usize {
+        switch (ty.tag()) {
+            .@"struct" => {
+                const struct_obj = ty.castTag(.@"struct").?.data;
+                return struct_obj.fields.count();
+            },
+            else => unreachable,
+        }
+    }
+
+    pub fn structFieldType(ty: Type, index: usize) Type {
+        switch (ty.tag()) {
+            .@"struct" => {
+                const struct_obj = ty.castTag(.@"struct").?.data;
+                return struct_obj.fields.values()[index].ty;
+            },
+            else => unreachable,
+        }
+    }
+
     pub fn declSrcLoc(ty: Type) Module.SrcLoc {
         switch (ty.tag()) {
             .enum_full, .enum_nonexhaustive => {
diff --git a/src/value.zig b/src/value.zig
index abb2ea7b1e..fc34473921 100644
--- a/src/value.zig
+++ b/src/value.zig
@@ -112,6 +112,10 @@ pub const Value = extern union {
         /// This value is repeated some number of times. The amount of times to repeat
         /// is stored externally.
         repeated,
+        /// Each element stored as a `Value`.
+        array,
+        /// Pointer and length as sub `Value` objects.
+        slice,
         float_16,
         float_32,
         float_64,
@@ -217,6 +221,9 @@ pub const Value = extern union {
                 .enum_literal,
                 => Payload.Bytes,
 
+                .array => Payload.Array,
+                .slice => Payload.Slice,
+
                 .enum_field_index => Payload.U32,
 
                 .ty => Payload.Ty,
@@ -442,6 +449,28 @@ pub const Value = extern union {
                 };
                 return Value{ .ptr_otherwise = &new_payload.base };
             },
+            .array => {
+                const payload = self.castTag(.array).?;
+                const new_payload = try allocator.create(Payload.Array);
+                new_payload.* = .{
+                    .base = payload.base,
+                    .data = try allocator.alloc(Value, payload.data.len),
+                };
+                std.mem.copy(Value, new_payload.data, payload.data);
+                return Value{ .ptr_otherwise = &new_payload.base };
+            },
+            .slice => {
+                const payload = self.castTag(.slice).?;
+                const new_payload = try allocator.create(Payload.Slice);
+                new_payload.* = .{
+                    .base = payload.base,
+                    .data = .{
+                        .ptr = try payload.data.ptr.copy(allocator),
+                        .len = try payload.data.len.copy(allocator),
+                    },
+                };
+                return Value{ .ptr_otherwise = &new_payload.base };
+            },
             .float_16 => return self.copyPayloadShallow(allocator, Payload.Float_16),
             .float_32 => return self.copyPayloadShallow(allocator, Payload.Float_32),
             .float_64 => return self.copyPayloadShallow(allocator, Payload.Float_64),
@@ -605,6 +634,8 @@ pub const Value = extern union {
                 try out_stream.writeAll("(repeated) ");
                 val = val.castTag(.repeated).?.data;
             },
+            .array => return out_stream.writeAll("(array)"),
+            .slice => return out_stream.writeAll("(slice)"),
             .float_16 => return out_stream.print("{}", .{val.castTag(.float_16).?.data}),
             .float_32 => return out_stream.print("{}", .{val.castTag(.float_32).?.data}),
             .float_64 => return out_stream.print("{}", .{val.castTag(.float_64).?.data}),
@@ -729,6 +760,8 @@ pub const Value = extern union {
             .field_ptr,
             .bytes,
             .repeated,
+            .array,
+            .slice,
             .float_16,
             .float_32,
             .float_64,
@@ -1075,6 +1108,8 @@ pub const Value = extern union {
         return orderAgainstZero(lhs).compare(op);
     }
 
+    /// TODO we can't compare value equality without also knowing the type to treat
+    /// the values as
     pub fn eql(a: Value, b: Value) bool {
         const a_tag = a.tag();
         const b_tag = b.tag();
@@ -1109,6 +1144,8 @@ pub const Value = extern union {
         return @truncate(u32, self.hash());
     }
 
+    /// TODO we can't hash without also knowing the type of the value.
+    /// we have to hash as if there were a canonical value memory layout.
     pub fn hash(self: Value) u64 {
         var hasher = std.hash.Wyhash.init(0);
 
@@ -1203,6 +1240,15 @@ pub const Value = extern union {
                 const payload = self.castTag(.bytes).?;
                 hasher.update(payload.data);
             },
+            .repeated => {
+                @panic("TODO Value.hash for repeated");
+            },
+            .array => {
+                @panic("TODO Value.hash for array");
+            },
+            .slice => {
+                @panic("TODO Value.hash for slice");
+            },
             .int_u64 => {
                 const payload = self.castTag(.int_u64).?;
                 std.hash.autoHash(&hasher, payload.data);
@@ -1211,10 +1257,6 @@ pub const Value = extern union {
                 const payload = self.castTag(.int_i64).?;
                 std.hash.autoHash(&hasher, payload.data);
             },
-            .repeated => {
-                const payload = self.castTag(.repeated).?;
-                std.hash.autoHash(&hasher, payload.data.hash());
-            },
             .ref_val => {
                 const payload = self.castTag(.ref_val).?;
                 std.hash.autoHash(&hasher, payload.data.hash());
@@ -1340,6 +1382,8 @@ pub const Value = extern union {
         return switch (val.tag()) {
             .empty_array => 0,
             .bytes => val.castTag(.bytes).?.data.len,
+            .array => val.castTag(.array).?.data.len,
+            .slice => val.castTag(.slice).?.data.len.toUnsignedInt(),
             .ref_val => sliceLen(val.castTag(.ref_val).?.data),
             .decl_ref => {
                 const decl = val.castTag(.decl_ref).?.data;
@@ -1364,6 +1408,9 @@ pub const Value = extern union {
             // No matter the index; all the elements are the same!
             .repeated => return self.castTag(.repeated).?.data,
 
+            .array => return self.castTag(.array).?.data[index],
+            .slice => return self.castTag(.slice).?.data.ptr.elemValue(allocator, index),
+
             else => unreachable,
         }
     }
@@ -1450,7 +1497,8 @@ pub const Value = extern union {
     }
 
     /// Valid for all types. Asserts the value is not undefined.
-    pub fn isType(self: Value) bool {
+    /// TODO this function is a code smell and should be deleted
+    fn isType(self: Value) bool {
         return switch (self.tag()) {
             .ty,
             .int_type,
@@ -1528,6 +1576,8 @@ pub const Value = extern union {
             .field_ptr,
             .bytes,
             .repeated,
+            .array,
+            .slice,
             .float_16,
             .float_32,
             .float_64,
@@ -1638,6 +1688,19 @@ pub const Value = extern union {
             data: []const u8,
         };
 
+        pub const Array = struct {
+            base: Payload,
+            data: []Value,
+        };
+
+        pub const Slice = struct {
+            base: Payload,
+            data: struct {
+                ptr: Value,
+                len: Value,
+            },
+        };
+
         pub const Ty = struct {
             base: Payload,
             data: Type,

From 1eeafc39675a349c912910da2a1b70097a934d57 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Tue, 27 Jul 2021 15:10:49 -0700
Subject: [PATCH 06/96] stage2: move call to populateTestFunctions() outside
 performAllTheWork()

Before calling populateTestFunctions() we want to check
totalErrorCount() but that will read from some tables that might get
populated by the thread pool for C compilation tasks. So we wait until
all those tasks are finished before proceeding.
---
 src/Compilation.zig | 15 +++++++--------
 1 file changed, 7 insertions(+), 8 deletions(-)

diff --git a/src/Compilation.zig b/src/Compilation.zig
index 00cdba85a4..8672a346c3 100644
--- a/src/Compilation.zig
+++ b/src/Compilation.zig
@@ -1737,6 +1737,13 @@ pub fn update(self: *Compilation) !void {
 
     if (!use_stage1) {
         if (self.bin_file.options.module) |module| {
+            if (self.bin_file.options.is_test and self.totalErrorCount() == 0) {
+                // The `test_functions` decl has been intentionally postponed until now,
+                // at which point we must populate it with the list of test functions that
+                // have been discovered and not filtered out.
+                try module.populateTestFunctions();
+            }
+
             // Process the deletion set. We use a while loop here because the
             // deletion set may grow as we call `clearDecl` within this loop,
             // and more unreferenced Decls are revealed.
@@ -2384,14 +2391,6 @@ pub fn performAllTheWork(self: *Compilation) error{ TimerUnsupported, OutOfMemor
             };
         },
     };
-
-    if (self.bin_file.options.is_test and self.totalErrorCount() == 0) {
-        // The `test_functions` decl has been intentionally postponed until now,
-        // at which point we must populate it with the list of test functions that
-        // have been discovered and not filtered out.
-        const mod = self.bin_file.options.module.?;
-        try mod.populateTestFunctions();
-    }
 }
 
 const AstGenSrc = union(enum) {

From a2eb91c42294ef380d70742e1111e4dc36ab2192 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Tue, 27 Jul 2021 15:44:21 -0700
Subject: [PATCH 07/96] stage2: add deinit for test_functions

---
 src/Module.zig | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/Module.zig b/src/Module.zig
index 4ddce33655..48c2eb8d0d 100644
--- a/src/Module.zig
+++ b/src/Module.zig
@@ -2123,6 +2123,7 @@ pub fn deinit(mod: *Module) void {
     mod.global_error_set.deinit(gpa);
 
     mod.error_name_list.deinit(gpa);
+    mod.test_functions.deinit(gpa);
 }
 
 fn freeExportList(gpa: *Allocator, export_list: []*Export) void {

From 66e5920dc3411daa4f0c84a8f4c733c1263e8523 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Tue, 27 Jul 2021 15:47:25 -0700
Subject: [PATCH 08/96] llvm backend: LLVMGetNamedGlobalAlias requires a null
 terminated string

---
 src/codegen/llvm.zig          | 8 ++++----
 src/codegen/llvm/bindings.zig | 5 ++++-
 2 files changed, 8 insertions(+), 5 deletions(-)

diff --git a/src/codegen/llvm.zig b/src/codegen/llvm.zig
index 2468b1dbde..74a51e6634 100644
--- a/src/codegen/llvm.zig
+++ b/src/codegen/llvm.zig
@@ -454,12 +454,12 @@ pub const Object = struct {
         // Until then we iterate over existing aliases and make them point
         // to the correct decl, or otherwise add a new alias. Old aliases are leaked.
         for (exports) |exp| {
-            if (self.llvm_module.getNamedGlobalAlias(exp.options.name.ptr, exp.options.name.len)) |alias| {
+            const exp_name_z = try module.gpa.dupeZ(u8, exp.options.name);
+            defer module.gpa.free(exp_name_z);
+
+            if (self.llvm_module.getNamedGlobalAlias(exp_name_z.ptr, exp_name_z.len)) |alias| {
                 alias.setAliasee(llvm_fn);
             } else {
-                const exp_name_z = try module.gpa.dupeZ(u8, exp.options.name);
-                defer module.gpa.free(exp_name_z);
-
                 const alias = self.llvm_module.addAlias(llvm_fn.typeOf(), llvm_fn, exp_name_z);
                 _ = alias;
             }
diff --git a/src/codegen/llvm/bindings.zig b/src/codegen/llvm/bindings.zig
index d63a75d8bd..6d09d69447 100644
--- a/src/codegen/llvm/bindings.zig
+++ b/src/codegen/llvm/bindings.zig
@@ -193,7 +193,10 @@ pub const Module = opaque {
     pub const getNamedGlobalAlias = LLVMGetNamedGlobalAlias;
     extern fn LLVMGetNamedGlobalAlias(
         M: *const Module,
-        Name: [*]const u8,
+        /// Empirically, LLVM will call strlen() on `Name` and so it
+        /// must be both null terminated and also have `NameLen` set
+        /// to the size.
+        Name: [*:0]const u8,
         NameLen: usize,
     ) ?*const Value;
 };

From dc88864c9742029c2980fc16cd2c9e6f04ff3568 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Tue, 27 Jul 2021 17:08:37 -0700
Subject: [PATCH 09/96] stage2: implement `@boolToInt`

This is the first commit in which some behavior tests are passing for
both stage1 and stage2.
---
 doc/langref.html.in  |  4 ++--
 src/Air.zig          |  6 ++++++
 src/AstGen.zig       |  2 ++
 src/Liveness.zig     |  1 +
 src/Sema.zig         | 11 +++++++++--
 src/Zir.zig          |  5 +++++
 src/codegen.zig      |  8 ++++++++
 src/codegen/c.zig    | 15 +++++++++++++++
 src/codegen/llvm.zig | 10 ++++++++++
 src/link/Coff.zig    |  7 +++++--
 src/link/Elf.zig     |  7 ++++---
 src/print_air.zig    |  1 +
 src/type.zig         | 17 +++++++++++++++--
 src/value.zig        |  7 +++++++
 test/behavior.zig    |  7 ++-----
 15 files changed, 92 insertions(+), 16 deletions(-)

diff --git a/doc/langref.html.in b/doc/langref.html.in
index 38b91468e2..4efa7d0e3c 100644
--- a/doc/langref.html.in
+++ b/doc/langref.html.in
@@ -7165,8 +7165,8 @@ fn func(y: *i32) void {
       {#header_open|@boolToInt#}
       <pre>{#syntax#}@boolToInt(value: bool) u1{#endsyntax#}</pre>
       <p>
-      Converts {#syntax#}true{#endsyntax#} to {#syntax#}u1(1){#endsyntax#} and {#syntax#}false{#endsyntax#} to
-                  {#syntax#}u1(0){#endsyntax#}.
+      Converts {#syntax#}true{#endsyntax#} to {#syntax#}@as(u1, 1){#endsyntax#} and {#syntax#}false{#endsyntax#} to
+                  {#syntax#}@as(u1, 0){#endsyntax#}.
       </p>
       <p>
       If the value is known at compile-time, the return type is {#syntax#}comptime_int{#endsyntax#}
diff --git a/src/Air.zig b/src/Air.zig
index 8cb7b943e3..bd7b3af733 100644
--- a/src/Air.zig
+++ b/src/Air.zig
@@ -189,6 +189,10 @@ pub const Inst = struct {
         /// Converts a pointer to its address. Result type is always `usize`.
         /// Uses the `un_op` field.
         ptrtoint,
+        /// Given a boolean, returns 0 or 1.
+        /// Result type is always `u1`.
+        /// Uses the `un_op` field.
+        bool_to_int,
         /// Stores a value onto the stack and returns a pointer to it.
         /// TODO audit where this AIR instruction is emitted, maybe it should instead be emitting
         /// alloca instruction and storing to the alloca.
@@ -490,6 +494,8 @@ pub fn typeOfIndex(air: Air, inst: Air.Inst.Index) Type {
         .slice_len,
         => return Type.initTag(.usize),
 
+        .bool_to_int => return Type.initTag(.u1),
+
         .call => {
             const callee_ty = air.typeOf(datas[inst].pl_op.operand);
             return callee_ty.fnReturnType();
diff --git a/src/AstGen.zig b/src/AstGen.zig
index 34f906fab1..b5e5d60b2c 100644
--- a/src/AstGen.zig
+++ b/src/AstGen.zig
@@ -7754,6 +7754,7 @@ pub const simple_types = std.ComptimeStringMap(Zir.Inst.Ref, .{
     .{ "u32", .u32_type },
     .{ "u64", .u64_type },
     .{ "u128", .u128_type },
+    .{ "u1", .u1_type },
     .{ "u8", .u8_type },
     .{ "undefined", .undef },
     .{ "usize", .usize_type },
@@ -8400,6 +8401,7 @@ fn rvalue(
             const as_usize = @as(u64, @enumToInt(Zir.Inst.Ref.usize_type)) << 32;
             const as_void = @as(u64, @enumToInt(Zir.Inst.Ref.void_type)) << 32;
             switch ((@as(u64, @enumToInt(ty_inst)) << 32) | @as(u64, @enumToInt(result))) {
+                as_ty | @enumToInt(Zir.Inst.Ref.u1_type),
                 as_ty | @enumToInt(Zir.Inst.Ref.u8_type),
                 as_ty | @enumToInt(Zir.Inst.Ref.i8_type),
                 as_ty | @enumToInt(Zir.Inst.Ref.u16_type),
diff --git a/src/Liveness.zig b/src/Liveness.zig
index a4c6d8c016..a44b582424 100644
--- a/src/Liveness.zig
+++ b/src/Liveness.zig
@@ -291,6 +291,7 @@ fn analyzeInst(
         .is_err_ptr,
         .is_non_err_ptr,
         .ptrtoint,
+        .bool_to_int,
         .ret,
         => {
             const operand = inst_datas[inst].un_op;
diff --git a/src/Sema.zig b/src/Sema.zig
index 46a41426c8..88a83fd661 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -5848,8 +5848,14 @@ fn zirAlignOf(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) CompileErr
 
 fn zirBoolToInt(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
     const inst_data = sema.code.instructions.items(.data)[inst].un_node;
-    const src = inst_data.src();
-    return sema.mod.fail(&block.base, src, "TODO: Sema.zirBoolToInt", .{});
+    const operand_src: LazySrcLoc = .{ .node_offset_builtin_call_arg0 = inst_data.src_node };
+    const operand = sema.resolveInst(inst_data.operand);
+    if (try sema.resolveMaybeUndefVal(block, operand_src, operand)) |val| {
+        if (val.isUndef()) return sema.addConstUndef(Type.initTag(.u1));
+        const bool_ints = [2]Air.Inst.Ref{ .zero, .one };
+        return bool_ints[@boolToInt(val.toBool())];
+    }
+    return block.addUnOp(.bool_to_int, operand);
 }
 
 fn zirEmbedFile(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
@@ -8252,6 +8258,7 @@ fn typeHasOnePossibleValue(
         .c_longdouble,
         .comptime_int,
         .comptime_float,
+        .u1,
         .u8,
         .i8,
         .u16,
diff --git a/src/Zir.zig b/src/Zir.zig
index 2b88a3415d..a8320b65d4 100644
--- a/src/Zir.zig
+++ b/src/Zir.zig
@@ -1633,6 +1633,7 @@ pub const Inst = struct {
         /// value and may instead be used as a sentinel to indicate null.
         none,
 
+        u1_type,
         u8_type,
         i8_type,
         u16_type,
@@ -1719,6 +1720,10 @@ pub const Inst = struct {
         pub const typed_value_map = std.enums.directEnumArray(Ref, TypedValue, 0, .{
             .none = undefined,
 
+            .u1_type = .{
+                .ty = Type.initTag(.type),
+                .val = Value.initTag(.u1_type),
+            },
             .u8_type = .{
                 .ty = Type.initTag(.type),
                 .val = Value.initTag(.u8_type),
diff --git a/src/codegen.zig b/src/codegen.zig
index 4924b68ca3..3b822c0f88 100644
--- a/src/codegen.zig
+++ b/src/codegen.zig
@@ -835,6 +835,7 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
                     .dbg_stmt        => try self.airDbgStmt(inst),
                     .floatcast       => try self.airFloatCast(inst),
                     .intcast         => try self.airIntCast(inst),
+                    .bool_to_int     => try self.airBoolToInt(inst),
                     .is_non_null     => try self.airIsNonNull(inst),
                     .is_non_null_ptr => try self.airIsNonNullPtr(inst),
                     .is_null         => try self.airIsNull(inst),
@@ -1110,6 +1111,13 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
             return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
         }
 
+        fn airBoolToInt(self: *Self, inst: Air.Inst.Index) !void {
+            const un_op = self.air.instructions.items(.data)[inst].un_op;
+            const operand = try self.resolveInst(un_op);
+            const result: MCValue = if (self.liveness.isUnused(inst)) .dead else operand;
+            return self.finishAir(inst, result, .{ un_op, .none, .none });
+        }
+
         fn airNot(self: *Self, inst: Air.Inst.Index) !void {
             const ty_op = self.air.instructions.items(.data)[inst].ty_op;
             const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
diff --git a/src/codegen/c.zig b/src/codegen/c.zig
index fa254af293..7299b21a61 100644
--- a/src/codegen/c.zig
+++ b/src/codegen/c.zig
@@ -925,6 +925,7 @@ fn genBody(o: *Object, body: []const Air.Inst.Index) error{ AnalysisFail, OutOfM
             .call             => try airCall(o, inst),
             .dbg_stmt         => try airDbgStmt(o, inst),
             .intcast          => try airIntCast(o, inst),
+            .bool_to_int      => try airBoolToInt(o, inst),
             .load             => try airLoad(o, inst),
             .ret              => try airRet(o, inst),
             .store            => try airStore(o, inst),
@@ -1083,6 +1084,20 @@ fn airIntCast(o: *Object, inst: Air.Inst.Index) !CValue {
     return local;
 }
 
+fn airBoolToInt(o: *Object, inst: Air.Inst.Index) !CValue {
+    if (o.liveness.isUnused(inst))
+        return CValue.none;
+    const un_op = o.air.instructions.items(.data)[inst].un_op;
+    const writer = o.writer();
+    const inst_ty = o.air.typeOfIndex(inst);
+    const operand = try o.resolveInst(un_op);
+    const local = try o.allocLocal(inst_ty, .Const);
+    try writer.writeAll(" = ");
+    try o.writeCValue(writer, operand);
+    try writer.writeAll(";\n");
+    return local;
+}
+
 fn airStore(o: *Object, inst: Air.Inst.Index) !CValue {
     // *a = b;
     const bin_op = o.air.instructions.items(.data)[inst].bin_op;
diff --git a/src/codegen/llvm.zig b/src/codegen/llvm.zig
index 74a51e6634..22f117aa1c 100644
--- a/src/codegen/llvm.zig
+++ b/src/codegen/llvm.zig
@@ -961,6 +961,7 @@ pub const FuncGen = struct {
                 .alloc      => try self.airAlloc(inst),
                 .arg        => try self.airArg(inst),
                 .bitcast    => try self.airBitCast(inst),
+                .bool_to_int=> try self.airBoolToInt(inst),
                 .block      => try self.airBlock(inst),
                 .br         => try self.airBr(inst),
                 .switch_br  => try self.airSwitchBr(inst),
@@ -1656,6 +1657,15 @@ pub const FuncGen = struct {
         return self.builder.buildBitCast(operand, dest_type, "");
     }
 
+    fn airBoolToInt(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+        if (self.liveness.isUnused(inst))
+            return null;
+
+        const un_op = self.air.instructions.items(.data)[inst].un_op;
+        const operand = try self.resolveInst(un_op);
+        return operand;
+    }
+
     fn airArg(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
         const arg_val = self.args[self.arg_index];
         self.arg_index += 1;
diff --git a/src/link/Coff.zig b/src/link/Coff.zig
index 0c9e513742..4f5df73f8d 100644
--- a/src/link/Coff.zig
+++ b/src/link/Coff.zig
@@ -885,7 +885,7 @@ fn linkWithLLD(self: *Coff, comp: *Compilation) !void {
         // Both stage1 and stage2 LLVM backend put the object file in the cache directory.
         if (self.base.options.use_llvm) {
             // Stage2 has to call flushModule since that outputs the LLVM object file.
-            if (!build_options.is_stage1) try self.flushModule(comp);
+            if (!build_options.is_stage1 or !self.base.options.use_stage1) try self.flushModule(comp);
 
             const obj_basename = try std.zig.binNameAlloc(arena, .{
                 .root_name = self.base.options.root_name,
@@ -1269,7 +1269,10 @@ fn linkWithLLD(self: *Coff, comp: *Compilation) !void {
 
         // TODO: remove when stage2 can build compiler_rt.zig, c.zig and ssp.zig
         // compiler-rt, libc and libssp
-        if (is_exe_or_dyn_lib and !self.base.options.skip_linker_dependencies and build_options.is_stage1) {
+        if (is_exe_or_dyn_lib and
+            !self.base.options.skip_linker_dependencies and
+            build_options.is_stage1 and self.base.options.use_stage1)
+        {
             if (!self.base.options.link_libc) {
                 try argv.append(comp.libc_static_lib.?.full_object_path);
             }
diff --git a/src/link/Elf.zig b/src/link/Elf.zig
index 502575f3c8..9ddebd3453 100644
--- a/src/link/Elf.zig
+++ b/src/link/Elf.zig
@@ -1257,7 +1257,7 @@ fn linkWithLLD(self: *Elf, comp: *Compilation) !void {
         // Both stage1 and stage2 LLVM backend put the object file in the cache directory.
         if (self.base.options.use_llvm) {
             // Stage2 has to call flushModule since that outputs the LLVM object file.
-            if (!build_options.is_stage1) try self.flushModule(comp);
+            if (!build_options.is_stage1 or !self.base.options.use_stage1) try self.flushModule(comp);
 
             const obj_basename = try std.zig.binNameAlloc(arena, .{
                 .root_name = self.base.options.root_name,
@@ -1287,7 +1287,7 @@ fn linkWithLLD(self: *Elf, comp: *Compilation) !void {
     const allow_shlib_undefined = self.base.options.allow_shlib_undefined orelse !self.base.options.is_native_os;
     const compiler_rt_path: ?[]const u8 = if (self.base.options.include_compiler_rt) blk: {
         // TODO: remove when stage2 can build compiler_rt.zig
-        if (!build_options.is_stage1) break :blk null;
+        if (!build_options.is_stage1 or !self.base.options.use_stage1) break :blk null;
 
         // In the case of build-obj we include the compiler-rt symbols directly alongside
         // the symbols of the root source file, in the same compilation unit.
@@ -1605,7 +1605,8 @@ fn linkWithLLD(self: *Elf, comp: *Compilation) !void {
         if (is_exe_or_dyn_lib and
             !self.base.options.skip_linker_dependencies and
             !self.base.options.link_libc and
-            build_options.is_stage1)
+            build_options.is_stage1 and
+            self.base.options.use_stage1)
         {
             try argv.append(comp.libc_static_lib.?.full_object_path);
         }
diff --git a/src/print_air.zig b/src/print_air.zig
index c20a6995e5..2d5d6b588e 100644
--- a/src/print_air.zig
+++ b/src/print_air.zig
@@ -137,6 +137,7 @@ const Writer = struct {
             .is_err_ptr,
             .is_non_err_ptr,
             .ptrtoint,
+            .bool_to_int,
             .ret,
             => try w.writeUnOp(s, inst),
 
diff --git a/src/type.zig b/src/type.zig
index 4dd1a15fdd..d828df550b 100644
--- a/src/type.zig
+++ b/src/type.zig
@@ -23,6 +23,7 @@ pub const Type = extern union {
 
     pub fn zigTypeTag(self: Type) std.builtin.TypeId {
         switch (self.tag()) {
+            .u1,
             .u8,
             .i8,
             .u16,
@@ -638,6 +639,7 @@ pub const Type = extern union {
         if (self.tag_if_small_enough < Tag.no_payload_count) {
             return Type{ .tag_if_small_enough = self.tag_if_small_enough };
         } else switch (self.ptr_otherwise.tag) {
+            .u1,
             .u8,
             .i8,
             .u16,
@@ -819,6 +821,7 @@ pub const Type = extern union {
         while (true) {
             const t = ty.tag();
             switch (t) {
+                .u1,
                 .u8,
                 .i8,
                 .u16,
@@ -1082,6 +1085,7 @@ pub const Type = extern union {
 
     pub fn toValue(self: Type, allocator: *Allocator) Allocator.Error!Value {
         switch (self.tag()) {
+            .u1 => return Value.initTag(.u1_type),
             .u8 => return Value.initTag(.u8_type),
             .i8 => return Value.initTag(.i8_type),
             .u16 => return Value.initTag(.u16_type),
@@ -1141,6 +1145,7 @@ pub const Type = extern union {
 
     pub fn hasCodeGenBits(self: Type) bool {
         return switch (self.tag()) {
+            .u1,
             .u8,
             .i8,
             .u16,
@@ -1321,6 +1326,7 @@ pub const Type = extern union {
     /// Asserts that hasCodeGenBits() is true.
     pub fn abiAlignment(self: Type, target: Target) u32 {
         return switch (self.tag()) {
+            .u1,
             .u8,
             .i8,
             .bool,
@@ -1539,6 +1545,7 @@ pub const Type = extern union {
                 @panic("TODO abiSize unions");
             },
 
+            .u1,
             .u8,
             .i8,
             .bool,
@@ -1704,7 +1711,7 @@ pub const Type = extern union {
 
             .u8, .i8 => 8,
 
-            .bool => 1,
+            .bool, .u1 => 1,
 
             .vector => {
                 const payload = self.castTag(.vector).?.data;
@@ -2217,12 +2224,13 @@ pub const Type = extern union {
     pub fn isUnsignedInt(self: Type) bool {
         return switch (self.tag()) {
             .int_unsigned,
-            .u8,
             .usize,
             .c_ushort,
             .c_uint,
             .c_ulong,
             .c_ulonglong,
+            .u1,
+            .u8,
             .u16,
             .u32,
             .u64,
@@ -2244,6 +2252,7 @@ pub const Type = extern union {
                 .signedness = .signed,
                 .bits = self.castTag(.int_signed).?.data,
             },
+            .u1 => .{ .signedness = .unsigned, .bits = 1 },
             .u8 => .{ .signedness = .unsigned, .bits = 8 },
             .i8 => .{ .signedness = .signed, .bits = 8 },
             .u16 => .{ .signedness = .unsigned, .bits = 16 },
@@ -2406,6 +2415,7 @@ pub const Type = extern union {
             .c_longdouble,
             .comptime_int,
             .comptime_float,
+            .u1,
             .u8,
             .i8,
             .u16,
@@ -2446,6 +2456,7 @@ pub const Type = extern union {
             .c_longdouble,
             .comptime_int,
             .comptime_float,
+            .u1,
             .u8,
             .i8,
             .u16,
@@ -2911,6 +2922,7 @@ pub const Type = extern union {
     /// See `zigTypeTag` for the function that corresponds to `std.builtin.TypeId`.
     pub const Tag = enum {
         // The first section of this enum are tags that require no payload.
+        u1,
         u8,
         i8,
         u16,
@@ -3018,6 +3030,7 @@ pub const Type = extern union {
 
         pub fn Type(comptime t: Tag) type {
             return switch (t) {
+                .u1,
                 .u8,
                 .i8,
                 .u16,
diff --git a/src/value.zig b/src/value.zig
index fc34473921..5d9fd27414 100644
--- a/src/value.zig
+++ b/src/value.zig
@@ -22,6 +22,7 @@ pub const Value = extern union {
 
     pub const Tag = enum {
         // The first section of this enum are tags that require no payload.
+        u1_type,
         u8_type,
         i8_type,
         u16_type,
@@ -138,6 +139,7 @@ pub const Value = extern union {
 
         pub fn Type(comptime t: Tag) type {
             return switch (t) {
+                .u1_type,
                 .u8_type,
                 .i8_type,
                 .u16_type,
@@ -314,6 +316,7 @@ pub const Value = extern union {
         if (self.tag_if_small_enough < Tag.no_payload_count) {
             return Value{ .tag_if_small_enough = self.tag_if_small_enough };
         } else switch (self.ptr_otherwise.tag) {
+            .u1_type,
             .u8_type,
             .i8_type,
             .u16_type,
@@ -520,6 +523,7 @@ pub const Value = extern union {
         comptime assert(fmt.len == 0);
         var val = start_val;
         while (true) switch (val.tag()) {
+            .u1_type => return out_stream.writeAll("u1"),
             .u8_type => return out_stream.writeAll("u8"),
             .i8_type => return out_stream.writeAll("i8"),
             .u16_type => return out_stream.writeAll("u16"),
@@ -671,6 +675,7 @@ pub const Value = extern union {
     pub fn toType(self: Value, allocator: *Allocator) !Type {
         return switch (self.tag()) {
             .ty => self.castTag(.ty).?.data,
+            .u1_type => Type.initTag(.u1),
             .u8_type => Type.initTag(.u8),
             .i8_type => Type.initTag(.i8),
             .u16_type => Type.initTag(.u16),
@@ -1150,6 +1155,7 @@ pub const Value = extern union {
         var hasher = std.hash.Wyhash.init(0);
 
         switch (self.tag()) {
+            .u1_type,
             .u8_type,
             .i8_type,
             .u16_type,
@@ -1502,6 +1508,7 @@ pub const Value = extern union {
         return switch (self.tag()) {
             .ty,
             .int_type,
+            .u1_type,
             .u8_type,
             .i8_type,
             .u16_type,
diff --git a/test/behavior.zig b/test/behavior.zig
index 101ee2ce53..a286b1a6e2 100644
--- a/test/behavior.zig
+++ b/test/behavior.zig
@@ -2,11 +2,9 @@ const builtin = @import("builtin");
 
 test {
     // Tests that pass for both.
-    {}
+    _ = @import("behavior/bool.zig");
 
-    if (builtin.zig_is_stage2) {
-        // Tests that only pass for stage2.
-    } else {
+    if (!builtin.zig_is_stage2) {
         // Tests that only pass for stage1.
         _ = @import("behavior/align.zig");
         _ = @import("behavior/alignof.zig");
@@ -20,7 +18,6 @@ test {
         _ = @import("behavior/bit_shifting.zig");
         _ = @import("behavior/bitcast.zig");
         _ = @import("behavior/bitreverse.zig");
-        _ = @import("behavior/bool.zig");
         _ = @import("behavior/bugs/1025.zig");
         _ = @import("behavior/bugs/1076.zig");
         _ = @import("behavior/bugs/1111.zig");

From bb2accba9bf1ec2bf32e7d461785b3084524dbf1 Mon Sep 17 00:00:00 2001
From: Meghan Denny <hello@nektro.net>
Date: Mon, 26 Jul 2021 12:26:11 -0700
Subject: [PATCH 10/96] stage1: add c_longdouble mapping for s390x

---
 src/stage1/codegen.cpp | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/stage1/codegen.cpp b/src/stage1/codegen.cpp
index d1bea6990a..083d15068a 100644
--- a/src/stage1/codegen.cpp
+++ b/src/stage1/codegen.cpp
@@ -8794,6 +8794,9 @@ static void define_builtin_types(CodeGen *g) {
         case ZigLLVM_sparcv9:
             add_fp_entry(g, "c_longdouble", 128, LLVMFP128Type(), &g->builtin_types.entry_c_longdouble);
             break;
+        case ZigLLVM_systemz:
+            add_fp_entry(g, "c_longdouble", 128, LLVMDoubleType(), &g->builtin_types.entry_c_longdouble);
+            break;
         case ZigLLVM_avr:
             // It's either a float or a double, depending on a toolchain switch
             add_fp_entry(g, "c_longdouble", 64, LLVMDoubleType(), &g->builtin_types.entry_c_longdouble);

From c234d4790ef51ac05e317e42a0a4836632a5d7a0 Mon Sep 17 00:00:00 2001
From: Lee Cannon <leecannon@leecannon.xyz>
Date: Wed, 28 Jul 2021 02:30:53 +0100
Subject: [PATCH 11/96] Add option to hide build command on compilation error
 to build_runner (#8513)

Co-authored-by: Veikka Tuominen <git@vexu.eu>
---
 lib/std/build.zig                | 12 ++++++--
 lib/std/build/RunStep.zig        | 18 ++++++++----
 lib/std/special/build_runner.zig | 49 +++++++++++++++++---------------
 src/main.zig                     | 13 +++++++--
 4 files changed, 60 insertions(+), 32 deletions(-)

diff --git a/lib/std/build.zig b/lib/std/build.zig
index cf592f2016..02774c6dad 100644
--- a/lib/std/build.zig
+++ b/lib/std/build.zig
@@ -45,6 +45,8 @@ pub const Builder = struct {
     verbose_llvm_ir: bool,
     verbose_cimport: bool,
     verbose_llvm_cpu_features: bool,
+    /// The purpose of executing the command is for a human to read compile errors from the terminal
+    prominent_compile_errors: bool,
     color: enum { auto, on, off } = .auto,
     invalid_user_input: bool,
     zig_exe: []const u8,
@@ -157,6 +159,7 @@ pub const Builder = struct {
             .verbose_llvm_ir = false,
             .verbose_cimport = false,
             .verbose_llvm_cpu_features = false,
+            .prominent_compile_errors = false,
             .invalid_user_input = false,
             .allocator = allocator,
             .user_input_options = UserInputOptionsMap.init(allocator),
@@ -1162,8 +1165,13 @@ pub const Builder = struct {
             },
             error.ExitCodeFailure => {
                 if (src_step) |s| warn("{s}...", .{s.name});
-                warn("The following command exited with error code {d}:\n", .{code});
-                printCmd(null, argv);
+                if (self.prominent_compile_errors) {
+                    warn("The step exited with error code {d}\n", .{code});
+                } else {
+                    warn("The following command exited with error code {d}:\n", .{code});
+                    printCmd(null, argv);
+                }
+
                 std.os.exit(@truncate(u8, code));
             },
             error.ProcessTerminated => {
diff --git a/lib/std/build/RunStep.zig b/lib/std/build/RunStep.zig
index 50fea83784..89d9cd911c 100644
--- a/lib/std/build/RunStep.zig
+++ b/lib/std/build/RunStep.zig
@@ -221,11 +221,19 @@ fn make(step: *Step) !void {
     switch (term) {
         .Exited => |code| {
             if (code != self.expected_exit_code) {
-                warn("The following command exited with error code {} (expected {}):\n", .{
-                    code,
-                    self.expected_exit_code,
-                });
-                printCmd(cwd, argv);
+                if (self.builder.prominent_compile_errors) {
+                    warn("Run step exited with error code {} (expected {})\n", .{
+                        code,
+                        self.expected_exit_code,
+                    });
+                } else {
+                    warn("The following command exited with error code {} (expected {}):\n", .{
+                        code,
+                        self.expected_exit_code,
+                    });
+                    printCmd(cwd, argv);
+                }
+
                 return error.UncleanExit;
             }
         },
diff --git a/lib/std/special/build_runner.zig b/lib/std/special/build_runner.zig
index 475199eaf4..20f72d2674 100644
--- a/lib/std/special/build_runner.zig
+++ b/lib/std/special/build_runner.zig
@@ -157,6 +157,8 @@ pub fn main() !void {
                 builder.verbose_cc = true;
             } else if (mem.eql(u8, arg, "--verbose-llvm-cpu-features")) {
                 builder.verbose_llvm_cpu_features = true;
+            } else if (mem.eql(u8, arg, "--prominent-compile-errors")) {
+                builder.prominent_compile_errors = true;
             } else if (mem.eql(u8, arg, "--")) {
                 builder.args = argsRest(args, arg_idx);
                 break;
@@ -214,24 +216,25 @@ fn usage(builder: *Builder, already_ran_build: bool, out_stream: anytype) !void
             try fmt.allocPrint(allocator, "{s} (default)", .{top_level_step.step.name})
         else
             top_level_step.step.name;
-        try out_stream.print("  {s:<27} {s}\n", .{ name, top_level_step.description });
+        try out_stream.print("  {s:<28} {s}\n", .{ name, top_level_step.description });
     }
 
     try out_stream.writeAll(
         \\
         \\General Options:
-        \\  -p, --prefix         [path] Override default install prefix
-        \\  --prefix-lib-dir     [path] Override default library directory path
-        \\  --prefix-exe-dir     [path] Override default executable directory path
-        \\  --prefix-include-dir [path] Override default include directory path
+        \\  -p, --prefix [path]          Override default install prefix
+        \\  --prefix-lib-dir [path]      Override default library directory path
+        \\  --prefix-exe-dir [path]      Override default executable directory path
+        \\  --prefix-include-dir [path]  Override default include directory path
         \\
-        \\  --sysroot [path]            Set the system root directory (usually /)
-        \\  --search-prefix [path]      Add a path to look for binaries, libraries, headers
-        \\  --libc [file]               Provide a file which specifies libc paths
+        \\  --sysroot [path]             Set the system root directory (usually /)
+        \\  --search-prefix [path]       Add a path to look for binaries, libraries, headers
+        \\  --libc [file]                Provide a file which specifies libc paths
         \\
-        \\  -h, --help                  Print this help and exit
-        \\  --verbose                   Print commands before executing them
-        \\  --color [auto|off|on]       Enable or disable colored error messages
+        \\  -h, --help                   Print this help and exit
+        \\  --verbose                    Print commands before executing them
+        \\  --color [auto|off|on]        Enable or disable colored error messages
+        \\  --prominent-compile-errors   Output compile errors formatted for a human to read
         \\
         \\Project-Specific Options:
         \\
@@ -246,24 +249,24 @@ fn usage(builder: *Builder, already_ran_build: bool, out_stream: anytype) !void
                 @tagName(option.type_id),
             });
             defer allocator.free(name);
-            try out_stream.print("{s:<29} {s}\n", .{ name, option.description });
+            try out_stream.print("{s:<30} {s}\n", .{ name, option.description });
         }
     }
 
     try out_stream.writeAll(
         \\
         \\Advanced Options:
-        \\  --build-file [file]         Override path to build.zig
-        \\  --cache-dir [path]          Override path to zig cache directory
-        \\  --zig-lib-dir [arg]         Override path to Zig lib directory
-        \\  --verbose-tokenize          Enable compiler debug output for tokenization
-        \\  --verbose-ast               Enable compiler debug output for parsing into an AST
-        \\  --verbose-link              Enable compiler debug output for linking
-        \\  --verbose-ir                Enable compiler debug output for Zig IR
-        \\  --verbose-llvm-ir           Enable compiler debug output for LLVM IR
-        \\  --verbose-cimport           Enable compiler debug output for C imports
-        \\  --verbose-cc                Enable compiler debug output for C compilation
-        \\  --verbose-llvm-cpu-features Enable compiler debug output for LLVM CPU features
+        \\  --build-file [file]          Override path to build.zig
+        \\  --cache-dir [path]           Override path to zig cache directory
+        \\  --zig-lib-dir [arg]          Override path to Zig lib directory
+        \\  --verbose-tokenize           Enable compiler debug output for tokenization
+        \\  --verbose-ast                Enable compiler debug output for parsing into an AST
+        \\  --verbose-link               Enable compiler debug output for linking
+        \\  --verbose-ir                 Enable compiler debug output for Zig IR
+        \\  --verbose-llvm-ir            Enable compiler debug output for LLVM IR
+        \\  --verbose-cimport            Enable compiler debug output for C imports
+        \\  --verbose-cc                 Enable compiler debug output for C compilation
+        \\  --verbose-llvm-cpu-features  Enable compiler debug output for LLVM CPU features
         \\
     );
 }
diff --git a/src/main.zig b/src/main.zig
index d0aa6213cb..5b0c9edc8f 100644
--- a/src/main.zig
+++ b/src/main.zig
@@ -2753,6 +2753,8 @@ pub const usage_build =
 ;
 
 pub fn cmdBuild(gpa: *Allocator, arena: *Allocator, args: []const []const u8) !void {
+    var prominent_compile_errors: bool = false;
+
     // We want to release all the locks before executing the child process, so we make a nice
     // big block here to ensure the cleanup gets run when we extract out our argv.
     const child_argv = argv: {
@@ -2804,6 +2806,8 @@ pub fn cmdBuild(gpa: *Allocator, arena: *Allocator, args: []const []const u8) !v
                         i += 1;
                         override_global_cache_dir = args[i];
                         continue;
+                    } else if (mem.eql(u8, arg, "--prominent-compile-errors")) {
+                        prominent_compile_errors = true;
                     }
                 }
                 try child_argv.append(arg);
@@ -2973,8 +2977,13 @@ pub fn cmdBuild(gpa: *Allocator, arena: *Allocator, args: []const []const u8) !v
     switch (term) {
         .Exited => |code| {
             if (code == 0) return cleanExit();
-            const cmd = try argvCmd(arena, child_argv);
-            fatal("the following build command failed with exit code {d}:\n{s}", .{ code, cmd });
+
+            if (prominent_compile_errors) {
+                fatal("the build command failed with exit code {d}", .{code});
+            } else {
+                const cmd = try argvCmd(arena, child_argv);
+                fatal("the following build command failed with exit code {d}:\n{s}", .{ code, cmd });
+            }
         },
         else => {
             const cmd = try argvCmd(arena, child_argv);

From a8e8927c4926176c683a4b66f86c8b011064e7b7 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Tue, 27 Jul 2021 18:33:49 -0700
Subject: [PATCH 12/96] fix old references to verbose-ir to be verbose-air

---
 lib/std/build.zig                | 6 +++---
 lib/std/special/build_runner.zig | 6 +++---
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/lib/std/build.zig b/lib/std/build.zig
index 02774c6dad..22f454adca 100644
--- a/lib/std/build.zig
+++ b/lib/std/build.zig
@@ -41,7 +41,7 @@ pub const Builder = struct {
     verbose_ast: bool,
     verbose_link: bool,
     verbose_cc: bool,
-    verbose_ir: bool,
+    verbose_air: bool,
     verbose_llvm_ir: bool,
     verbose_cimport: bool,
     verbose_llvm_cpu_features: bool,
@@ -155,7 +155,7 @@ pub const Builder = struct {
             .verbose_ast = false,
             .verbose_link = false,
             .verbose_cc = false,
-            .verbose_ir = false,
+            .verbose_air = false,
             .verbose_llvm_ir = false,
             .verbose_cimport = false,
             .verbose_llvm_cpu_features = false,
@@ -2451,7 +2451,7 @@ pub const LibExeObjStep = struct {
         if (builder.verbose_tokenize) zig_args.append("--verbose-tokenize") catch unreachable;
         if (builder.verbose_ast) zig_args.append("--verbose-ast") catch unreachable;
         if (builder.verbose_cimport) zig_args.append("--verbose-cimport") catch unreachable;
-        if (builder.verbose_ir) zig_args.append("--verbose-ir") catch unreachable;
+        if (builder.verbose_air) zig_args.append("--verbose-air") catch unreachable;
         if (builder.verbose_llvm_ir) zig_args.append("--verbose-llvm-ir") catch unreachable;
         if (builder.verbose_link or self.verbose_link) zig_args.append("--verbose-link") catch unreachable;
         if (builder.verbose_cc or self.verbose_cc) zig_args.append("--verbose-cc") catch unreachable;
diff --git a/lib/std/special/build_runner.zig b/lib/std/special/build_runner.zig
index 20f72d2674..2da273a673 100644
--- a/lib/std/special/build_runner.zig
+++ b/lib/std/special/build_runner.zig
@@ -147,8 +147,8 @@ pub fn main() !void {
                 builder.verbose_ast = true;
             } else if (mem.eql(u8, arg, "--verbose-link")) {
                 builder.verbose_link = true;
-            } else if (mem.eql(u8, arg, "--verbose-ir")) {
-                builder.verbose_ir = true;
+            } else if (mem.eql(u8, arg, "--verbose-air")) {
+                builder.verbose_air = true;
             } else if (mem.eql(u8, arg, "--verbose-llvm-ir")) {
                 builder.verbose_llvm_ir = true;
             } else if (mem.eql(u8, arg, "--verbose-cimport")) {
@@ -262,7 +262,7 @@ fn usage(builder: *Builder, already_ran_build: bool, out_stream: anytype) !void
         \\  --verbose-tokenize           Enable compiler debug output for tokenization
         \\  --verbose-ast                Enable compiler debug output for parsing into an AST
         \\  --verbose-link               Enable compiler debug output for linking
-        \\  --verbose-ir                 Enable compiler debug output for Zig IR
+        \\  --verbose-air                Enable compiler debug output for Zig AIR
         \\  --verbose-llvm-ir            Enable compiler debug output for LLVM IR
         \\  --verbose-cimport            Enable compiler debug output for C imports
         \\  --verbose-cc                 Enable compiler debug output for C compilation

From eb010ce65ddddb23ceddae86d377432cf1b2b01c Mon Sep 17 00:00:00 2001
From: Austin Clements <austinclementsbass@gmail.com>
Date: Mon, 26 Jul 2021 16:03:30 -0500
Subject: [PATCH 13/96] Skip empty strings in std.fs.path.join function

---
 lib/std/fs/path.zig | 48 ++++++++++++++++++++++++++++++++++-----------
 1 file changed, 37 insertions(+), 11 deletions(-)

diff --git a/lib/std/fs/path.zig b/lib/std/fs/path.zig
index 04404a61bb..ed04f0b09d 100644
--- a/lib/std/fs/path.zig
+++ b/lib/std/fs/path.zig
@@ -43,17 +43,32 @@ pub fn isSep(byte: u8) bool {
 fn joinSepMaybeZ(allocator: *Allocator, separator: u8, sepPredicate: fn (u8) bool, paths: []const []const u8, zero: bool) ![]u8 {
     if (paths.len == 0) return if (zero) try allocator.dupe(u8, &[1]u8{0}) else &[0]u8{};
 
+    // Find first non-empty path index.
+    const first_path_index = blk: {
+        for (paths) |path, index| {
+            if (path.len == 0) continue else break :blk index;
+        }
+
+        // All paths provided were empty, so return early.
+        return if (zero) try allocator.dupe(u8, &[1]u8{0}) else &[0]u8{};
+    };
+
+    // Calculate length needed for resulting joined path buffer.
     const total_len = blk: {
-        var sum: usize = paths[0].len;
-        var i: usize = 1;
+        var sum: usize = paths[first_path_index].len;
+        var prev_path = paths[first_path_index];
+        assert(prev_path.len > 0);
+        var i: usize = first_path_index + 1;
         while (i < paths.len) : (i += 1) {
-            const prev_path = paths[i - 1];
             const this_path = paths[i];
-            const prev_sep = (prev_path.len != 0 and sepPredicate(prev_path[prev_path.len - 1]));
-            const this_sep = (this_path.len != 0 and sepPredicate(this_path[0]));
+            if (this_path.len == 0) continue;
+            const prev_sep = sepPredicate(prev_path[prev_path.len - 1]);
+            const this_sep = sepPredicate(this_path[0]);
             sum += @boolToInt(!prev_sep and !this_sep);
             sum += if (prev_sep and this_sep) this_path.len - 1 else this_path.len;
+            prev_path = this_path;
         }
+
         if (zero) sum += 1;
         break :blk sum;
     };
@@ -61,14 +76,16 @@ fn joinSepMaybeZ(allocator: *Allocator, separator: u8, sepPredicate: fn (u8) boo
     const buf = try allocator.alloc(u8, total_len);
     errdefer allocator.free(buf);
 
-    mem.copy(u8, buf, paths[0]);
-    var buf_index: usize = paths[0].len;
-    var i: usize = 1;
+    mem.copy(u8, buf, paths[first_path_index]);
+    var buf_index: usize = paths[first_path_index].len;
+    var prev_path = paths[first_path_index];
+    assert(prev_path.len > 0);
+    var i: usize = first_path_index + 1;
     while (i < paths.len) : (i += 1) {
-        const prev_path = paths[i - 1];
         const this_path = paths[i];
-        const prev_sep = (prev_path.len != 0 and sepPredicate(prev_path[prev_path.len - 1]));
-        const this_sep = (this_path.len != 0 and sepPredicate(this_path[0]));
+        if (this_path.len == 0) continue;
+        const prev_sep = sepPredicate(prev_path[prev_path.len - 1]);
+        const this_sep = sepPredicate(this_path[0]);
         if (!prev_sep and !this_sep) {
             buf[buf_index] = separator;
             buf_index += 1;
@@ -76,6 +93,7 @@ fn joinSepMaybeZ(allocator: *Allocator, separator: u8, sepPredicate: fn (u8) boo
         const adjusted_path = if (prev_sep and this_sep) this_path[1..] else this_path;
         mem.copy(u8, buf[buf_index..], adjusted_path);
         buf_index += adjusted_path.len;
+        prev_path = this_path;
     }
 
     if (zero) buf[buf.len - 1] = 0;
@@ -148,6 +166,10 @@ test "join" {
         try testJoinMaybeZWindows(&[_][]const u8{ "c:\\", "a", "b/", "c" }, "c:\\a\\b/c", zero);
         try testJoinMaybeZWindows(&[_][]const u8{ "c:\\a/", "b\\", "/c" }, "c:\\a/b\\c", zero);
 
+        try testJoinMaybeZWindows(&[_][]const u8{ "", "c:\\", "", "", "a", "b\\", "c", "" }, "c:\\a\\b\\c", zero);
+        try testJoinMaybeZWindows(&[_][]const u8{ "c:\\a/", "", "b\\", "", "/c" }, "c:\\a/b\\c", zero);
+        try testJoinMaybeZWindows(&[_][]const u8{ "", "" }, "", zero);
+
         try testJoinMaybeZPosix(&[_][]const u8{}, "", zero);
         try testJoinMaybeZPosix(&[_][]const u8{ "/a/b", "c" }, "/a/b/c", zero);
         try testJoinMaybeZPosix(&[_][]const u8{ "/a/b/", "c" }, "/a/b/c", zero);
@@ -163,6 +185,10 @@ test "join" {
 
         try testJoinMaybeZPosix(&[_][]const u8{ "a", "/c" }, "a/c", zero);
         try testJoinMaybeZPosix(&[_][]const u8{ "a/", "/c" }, "a/c", zero);
+
+        try testJoinMaybeZPosix(&[_][]const u8{ "", "/", "a", "", "b/", "c", "" }, "/a/b/c", zero);
+        try testJoinMaybeZPosix(&[_][]const u8{ "/a/", "", "", "b/", "c" }, "/a/b/c", zero);
+        try testJoinMaybeZPosix(&[_][]const u8{ "", "" }, "", zero);
     }
 }
 

From 98eea963deb85d2174262d5f45ddd614a7906231 Mon Sep 17 00:00:00 2001
From: Evan Haas <evan@lagerdata.com>
Date: Mon, 26 Jul 2021 12:08:29 -0700
Subject: [PATCH 14/96] translate-c: fix import path in translation failure
 comment

---
 src/translate_c.zig       | 4 ++--
 test/run_translated_c.zig | 2 +-
 test/translate_c.zig      | 4 ++--
 3 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/translate_c.zig b/src/translate_c.zig
index 395a314f7c..df8e285b59 100644
--- a/src/translate_c.zig
+++ b/src/translate_c.zig
@@ -1969,7 +1969,7 @@ fn transBuiltinFnExpr(c: *Context, scope: *Scope, expr: *const clang.Expr, used:
     const node = try transExpr(c, scope, expr, used);
     if (node.castTag(.identifier)) |ident| {
         const name = ident.data;
-        if (!isBuiltinDefined(name)) return fail(c, error.UnsupportedTranslation, expr.getBeginLoc(), "TODO implement function '{s}' in std.c.builtins", .{name});
+        if (!isBuiltinDefined(name)) return fail(c, error.UnsupportedTranslation, expr.getBeginLoc(), "TODO implement function '{s}' in std.zig.c_builtins", .{name});
     }
     return node;
 }
@@ -5574,7 +5574,7 @@ fn parseCPrimaryExprInner(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!N
         .Identifier => {
             const mangled_name = scope.getAlias(slice);
             if (mem.startsWith(u8, mangled_name, "__builtin_") and !isBuiltinDefined(mangled_name)) {
-                try m.fail(c, "TODO implement function '{s}' in std.c.builtins", .{mangled_name});
+                try m.fail(c, "TODO implement function '{s}' in std.zig.c_builtins", .{mangled_name});
                 return error.ParseError;
             }
             const identifier = try Tag.identifier.create(c.arena, builtin_typedef_map.get(mangled_name) orelse mangled_name);
diff --git a/test/run_translated_c.zig b/test/run_translated_c.zig
index 4953896636..ef2fd187df 100644
--- a/test/run_translated_c.zig
+++ b/test/run_translated_c.zig
@@ -1243,7 +1243,7 @@ pub fn addCases(cases: *tests.RunTranslatedCContext) void {
         \\}
     , "");
 
-    // See __builtin_alloca_with_align comment in std.c.builtins
+    // See __builtin_alloca_with_align comment in std.zig.c_builtins
     cases.add("use of unimplemented builtin in unused function does not prevent compilation",
         \\#include <stdlib.h>
         \\void unused() {
diff --git a/test/translate_c.zig b/test/translate_c.zig
index 1ceaf15e5c..b75d3b5cac 100644
--- a/test/translate_c.zig
+++ b/test/translate_c.zig
@@ -3461,11 +3461,11 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\pub const MAY_NEED_PROMOTION_OCT = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0o20000000000, .octal);
     });
 
-    // See __builtin_alloca_with_align comment in std.c.builtins
+    // See __builtin_alloca_with_align comment in std.zig.c_builtins
     cases.add("demote un-implemented builtins",
         \\#define FOO(X) __builtin_alloca_with_align((X), 8)
     , &[_][]const u8{
-        \\pub const FOO = @compileError("TODO implement function '__builtin_alloca_with_align' in std.c.builtins");
+        \\pub const FOO = @compileError("TODO implement function '__builtin_alloca_with_align' in std.zig.c_builtins");
     });
 
     cases.add("null sentinel arrays when initialized from string literal. Issue #8256",

From c090e38340f3b0df30e1affb838a6e171f943280 Mon Sep 17 00:00:00 2001
From: Evan Haas <evan@lagerdata.com>
Date: Tue, 27 Jul 2021 16:06:38 -0700
Subject: [PATCH 15/96] translate-c: add support for ChooseExpr

---
 src/clang.zig             |  5 ++++
 src/translate_c.zig       |  4 ++++
 src/zig_clang.cpp         |  5 ++++
 src/zig_clang.h           |  3 +++
 test/run_translated_c.zig | 50 +++++++++++++++++++++++++++++++++++++++
 5 files changed, 67 insertions(+)

diff --git a/src/clang.zig b/src/clang.zig
index 023d1aba4b..0632c5ab67 100644
--- a/src/clang.zig
+++ b/src/clang.zig
@@ -269,6 +269,11 @@ pub const CharacterLiteral = opaque {
     extern fn ZigClangCharacterLiteral_getValue(*const CharacterLiteral) c_uint;
 };
 
+pub const ChooseExpr = opaque {
+    pub const getChosenSubExpr = ZigClangChooseExpr_getChosenSubExpr;
+    extern fn ZigClangChooseExpr_getChosenSubExpr(*const ChooseExpr) *const Expr;
+};
+
 pub const CompoundAssignOperator = opaque {
     pub const getType = ZigClangCompoundAssignOperator_getType;
     extern fn ZigClangCompoundAssignOperator_getType(*const CompoundAssignOperator) QualType;
diff --git a/src/translate_c.zig b/src/translate_c.zig
index df8e285b59..fb40344b34 100644
--- a/src/translate_c.zig
+++ b/src/translate_c.zig
@@ -1308,6 +1308,10 @@ fn transStmt(
             const shuffle_vec_node = try transShuffleVectorExpr(c, scope, shuffle_vec_expr);
             return maybeSuppressResult(c, scope, result_used, shuffle_vec_node);
         },
+        .ChooseExprClass => {
+            const choose_expr = @ptrCast(*const clang.ChooseExpr, stmt);
+            return transExpr(c, scope, choose_expr.getChosenSubExpr(), result_used);
+        },
         // When adding new cases here, see comment for maybeBlockify()
         .GCCAsmStmtClass,
         .GotoStmtClass,
diff --git a/src/zig_clang.cpp b/src/zig_clang.cpp
index 7c923021d8..4fe1dfc286 100644
--- a/src/zig_clang.cpp
+++ b/src/zig_clang.cpp
@@ -2832,6 +2832,11 @@ unsigned ZigClangCharacterLiteral_getValue(const struct ZigClangCharacterLiteral
     return casted->getValue();
 }
 
+const struct ZigClangExpr *ZigClangChooseExpr_getChosenSubExpr(const struct ZigClangChooseExpr *self) {
+    auto casted = reinterpret_cast<const clang::ChooseExpr *>(self);
+    return reinterpret_cast<const ZigClangExpr *>(casted->getChosenSubExpr());
+}
+
 const struct ZigClangExpr *ZigClangAbstractConditionalOperator_getCond(const struct ZigClangAbstractConditionalOperator *self) {
     auto casted = reinterpret_cast<const clang::AbstractConditionalOperator *>(self);
     return reinterpret_cast<const struct ZigClangExpr *>(casted->getCond());
diff --git a/src/zig_clang.h b/src/zig_clang.h
index 634534dfb4..dc35df3772 100644
--- a/src/zig_clang.h
+++ b/src/zig_clang.h
@@ -104,6 +104,7 @@ struct ZigClangCStyleCastExpr;
 struct ZigClangCallExpr;
 struct ZigClangCaseStmt;
 struct ZigClangCharacterLiteral;
+struct ZigClangChooseExpr;
 struct ZigClangCompoundAssignOperator;
 struct ZigClangCompoundStmt;
 struct ZigClangConditionalOperator;
@@ -1242,6 +1243,8 @@ ZIG_EXTERN_C struct ZigClangSourceLocation ZigClangCharacterLiteral_getBeginLoc(
 ZIG_EXTERN_C enum ZigClangCharacterLiteral_CharacterKind ZigClangCharacterLiteral_getKind(const struct ZigClangCharacterLiteral *);
 ZIG_EXTERN_C unsigned ZigClangCharacterLiteral_getValue(const struct ZigClangCharacterLiteral *);
 
+ZIG_EXTERN_C const struct ZigClangExpr *ZigClangChooseExpr_getChosenSubExpr(const struct ZigClangChooseExpr *);
+
 ZIG_EXTERN_C const struct ZigClangExpr *ZigClangAbstractConditionalOperator_getCond(const struct ZigClangAbstractConditionalOperator *);
 ZIG_EXTERN_C const struct ZigClangExpr *ZigClangAbstractConditionalOperator_getTrueExpr(const struct ZigClangAbstractConditionalOperator *);
 ZIG_EXTERN_C const struct ZigClangExpr *ZigClangAbstractConditionalOperator_getFalseExpr(const struct ZigClangAbstractConditionalOperator *);
diff --git a/test/run_translated_c.zig b/test/run_translated_c.zig
index ef2fd187df..dab200af0d 100644
--- a/test/run_translated_c.zig
+++ b/test/run_translated_c.zig
@@ -1659,4 +1659,54 @@ pub fn addCases(cases: *tests.RunTranslatedCContext) void {
         \\    return 0;
         \\}
     , "");
+
+    cases.add("__builtin_choose_expr (unchosen expression is not evaluated)",
+        \\#include <stdlib.h>
+        \\int main(void) {
+        \\    int x = 0.0;
+        \\    int y = 0.0;
+        \\    int res;
+        \\    res = __builtin_choose_expr(1, 1, x / y);
+        \\    if (res != 1) abort();
+        \\    res = __builtin_choose_expr(0, x / y, 2);
+        \\    if (res != 2) abort();
+        \\    return 0;
+        \\}
+    , "");
+
+    // TODO: add isnan check for long double once bitfield support is added
+    //       (needed for x86_64-windows-gnu)
+    // TODO: add isinf check for long double once std.math.isInf supports c_longdouble
+    cases.add("NAN and INFINITY",
+        \\#include <math.h>
+        \\#include <stdint.h>
+        \\#include <stdlib.h>
+        \\union uf { uint32_t u; float f; };
+        \\#define CHECK_NAN(STR, VAL) { \
+        \\    union uf unpack = {.f = __builtin_nanf(STR)}; \
+        \\    if (!isnan(unpack.f)) abort(); \
+        \\    if (unpack.u != VAL) abort(); \
+        \\}
+        \\int main(void) {
+        \\    float f_nan = NAN;
+        \\    if (!isnan(f_nan)) abort();
+        \\    double d_nan = NAN;
+        \\    if (!isnan(d_nan)) abort();
+        \\    CHECK_NAN("0", 0x7FC00000);
+        \\    CHECK_NAN("", 0x7FC00000);
+        \\    CHECK_NAN("1", 0x7FC00001);
+        \\    CHECK_NAN("0x7FC00000", 0x7FC00000);
+        \\    CHECK_NAN("0x7FC0000F", 0x7FC0000F);
+        \\    CHECK_NAN("0x7FC000F0", 0x7FC000F0);
+        \\    CHECK_NAN("0x7FC00F00", 0x7FC00F00);
+        \\    CHECK_NAN("0x7FC0F000", 0x7FC0F000);
+        \\    CHECK_NAN("0x7FCF0000", 0x7FCF0000);
+        \\    CHECK_NAN("0xFFFFFFFF", 0x7FFFFFFF);
+        \\    float f_inf = INFINITY;
+        \\    if (!isinf(f_inf)) abort();
+        \\    double d_inf = INFINITY;
+        \\    if (!isinf(d_inf)) abort();
+        \\    return 0;
+        \\}
+    , "");
 }

From d4d3a9dcc93d517ffec43c9b4572977c05ee4d4b Mon Sep 17 00:00:00 2001
From: Evan Haas <evan@lagerdata.com>
Date: Mon, 26 Jul 2021 12:05:53 -0700
Subject: [PATCH 16/96] translate-c: handle floating point NAN and INFINITY
 macros

---
 lib/std/zig/c_builtins.zig | 43 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 43 insertions(+)

diff --git a/lib/std/zig/c_builtins.zig b/lib/std/zig/c_builtins.zig
index afa3ae0a87..479f7a3b0e 100644
--- a/lib/std/zig/c_builtins.zig
+++ b/lib/std/zig/c_builtins.zig
@@ -191,6 +191,49 @@ pub inline fn __builtin_expect(expr: c_long, c: c_long) c_long {
     return expr;
 }
 
+/// returns a quiet NaN. Quiet NaNs have many representations; tagp is used to select one in an
+/// implementation-defined way.
+/// This implementation is based on the description for __builtin_nan provided in the GCC docs at
+/// https://gcc.gnu.org/onlinedocs/gcc/Other-Builtins.html#index-_005f_005fbuiltin_005fnan
+/// Comment is reproduced below:
+/// Since ISO C99 defines this function in terms of strtod, which we do not implement, a description
+/// of the parsing is in order.
+/// The string is parsed as by strtol; that is, the base is recognized by leading ‘0’ or ‘0x’ prefixes.
+/// The number parsed is placed in the significand such that the least significant bit of the number is
+///    at the least significant bit of the significand.
+/// The number is truncated to fit the significand field provided.
+/// The significand is forced to be a quiet NaN.
+///
+/// If tagp contains any non-numeric characters, the function returns a NaN whose significand is zero.
+/// If tagp is empty, the function returns a NaN whose significand is zero.
+pub inline fn __builtin_nanf(tagp: []const u8) f32 {
+    const parsed = std.fmt.parseUnsigned(c_ulong, tagp, 0) catch 0;
+    const bits = @truncate(u23, parsed); // single-precision float trailing significand is 23 bits
+    return @bitCast(f32, @as(u32, bits) | std.math.qnan_u32);
+}
+
+pub inline fn __builtin_huge_valf() f32 {
+    return std.math.inf(f32);
+}
+
+pub inline fn __builtin_inff() f32 {
+    return std.math.inf(f32);
+}
+
+pub inline fn __builtin_isnan(x: anytype) c_int {
+    return @boolToInt(std.math.isNan(x));
+}
+
+pub inline fn __builtin_isinf(x: anytype) c_int {
+    return @boolToInt(std.math.isInf(x));
+}
+
+/// Similar to isinf, except the return value is -1 for an argument of -Inf and 1 for an argument of +Inf.
+pub inline fn __builtin_isinf_sign(x: anytype) c_int {
+    if (!std.math.isInf(x)) return 0;
+    return if (std.math.isPositiveInf(x)) 1 else -1;
+}
+
 // __builtin_alloca_with_align is not currently implemented.
 // It is used in a run-translated-c test and a test-translate-c test to ensure that non-implemented
 // builtins are correctly demoted. If you implement __builtin_alloca_with_align, please update the

From c1285a1bbe04ab9960768ed8eb583ba8eb32cbe1 Mon Sep 17 00:00:00 2001
From: Ominitay <37453713+Ominitay@users.noreply.github.com>
Date: Sat, 17 Apr 2021 18:33:43 +0100
Subject: [PATCH 17/96] Move fs.Walker to fs.Dir.Walker

fs.Walker has been replaced with fs.Dir.Walker. Paths of entries
returned are relative to the Dir.
---
 lib/std/build.zig   |  12 ++-
 lib/std/fs.zig      | 183 +++++++++++++++++++++-----------------------
 lib/std/fs/test.zig |   5 +-
 3 files changed, 100 insertions(+), 100 deletions(-)

diff --git a/lib/std/build.zig b/lib/std/build.zig
index 22f454adca..685fd2bdc5 100644
--- a/lib/std/build.zig
+++ b/lib/std/build.zig
@@ -3015,7 +3015,8 @@ pub const InstallDirStep = struct {
         const self = @fieldParentPtr(InstallDirStep, "step", step);
         const dest_prefix = self.builder.getInstallPath(self.options.install_dir, self.options.install_subdir);
         const full_src_dir = self.builder.pathFromRoot(self.options.source_dir);
-        var it = try fs.walkPath(self.builder.allocator, full_src_dir);
+        const src_dir = try std.fs.cwd().openDir(full_src_dir, .{ .iterate = true });
+        var it = try src_dir.walk(self.builder.allocator);
         next_entry: while (try it.next()) |entry| {
             for (self.options.exclude_extensions) |ext| {
                 if (mem.endsWith(u8, entry.path, ext)) {
@@ -3023,9 +3024,12 @@ pub const InstallDirStep = struct {
                 }
             }
 
-            const rel_path = entry.path[full_src_dir.len + 1 ..];
+            const full_path = try fs.path.join(self.builder.allocator, &[_][]const u8{
+                full_src_dir, entry.path,
+            });
+
             const dest_path = try fs.path.join(self.builder.allocator, &[_][]const u8{
-                dest_prefix, rel_path,
+                dest_prefix, entry.path,
             });
 
             switch (entry.kind) {
@@ -3038,7 +3042,7 @@ pub const InstallDirStep = struct {
                         }
                     }
 
-                    try self.builder.updateFile(entry.path, dest_path);
+                    try self.builder.updateFile(full_path, dest_path);
                 },
                 else => continue,
             }
diff --git a/lib/std/fs.zig b/lib/std/fs.zig
index 4ecdc3803b..2504965e3a 100644
--- a/lib/std/fs.zig
+++ b/lib/std/fs.zig
@@ -737,6 +737,94 @@ pub const Dir = struct {
         }
     }
 
+    pub const Walker = struct {
+        stack: std.ArrayList(StackItem),
+        name_buffer: std.ArrayList(u8),
+
+        pub const WalkerEntry = struct {
+            /// The containing directory. This can be used to operate directly on `basename`
+            /// rather than `path`, avoiding `error.NameTooLong` for deeply nested paths.
+            /// The directory remains open until `next` or `deinit` is called.
+            dir: Dir,
+            basename: []const u8,
+            path: []const u8,
+            kind: Dir.Entry.Kind,
+        };
+
+        const StackItem = struct {
+            iter: Dir.Iterator,
+            dirname_len: usize,
+        };
+
+        /// After each call to this function, and on deinit(), the memory returned
+        /// from this function becomes invalid. A copy must be made in order to keep
+        /// a reference to the path.
+        pub fn next(self: *Walker) !?WalkerEntry {
+            while (self.stack.items.len != 0) {
+                // `top` becomes invalid after appending to `self.stack`
+                var top = &self.stack.items[self.stack.items.len - 1];
+                const dirname_len = top.dirname_len;
+                if (try top.iter.next()) |base| {
+                    self.name_buffer.shrinkRetainingCapacity(dirname_len);
+                    if (self.name_buffer.items.len != 0) {
+                        try self.name_buffer.append(path.sep);
+                    }
+                    try self.name_buffer.appendSlice(base.name);
+                    if (base.kind == .Directory) {
+                        var new_dir = top.iter.dir.openDir(base.name, .{ .iterate = true }) catch |err| switch (err) {
+                            error.NameTooLong => unreachable, // no path sep in base.name
+                            else => |e| return e,
+                        };
+                        {
+                            errdefer new_dir.close();
+                            try self.stack.append(StackItem{
+                                .iter = new_dir.iterate(),
+                                .dirname_len = self.name_buffer.items.len,
+                            });
+                            top = &self.stack.items[self.stack.items.len - 1];
+                        }
+                    }
+                    return WalkerEntry{
+                        .dir = top.iter.dir,
+                        .basename = self.name_buffer.items[dirname_len + 1 ..],
+                        .path = self.name_buffer.items,
+                        .kind = base.kind,
+                    };
+                } else {
+                    self.stack.pop().iter.dir.close();
+                }
+            }
+            return null;
+        }
+
+        pub fn deinit(self: *Walker) void {
+            while (self.stack.popOrNull()) |*item| item.iter.dir.close();
+            self.stack.deinit();
+            self.name_buffer.deinit();
+        }
+    };
+
+    /// Recursively iterates over a directory.
+    /// Must call `Walker.deinit` when done.
+    /// The order of returned file system entries is undefined.
+    pub fn walk(self: Dir, allocator: *Allocator) !Walker {
+        var name_buffer = std.ArrayList(u8).init(allocator);
+        errdefer name_buffer.deinit();
+
+        var stack = std.ArrayList(Walker.StackItem).init(allocator);
+        errdefer stack.deinit();
+
+        try stack.append(Walker.StackItem{
+            .iter = self.iterate(),
+            .dirname_len = 0,
+        });
+
+        return Walker{
+            .stack = stack,
+            .name_buffer = name_buffer,
+        };
+    }
+
     pub const OpenError = error{
         FileNotFound,
         NotDir,
@@ -2259,100 +2347,7 @@ pub fn symLinkAbsoluteZ(target_path_c: [*:0]const u8, sym_link_path_c: [*:0]cons
 pub const symLink = @compileError("deprecated: use Dir.symLink or symLinkAbsolute");
 pub const symLinkC = @compileError("deprecated: use Dir.symLinkZ or symLinkAbsoluteZ");
 
-pub const Walker = struct {
-    stack: std.ArrayList(StackItem),
-    name_buffer: std.ArrayList(u8),
-
-    pub const Entry = struct {
-        /// The containing directory. This can be used to operate directly on `basename`
-        /// rather than `path`, avoiding `error.NameTooLong` for deeply nested paths.
-        /// The directory remains open until `next` or `deinit` is called.
-        dir: Dir,
-        /// TODO make this null terminated for API convenience
-        basename: []const u8,
-
-        path: []const u8,
-        kind: Dir.Entry.Kind,
-    };
-
-    const StackItem = struct {
-        dir_it: Dir.Iterator,
-        dirname_len: usize,
-    };
-
-    /// After each call to this function, and on deinit(), the memory returned
-    /// from this function becomes invalid. A copy must be made in order to keep
-    /// a reference to the path.
-    pub fn next(self: *Walker) !?Entry {
-        while (true) {
-            if (self.stack.items.len == 0) return null;
-            // `top` becomes invalid after appending to `self.stack`.
-            var top = &self.stack.items[self.stack.items.len - 1];
-            const dirname_len = top.dirname_len;
-            if (try top.dir_it.next()) |base| {
-                self.name_buffer.shrinkRetainingCapacity(dirname_len);
-                try self.name_buffer.append(path.sep);
-                try self.name_buffer.appendSlice(base.name);
-                if (base.kind == .Directory) {
-                    var new_dir = top.dir_it.dir.openDir(base.name, .{ .iterate = true }) catch |err| switch (err) {
-                        error.NameTooLong => unreachable, // no path sep in base.name
-                        else => |e| return e,
-                    };
-                    {
-                        errdefer new_dir.close();
-                        try self.stack.append(StackItem{
-                            .dir_it = new_dir.iterate(),
-                            .dirname_len = self.name_buffer.items.len,
-                        });
-                        top = &self.stack.items[self.stack.items.len - 1];
-                    }
-                }
-                return Entry{
-                    .dir = top.dir_it.dir,
-                    .basename = self.name_buffer.items[dirname_len + 1 ..],
-                    .path = self.name_buffer.items,
-                    .kind = base.kind,
-                };
-            } else {
-                self.stack.pop().dir_it.dir.close();
-            }
-        }
-    }
-
-    pub fn deinit(self: *Walker) void {
-        while (self.stack.popOrNull()) |*item| item.dir_it.dir.close();
-        self.stack.deinit();
-        self.name_buffer.deinit();
-    }
-};
-
-/// Recursively iterates over a directory.
-/// Must call `Walker.deinit` when done.
-/// `dir_path` must not end in a path separator.
-/// The order of returned file system entries is undefined.
-pub fn walkPath(allocator: *Allocator, dir_path: []const u8) !Walker {
-    assert(!mem.endsWith(u8, dir_path, path.sep_str));
-
-    var dir = try cwd().openDir(dir_path, .{ .iterate = true });
-    errdefer dir.close();
-
-    var name_buffer = std.ArrayList(u8).init(allocator);
-    errdefer name_buffer.deinit();
-
-    try name_buffer.appendSlice(dir_path);
-
-    var walker = Walker{
-        .stack = std.ArrayList(Walker.StackItem).init(allocator),
-        .name_buffer = name_buffer,
-    };
-
-    try walker.stack.append(Walker.StackItem{
-        .dir_it = dir.iterate(),
-        .dirname_len = dir_path.len,
-    });
-
-    return walker;
-}
+pub const walkPath = @compileError("deprecated: use Dir.walk");
 
 pub const OpenSelfExeError = error{
     SharingViolation,
diff --git a/lib/std/fs/test.zig b/lib/std/fs/test.zig
index 9464959cdb..54f3e238d3 100644
--- a/lib/std/fs/test.zig
+++ b/lib/std/fs/test.zig
@@ -927,8 +927,9 @@ test "walker" {
     }
 
     const tmp_path = try fs.path.join(allocator, &[_][]const u8{ "zig-cache", "tmp", tmp.sub_path[0..] });
+    const tmp_dir = try fs.cwd().openDir(tmp_path, .{ .iterate = true });
 
-    var walker = try fs.walkPath(testing.allocator, tmp_path);
+    var walker = try tmp_dir.walk(testing.allocator);
     defer walker.deinit();
 
     i = 0;
@@ -941,7 +942,7 @@ test "walker" {
             try fs.path.join(allocator, &[_][]const u8{ expected_dir_name, name });
 
         var entry = (try walker.next()).?;
-        try testing.expectEqualStrings(expected_dir_name, try fs.path.relative(allocator, tmp_path, entry.path));
+        try testing.expectEqualStrings(expected_dir_name, entry.path);
     }
 }
 

From c47b46fc8dcb24a9af8e28d169d93170fce0e061 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Tue, 27 Jul 2021 17:16:26 -0700
Subject: [PATCH 18/96] CI: enable stage2 behavior test coverage

---
 ci/azure/linux_script            | 8 +++++---
 ci/azure/macos_script            | 9 ++++++---
 ci/azure/windows_msvc_script.bat | 4 ++++
 ci/srht/freebsd_script           | 5 +++++
 ci/srht/netbsd_script            | 5 +++++
 5 files changed, 25 insertions(+), 6 deletions(-)

diff --git a/ci/azure/linux_script b/ci/azure/linux_script
index 33ad349044..dac7bac614 100755
--- a/ci/azure/linux_script
+++ b/ci/azure/linux_script
@@ -69,9 +69,11 @@ release/bin/zig fmt --check ..
 cmake .. -DZIG_EXECUTABLE="$(pwd)/release/bin/zig"
 make $JOBS install
 
-for step in test-toolchain test-std docs; do
-  release/bin/zig build $step -Denable-qemu -Denable-wasmtime
-done
+release/bin/zig test ../test/behavior.zig -fno-stage1 -fLLVM -I ../test
+
+release/bin/zig build test-toolchain -Denable-qemu -Denable-wasmtime
+release/bin/zig build test-std       -Denable-qemu -Denable-wasmtime
+release/bin/zig build docs           -Denable-qemu -Denable-wasmtime
 
 # Look for HTML errors.
 tidy -qe ../zig-cache/langref.html
diff --git a/ci/azure/macos_script b/ci/azure/macos_script
index 4afaedfa12..01ac3f5838 100755
--- a/ci/azure/macos_script
+++ b/ci/azure/macos_script
@@ -54,9 +54,12 @@ make $JOBS install
 cmake .. -DZIG_EXECUTABLE="$(pwd)/release/bin/zig"
 make $JOBS install
 
-for step in test-toolchain test-std docs; do
-  release/bin/zig build $step
-done
+# TODO figure out why this causes a segmentation fault
+# release/bin/zig test ../test/behavior.zig -fno-stage1 -fLLVM -I ../test
+
+release/bin/zig build test-toolchain
+release/bin/zig build test-std
+release/bin/zig build docs
 
 if [ "${BUILD_REASON}" != "PullRequest" ]; then
   mv ../LICENSE release/
diff --git a/ci/azure/windows_msvc_script.bat b/ci/azure/windows_msvc_script.bat
index df1b63b485..a073650717 100644
--- a/ci/azure/windows_msvc_script.bat
+++ b/ci/azure/windows_msvc_script.bat
@@ -26,6 +26,10 @@ cd %ZIGBUILDDIR%
 cmake.exe .. -Thost=x64 -G"Visual Studio 16 2019" -A x64 "-DCMAKE_INSTALL_PREFIX=%ZIGINSTALLDIR%" "-DCMAKE_PREFIX_PATH=%ZIGPREFIXPATH%" -DCMAKE_BUILD_TYPE=Release -DZIG_OMIT_STAGE2=ON || exit /b
 msbuild /maxcpucount /p:Configuration=Release INSTALL.vcxproj || exit /b
 
+REM Sadly, stage2 is omitted from this build to save memory on the CI server. Once self-hosted is
+REM built with itself and does not gobble as much memory, we can enable these tests.
+REM "%ZIGINSTALLDIR%\bin\zig.exe" test "..\test\behavior.zig" -fno-stage1 -fLLVM -I "..\test" || exit /b
+
 "%ZIGINSTALLDIR%\bin\zig.exe" build test-toolchain -Dskip-non-native -Dskip-stage2-tests || exit /b
 "%ZIGINSTALLDIR%\bin\zig.exe" build test-std -Dskip-non-native || exit /b
 "%ZIGINSTALLDIR%\bin\zig.exe" build docs || exit /b
diff --git a/ci/srht/freebsd_script b/ci/srht/freebsd_script
index 44b0330542..27c7df4933 100755
--- a/ci/srht/freebsd_script
+++ b/ci/srht/freebsd_script
@@ -38,6 +38,11 @@ cmake .. \
     -GNinja
 samu install
 
+# TODO ld.lld: error: undefined symbol: main
+# >>> referenced by crt1_c.c:75 (/usr/src/lib/csu/amd64/crt1_c.c:75)
+# >>>               /usr/lib/crt1.o:(_start)
+#release/bin/zig test ../test/behavior.zig -fno-stage1 -fLLVM -I ../test
+
 # Here we skip some tests to save time.
 release/bin/zig build test -Dskip-compile-errors -Dskip-non-native
 
diff --git a/ci/srht/netbsd_script b/ci/srht/netbsd_script
index 508da4b324..f2d2f09467 100755
--- a/ci/srht/netbsd_script
+++ b/ci/srht/netbsd_script
@@ -51,6 +51,11 @@ samu install
 unset CC
 unset CXX
 
+# TODO ld.lld: error: undefined symbol: main
+#>>> referenced by crt0-common.c
+#>>>               /usr/lib/crt0.o:(___start)
+#release/bin/zig test ../test/behavior.zig -fno-stage1 -fLLVM -I ../test
+
 # Here we skip some tests to save time.
 release/bin/zig build test -Dskip-compile-errors -Dskip-non-native
 

From 8028e46f0150842df4ac6fc050dca8dc58ae5f18 Mon Sep 17 00:00:00 2001
From: Evan Haas <evan@lagerdata.com>
Date: Mon, 19 Apr 2021 12:15:38 -0700
Subject: [PATCH 19/96] translate-c: handle signed array subscripts

A rather complicated workaround for handling signed array subscripts.
Once `[*]T + isize` is allowed, this can be removed.

Fixes #8556
---
 src/translate_c.zig       | 103 ++++++++++++++++++++++++++++++++++----
 test/run_translated_c.zig |  40 +++++++++++++++
 2 files changed, 133 insertions(+), 10 deletions(-)

diff --git a/src/translate_c.zig b/src/translate_c.zig
index fb40344b34..8b465fff96 100644
--- a/src/translate_c.zig
+++ b/src/translate_c.zig
@@ -3273,30 +3273,113 @@ fn transMemberExpr(c: *Context, scope: *Scope, stmt: *const clang.MemberExpr, re
     return maybeSuppressResult(c, scope, result_used, node);
 }
 
+/// ptr[subscr] (`subscr` is a signed integer expression, `ptr` a pointer) becomes:
+/// (blk: {
+///     const tmp = subscr;
+///     if (tmp >= 0) break :blk ptr + @intCast(usize, tmp) else break :blk ptr - ~@bitCast(usize, @intCast(isize, tmp) +% -1);
+/// }).*
+/// Todo: rip this out once `[*]T + isize` becomes valid.
+fn transSignedArrayAccess(
+    c: *Context,
+    scope: *Scope,
+    container_expr: *const clang.Expr,
+    subscr_expr: *const clang.Expr,
+    result_used: ResultUsed,
+) TransError!Node {
+    var block_scope = try Scope.Block.init(c, scope, true);
+    defer block_scope.deinit();
+
+    const tmp = try block_scope.makeMangledName(c, "tmp");
+
+    const subscr_node = try transExpr(c, &block_scope.base, subscr_expr, .used);
+    const subscr_decl = try Tag.var_simple.create(c.arena, .{ .name = tmp, .init = subscr_node });
+    try block_scope.statements.append(subscr_decl);
+
+    const tmp_ref = try Tag.identifier.create(c.arena, tmp);
+
+    const container_node = try transExpr(c, &block_scope.base, container_expr, .used);
+
+    const cond_node = try Tag.greater_than_equal.create(c.arena, .{ .lhs = tmp_ref, .rhs = Tag.zero_literal.init() });
+
+    const then_value = try Tag.add.create(c.arena, .{
+        .lhs = container_node,
+        .rhs = try Tag.int_cast.create(c.arena, .{
+            .lhs = try Tag.identifier.create(c.arena, "usize"),
+            .rhs = tmp_ref,
+        }),
+    });
+
+    const then_body = try Tag.break_val.create(c.arena, .{
+        .label = block_scope.label,
+        .val = then_value,
+    });
+
+    const minuend = container_node;
+    const signed_size = try Tag.int_cast.create(c.arena, .{
+        .lhs = try Tag.identifier.create(c.arena, "isize"),
+        .rhs = tmp_ref,
+    });
+    const to_cast = try Tag.add_wrap.create(c.arena, .{
+        .lhs = signed_size,
+        .rhs = try Tag.negate.create(c.arena, Tag.one_literal.init()),
+    });
+    const bitcast_node = try Tag.bit_cast.create(c.arena, .{
+        .lhs = try Tag.identifier.create(c.arena, "usize"),
+        .rhs = to_cast,
+    });
+    const subtrahend = try Tag.bit_not.create(c.arena, bitcast_node);
+    const difference = try Tag.sub.create(c.arena, .{
+        .lhs = minuend,
+        .rhs = subtrahend,
+    });
+    const else_body = try Tag.break_val.create(c.arena, .{
+        .label = block_scope.label,
+        .val = difference,
+    });
+
+    const if_node = try Tag.@"if".create(c.arena, .{
+        .cond = cond_node,
+        .then = then_body,
+        .@"else" = else_body,
+    });
+
+    try block_scope.statements.append(if_node);
+    const block_node = try block_scope.complete(c);
+
+    const derefed = try Tag.deref.create(c.arena, block_node);
+
+    return maybeSuppressResult(c, &block_scope.base, result_used, derefed);
+}
+
 fn transArrayAccess(c: *Context, scope: *Scope, stmt: *const clang.ArraySubscriptExpr, result_used: ResultUsed) TransError!Node {
-    var base_stmt = stmt.getBase();
+    const base_stmt = stmt.getBase();
+    const base_qt = getExprQualType(c, base_stmt);
+    const is_vector = cIsVector(base_qt);
+
+    const subscr_expr = stmt.getIdx();
+    const subscr_qt = getExprQualType(c, subscr_expr);
+    const is_longlong = cIsLongLongInteger(subscr_qt);
+    const is_signed = cIsSignedInteger(subscr_qt);
 
     // Unwrap the base statement if it's an array decayed to a bare pointer type
     // so that we index the array itself
+    var unwrapped_base = base_stmt;
     if (@ptrCast(*const clang.Stmt, base_stmt).getStmtClass() == .ImplicitCastExprClass) {
         const implicit_cast = @ptrCast(*const clang.ImplicitCastExpr, base_stmt);
 
         if (implicit_cast.getCastKind() == .ArrayToPointerDecay) {
-            base_stmt = implicit_cast.getSubExpr();
+            unwrapped_base = implicit_cast.getSubExpr();
         }
     }
 
-    const container_node = try transExpr(c, scope, base_stmt, .used);
-
-    // cast if the index is long long or signed
-    const subscr_expr = stmt.getIdx();
-    const qt = getExprQualType(c, subscr_expr);
-    const is_longlong = cIsLongLongInteger(qt);
-    const is_signed = cIsSignedInteger(qt);
+    // Special case: actual pointer (not decayed array) and signed integer subscript
+    // See discussion at https://github.com/ziglang/zig/pull/8589
+    if (is_signed and (base_stmt == unwrapped_base) and !is_vector) return transSignedArrayAccess(c, scope, base_stmt, subscr_expr, result_used);
 
+    const container_node = try transExpr(c, scope, unwrapped_base, .used);
     const rhs = if (is_longlong or is_signed) blk: {
         // check if long long first so that signed long long doesn't just become unsigned long long
-        var typeid_node = if (is_longlong) try Tag.identifier.create(c.arena, "usize") else try transQualTypeIntWidthOf(c, qt, false);
+        const typeid_node = if (is_longlong) try Tag.identifier.create(c.arena, "usize") else try transQualTypeIntWidthOf(c, subscr_qt, false);
         break :blk try Tag.int_cast.create(c.arena, .{ .lhs = typeid_node, .rhs = try transExpr(c, scope, subscr_expr, .used) });
     } else try transExpr(c, scope, subscr_expr, .used);
 
diff --git a/test/run_translated_c.zig b/test/run_translated_c.zig
index dab200af0d..2e579b06c7 100644
--- a/test/run_translated_c.zig
+++ b/test/run_translated_c.zig
@@ -1709,4 +1709,44 @@ pub fn addCases(cases: *tests.RunTranslatedCContext) void {
         \\    return 0;
         \\}
     , "");
+
+    cases.add("signed array subscript. Issue #8556",
+        \\#include <stdint.h>
+        \\#include <stdlib.h>
+        \\#define TEST_NEGATIVE(type) { type x = -1; if (ptr[x] != 42) abort(); }
+        \\#define TEST_UNSIGNED(type) { type x = 2; if (arr[x] != 42) abort(); }
+        \\int main(void) {
+        \\    int arr[] = {40, 41, 42, 43};
+        \\    int *ptr = arr + 3;
+        \\    if (ptr[-1] != 42) abort();
+        \\    TEST_NEGATIVE(int);
+        \\    TEST_NEGATIVE(long);
+        \\    TEST_NEGATIVE(long long);
+        \\    TEST_NEGATIVE(int64_t);
+        \\    TEST_NEGATIVE(__int128);
+        \\    TEST_UNSIGNED(unsigned);
+        \\    TEST_UNSIGNED(unsigned long);
+        \\    TEST_UNSIGNED(unsigned long long);
+        \\    TEST_UNSIGNED(uint64_t);
+        \\    TEST_UNSIGNED(size_t);
+        \\    TEST_UNSIGNED(unsigned __int128);
+        \\    return 0;
+        \\}
+    , "");
+
+    cases.add("Ensure side-effects only evaluated once for signed array indices",
+        \\#include <stdlib.h>
+        \\int main(void) {
+        \\    int foo[] = {1, 2, 3, 4};
+        \\    int *p = foo;
+        \\    int idx = 1;
+        \\    if ((++p)[--idx] != 2) abort();
+        \\    if (p != foo + 1) abort();
+        \\    if (idx != 0) abort();
+        \\    if ((p++)[idx++] != 2) abort();
+        \\    if (p != foo + 2) abort();
+        \\    if (idx != 1) abort();
+        \\    return 0;
+        \\}
+    , "");
 }

From 9c028b2078649941366663c6b9a7ed7983c1621e Mon Sep 17 00:00:00 2001
From: Zach Banks <zjbanks@gmail.com>
Date: Fri, 23 Apr 2021 14:24:58 -0400
Subject: [PATCH 20/96] std/ArrayList: Allow `ArrayList(u0)` to be created

Enable creating ArrayList with zero-sized types.
This type still tracks length, but does not allocate
additional memory.
---
 lib/std/array_list.zig | 77 ++++++++++++++++++++++++++++++------------
 1 file changed, 56 insertions(+), 21 deletions(-)

diff --git a/lib/std/array_list.zig b/lib/std/array_list.zig
index 8b46ec2145..1e74d34922 100644
--- a/lib/std/array_list.zig
+++ b/lib/std/array_list.zig
@@ -65,16 +65,23 @@ pub fn ArrayListAligned(comptime T: type, comptime alignment: ?u29) type {
         pub fn initCapacity(allocator: *Allocator, num: usize) !Self {
             var self = Self.init(allocator);
 
-            const new_memory = try self.allocator.allocAdvanced(T, alignment, num, .at_least);
-            self.items.ptr = new_memory.ptr;
-            self.capacity = new_memory.len;
+            if (@sizeOf(T) > 0) {
+                const new_memory = try self.allocator.allocAdvanced(T, alignment, num, .at_least);
+                self.items.ptr = new_memory.ptr;
+                self.capacity = new_memory.len;
+            } else {
+                // If `T` is a zero-sized type, then we do not need to allocate memory.
+                self.capacity = std.math.maxInt(usize);
+            }
 
             return self;
         }
 
         /// Release all allocated memory.
         pub fn deinit(self: Self) void {
-            self.allocator.free(self.allocatedSlice());
+            if (@sizeOf(T) > 0) {
+                self.allocator.free(self.allocatedSlice());
+            }
         }
 
         pub const span = @compileError("deprecated: use `items` field directly");
@@ -279,13 +286,17 @@ pub fn ArrayListAligned(comptime T: type, comptime alignment: ?u29) type {
         pub fn shrinkAndFree(self: *Self, new_len: usize) void {
             assert(new_len <= self.items.len);
 
-            self.items = self.allocator.realloc(self.allocatedSlice(), new_len) catch |e| switch (e) {
-                error.OutOfMemory => { // no problem, capacity is still correct then.
-                    self.items.len = new_len;
-                    return;
-                },
-            };
-            self.capacity = new_len;
+            if (@sizeOf(T) > 0) {
+                self.items = self.allocator.realloc(self.allocatedSlice(), new_len) catch |e| switch (e) {
+                    error.OutOfMemory => { // no problem, capacity is still correct then.
+                        self.items.len = new_len;
+                        return;
+                    },
+                };
+                self.capacity = new_len;
+            } else {
+                self.items.len = new_len;
+            }
         }
 
         /// Reduce length to `new_len`.
@@ -313,18 +324,22 @@ pub fn ArrayListAligned(comptime T: type, comptime alignment: ?u29) type {
         /// Modify the array so that it can hold at least `new_capacity` items.
         /// Invalidates pointers if additional memory is needed.
         pub fn ensureTotalCapacity(self: *Self, new_capacity: usize) !void {
-            var better_capacity = self.capacity;
-            if (better_capacity >= new_capacity) return;
+            if (@sizeOf(T) > 0) {
+                var better_capacity = self.capacity;
+                if (better_capacity >= new_capacity) return;
 
-            while (true) {
-                better_capacity += better_capacity / 2 + 8;
-                if (better_capacity >= new_capacity) break;
+                while (true) {
+                    better_capacity += better_capacity / 2 + 8;
+                    if (better_capacity >= new_capacity) break;
+                }
+
+                // TODO This can be optimized to avoid needlessly copying undefined memory.
+                const new_memory = try self.allocator.reallocAtLeast(self.allocatedSlice(), better_capacity);
+                self.items.ptr = new_memory.ptr;
+                self.capacity = new_memory.len;
+            } else {
+                self.capacity = std.math.maxInt(usize);
             }
-
-            // TODO This can be optimized to avoid needlessly copying undefined memory.
-            const new_memory = try self.allocator.reallocAtLeast(self.allocatedSlice(), better_capacity);
-            self.items.ptr = new_memory.ptr;
-            self.capacity = new_memory.len;
         }
 
         /// Modify the array so that it can hold at least `additional_count` **more** items.
@@ -1299,3 +1314,23 @@ test "ArrayListAligned/ArrayListAlignedUnmanaged accepts unaligned slices" {
         try testing.expectEqualSlices(u8, list.items, &.{ 0, 8, 9, 6, 7, 2, 3 });
     }
 }
+
+test "std.ArrayList(u0)" {
+    // An ArrayList on zero-sized types should not need to allocate
+    const a = &testing.FailingAllocator.init(testing.allocator, 0).allocator;
+
+    var list = ArrayList(u0).init(a);
+    defer list.deinit();
+
+    try list.append(0);
+    try list.append(0);
+    try list.append(0);
+    try testing.expectEqual(list.items.len, 3);
+
+    var count: usize = 0;
+    for (list.items) |x| {
+        try testing.expectEqual(x, 0);
+        count += 1;
+    }
+    try testing.expectEqual(count, 3);
+}

From 2f9e498c6fa0395e4318b2359291353b495a94e1 Mon Sep 17 00:00:00 2001
From: Matt Knight <mattnite@protonmail.com>
Date: Wed, 28 Jul 2021 07:38:36 -0700
Subject: [PATCH 21/96] add build dependency when linkerscript is a generated
 file

---
 lib/std/build.zig | 1 +
 1 file changed, 1 insertion(+)

diff --git a/lib/std/build.zig b/lib/std/build.zig
index 685fd2bdc5..a88667a613 100644
--- a/lib/std/build.zig
+++ b/lib/std/build.zig
@@ -1731,6 +1731,7 @@ pub const LibExeObjStep = struct {
 
     pub fn setLinkerScriptPath(self: *LibExeObjStep, source: FileSource) void {
         self.linker_script = source.dupe(self.builder);
+        source.addStepDependencies(&self.step);
     }
 
     pub fn linkFramework(self: *LibExeObjStep, framework_name: []const u8) void {

From f5d9d739d70f5d99756e277cc7c77484d60ddf42 Mon Sep 17 00:00:00 2001
From: Belhorma Bendebiche <amro@bndb.sh>
Date: Fri, 23 Jul 2021 12:43:38 -0400
Subject: [PATCH 22/96] stage1: Expand SysV C ABI support for small structs

While the SysV ABI is not that complicated, LLVM does not allow us
direct access to enforce it. By mimicking the IR generated by clang,
we can trick LLVM into doing the right thing. This involves two main
additions:

1. `AGG` ABI class
This is not part of the spec, but since we have to track class per
eightbyte and not per struct, the current enum is not enough. I
considered adding multiple classes like: `INTEGER_INTEGER`,
`INTEGER_SSE`, `SSE_INTEGER`. However, all of those cases would trigger
the same code path so it's simpler to collapse into one. This class is
only used on SysV.

2. LLVM C ABI type
Clang uses different types in C ABI function signatures than the
original structs passed in, and does conversion. For example, this
struct: `{ i8, i8, float }` would use `{ i16, float }` at ABI boundaries.
When passed as an argument, it is instead split into two arguments `i16`
and `float`. Therefore, for every struct that passes ABI boundaries we
need to keep track of its corresponding ABI type. Here are some more
examples:

```
| Struct             | ABI equivalent |
| { i8, i8, i8, i8 } | i32            |
| { float, float }   | double         |
| { float, i32, i8 } | { float, i64 } |
```

Then, we must update function calls, returns, parameter lists and inits
to properly convert back and forth as needed.
---
 src/stage1/all_types.hpp   |   5 +-
 src/stage1/analyze.cpp     | 124 +++++++++++++++++++++++++++-
 src/stage1/analyze.hpp     |   3 +
 src/stage1/codegen.cpp     | 160 +++++++++++++++++++++++++++----------
 test/stage1/c_abi/cfuncs.c |  89 +++++++++++++++++++++
 test/stage1/c_abi/main.zig |  87 ++++++++++++++++++++
 6 files changed, 419 insertions(+), 49 deletions(-)

diff --git a/src/stage1/all_types.hpp b/src/stage1/all_types.hpp
index a72faa15ce..dfebc66cfd 100644
--- a/src/stage1/all_types.hpp
+++ b/src/stage1/all_types.hpp
@@ -107,6 +107,7 @@ enum X64CABIClass {
     X64CABIClass_MEMORY_nobyval,
     X64CABIClass_INTEGER,
     X64CABIClass_SSE,
+    X64CABIClass_AGG,
 };
 
 struct Stage1Zir {
@@ -1569,8 +1570,9 @@ struct ZigType {
 
     // These are not supposed to be accessed directly. They're
     // null during semantic analysis, memoized with get_llvm_type
-    // and get_llvm_di_type
+    // get_llvm_c_abi_type and get_llvm_di_type
     LLVMTypeRef llvm_type;
+    LLVMTypeRef llvm_c_abi_type;
     ZigLLVMDIType *llvm_di_type;
 
     union {
@@ -1624,6 +1626,7 @@ struct GlobalExport {
 
 struct ZigFn {
     LLVMValueRef llvm_value;
+    LLVMValueRef abi_return_value; // alloca used when converting at SysV ABI boundaries
     const char *llvm_name;
     AstNode *proto_node;
     AstNode *body_node;
diff --git a/src/stage1/analyze.cpp b/src/stage1/analyze.cpp
index 501e43373d..cf61bf79b7 100644
--- a/src/stage1/analyze.cpp
+++ b/src/stage1/analyze.cpp
@@ -6063,6 +6063,12 @@ Error type_has_bits2(CodeGen *g, ZigType *type_entry, bool *result) {
     return ErrorNone;
 }
 
+bool fn_returns_c_abi_small_struct(FnTypeId *fn_type_id) {
+    ZigType *type = fn_type_id->return_type;
+    return !calling_convention_allows_zig_types(fn_type_id->cc) && 
+        type->id == ZigTypeIdStruct && type->abi_size <= 16;
+}
+
 // Whether you can infer the value based solely on the type.
 OnePossibleValue type_has_one_possible_value(CodeGen *g, ZigType *type_entry) {
     assert(type_entry != nullptr);
@@ -8376,6 +8382,9 @@ static X64CABIClass type_system_V_abi_x86_64_class(CodeGen *g, ZigType *ty, size
                 // be memory.
                 return X64CABIClass_MEMORY;
             }
+            // "If the size of the aggregate exceeds a single eightbyte, each is classified
+            // separately.".
+            // "If one of the classes is MEMORY, the whole argument is passed in memory"
             X64CABIClass working_class = X64CABIClass_Unknown;
             for (uint32_t i = 0; i < ty->data.structure.src_field_count; i += 1) {
                 X64CABIClass field_class = type_c_abi_x86_64_class(g, ty->data.structure.fields[0]->type_entry);
@@ -8385,7 +8394,10 @@ static X64CABIClass type_system_V_abi_x86_64_class(CodeGen *g, ZigType *ty, size
                     working_class = field_class;
                 }
             }
-            return working_class;
+            if (working_class == X64CABIClass_MEMORY) {
+                return X64CABIClass_MEMORY;
+            }
+            return X64CABIClass_AGG;
         }
         case ZigTypeIdUnion: {
             // "If the size of an object is larger than four eightbytes, or it contains unaligned
@@ -8407,7 +8419,7 @@ static X64CABIClass type_system_V_abi_x86_64_class(CodeGen *g, ZigType *ty, size
                 X64CABIClass field_class = type_c_abi_x86_64_class(g, ty->data.unionation.fields->type_entry);
                 if (field_class == X64CABIClass_Unknown)
                     return X64CABIClass_Unknown;
-                if (i == 0 || field_class == X64CABIClass_MEMORY || working_class == X64CABIClass_SSE) {
+                if (i == 0 || field_class == X64CABIClass_MEMORY || field_class == X64CABIClass_INTEGER || working_class == X64CABIClass_SSE) {
                     working_class = field_class;
                 }
             }
@@ -8678,6 +8690,95 @@ static LLVMTypeRef get_llvm_type_of_n_bytes(unsigned byte_size) {
         LLVMInt8Type() : LLVMArrayType(LLVMInt8Type(), byte_size);
 }
 
+static LLVMTypeRef llvm_int_for_size(size_t size) {
+    if (size > 4) {
+        return LLVMInt64Type();
+    } else if (size > 2) {
+        return LLVMInt32Type();
+    } else if (size == 2) {
+        return LLVMInt16Type();
+    } else {
+        return LLVMInt8Type();
+    }
+}
+
+static LLVMTypeRef llvm_sse_for_size(size_t size) {
+    if (size > 4)
+        return LLVMDoubleType();
+    else 
+        return LLVMFloatType();
+}
+
+// Since it's not possible to control calling convention or register
+// allocation in LLVM, clang seems to use intermediate types to manipulate
+// LLVM into doing the right thing. It uses a float to force SSE registers,
+// and a struct when 2 registers must be used. Some examples:
+// { f32 } -> float
+// { f32, i32 } -> { float, i32 }
+// { i32, i32, f32 } -> { i64, float }
+//
+// The implementation below does not match clang 1:1. For instance, clang
+// uses `<2x float>` while we generate `double`. There's a lot more edge
+// cases and complexity when converting back and forth in clang though,
+// so below is the simplest implementation that passes all tests.
+static Error resolve_llvm_c_abi_type(CodeGen *g, ZigType *ty) {
+    size_t ty_size = type_size(g, ty);
+    LLVMTypeRef abi_type;
+    switch (ty->id) {
+        case ZigTypeIdEnum:
+        case ZigTypeIdInt:
+        case ZigTypeIdBool:
+            abi_type = llvm_int_for_size(ty_size);
+            break;
+        case ZigTypeIdFloat:
+        case ZigTypeIdVector:
+            abi_type = llvm_sse_for_size(ty_size);
+            break;
+        case ZigTypeIdStruct: {
+            uint32_t eightbyte_index = 0;
+            size_t type_sizes[] = {0, 0};
+            X64CABIClass type_classes[] = {X64CABIClass_Unknown, X64CABIClass_Unknown};
+            for (uint32_t i = 0; i < ty->data.structure.src_field_count; i += 1) {
+                if (ty->data.structure.fields[i]->offset >= 8) {
+                    eightbyte_index = 1;
+                }
+                X64CABIClass field_class = type_c_abi_x86_64_class(g, ty->data.structure.fields[i]->type_entry);
+
+                if (field_class == X64CABIClass_INTEGER) {
+                    type_classes[eightbyte_index] = X64CABIClass_INTEGER;
+                } else if (type_classes[eightbyte_index] == X64CABIClass_Unknown) {
+                    type_classes[eightbyte_index] = field_class;
+                }
+                type_sizes[eightbyte_index] += ty->data.structure.fields[i]->type_entry->abi_size;
+            }
+
+            LLVMTypeRef return_elem_types[] = {
+                LLVMVoidType(),
+                LLVMVoidType(), 
+            };
+            for (uint32_t i = 0; i <= eightbyte_index; i += 1) {
+                if (type_classes[i] == X64CABIClass_INTEGER) {
+                    return_elem_types[i] = llvm_int_for_size(type_sizes[i]);
+                } else {
+                    return_elem_types[i] = llvm_sse_for_size(type_sizes[i]);
+                }
+            }
+            if (eightbyte_index == 0) {
+                abi_type = return_elem_types[0];
+            } else {
+                abi_type = LLVMStructType(return_elem_types, 2, false);
+            }
+            break;
+        }
+        case ZigTypeIdUnion:
+        default:
+            // currently unreachable
+            zig_panic("TODO: support C ABI unions");
+    }
+    ty->llvm_c_abi_type = abi_type;
+    return ErrorNone;
+}
+
 static void resolve_llvm_types_struct(CodeGen *g, ZigType *struct_type, ResolveStatus wanted_resolve_status,
         ZigType *async_frame_type)
 {
@@ -8936,6 +9037,9 @@ static void resolve_llvm_types_struct(CodeGen *g, ZigType *struct_type, ResolveS
         g->type_resolve_stack.swap_remove(struct_type->data.structure.llvm_full_type_queue_index);
         struct_type->data.structure.llvm_full_type_queue_index = SIZE_MAX;
     }
+
+    if (struct_type->abi_size <= 16 && struct_type->data.structure.layout == ContainerLayoutExtern)
+        resolve_llvm_c_abi_type(g, struct_type);
 }
 
 // This is to be used instead of void for debug info types, to avoid tripping
@@ -9536,8 +9640,13 @@ static void resolve_llvm_types_fn_type(CodeGen *g, ZigType *fn_type) {
         assert(gen_param_types.items[i] != nullptr);
     }
 
-    fn_type->data.fn.raw_type_ref = LLVMFunctionType(get_llvm_type(g, gen_return_type),
-            gen_param_types.items, (unsigned int)gen_param_types.length, fn_type_id->is_var_args);
+    if (!first_arg_return && fn_returns_c_abi_small_struct(fn_type_id)) {
+        fn_type->data.fn.raw_type_ref = LLVMFunctionType(get_llvm_c_abi_type(g, gen_return_type),
+                gen_param_types.items, (unsigned int)gen_param_types.length, fn_type_id->is_var_args);
+    } else {
+        fn_type->data.fn.raw_type_ref = LLVMFunctionType(get_llvm_type(g, gen_return_type),
+                gen_param_types.items, (unsigned int)gen_param_types.length, fn_type_id->is_var_args);
+    }
     const unsigned fn_addrspace = ZigLLVMDataLayoutGetProgramAddressSpace(g->target_data_ref);
     fn_type->llvm_type = LLVMPointerType(fn_type->data.fn.raw_type_ref, fn_addrspace);
     fn_type->data.fn.raw_di_type = ZigLLVMCreateSubroutineType(g->dbuilder, param_di_types.items, (int)param_di_types.length, 0);
@@ -9827,6 +9936,13 @@ static void resolve_llvm_types(CodeGen *g, ZigType *type, ResolveStatus wanted_r
     zig_unreachable();
 }
 
+LLVMTypeRef get_llvm_c_abi_type(CodeGen *g, ZigType *type) {
+    assertNoError(type_resolve(g, type, ResolveStatusLLVMFull));
+    assert(type->abi_size == 0 || type->abi_size >= LLVMABISizeOfType(g->target_data_ref, type->llvm_type));
+    assert(type->abi_align == 0 || type->abi_align >= LLVMABIAlignmentOfType(g->target_data_ref, type->llvm_type));
+    return type->llvm_c_abi_type;
+}
+
 LLVMTypeRef get_llvm_type(CodeGen *g, ZigType *type) {
     assertNoError(type_resolve(g, type, ResolveStatusLLVMFull));
     assert(type->abi_size == 0 || type->abi_size >= LLVMABISizeOfType(g->target_data_ref, type->llvm_type));
diff --git a/src/stage1/analyze.hpp b/src/stage1/analyze.hpp
index 22951db0f0..8290ef572c 100644
--- a/src/stage1/analyze.hpp
+++ b/src/stage1/analyze.hpp
@@ -54,6 +54,8 @@ uint32_t get_async_frame_align_bytes(CodeGen *g);
 bool type_has_bits(CodeGen *g, ZigType *type_entry);
 Error type_has_bits2(CodeGen *g, ZigType *type_entry, bool *result);
 
+bool fn_returns_c_abi_small_struct(FnTypeId *fn_type_id);
+
 enum ExternPosition {
     ExternPositionFunctionParameter,
     ExternPositionFunctionReturn,
@@ -268,6 +270,7 @@ Buf *type_bare_name(ZigType *t);
 Buf *type_h_name(ZigType *t);
 
 LLVMTypeRef get_llvm_type(CodeGen *g, ZigType *type);
+LLVMTypeRef get_llvm_c_abi_type(CodeGen *g, ZigType *type);
 ZigLLVMDIType *get_llvm_di_type(CodeGen *g, ZigType *type);
 
 void add_cc_args(CodeGen *g, ZigList<const char *> &args, const char *out_dep_path, bool translate_c,
diff --git a/src/stage1/codegen.cpp b/src/stage1/codegen.cpp
index 083d15068a..dcb69ca64a 100644
--- a/src/stage1/codegen.cpp
+++ b/src/stage1/codegen.cpp
@@ -2142,75 +2142,103 @@ static bool iter_function_params_c_abi(CodeGen *g, ZigType *fn_type, FnWalk *fn_
                 }
             }
             return true;
-        } else if (abi_class == X64CABIClass_SSE) {
-            // For now only handle structs with only floats/doubles in it.
-            if (ty->id != ZigTypeIdStruct) {
-                if (source_node != nullptr) {
-                    give_up_with_c_abi_error(g, source_node);
-                }
-                // otherwise allow codegen code to report a compile error
-                return false;
-            }
-
-            for (uint32_t i = 0; i < ty->data.structure.src_field_count; i += 1) {
-                if (ty->data.structure.fields[i]->type_entry->id != ZigTypeIdFloat) {
-                    if (source_node != nullptr) {
-                        give_up_with_c_abi_error(g, source_node);
-                    }
-                    // otherwise allow codegen code to report a compile error
-                    return false;
-                }
-            }
-
-            // The SystemV ABI says that we have to setup 1 FP register per f64.
+        } else if (abi_class == X64CABIClass_AGG) {
+            // The SystemV ABI says that we have to setup 1 register per eightbyte.
             // So two f32 can be passed in one f64, but 3 f32 have to be passed in 2 FP registers.
-            // To achieve this with LLVM API, we pass multiple f64 parameters to the LLVM function if
-            // the type is bigger than 8 bytes.
+            // Similarly, two i32 can be passed in one i64, but 3 i32 have to be passed in 2 registers.
+            // LLVM does not allow us to control registers in this way, nor to request specific
+            // ABI conventions. So we have to trick it into allocating the right registers, based
+            // on how clang does it.
+
+            // First, we get the LLVM type corresponding to the C abi for the struct, then
+            // we pass each field as an argument.
 
             // Example:
             // extern struct {
             //      x: f32,
             //      y: f32,
-            //      z: f32,
+            //      z: i32,
             // };
-            // const ptr = (*f64)*Struct;
-            // Register 1: ptr.*
-            // Register 2: (ptr + 1).*
+            // LLVM abi type: { double, i32 }
+            // const ptr = (*abi_type)*Struct;
+            // FP Register 1: abi_type[0]
+            // Register 1: abi_type[1]
 
-            // One floating point register per f64 or 2 f32's
-            size_t number_of_fp_regs = (ty_size + 7) / 8;
+            // However, if the struct fits in one register, then we'll pass it as such
+            size_t number_of_regs = (size_t)ceilf((float)ty_size / (float)8);
+
+            LLVMTypeRef abi_type = get_llvm_c_abi_type(g, ty);
+
+            assert(ty_size <= 16);
 
             switch (fn_walk->id) {
                 case FnWalkIdAttrs: {
-                    fn_walk->data.attrs.gen_i += number_of_fp_regs;
+                    fn_walk->data.attrs.gen_i += number_of_regs;
                     break;
                 }
                 case FnWalkIdCall: {
-                    LLVMValueRef f64_ptr_to_struct = LLVMBuildBitCast(g->builder, val, LLVMPointerType(LLVMDoubleType(), 0), "");
-                    for (uint32_t i = 0; i < number_of_fp_regs; i += 1) {
-                        LLVMValueRef index = LLVMConstInt(g->builtin_types.entry_usize->llvm_type, i, false);
-                        LLVMValueRef indices[] = { index };
-                        LLVMValueRef adjusted_ptr_to_struct = LLVMBuildInBoundsGEP(g->builder, f64_ptr_to_struct, indices, 1, "");
+                    LLVMValueRef abi_ptr_to_struct = LLVMBuildBitCast(g->builder, val, LLVMPointerType(abi_type, 0), "");
+                    if (number_of_regs == 1) {
+                        LLVMValueRef loaded = LLVMBuildLoad(g->builder, abi_ptr_to_struct, "");
+                        fn_walk->data.call.gen_param_values->append(loaded);
+                        break;
+                    }
+                    for (uint32_t i = 0; i < number_of_regs; i += 1) {
+                        LLVMValueRef zero = LLVMConstInt(LLVMInt32Type(), 0, false);
+                        LLVMValueRef index = LLVMConstInt(LLVMInt32Type(), i, false);
+                        LLVMValueRef indices[] = { zero, index };
+                        LLVMValueRef adjusted_ptr_to_struct = LLVMBuildInBoundsGEP(g->builder, abi_ptr_to_struct, indices, 2, "");
                         LLVMValueRef loaded = LLVMBuildLoad(g->builder, adjusted_ptr_to_struct, "");
                         fn_walk->data.call.gen_param_values->append(loaded);
                     }
                     break;
                 }
                 case FnWalkIdTypes: {
-                    for (uint32_t i = 0; i < number_of_fp_regs; i += 1) {
-                        fn_walk->data.types.gen_param_types->append(get_llvm_type(g, g->builtin_types.entry_f64));
+                    if (number_of_regs == 1) {
+                        fn_walk->data.types.gen_param_types->append(abi_type);
+                        fn_walk->data.types.param_di_types->append(get_llvm_di_type(g, g->builtin_types.entry_f64));
+                        break;
+                    }
+                    for (uint32_t i = 0; i < number_of_regs; i += 1) {
+                        fn_walk->data.types.gen_param_types->append(LLVMStructGetTypeAtIndex(abi_type, i));
                         fn_walk->data.types.param_di_types->append(get_llvm_di_type(g, g->builtin_types.entry_f64));
                     }
                     break;
                 }
-                case FnWalkIdVars:
+                case FnWalkIdVars: {
+                    var->value_ref = build_alloca(g, ty, var->name, var->align_bytes);
+                    di_arg_index = fn_walk->data.vars.gen_i;
+                    fn_walk->data.vars.gen_i += 1;
+                    dest_ty = ty;
+                    goto var_ok;
+                }
                 case FnWalkIdInits: {
-                    // TODO: Handle exporting functions
-                    if (source_node != nullptr) {
-                        give_up_with_c_abi_error(g, source_node);
+                    // since we're representing the struct differently as an arg, and potentially
+                    // splitting it, we have to do some work to put it back together.
+                    // the one reg case is straightforward, but if we used two registers we have
+                    // to iterate through the struct abi repr fields and load them one by one.
+                    if (number_of_regs == 1) {
+                        LLVMValueRef arg = LLVMGetParam(llvm_fn, fn_walk->data.inits.gen_i);
+                        LLVMTypeRef ptr_to_int_type_ref = LLVMPointerType(abi_type, 0);
+                        LLVMValueRef bitcasted = LLVMBuildBitCast(g->builder, var->value_ref, ptr_to_int_type_ref, "");
+                        gen_store_untyped(g, arg, bitcasted, var->align_bytes, false);
+                    } else {
+                        LLVMValueRef abi_ptr_to_struct = LLVMBuildBitCast(g->builder, var->value_ref, LLVMPointerType(abi_type, 0), "");
+                        for (uint32_t i = 0; i < number_of_regs; i += 1) {
+                            LLVMValueRef arg = LLVMGetParam(llvm_fn, fn_walk->data.inits.gen_i + i);
+                            LLVMValueRef zero = LLVMConstInt(LLVMInt32Type(), 0, false);
+                            LLVMValueRef index = LLVMConstInt(LLVMInt32Type(), i, false);
+                            LLVMValueRef indices[] = { zero, index };
+                            LLVMValueRef adjusted_ptr_to_struct = LLVMBuildInBoundsGEP(g->builder, abi_ptr_to_struct, indices, 2, "");
+                            LLVMBuildStore(g->builder, arg, adjusted_ptr_to_struct);
+                        }
+                        fn_walk->data.inits.gen_i += 1;
                     }
-                    // otherwise allow codegen code to report a compile error
-                    return false;
+                    if (var->decl_node) {
+                        gen_var_debug_decl(g, var);
+                    }
+                    fn_walk->data.inits.gen_i += 1;
+                    break;
                 }
             }
             return true;
@@ -2654,13 +2682,36 @@ static void gen_async_return(CodeGen *g, Stage1AirInstReturn *instruction) {
     LLVMBuildRetVoid(g->builder);
 }
 
+static LLVMValueRef gen_convert_to_c_abi(CodeGen *g, LLVMValueRef location, LLVMValueRef value) {
+    ZigType *return_type = g->cur_fn->type_entry->data.fn.gen_return_type;
+    size_t size = type_size(g, return_type);
+
+    LLVMTypeRef abi_return_type = get_llvm_c_abi_type(g, return_type);
+    LLVMTypeRef abi_return_type_pointer = LLVMPointerType(abi_return_type, 0);
+
+    if (size < 8) {
+        LLVMValueRef bitcast = LLVMBuildBitCast(g->builder, value, abi_return_type_pointer, "");
+        return LLVMBuildLoad(g->builder, bitcast, "");
+    } else {
+        LLVMTypeRef i8ptr = LLVMPointerType(LLVMInt8Type(), 0);
+        LLVMValueRef bc_location = LLVMBuildBitCast(g->builder, location, i8ptr, "");
+        LLVMValueRef bc_value = LLVMBuildBitCast(g->builder, value, i8ptr, "");
+
+        LLVMValueRef len = LLVMConstInt(LLVMInt64Type(), size, false);
+        ZigLLVMBuildMemCpy(g->builder, bc_location, 8, bc_value, return_type->abi_align, len, false);
+        return LLVMBuildLoad(g->builder, location, "");
+    }
+}
+
 static LLVMValueRef ir_render_return(CodeGen *g, Stage1Air *executable, Stage1AirInstReturn *instruction) {
     if (fn_is_async(g->cur_fn)) {
         gen_async_return(g, instruction);
         return nullptr;
     }
 
-    if (want_first_arg_sret(g, &g->cur_fn->type_entry->data.fn.fn_type_id)) {
+    FnTypeId *fn_type_id = &g->cur_fn->type_entry->data.fn.fn_type_id;
+
+    if (want_first_arg_sret(g, fn_type_id)) {
         if (instruction->operand == nullptr) {
             LLVMBuildRetVoid(g->builder);
             return nullptr;
@@ -2671,6 +2722,16 @@ static LLVMValueRef ir_render_return(CodeGen *g, Stage1Air *executable, Stage1Ai
         ZigType *return_type = instruction->operand->value->type;
         gen_assign_raw(g, g->cur_ret_ptr, get_pointer_to_type(g, return_type, false), value);
         LLVMBuildRetVoid(g->builder);
+    } else if (fn_returns_c_abi_small_struct(fn_type_id)) {
+        LLVMValueRef location = g->cur_fn->abi_return_value;
+        if (instruction->operand == nullptr) {
+            LLVMValueRef converted = gen_convert_to_c_abi(g, location, g->cur_ret_ptr);
+            LLVMBuildRet(g->builder, converted);
+        } else {
+            LLVMValueRef value = ir_llvm_value(g, instruction->operand);
+            LLVMValueRef converted = gen_convert_to_c_abi(g, location, value);
+            LLVMBuildRet(g->builder, converted);
+        }
     } else if (g->cur_fn->type_entry->data.fn.fn_type_id.cc != CallingConventionAsync &&
             handle_is_ptr(g, g->cur_fn->type_entry->data.fn.fn_type_id.return_type))
     {
@@ -4678,6 +4739,12 @@ static LLVMValueRef ir_render_call(CodeGen *g, Stage1Air *executable, Stage1AirI
     } else if (first_arg_ret) {
         ZigLLVMSetCallSret(result, get_llvm_type(g, src_return_type));
         return result_loc;
+    } else if (fn_returns_c_abi_small_struct(fn_type_id)) {
+        LLVMTypeRef abi_type = get_llvm_c_abi_type(g, src_return_type);
+        LLVMTypeRef abi_type_ptr = LLVMPointerType(abi_type, 0);
+        LLVMValueRef bitcast = LLVMBuildBitCast(g->builder, result_loc, abi_type_ptr, "");
+        LLVMBuildStore(g->builder, result, bitcast);
+        return result_loc;
     } else if (handle_is_ptr(g, src_return_type)) {
         LLVMValueRef store_instr = LLVMBuildStore(g->builder, result, result_loc);
         LLVMSetAlignment(store_instr, get_ptr_align(g, instruction->result_loc->value->type));
@@ -8291,6 +8358,11 @@ static void do_code_gen(CodeGen *g) {
             g->cur_err_ret_trace_val_stack = nullptr;
         }
 
+        if (fn_returns_c_abi_small_struct(fn_type_id)) {
+            LLVMTypeRef abi_type = get_llvm_c_abi_type(g, fn_type_id->return_type);
+            fn_table_entry->abi_return_value = LLVMBuildAlloca(g->builder, abi_type, "");
+        }
+
         if (!is_async) {
             // allocate async frames for nosuspend calls & awaits to async functions
             ZigType *largest_call_frame_type = nullptr;
diff --git a/test/stage1/c_abi/cfuncs.c b/test/stage1/c_abi/cfuncs.c
index a3b8c9a8c6..0182462716 100644
--- a/test/stage1/c_abi/cfuncs.c
+++ b/test/stage1/c_abi/cfuncs.c
@@ -61,7 +61,20 @@ struct SmallStructInts {
     uint8_t c;
     uint8_t d;
 };
+
 void zig_small_struct_ints(struct SmallStructInts);
+struct SmallStructInts zig_ret_small_struct_ints();
+
+struct MedStructMixed {
+    uint32_t a;
+    float b;
+    float c;
+    uint32_t d;
+};
+
+void zig_med_struct_mixed(struct MedStructMixed);
+struct MedStructMixed zig_ret_med_struct_mixed();
+
 
 struct SplitStructInts {
     uint64_t a;
@@ -70,6 +83,14 @@ struct SplitStructInts {
 };
 void zig_split_struct_ints(struct SplitStructInts);
 
+struct SplitStructMixed {
+    uint64_t a;
+    uint8_t b;
+    float c;
+};
+void zig_split_struct_mixed(struct SplitStructMixed);
+struct SplitStructMixed zig_ret_split_struct_mixed();
+
 struct BigStruct zig_big_struct_both(struct BigStruct);
 
 typedef struct Vector3 {
@@ -121,6 +142,16 @@ void run_c_tests(void) {
         zig_split_struct_ints(s);
     }
 
+    {
+        struct MedStructMixed s = {1234, 100.0f, 1337.0f};
+        zig_med_struct_mixed(s);
+    }
+
+    {
+        struct SplitStructMixed s = {1234, 100, 1337.0f};
+        zig_split_struct_mixed(s);
+    }
+
     {
         struct BigStruct s = {30, 31, 32, 33, 34};
         struct BigStruct res = zig_big_struct_both(s);
@@ -230,6 +261,44 @@ void c_small_struct_ints(struct SmallStructInts x) {
     assert_or_panic(x.b == 2);
     assert_or_panic(x.c == 3);
     assert_or_panic(x.d == 4);
+
+    struct SmallStructInts y = zig_ret_small_struct_ints();
+
+    assert_or_panic(y.a == 1);
+    assert_or_panic(y.b == 2);
+    assert_or_panic(y.c == 3);
+    assert_or_panic(y.d == 4);
+}
+
+struct SmallStructInts c_ret_small_struct_ints() {
+    struct SmallStructInts s = {
+        .a = 1,
+        .b = 2,
+        .c = 3,
+        .d = 4,
+    };
+    return s;
+}
+
+void c_med_struct_mixed(struct MedStructMixed x) {
+    assert_or_panic(x.a == 1234);
+    assert_or_panic(x.b == 100.0f);
+    assert_or_panic(x.c == 1337.0f);
+
+    struct MedStructMixed y = zig_ret_med_struct_mixed();
+
+    assert_or_panic(y.a == 1234);
+    assert_or_panic(y.b == 100.0f);
+    assert_or_panic(y.c == 1337.0f);
+}
+
+struct MedStructMixed c_ret_med_struct_mixed() {
+    struct MedStructMixed s = {
+        .a = 1234,
+        .b = 100.0,
+        .c = 1337.0,
+    };
+    return s;
 }
 
 void c_split_struct_ints(struct SplitStructInts x) {
@@ -238,6 +307,26 @@ void c_split_struct_ints(struct SplitStructInts x) {
     assert_or_panic(x.c == 1337);
 }
 
+void c_split_struct_mixed(struct SplitStructMixed x) {
+    assert_or_panic(x.a == 1234);
+    assert_or_panic(x.b == 100);
+    assert_or_panic(x.c == 1337.0f);
+    struct SplitStructMixed y = zig_ret_split_struct_mixed();
+
+    assert_or_panic(y.a == 1234);
+    assert_or_panic(y.b == 100);
+    assert_or_panic(y.c == 1337.0f);
+}
+
+struct SplitStructMixed c_ret_split_struct_mixed() {
+    struct SplitStructMixed s = {
+        .a = 1234,
+        .b = 100,
+        .c = 1337.0f,
+    };
+    return s;
+}
+
 struct BigStruct c_big_struct_both(struct BigStruct x) {
     assert_or_panic(x.a == 1);
     assert_or_panic(x.b == 2);
diff --git a/test/stage1/c_abi/main.zig b/test/stage1/c_abi/main.zig
index ed5cad7c56..b8137334ec 100644
--- a/test/stage1/c_abi/main.zig
+++ b/test/stage1/c_abi/main.zig
@@ -1,4 +1,5 @@
 const std = @import("std");
+const print = std.debug.print;
 const expect = std.testing.expect;
 
 extern fn run_c_tests() void;
@@ -170,6 +171,34 @@ export fn zig_big_union(x: BigUnion) void {
     expect(x.a.e == 5) catch @panic("test failure");
 }
 
+const MedStructMixed = extern struct {
+    a: u32,
+    b: f32,
+    c: f32,
+    d: u32 = 0,
+};
+extern fn c_med_struct_mixed(MedStructMixed) void;
+extern fn c_ret_med_struct_mixed() MedStructMixed;
+
+test "C ABI medium struct of ints and floats" {
+    var s = MedStructMixed{
+        .a = 1234,
+        .b = 100.0,
+        .c = 1337.0,
+    };
+    c_med_struct_mixed(s);
+    var s2 = c_ret_med_struct_mixed();
+    expect(s2.a == 1234) catch @panic("test failure");
+    expect(s2.b == 100.0) catch @panic("test failure");
+    expect(s2.c == 1337.0) catch @panic("test failure");
+}
+
+export fn zig_med_struct_mixed(x: MedStructMixed) void {
+    expect(x.a == 1234) catch @panic("test failure");
+    expect(x.b == 100.0) catch @panic("test failure");
+    expect(x.c == 1337.0) catch @panic("test failure");
+}
+
 const SmallStructInts = extern struct {
     a: u8,
     b: u8,
@@ -177,6 +206,7 @@ const SmallStructInts = extern struct {
     d: u8,
 };
 extern fn c_small_struct_ints(SmallStructInts) void;
+extern fn c_ret_small_struct_ints() SmallStructInts;
 
 test "C ABI small struct of ints" {
     var s = SmallStructInts{
@@ -186,6 +216,11 @@ test "C ABI small struct of ints" {
         .d = 4,
     };
     c_small_struct_ints(s);
+    var s2 = c_ret_small_struct_ints();
+    expect(s2.a == 1) catch @panic("test failure");
+    expect(s2.b == 2) catch @panic("test failure");
+    expect(s2.c == 3) catch @panic("test failure");
+    expect(s2.d == 4) catch @panic("test failure");
 }
 
 export fn zig_small_struct_ints(x: SmallStructInts) void {
@@ -217,6 +252,33 @@ export fn zig_split_struct_ints(x: SplitStructInt) void {
     expect(x.c == 1337) catch @panic("test failure");
 }
 
+const SplitStructMixed = extern struct {
+    a: u64,
+    b: u8,
+    c: f32,
+};
+extern fn c_split_struct_mixed(SplitStructMixed) void;
+extern fn c_ret_split_struct_mixed() SplitStructMixed;
+
+test "C ABI split struct of ints and floats" {
+    var s = SplitStructMixed{
+        .a = 1234,
+        .b = 100,
+        .c = 1337.0,
+    };
+    c_split_struct_mixed(s);
+    var s2 = c_ret_split_struct_mixed();
+    expect(s2.a == 1234) catch @panic("test failure");
+    expect(s2.b == 100) catch @panic("test failure");
+    expect(s2.c == 1337.0) catch @panic("test failure");
+}
+
+export fn zig_split_struct_mixed(x: SplitStructMixed) void {
+    expect(x.a == 1234) catch @panic("test failure");
+    expect(x.b == 100) catch @panic("test failure");
+    expect(x.c == 1337.0) catch @panic("test failure");
+}
+
 extern fn c_big_struct_both(BigStruct) BigStruct;
 
 test "C ABI sret and byval together" {
@@ -315,6 +377,31 @@ export fn zig_ret_i64() i64 {
     return -1;
 }
 
+export fn zig_ret_small_struct_ints() SmallStructInts {
+    return .{
+        .a = 1,
+        .b = 2,
+        .c = 3,
+        .d = 4,
+    };
+}
+
+export fn zig_ret_med_struct_mixed() MedStructMixed {
+    return .{
+        .a = 1234,
+        .b = 100.0,
+        .c = 1337.0,
+    };
+}
+
+export fn zig_ret_split_struct_mixed() SplitStructMixed {
+    return .{
+        .a = 1234,
+        .b = 100,
+        .c = 1337.0,
+    };
+}
+
 extern fn c_ret_bool() bool;
 extern fn c_ret_u8() u8;
 extern fn c_ret_u16() u16;

From 15bec20b0013d8afb90a0a2a08c25ce9fb1f2693 Mon Sep 17 00:00:00 2001
From: Mahdi Khanalizadeh <mahdi@khanalizadeh.com>
Date: Tue, 13 Jul 2021 15:35:23 +0200
Subject: [PATCH 23/96] linux: add mknod and mknodat syscalls

---
 lib/std/os/linux.zig | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/lib/std/os/linux.zig b/lib/std/os/linux.zig
index ef7c0ff077..ca8f0907e1 100644
--- a/lib/std/os/linux.zig
+++ b/lib/std/os/linux.zig
@@ -253,6 +253,18 @@ pub fn mkdirat(dirfd: i32, path: [*:0]const u8, mode: u32) usize {
     return syscall3(.mkdirat, @bitCast(usize, @as(isize, dirfd)), @ptrToInt(path), mode);
 }
 
+pub fn mknod(path: [*:0]const u8, mode: u32, dev: u32) usize {
+    if (@hasField(SYS, "mknod")) {
+        return syscall3(.mknod, @ptrToInt(path), mode, dev);
+    } else {
+        return mknodat(AT_FDCWD, path, mode, dev);
+    }
+}
+
+pub fn mknodat(dirfd: i32, path: [*:0]const u8, mode: u32, dev: u32) usize {
+    return syscall4(.mknodat, @bitCast(usize, @as(isize, dirfd)), @ptrToInt(path), mode, dev);
+}
+
 pub fn mount(special: [*:0]const u8, dir: [*:0]const u8, fstype: [*:0]const u8, flags: u32, data: usize) usize {
     return syscall5(.mount, @ptrToInt(special), @ptrToInt(dir), @ptrToInt(fstype), flags, data);
 }

From ed174b7386cb5a6f2008cb6a25c3ff684645d847 Mon Sep 17 00:00:00 2001
From: Michael Dusan <michael.dusan@gmail.com>
Date: Mon, 19 Jul 2021 02:35:17 -0400
Subject: [PATCH 24/96] stage1: fix anon struct naming in certain cases

- generic "struct:L:C" naming if rloc is NodeTypeStructValueField
- generic "struct:L:C" naming if rloc is NodeTypeFnCallExpr
- move some tests from test/behavior/misc to test/behavior/typename

closes #4330
closes #9339
---
 src/stage1/astgen.cpp      |  93 ++++++++++++++++++++-----------
 src/stage1/astgen.hpp      |   2 +-
 src/stage1/ir.cpp          |  17 +++---
 test/behavior/misc.zig     |  24 --------
 test/behavior/typename.zig | 111 ++++++++++++++++++++++++++++++++++++-
 5 files changed, 181 insertions(+), 66 deletions(-)

diff --git a/src/stage1/astgen.cpp b/src/stage1/astgen.cpp
index a5afe32d8b..44dc1080c2 100644
--- a/src/stage1/astgen.cpp
+++ b/src/stage1/astgen.cpp
@@ -3454,7 +3454,7 @@ static Stage1ZirInst *astgen_merge_err_sets(Stage1AstGen *ag, Scope *scope, AstN
 
     // TODO only pass type_name when the || operator is the top level AST node in the var decl expr
     Buf bare_name = BUF_INIT;
-    Buf *type_name = get_anon_type_name(ag->codegen, ag->exec, "error", scope, node, &bare_name);
+    Buf *type_name = get_anon_type_name(ag->codegen, ag->exec, "error", scope, node, &bare_name, nullptr);
 
     return ir_build_merge_err_sets(ag, scope, node, op1, op2, type_name);
 }
@@ -7588,42 +7588,73 @@ static bool render_instance_name_recursive(CodeGen *codegen, Buf *name, Scope *o
 }
 
 Buf *get_anon_type_name(CodeGen *codegen, Stage1Zir *exec, const char *kind_name,
-        Scope *scope, AstNode *source_node, Buf *out_bare_name)
+        Scope *scope, AstNode *source_node, Buf *out_bare_name, ResultLoc *result_loc)
 {
-    if (exec != nullptr && exec->name) {
-        ZigType *import = get_scope_import(scope);
-        Buf *namespace_name = buf_alloc();
-        append_namespace_qualification(codegen, namespace_name, import);
-        buf_append_buf(namespace_name, exec->name);
-        buf_init_from_buf(out_bare_name, exec->name);
-        return namespace_name;
-    } else if (exec != nullptr && exec->name_fn != nullptr) {
-        Buf *name = buf_alloc();
-        buf_append_buf(name, &exec->name_fn->symbol_name);
-        buf_appendf(name, "(");
-        render_instance_name_recursive(codegen, name, &exec->name_fn->fndef_scope->base, exec->begin_scope);
-        buf_appendf(name, ")");
-        buf_init_from_buf(out_bare_name, name);
-        return name;
-    } else {
-        ZigType *import = get_scope_import(scope);
-        Buf *namespace_name = buf_alloc();
-        append_namespace_qualification(codegen, namespace_name, import);
-        RootStruct *root_struct = source_node->owner->data.structure.root_struct;
-        TokenLoc tok_loc = root_struct->token_locs[source_node->main_token];
-        buf_appendf(namespace_name, "%s:%u:%u", kind_name,
-                tok_loc.line + 1, tok_loc.column + 1);
-        buf_init_from_buf(out_bare_name, namespace_name);
-        return namespace_name;
+    // See https://ziglang.org/documentation/master/#Struct-Naming .
+    bool force_generic = false;
+    if (result_loc != nullptr
+        && result_loc->source_instruction != nullptr
+        && result_loc->source_instruction->source_node != nullptr
+    ) {
+        switch (result_loc->source_instruction->source_node->type) {
+            case NodeTypeVariableDeclaration: {
+                    ZigType *import = get_scope_import(scope);
+                    Buf *name = buf_alloc();
+                    append_namespace_qualification(codegen, name, import);
+                    const auto &basename = result_loc->source_instruction->source_node->data.variable_declaration.symbol;
+                    buf_append_buf(name, basename);
+                    buf_init_from_buf(out_bare_name, basename);
+                    return name;
+                }
+            case NodeTypeFnCallExpr:
+            case NodeTypeStructValueField:
+                force_generic = true;
+                break;
+            default:
+                break;
+        }
     }
+
+    if (!force_generic) {
+        if (exec != nullptr && exec->name != nullptr) {
+            ZigType *import = get_scope_import(scope);
+            Buf *namespace_name = buf_alloc();
+            append_namespace_qualification(codegen, namespace_name, import);
+            buf_append_buf(namespace_name, exec->name);
+            buf_init_from_buf(out_bare_name, exec->name);
+            return namespace_name;
+        }
+        if (exec != nullptr && exec->name_fn != nullptr) {
+            Buf *name = buf_alloc();
+            buf_append_buf(name, &exec->name_fn->symbol_name);
+            buf_appendf(name, "(");
+            render_instance_name_recursive(codegen, name, &exec->name_fn->fndef_scope->base, exec->begin_scope);
+            buf_appendf(name, ")");
+            buf_init_from_buf(out_bare_name, name);
+            return name;
+        }
+    }
+
+    ZigType *import = get_scope_import(scope);
+    Buf *namespace_name = buf_alloc();
+    append_namespace_qualification(codegen, namespace_name, import);
+    RootStruct *root_struct = source_node->owner->data.structure.root_struct;
+    TokenLoc tok_loc = root_struct->token_locs[source_node->main_token];
+    buf_appendf(namespace_name, "%s:%u:%u", kind_name,
+            tok_loc.line + 1, tok_loc.column + 1);
+    buf_init_from_buf(out_bare_name, namespace_name);
+    return namespace_name;
 }
 
-static Stage1ZirInst *astgen_container_decl(Stage1AstGen *ag, Scope *parent_scope, AstNode *node) {
+static Stage1ZirInst *astgen_container_decl(Stage1AstGen *ag, Scope *parent_scope,
+        AstNode *node, ResultLoc *result_loc)
+{
     assert(node->type == NodeTypeContainerDecl);
 
     ContainerKind kind = node->data.container_decl.kind;
     Buf *bare_name = buf_alloc();
-    Buf *name = get_anon_type_name(ag->codegen, ag->exec, container_string(kind), parent_scope, node, bare_name);
+    Buf *name = get_anon_type_name(ag->codegen,
+        ag->exec, container_string(kind), parent_scope, node, bare_name, result_loc);
 
     ContainerLayout layout = node->data.container_decl.layout;
     ZigType *container_type = get_partial_container_type(ag->codegen, parent_scope,
@@ -7653,7 +7684,7 @@ static Stage1ZirInst *astgen_err_set_decl(Stage1AstGen *ag, Scope *parent_scope,
     uint32_t err_count = node->data.err_set_decl.decls.length;
 
     Buf bare_name = BUF_INIT;
-    Buf *type_name = get_anon_type_name(ag->codegen, ag->exec, "error", parent_scope, node, &bare_name);
+    Buf *type_name = get_anon_type_name(ag->codegen, ag->exec, "error", parent_scope, node, &bare_name, nullptr);
     ZigType *err_set_type = new_type_table_entry(ZigTypeIdErrorSet);
     buf_init_from_buf(&err_set_type->name, type_name);
     err_set_type->data.error_set.err_count = err_count;
@@ -7963,7 +7994,7 @@ static Stage1ZirInst *astgen_node_raw(Stage1AstGen *ag, AstNode *node, Scope *sc
         case NodeTypeCatchExpr:
             return astgen_catch(ag, scope, node, lval, result_loc);
         case NodeTypeContainerDecl:
-            return ir_lval_wrap(ag, scope, astgen_container_decl(ag, scope, node), lval, result_loc);
+            return ir_lval_wrap(ag, scope, astgen_container_decl(ag, scope, node, result_loc), lval, result_loc);
         case NodeTypeFnProto:
             return ir_lval_wrap(ag, scope, astgen_fn_proto(ag, scope, node), lval, result_loc);
         case NodeTypeErrorSetDecl:
diff --git a/src/stage1/astgen.hpp b/src/stage1/astgen.hpp
index d4bb6923a1..c0ca583f56 100644
--- a/src/stage1/astgen.hpp
+++ b/src/stage1/astgen.hpp
@@ -32,6 +32,6 @@ void destroy_instruction_src(Stage1ZirInst *inst);
 
 bool ir_should_inline(Stage1Zir *exec, Scope *scope);
 Buf *get_anon_type_name(CodeGen *codegen, Stage1Zir *exec, const char *kind_name,
-        Scope *scope, AstNode *source_node, Buf *out_bare_name);
+        Scope *scope, AstNode *source_node, Buf *out_bare_name, ResultLoc *result_loc);
 
 #endif
diff --git a/src/stage1/ir.cpp b/src/stage1/ir.cpp
index e9bb7b1d15..b1583cc6b4 100644
--- a/src/stage1/ir.cpp
+++ b/src/stage1/ir.cpp
@@ -10423,7 +10423,7 @@ static Stage1AirInst *ir_analyze_tuple_cat(IrAnalyze *ira, Scope *scope, AstNode
 
     Buf *bare_name = buf_alloc();
     Buf *name = get_anon_type_name(ira->codegen, nullptr, container_string(ContainerKindStruct),
-            scope, source_node, bare_name);
+            scope, source_node, bare_name, nullptr);
     ZigType *new_type = get_partial_container_type(ira->codegen, scope,
         ContainerKindStruct, source_node, buf_ptr(name), bare_name, ContainerLayoutAuto);
     new_type->data.structure.special = StructSpecialInferredTuple;
@@ -10755,7 +10755,7 @@ static Stage1AirInst *ir_analyze_tuple_mult(IrAnalyze *ira, Scope *scope, AstNod
 
     Buf *bare_name = buf_alloc();
     Buf *name = get_anon_type_name(ira->codegen, nullptr, container_string(ContainerKindStruct),
-        scope, source_node, bare_name);
+        scope, source_node, bare_name, nullptr);
     ZigType *new_type = get_partial_container_type(ira->codegen, scope,
         ContainerKindStruct, source_node, buf_ptr(name), bare_name, ContainerLayoutAuto);
     new_type->data.structure.special = StructSpecialInferredTuple;
@@ -12277,7 +12277,7 @@ static Stage1AirInst *ir_analyze_instruction_resolve_result(IrAnalyze *ira, Stag
         if (implicit_elem_type == ira->codegen->builtin_types.entry_anytype) {
             Buf *bare_name = buf_alloc();
             Buf *name = get_anon_type_name(ira->codegen, nullptr, container_string(ContainerKindStruct),
-                    instruction->base.scope, instruction->base.source_node, bare_name);
+                    instruction->base.scope, instruction->base.source_node, bare_name, nullptr);
 
             StructSpecial struct_special = StructSpecialInferredStruct;
             if (instruction->base.source_node->type == NodeTypeContainerInitExpr &&
@@ -18898,7 +18898,7 @@ static ZigType *type_info_to_type(IrAnalyze *ira, Scope *scope, AstNode *source_
 
             Buf *bare_name = buf_alloc();
             Buf *full_name = get_anon_type_name(ira->codegen,
-                ira->zir, "opaque", scope, source_node, bare_name);
+                ira->zir, "opaque", scope, source_node, bare_name, nullptr);
             return get_opaque_type(ira->codegen,
                 scope, source_node, buf_ptr(full_name), bare_name);
         }
@@ -18945,7 +18945,8 @@ static ZigType *type_info_to_type(IrAnalyze *ira, Scope *scope, AstNode *source_
             assert(is_slice(slice->type));
             ZigType *err_set_type = new_type_table_entry(ZigTypeIdErrorSet);
             Buf bare_name = BUF_INIT;
-            buf_init_from_buf(&err_set_type->name, get_anon_type_name(ira->codegen, ira->zir, "error", scope, source_node, &bare_name));
+            buf_init_from_buf(&err_set_type->name,
+                get_anon_type_name(ira->codegen, ira->zir, "error", scope, source_node, &bare_name, nullptr));
             err_set_type->size_in_bits = ira->codegen->builtin_types.entry_global_error_set->size_in_bits;
             err_set_type->abi_align = ira->codegen->builtin_types.entry_global_error_set->abi_align;
             err_set_type->abi_size = ira->codegen->builtin_types.entry_global_error_set->abi_size;
@@ -19024,7 +19025,7 @@ static ZigType *type_info_to_type(IrAnalyze *ira, Scope *scope, AstNode *source_
 
             ZigType *entry = new_type_table_entry(ZigTypeIdStruct);
             buf_init_from_buf(&entry->name,
-                get_anon_type_name(ira->codegen, ira->zir, "struct", scope, source_node, &entry->name));
+                get_anon_type_name(ira->codegen, ira->zir, "struct", scope, source_node, &entry->name, nullptr));
             entry->data.structure.decl_node = source_node;
             entry->data.structure.fields = alloc_type_struct_fields(fields_len);
             entry->data.structure.fields_by_name.init(fields_len);
@@ -19134,7 +19135,7 @@ static ZigType *type_info_to_type(IrAnalyze *ira, Scope *scope, AstNode *source_
 
             ZigType *entry = new_type_table_entry(ZigTypeIdEnum);
             buf_init_from_buf(&entry->name,
-                get_anon_type_name(ira->codegen, ira->zir, "enum", scope, source_node, &entry->name));
+                get_anon_type_name(ira->codegen, ira->zir, "enum", scope, source_node, &entry->name, nullptr));
             entry->data.enumeration.decl_node = source_node;
             entry->data.enumeration.tag_int_type = tag_type;
             entry->data.enumeration.decls_scope = create_decls_scope(
@@ -19216,7 +19217,7 @@ static ZigType *type_info_to_type(IrAnalyze *ira, Scope *scope, AstNode *source_
 
             ZigType *entry = new_type_table_entry(ZigTypeIdUnion);
             buf_init_from_buf(&entry->name,
-                get_anon_type_name(ira->codegen, ira->zir, "union", scope, source_node, &entry->name));
+                get_anon_type_name(ira->codegen, ira->zir, "union", scope, source_node, &entry->name, nullptr));
             entry->data.unionation.decl_node = source_node;
             entry->data.unionation.fields = heap::c_allocator.allocate<TypeUnionField>(fields_len);
             entry->data.unionation.fields_by_name.init(fields_len);
diff --git a/test/behavior/misc.zig b/test/behavior/misc.zig
index 6fabbf487b..fdd3f3477b 100644
--- a/test/behavior/misc.zig
+++ b/test/behavior/misc.zig
@@ -436,30 +436,6 @@ const AUnion = union {
     Two: void,
 };
 
-test "@typeName" {
-    const Struct = struct {};
-    const Union = union {
-        unused: u8,
-    };
-    const Enum = enum {
-        Unused,
-    };
-    comptime {
-        try expect(mem.eql(u8, @typeName(i64), "i64"));
-        try expect(mem.eql(u8, @typeName(*usize), "*usize"));
-        // https://github.com/ziglang/zig/issues/675
-        try expect(mem.eql(u8, "behavior.misc.TypeFromFn(u8)", @typeName(TypeFromFn(u8))));
-        try expect(mem.eql(u8, @typeName(Struct), "Struct"));
-        try expect(mem.eql(u8, @typeName(Union), "Union"));
-        try expect(mem.eql(u8, @typeName(Enum), "Enum"));
-    }
-}
-
-fn TypeFromFn(comptime T: type) type {
-    _ = T;
-    return struct {};
-}
-
 test "double implicit cast in same expression" {
     var x = @as(i32, @as(u16, nine()));
     try expect(x == 9);
diff --git a/test/behavior/typename.zig b/test/behavior/typename.zig
index bf8464244b..4d87e0030c 100644
--- a/test/behavior/typename.zig
+++ b/test/behavior/typename.zig
@@ -2,6 +2,113 @@ const std = @import("std");
 const expect = std.testing.expect;
 const expectEqualSlices = std.testing.expectEqualSlices;
 
-test "slice" {
-    try expectEqualSlices(u8, "[]u8", @typeName([]u8));
+// Most tests here can be comptime but use runtime so that a stacktrace
+// can show failure location.
+//
+// Note certain results of `@typeName()` expect `behavior.zig` to be the
+// root file. Running a test against this file as root will result in
+// failures.
+
+// CAUTION: this test is source-location sensitive.
+test "anon fn param - source-location sensitive" {
+    // https://github.com/ziglang/zig/issues/9339
+    try expectEqualSlices(u8, @typeName(TypeFromFn(struct {})), "behavior.typename.TypeFromFn(behavior.typename.struct:15:52)");
+    try expectEqualSlices(u8, @typeName(TypeFromFn(union { unused: u8 })), "behavior.typename.TypeFromFn(behavior.typename.union:16:52)");
+    try expectEqualSlices(u8, @typeName(TypeFromFn(enum { unused })), "behavior.typename.TypeFromFn(behavior.typename.enum:17:52)");
+
+    try expectEqualSlices(
+        u8,
+        @typeName(TypeFromFn3(struct {}, union { unused: u8 }, enum { unused })),
+        "behavior.typename.TypeFromFn3(behavior.typename.struct:21:31,behavior.typename.union:21:42,behavior.typename.enum:21:64)",
+    );
+}
+
+// CAUTION: this test is source-location sensitive.
+test "anon field init" {
+    const Foo = .{
+        .T1 = struct {},
+        .T2 = union { unused: u8 },
+        .T3 = enum { unused },
+    };
+
+    try expectEqualSlices(u8, @typeName(Foo.T1), "behavior.typename.struct:29:15");
+    try expectEqualSlices(u8, @typeName(Foo.T2), "behavior.typename.union:30:15");
+    try expectEqualSlices(u8, @typeName(Foo.T3), "behavior.typename.enum:31:15");
+}
+
+test "basic" {
+    try expectEqualSlices(u8, @typeName(i64), "i64");
+    try expectEqualSlices(u8, @typeName(*usize), "*usize");
+    try expectEqualSlices(u8, @typeName([]u8), "[]u8");
+}
+
+test "top level decl" {
+    try expectEqualSlices(u8, @typeName(A_Struct), "A_Struct");
+    try expectEqualSlices(u8, @typeName(A_Union), "A_Union");
+    try expectEqualSlices(u8, @typeName(A_Enum), "A_Enum");
+
+    // regular fn, without error
+    try expectEqualSlices(u8, @typeName(@TypeOf(regular)), "fn() void");
+    // regular fn inside struct, with error
+    try expectEqualSlices(u8, @typeName(@TypeOf(B.doTest)), "fn() @typeInfo(@typeInfo(@TypeOf(behavior.typename.B.doTest)).Fn.return_type.?).ErrorUnion.error_set!void");
+    // generic fn
+    try expectEqualSlices(u8, @typeName(@TypeOf(TypeFromFn)), "fn(type) anytype");
+}
+
+const A_Struct = struct {};
+const A_Union = union {
+    unused: u8,
+};
+const A_Enum = enum {
+    unused,
+};
+
+fn regular() void {}
+
+test "fn body decl" {
+    try B.doTest();
+}
+
+const B = struct {
+    fn doTest() !void {
+        const B_Struct = struct {};
+        const B_Union = union {
+            unused: u8,
+        };
+        const B_Enum = enum {
+            unused,
+        };
+
+        try expectEqualSlices(u8, @typeName(B_Struct), "B_Struct");
+        try expectEqualSlices(u8, @typeName(B_Union), "B_Union");
+        try expectEqualSlices(u8, @typeName(B_Enum), "B_Enum");
+    }
+};
+
+test "fn param" {
+    // https://github.com/ziglang/zig/issues/675
+    try expectEqualSlices(u8, @typeName(TypeFromFn(u8)), "behavior.typename.TypeFromFn(u8)");
+    try expectEqualSlices(u8, @typeName(TypeFromFn(A_Struct)), "behavior.typename.TypeFromFn(behavior.typename.A_Struct)");
+    try expectEqualSlices(u8, @typeName(TypeFromFn(A_Union)), "behavior.typename.TypeFromFn(behavior.typename.A_Union)");
+    try expectEqualSlices(u8, @typeName(TypeFromFn(A_Enum)), "behavior.typename.TypeFromFn(behavior.typename.A_Enum)");
+
+    try expectEqualSlices(u8, @typeName(TypeFromFn2(u8, bool)), "behavior.typename.TypeFromFn2(u8,bool)");
+}
+
+fn TypeFromFn(comptime T: type) type {
+    _ = T;
+    return struct {};
+}
+
+fn TypeFromFn2(comptime T1: type, comptime T2: type) type {
+    _ = T1;
+    _ = T2;
+    return struct {};
+}
+
+fn TypeFromFn3(comptime T1: type, comptime T2: type, comptime T3: type) type {
+    _ = T1;
+    _ = T2;
+    _ = T3;
+    return struct {};
 }

From c0f40a5fe62bbd8e5e0ad5d127dbd4411c1e36f1 Mon Sep 17 00:00:00 2001
From: Vincent Rischmann <vincent@rischmann.fr>
Date: Sun, 18 Apr 2021 19:24:01 +0200
Subject: [PATCH 25/96] std/c: add pthread_setname_np and pthread_getname_np

---
 lib/std/c/darwin.zig  | 2 ++
 lib/std/c/freebsd.zig | 2 ++
 lib/std/c/linux.zig   | 3 +++
 lib/std/c/netbsd.zig  | 3 +++
 lib/std/c/openbsd.zig | 3 +++
 5 files changed, 13 insertions(+)

diff --git a/lib/std/c/darwin.zig b/lib/std/c/darwin.zig
index ca18b5130a..e216afd643 100644
--- a/lib/std/c/darwin.zig
+++ b/lib/std/c/darwin.zig
@@ -193,6 +193,8 @@ pub const pthread_attr_t = extern struct {
 
 const pthread_t = std.c.pthread_t;
 pub extern "c" fn pthread_threadid_np(thread: ?pthread_t, thread_id: *u64) c_int;
+pub extern "c" fn pthread_setname_np(name: [*:0]const u8) c_int;
+pub extern "c" fn pthread_getname_np(thread: std.c.pthread_t, name: [*:0]u8, len: usize) c_int;
 
 pub extern "c" fn arc4random_buf(buf: [*]u8, len: usize) void;
 
diff --git a/lib/std/c/freebsd.zig b/lib/std/c/freebsd.zig
index 3e4b522685..eb449165d3 100644
--- a/lib/std/c/freebsd.zig
+++ b/lib/std/c/freebsd.zig
@@ -14,6 +14,8 @@ pub extern "c" fn sigaltstack(ss: ?*stack_t, old_ss: ?*stack_t) c_int;
 pub extern "c" fn getrandom(buf_ptr: [*]u8, buf_len: usize, flags: c_uint) isize;
 
 pub extern "c" fn pthread_getthreadid_np() c_int;
+pub extern "c" fn pthread_set_name_np(thread: std.c.pthread_t, name: [*:0]const u8) void;
+pub extern "c" fn pthread_get_name_np(thread: std.c.pthread_t, name: [*:0]u8, len: usize) void;
 pub extern "c" fn pipe2(fds: *[2]fd_t, flags: u32) c_int;
 
 pub extern "c" fn posix_memalign(memptr: *?*c_void, alignment: usize, size: usize) c_int;
diff --git a/lib/std/c/linux.zig b/lib/std/c/linux.zig
index 6e897c3098..694af28904 100644
--- a/lib/std/c/linux.zig
+++ b/lib/std/c/linux.zig
@@ -186,6 +186,9 @@ const __SIZEOF_PTHREAD_MUTEX_T = if (os_tag == .fuchsia) 40 else switch (abi) {
 };
 const __SIZEOF_SEM_T = 4 * @sizeOf(usize);
 
+pub extern "c" fn pthread_setname_np(thread: std.c.pthread_t, name: [*:0]const u8) c_int;
+pub extern "c" fn pthread_getname_np(thread: std.c.pthread_t, name: [*:0]u8, len: usize) c_int;
+
 pub const RTLD_LAZY = 1;
 pub const RTLD_NOW = 2;
 pub const RTLD_NOLOAD = 4;
diff --git a/lib/std/c/netbsd.zig b/lib/std/c/netbsd.zig
index 8e6d556fbc..32b7cc69e3 100644
--- a/lib/std/c/netbsd.zig
+++ b/lib/std/c/netbsd.zig
@@ -94,3 +94,6 @@ pub const pthread_attr_t = extern struct {
 };
 
 pub const sem_t = ?*opaque {};
+
+pub extern "c" fn pthread_setname_np(thread: std.c.pthread_t, name: [*:0]const u8, arg: ?*c_void) c_int;
+pub extern "c" fn pthread_getname_np(thread: std.c.pthread_t, name: [*:0]u8, len: usize) c_int;
diff --git a/lib/std/c/openbsd.zig b/lib/std/c/openbsd.zig
index cac3df867d..15820fb0a9 100644
--- a/lib/std/c/openbsd.zig
+++ b/lib/std/c/openbsd.zig
@@ -45,3 +45,6 @@ pub extern "c" fn posix_memalign(memptr: *?*c_void, alignment: usize, size: usiz
 
 pub extern "c" fn pledge(promises: ?[*:0]const u8, execpromises: ?[*:0]const u8) c_int;
 pub extern "c" fn unveil(path: ?[*:0]const u8, permissions: ?[*:0]const u8) c_int;
+
+pub extern "c" fn pthread_set_name_np(thread: std.c.pthread_t, name: [*:0]const u8) void;
+pub extern "c" fn pthread_get_name_np(thread: std.c.pthread_t, name: [*:0]u8, len: usize) void;

From 0be1e74902e9bfb7dd35d2a3ba927db76f6d67c7 Mon Sep 17 00:00:00 2001
From: Vincent Rischmann <vincent@rischmann.fr>
Date: Mon, 19 Apr 2021 23:14:33 +0200
Subject: [PATCH 26/96] windows/kernel32: add LocalFree, SetThreadDescription
 and GetThreadDescription

---
 lib/std/os/windows/kernel32.zig | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/lib/std/os/windows/kernel32.zig b/lib/std/os/windows/kernel32.zig
index 971273ef3a..a04314324d 100644
--- a/lib/std/os/windows/kernel32.zig
+++ b/lib/std/os/windows/kernel32.zig
@@ -192,6 +192,8 @@ pub extern "kernel32" fn HeapValidate(hHeap: HANDLE, dwFlags: DWORD, lpMem: ?*co
 pub extern "kernel32" fn VirtualAlloc(lpAddress: ?LPVOID, dwSize: SIZE_T, flAllocationType: DWORD, flProtect: DWORD) callconv(WINAPI) ?LPVOID;
 pub extern "kernel32" fn VirtualFree(lpAddress: ?LPVOID, dwSize: SIZE_T, dwFreeType: DWORD) callconv(WINAPI) BOOL;
 
+pub extern "kernel32" fn LocalFree(hMem: HLOCAL) callconv(WINAPI) ?HLOCAL;
+
 pub extern "kernel32" fn MoveFileExW(
     lpExistingFileName: [*:0]const u16,
     lpNewFileName: [*:0]const u16,
@@ -342,3 +344,6 @@ pub extern "kernel32" fn SleepConditionVariableSRW(
 pub extern "kernel32" fn TryAcquireSRWLockExclusive(s: *SRWLOCK) callconv(WINAPI) BOOLEAN;
 pub extern "kernel32" fn AcquireSRWLockExclusive(s: *SRWLOCK) callconv(WINAPI) void;
 pub extern "kernel32" fn ReleaseSRWLockExclusive(s: *SRWLOCK) callconv(WINAPI) void;
+
+pub extern "kernel32" fn SetThreadDescription(hThread: HANDLE, lpThreadDescription: LPCWSTR) callconv(WINAPI) HRESULT;
+pub extern "kernel32" fn GetThreadDescription(hThread: HANDLE, ppszThreadDescription: *LPWSTR) callconv(WINAPI) HRESULT;

From accde7fe2d8966ed181af4e819dc73e4d11caef9 Mon Sep 17 00:00:00 2001
From: Vincent Rischmann <vincent@rischmann.fr>
Date: Mon, 19 Apr 2021 23:14:55 +0200
Subject: [PATCH 27/96] windows: add wrappers for LocalFree,
 SetThreadDescription and GetThreadDescription

---
 lib/std/os/windows.zig | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/lib/std/os/windows.zig b/lib/std/os/windows.zig
index cbd4ce065b..04ce433758 100644
--- a/lib/std/os/windows.zig
+++ b/lib/std/os/windows.zig
@@ -1631,6 +1631,10 @@ pub fn HeapDestroy(hHeap: HANDLE) void {
     assert(kernel32.HeapDestroy(hHeap) != 0);
 }
 
+pub fn LocalFree(hMem: HLOCAL) void {
+    assert(kernel32.LocalFree(hMem) == null);
+}
+
 pub const GetFileInformationByHandleError = error{Unexpected};
 
 pub fn GetFileInformationByHandle(
@@ -2011,6 +2015,21 @@ pub fn unexpectedStatus(status: NTSTATUS) std.os.UnexpectedError {
     return error.Unexpected;
 }
 
+pub fn SetThreadDescription(hThread: HANDLE, lpThreadDescription: LPCWSTR) !void {
+    if (kernel32.SetThreadDescription(hThread, lpThreadDescription) == 0) {
+        switch (kernel32.GetLastError()) {
+            else => |err| return unexpectedError(err),
+        }
+    }
+}
+pub fn GetThreadDescription(hThread: HANDLE, ppszThreadDescription: *LPWSTR) !void {
+    if (kernel32.GetThreadDescription(hThread, ppszThreadDescription) == 0) {
+        switch (kernel32.GetLastError()) {
+            else => |err| return unexpectedError(err),
+        }
+    }
+}
+
 test "" {
     if (builtin.os.tag == .windows) {
         _ = @import("windows/test.zig");

From df4fe8716374e4cfdf1dee2bbcda7969eb6d057a Mon Sep 17 00:00:00 2001
From: Vincent Rischmann <vincent@rischmann.fr>
Date: Wed, 21 Apr 2021 10:59:36 +0200
Subject: [PATCH 28/96] thread: implement setName/getName

---
 lib/std/Thread.zig | 274 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 274 insertions(+)

diff --git a/lib/std/Thread.zig b/lib/std/Thread.zig
index 58a409c64e..2584b38072 100644
--- a/lib/std/Thread.zig
+++ b/lib/std/Thread.zig
@@ -38,6 +38,192 @@ else
 
 impl: Impl,
 
+pub const max_name_len = switch (std.Target.current.os.tag) {
+    .linux => 15,
+    .windows => 31,
+    .macos, .ios, .watchos, .tvos => 63,
+    .netbsd => 31,
+    .freebsd => 15,
+    .openbsd => 31,
+    else => 0,
+};
+
+pub const SetNameError = error{
+    NameTooLong,
+    Unsupported,
+    Unexpected,
+} || os.PrctlError || os.WriteError || std.fs.File.OpenError || std.fmt.BufPrintError;
+
+pub fn setName(self: Thread, name: []const u8) SetNameError!void {
+    if (name.len > max_name_len) return error.NameTooLong;
+
+    const name_with_terminator = blk: {
+        var name_buf: [max_name_len:0]u8 = undefined;
+        std.mem.copy(u8, &name_buf, name);
+        name_buf[name.len] = 0;
+        break :blk name_buf[0..name.len :0];
+    };
+
+    switch (std.Target.current.os.tag) {
+        .linux => if (use_pthreads) {
+            const err = std.c.pthread_setname_np(self.getHandle(), name_with_terminator.ptr);
+            return switch (err) {
+                0 => {},
+                os.ERANGE => unreachable,
+                else => return os.unexpectedErrno(err),
+            };
+        } else if (use_pthreads and self.getHandle() == std.c.pthread_self()) {
+            const err = try os.prctl(.SET_NAME, .{@ptrToInt(name_with_terminator.ptr)});
+            return switch (err) {
+                0 => {},
+                else => return os.unexpectedErrno(err),
+            };
+        } else {
+            var buf: [32]u8 = undefined;
+            const path = try std.fmt.bufPrint(&buf, "/proc/self/task/{d}/comm", .{self.getHandle()});
+
+            const file = try std.fs.cwd().openFile(path, .{ .write = true });
+            defer file.close();
+
+            try file.writer().writeAll(name);
+        },
+        .windows => if (std.Target.current.os.isAtLeast(.windows, .win10_rs1)) |res| {
+            // SetThreadDescription is only available since version 1607, which is 10.0.14393.795
+            // See https://en.wikipedia.org/wiki/Microsoft_Windows_SDK
+            if (!res) {
+                return error.Unsupported;
+            }
+
+            var name_buf_w: [max_name_len:0]u16 = undefined;
+            const length = try std.unicode.utf8ToUtf16Le(&name_buf_w, name);
+            name_buf_w[length] = 0;
+
+            try os.windows.SetThreadDescription(
+                self.getHandle(),
+                @ptrCast(os.windows.LPWSTR, &name_buf_w),
+            );
+        } else {
+            return error.Unsupported;
+        },
+        .macos, .ios, .watchos, .tvos => if (use_pthreads) {
+            // There doesn't seem to be a way to set the name for an arbitrary thread, only the current one.
+            if (self.getHandle() != std.c.pthread_self()) return error.Unsupported;
+
+            const err = std.c.pthread_setname_np(name_with_terminator.ptr);
+            return switch (err) {
+                0 => {},
+                else => return os.unexpectedErrno(err),
+            };
+        },
+        .netbsd => if (use_pthreads) {
+            const err = std.c.pthread_setname_np(self.getHandle(), name_with_terminator.ptr, null);
+            return switch (err) {
+                0 => {},
+                os.EINVAL => unreachable,
+                os.ESRCH => unreachable,
+                os.ENOMEM => unreachable,
+                else => return os.unexpectedErrno(err),
+            };
+        },
+        .freebsd, .openbsd => if (use_pthreads) {
+            // Use pthread_set_name_np for FreeBSD because pthread_setname_np is FreeBSD 12.2+ only.
+            // TODO maybe revisit this if depending on FreeBSD 12.2+ is acceptable because pthread_setname_np can return an error.
+
+            std.c.pthread_set_name_np(self.getHandle(), name_with_terminator.ptr);
+        },
+        else => return error.Unsupported,
+    }
+}
+
+pub const GetNameError = error{
+    // For Windows, the name is converted from UTF16 to UTF8
+    CodepointTooLarge,
+    Utf8CannotEncodeSurrogateHalf,
+    DanglingSurrogateHalf,
+    ExpectedSecondSurrogateHalf,
+    UnexpectedSecondSurrogateHalf,
+
+    Unsupported,
+    Unexpected,
+} || os.PrctlError || os.ReadError || std.fs.File.OpenError || std.fmt.BufPrintError;
+
+pub fn getName(self: Thread, buffer_ptr: *[max_name_len:0]u8) GetNameError!?[]const u8 {
+    buffer_ptr[max_name_len] = 0;
+    var buffer = std.mem.span(buffer_ptr);
+
+    switch (std.Target.current.os.tag) {
+        .linux => if (use_pthreads and comptime std.Target.current.abi.isGnu()) {
+            const err = std.c.pthread_getname_np(self.getHandle(), buffer.ptr, max_name_len + 1);
+            return switch (err) {
+                0 => std.mem.sliceTo(buffer, 0),
+                os.ERANGE => unreachable,
+                else => return os.unexpectedErrno(err),
+            };
+        } else if (use_pthreads and self.getHandle() == std.c.pthread_self()) {
+            const err = try os.prctl(.GET_NAME, .{@ptrToInt(buffer.ptr)});
+            return switch (err) {
+                0 => std.mem.sliceTo(buffer, 0),
+                else => return os.unexpectedErrno(err),
+            };
+        } else if (!use_pthreads) {
+            var buf: [32]u8 = undefined;
+            const path = try std.fmt.bufPrint(&buf, "/proc/self/task/{d}/comm", .{self.getHandle()});
+
+            const file = try std.fs.cwd().openFile(path, .{});
+            defer file.close();
+
+            const data_len = try file.reader().readAll(buffer_ptr[0 .. max_name_len + 1]);
+
+            return if (data_len >= 1) buffer[0 .. data_len - 1] else null;
+        } else {
+            // musl doesn't provide pthread_getname_np and there's no way to retrieve the thread id of an arbitrary thread.
+            return error.Unsupported;
+        },
+        .windows => if (std.Target.current.os.isAtLeast(.windows, .win10_rs1)) |res| {
+            // GetThreadDescription is only available since version 1607, which is 10.0.14393.795
+            // See https://en.wikipedia.org/wiki/Microsoft_Windows_SDK
+            if (!res) {
+                return error.Unsupported;
+            }
+
+            var name_w: os.windows.LPWSTR = undefined;
+            try os.windows.GetThreadDescription(self.getHandle(), &name_w);
+            defer os.windows.LocalFree(name_w);
+
+            const data_len = try std.unicode.utf16leToUtf8(buffer, std.mem.sliceTo(name_w, 0));
+
+            return if (data_len >= 1) buffer[0..data_len] else null;
+        } else {
+            return error.Unsupported;
+        },
+        .macos, .ios, .watchos, .tvos => if (use_pthreads) {
+            const err = std.c.pthread_getname_np(self.getHandle(), buffer.ptr, max_name_len + 1);
+            return switch (err) {
+                0 => std.mem.sliceTo(buffer, 0),
+                os.ESRCH => unreachable,
+                else => return os.unexpectedErrno(err),
+            };
+        },
+        .netbsd => if (use_pthreads) {
+            const err = std.c.pthread_getname_np(self.getHandle(), buffer.ptr, max_name_len + 1);
+            return switch (err) {
+                0 => std.mem.sliceTo(buffer, 0),
+                os.EINVAL => unreachable,
+                os.ESRCH => unreachable,
+                else => return os.unexpectedErrno(err),
+            };
+        },
+        .freebsd, .openbsd => if (use_pthreads) {
+            // Use pthread_get_name_np for FreeBSD because pthread_getname_np is FreeBSD 12.2+ only.
+            // TODO maybe revisit this if depending on FreeBSD 12.2+ is acceptable because pthread_getname_np can return an error.
+
+            std.c.pthread_get_name_np(self.getHandle(), buffer.ptr, max_name_len + 1);
+            return std.mem.sliceTo(buffer, 0);
+        },
+        else => return error.Unsupported,
+    }
+}
+
 /// Represents a unique ID per thread.
 pub const Id = u64;
 
@@ -779,6 +965,94 @@ const LinuxThreadImpl = struct {
     }
 };
 
+fn testThreadName(thread: *Thread) !void {
+    const testCases = &[_][]const u8{
+        "mythread",
+        "b" ** max_name_len,
+    };
+
+    inline for (testCases) |tc| {
+        try thread.setName(tc);
+
+        var name_buffer: [max_name_len:0]u8 = undefined;
+
+        const name = try thread.getName(&name_buffer);
+        if (name) |value| {
+            try std.testing.expectEqual(tc.len, value.len);
+            try std.testing.expectEqualStrings(tc, value);
+        }
+    }
+}
+
+test "setName, getName" {
+    if (std.builtin.single_threaded) return error.SkipZigTest;
+
+    const Context = struct {
+        start_wait_event: ResetEvent = undefined,
+        test_done_event: ResetEvent = undefined,
+
+        done: std.atomic.Atomic(bool) = std.atomic.Atomic(bool).init(false),
+        thread: Thread = undefined,
+
+        fn init(self: *@This()) !void {
+            try self.start_wait_event.init();
+            try self.test_done_event.init();
+        }
+
+        pub fn run(ctx: *@This()) !void {
+            // Wait for the main thread to have set the thread field in the context.
+            ctx.start_wait_event.wait();
+
+            switch (std.Target.current.os.tag) {
+                .windows => testThreadName(&ctx.thread) catch |err| switch (err) {
+                    error.Unsupported => return error.SkipZigTest,
+                    else => return err,
+                },
+                else => try testThreadName(&ctx.thread),
+            }
+
+            // Signal our test is done
+            ctx.test_done_event.set();
+
+            while (!ctx.done.load(.SeqCst)) {
+                std.time.sleep(5 * std.time.ns_per_ms);
+            }
+        }
+    };
+
+    var context = Context{};
+    try context.init();
+
+    var thread = try spawn(.{}, Context.run, .{&context});
+    context.thread = thread;
+    context.start_wait_event.set();
+    context.test_done_event.wait();
+
+    switch (std.Target.current.os.tag) {
+        .macos, .ios, .watchos, .tvos => {
+            const res = thread.setName("foobar");
+            try std.testing.expectError(error.Unsupported, res);
+        },
+        .windows => testThreadName(&thread) catch |err| switch (err) {
+            error.Unsupported => return error.SkipZigTest,
+            else => return err,
+        },
+        else => |tag| if (tag == .linux and use_pthreads and comptime std.Target.current.abi.isMusl()) {
+            try thread.setName("foobar");
+
+            var name_buffer: [max_name_len:0]u8 = undefined;
+            const res = thread.getName(&name_buffer);
+
+            try std.testing.expectError(error.Unsupported, res);
+        } else {
+            try testThreadName(&thread);
+        },
+    }
+
+    context.done.store(true, .SeqCst);
+    thread.join();
+}
+
 test "std.Thread" {
     // Doesn't use testing.refAllDecls() since that would pull in the compileError spinLoopHint.
     _ = AutoResetEvent;

From a5c6e51f03ab164e64b1a1d8370071dd1e670458 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Thu, 29 Jul 2021 15:59:51 -0700
Subject: [PATCH 29/96] stage2: more principled approach to comptime references

 * AIR no longer has a `variables` array. Instead of the `varptr`
   instruction, Sema emits a constant with a `decl_ref`.
 * AIR no longer has a `ref` instruction. There is no longer any
   instruction that takes a value and returns a pointer to it. If this
   is desired, Sema must either create an anynomous Decl and return a
   constant `decl_ref`, or in the case of a runtime value, emit an
   `alloc` instruction, `store` the value to it, and then return the
   `alloc`.
 * The `ref_val` Value Tag is eliminated. `decl_ref` should be used
   instead. Also added is `eu_payload_ptr` which points to the payload
   of an error union, given an error union pointer.

In general, Sema should avoid calling `analyzeRef` if it can be helped.
For example in the case of field_val and elem_val, there should never be
a reason to create a temporary (alloc or decl). Recent previous commits
made progress along that front.

There is a new abstraction in Sema, which looks like this:

    var anon_decl = try block.startAnonDecl();
    defer anon_decl.deinit();
    // here 'anon_decl.arena()` may be used
    const decl = try anon_decl.finish(ty, val);
    // decl is typically now used with `decl_ref`.

This pattern is used to upgrade `ref_val` usages to `decl_ref` usages.

Additional improvements:

 * Sema: fix source location resolution for calling convention
   expression.
 * Sema: properly report "unable to resolve comptime value" for loads of
   global variables. There is now a set of functions which can be
   called if the callee wants to obtain the Value even if the tag is
   `variable` (indicating comptime-known address but runtime-known value).
 * Sema: `coerce` resolves builtin types before checking equality.
 * Sema: fix `u1_type` missing from `addType`, making this type have a
   slightly more efficient representation in AIR.
 * LLVM backend: fix `genTypedValue` for tags `decl_ref` and `variable`
   to properly do an LLVMConstBitCast.
 * Remove unused parameter from `Value.toEnum`.

After this commit, some test cases are no longer passing. This is due to
the more principled approach to comptime references causing more
anonymous decls to get sent to the linker for codegen. However, in all
these cases the decls are not actually referenced by the runtime machine
code. A future commit in this branch will implement garbage collection
of decls so that unused decls do not get sent to the linker for codegen.
This will make the tests go back to passing.
---
 src/Air.zig                   |  14 ---
 src/Liveness.zig              |   2 -
 src/Module.zig                |  47 ++++++++-
 src/Sema.zig                  | 191 +++++++++++++++++++++++-----------
 src/codegen.zig               |  41 --------
 src/codegen/c.zig             |  41 +-------
 src/codegen/llvm.zig          |  35 +------
 src/codegen/llvm/bindings.zig |   3 +
 src/codegen/wasm.zig          |  59 ++++++-----
 src/link/Wasm.zig             |   2 +-
 src/print_air.zig             |  13 +--
 src/value.zig                 |  71 +++++--------
 test/cases.zig                |   5 +-
 13 files changed, 246 insertions(+), 278 deletions(-)

diff --git a/src/Air.zig b/src/Air.zig
index bd7b3af733..fb95d60d00 100644
--- a/src/Air.zig
+++ b/src/Air.zig
@@ -15,7 +15,6 @@ instructions: std.MultiArrayList(Inst).Slice,
 /// The first few indexes are reserved. See `ExtraIndex` for the values.
 extra: []const u32,
 values: []const Value,
-variables: []const *Module.Var,
 
 pub const ExtraIndex = enum(u32) {
     /// Payload index of the main `Block` in the `extra` array.
@@ -193,20 +192,10 @@ pub const Inst = struct {
         /// Result type is always `u1`.
         /// Uses the `un_op` field.
         bool_to_int,
-        /// Stores a value onto the stack and returns a pointer to it.
-        /// TODO audit where this AIR instruction is emitted, maybe it should instead be emitting
-        /// alloca instruction and storing to the alloca.
-        /// Uses the `ty_op` field.
-        ref,
         /// Return a value from a function.
         /// Result type is always noreturn; no instructions in a block follow this one.
         /// Uses the `un_op` field.
         ret,
-        /// Returns a pointer to a global variable.
-        /// Uses the `ty_pl` field. Index is into the `variables` array.
-        /// TODO this can be modeled simply as a constant with a decl ref and then
-        /// the variables array can be removed from Air.
-        varptr,
         /// Write a value to a pointer. LHS is pointer, RHS is value.
         /// Result type is always void.
         /// Uses the `bin_op` field.
@@ -454,7 +443,6 @@ pub fn typeOfIndex(air: Air, inst: Air.Inst.Index) Type {
         .assembly,
         .block,
         .constant,
-        .varptr,
         .struct_field_ptr,
         .struct_field_val,
         => return air.getRefType(datas[inst].ty_pl.ty),
@@ -462,7 +450,6 @@ pub fn typeOfIndex(air: Air, inst: Air.Inst.Index) Type {
         .not,
         .bitcast,
         .load,
-        .ref,
         .floatcast,
         .intcast,
         .optional_payload,
@@ -550,7 +537,6 @@ pub fn deinit(air: *Air, gpa: *std.mem.Allocator) void {
     air.instructions.deinit(gpa);
     gpa.free(air.extra);
     gpa.free(air.values);
-    gpa.free(air.variables);
     air.* = undefined;
 }
 
diff --git a/src/Liveness.zig b/src/Liveness.zig
index a44b582424..7ba062fa31 100644
--- a/src/Liveness.zig
+++ b/src/Liveness.zig
@@ -256,14 +256,12 @@ fn analyzeInst(
         .const_ty,
         .breakpoint,
         .dbg_stmt,
-        .varptr,
         .unreach,
         => return trackOperands(a, new_set, inst, main_tomb, .{ .none, .none, .none }),
 
         .not,
         .bitcast,
         .load,
-        .ref,
         .floatcast,
         .intcast,
         .optional_payload,
diff --git a/src/Module.zig b/src/Module.zig
index 48c2eb8d0d..f89f72bc65 100644
--- a/src/Module.zig
+++ b/src/Module.zig
@@ -1324,6 +1324,42 @@ pub const Scope = struct {
             block.instructions.appendAssumeCapacity(result_index);
             return result_index;
         }
+
+        pub fn startAnonDecl(block: *Block) !WipAnonDecl {
+            return WipAnonDecl{
+                .block = block,
+                .new_decl_arena = std.heap.ArenaAllocator.init(block.sema.gpa),
+                .finished = false,
+            };
+        }
+
+        pub const WipAnonDecl = struct {
+            block: *Scope.Block,
+            new_decl_arena: std.heap.ArenaAllocator,
+            finished: bool,
+
+            pub fn arena(wad: *WipAnonDecl) *Allocator {
+                return &wad.new_decl_arena.allocator;
+            }
+
+            pub fn deinit(wad: *WipAnonDecl) void {
+                if (!wad.finished) {
+                    wad.new_decl_arena.deinit();
+                }
+                wad.* = undefined;
+            }
+
+            pub fn finish(wad: *WipAnonDecl, ty: Type, val: Value) !*Decl {
+                const new_decl = try wad.block.sema.mod.createAnonymousDecl(&wad.block.base, .{
+                    .ty = ty,
+                    .val = val,
+                });
+                errdefer wad.block.sema.mod.deleteAnonDecl(&wad.block.base, new_decl);
+                try new_decl.finalizeNewArena(&wad.new_decl_arena);
+                wad.finished = true;
+                return new_decl;
+            }
+        };
     };
 };
 
@@ -1700,6 +1736,7 @@ pub const SrcLoc = struct {
 
             .node_offset_fn_type_cc => |node_off| {
                 const tree = try src_loc.file_scope.getTree(gpa);
+                const node_datas = tree.nodes.items(.data);
                 const node_tags = tree.nodes.items(.tag);
                 const node = src_loc.declRelativeToNodeIndex(node_off);
                 var params: [1]ast.Node.Index = undefined;
@@ -1708,6 +1745,13 @@ pub const SrcLoc = struct {
                     .fn_proto_multi => tree.fnProtoMulti(node),
                     .fn_proto_one => tree.fnProtoOne(&params, node),
                     .fn_proto => tree.fnProto(node),
+                    .fn_decl => switch (node_tags[node_datas[node].lhs]) {
+                        .fn_proto_simple => tree.fnProtoSimple(&params, node_datas[node].lhs),
+                        .fn_proto_multi => tree.fnProtoMulti(node_datas[node].lhs),
+                        .fn_proto_one => tree.fnProtoOne(&params, node_datas[node].lhs),
+                        .fn_proto => tree.fnProto(node_datas[node].lhs),
+                        else => unreachable,
+                    },
                     else => unreachable,
                 };
                 const main_tokens = tree.nodes.items(.main_token);
@@ -2935,7 +2979,7 @@ fn semaDecl(mod: *Module, decl: *Decl) !bool {
     const break_index = try sema.analyzeBody(&block_scope, body);
     const result_ref = zir_datas[break_index].@"break".operand;
     const src: LazySrcLoc = .{ .node_offset = 0 };
-    const decl_tv = try sema.resolveInstConst(&block_scope, src, result_ref);
+    const decl_tv = try sema.resolveInstValue(&block_scope, src, result_ref);
     const align_val = blk: {
         const align_ref = decl.zirAlignRef();
         if (align_ref == .none) break :blk Value.initTag(.null_value);
@@ -3603,7 +3647,6 @@ pub fn analyzeFnBody(mod: *Module, decl: *Decl, func: *Fn) SemaError!Air {
         .instructions = sema.air_instructions.toOwnedSlice(),
         .extra = sema.air_extra.toOwnedSlice(gpa),
         .values = sema.air_values.toOwnedSlice(gpa),
-        .variables = sema.air_variables.toOwnedSlice(gpa),
     };
 }
 
diff --git a/src/Sema.zig b/src/Sema.zig
index 88a83fd661..95baae7e92 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -14,7 +14,6 @@ code: Zir,
 air_instructions: std.MultiArrayList(Air.Inst) = .{},
 air_extra: std.ArrayListUnmanaged(u32) = .{},
 air_values: std.ArrayListUnmanaged(Value) = .{},
-air_variables: std.ArrayListUnmanaged(*Module.Var) = .{},
 /// Maps ZIR to AIR.
 inst_map: InstMap = .{},
 /// When analyzing an inline function call, owner_decl is the Decl of the caller
@@ -76,7 +75,6 @@ pub fn deinit(sema: *Sema) void {
     sema.air_instructions.deinit(gpa);
     sema.air_extra.deinit(gpa);
     sema.air_values.deinit(gpa);
-    sema.air_variables.deinit(gpa);
     sema.inst_map.deinit(gpa);
     sema.decl_val_table.deinit(gpa);
     sema.* = undefined;
@@ -639,16 +637,40 @@ fn analyzeAsType(
     return val.toType(sema.arena);
 }
 
+/// May return Value Tags: `variable`, `undef`.
+/// See `resolveConstValue` for an alternative.
+fn resolveValue(
+    sema: *Sema,
+    block: *Scope.Block,
+    src: LazySrcLoc,
+    air_ref: Air.Inst.Ref,
+) CompileError!Value {
+    if (try sema.resolveMaybeUndefValAllowVariables(block, src, air_ref)) |val| {
+        return val;
+    }
+    return sema.failWithNeededComptime(block, src);
+}
+
+/// Will not return Value Tags: `variable`, `undef`. Instead they will emit compile errors.
+/// See `resolveValue` for an alternative.
 fn resolveConstValue(
     sema: *Sema,
     block: *Scope.Block,
     src: LazySrcLoc,
     air_ref: Air.Inst.Ref,
 ) CompileError!Value {
-    return (try sema.resolveDefinedValue(block, src, air_ref)) orelse
-        return sema.failWithNeededComptime(block, src);
+    if (try sema.resolveMaybeUndefValAllowVariables(block, src, air_ref)) |val| {
+        switch (val.tag()) {
+            .undef => return sema.failWithUseOfUndef(block, src),
+            .variable => return sema.failWithNeededComptime(block, src),
+            else => return val,
+        }
+    }
+    return sema.failWithNeededComptime(block, src);
 }
 
+/// Value Tag `variable` causes this function to return `null`.
+/// Value Tag `undef` causes this function to return a compile error.
 fn resolveDefinedValue(
     sema: *Sema,
     block: *Scope.Block,
@@ -664,11 +686,27 @@ fn resolveDefinedValue(
     return null;
 }
 
+/// Value Tag `variable` causes this function to return `null`.
+/// Value Tag `undef` causes this function to return the Value.
 fn resolveMaybeUndefVal(
     sema: *Sema,
     block: *Scope.Block,
     src: LazySrcLoc,
     inst: Air.Inst.Ref,
+) CompileError!?Value {
+    const val = (try sema.resolveMaybeUndefValAllowVariables(block, src, inst)) orelse return null;
+    if (val.tag() == .variable) {
+        return sema.failWithNeededComptime(block, src);
+    }
+    return val;
+}
+
+/// Returns all Value tags including `variable` and `undef`.
+fn resolveMaybeUndefValAllowVariables(
+    sema: *Sema,
+    block: *Scope.Block,
+    src: LazySrcLoc,
+    inst: Air.Inst.Ref,
 ) CompileError!?Value {
     // First section of indexes correspond to a set number of constant values.
     var i: usize = @enumToInt(inst);
@@ -734,6 +772,8 @@ fn resolveInt(
     return val.toUnsignedInt();
 }
 
+// Returns a compile error if the value has tag `variable`. See `resolveInstValue` for
+// a function that does not.
 pub fn resolveInstConst(
     sema: *Sema,
     block: *Scope.Block,
@@ -748,6 +788,22 @@ pub fn resolveInstConst(
     };
 }
 
+// Value Tag may be `undef` or `variable`.
+// See `resolveInstConst` for an alternative.
+pub fn resolveInstValue(
+    sema: *Sema,
+    block: *Scope.Block,
+    src: LazySrcLoc,
+    zir_ref: Zir.Inst.Ref,
+) CompileError!TypedValue {
+    const air_ref = sema.resolveInst(zir_ref);
+    const val = try sema.resolveValue(block, src, air_ref);
+    return TypedValue{
+        .ty = sema.typeOf(air_ref),
+        .val = val,
+    };
+}
+
 fn zirBitcastResultPtr(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
     const inst_data = sema.code.instructions.items(.data)[inst].pl_node;
     const src = inst_data.src();
@@ -1707,7 +1763,7 @@ fn zirStr(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) CompileError!A
     });
     errdefer sema.mod.deleteAnonDecl(&block.base, new_decl);
     try new_decl.finalizeNewArena(&new_decl_arena);
-    return sema.analyzeDeclRef(block, .unneeded, new_decl);
+    return sema.analyzeDeclRef(new_decl);
 }
 
 fn zirInt(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
@@ -2090,10 +2146,7 @@ fn zirExport(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) CompileErro
     const linkage_index = struct_obj.fields.getIndex("linkage").?;
     const section_index = struct_obj.fields.getIndex("section").?;
     const export_name = try fields[name_index].toAllocatedBytes(sema.arena);
-    const linkage = fields[linkage_index].toEnum(
-        struct_obj.fields.values()[linkage_index].ty,
-        std.builtin.GlobalLinkage,
-    );
+    const linkage = fields[linkage_index].toEnum(std.builtin.GlobalLinkage);
 
     if (linkage != .Strong) {
         return sema.mod.fail(&block.base, src, "TODO: implement exporting with non-strong linkage", .{});
@@ -2194,7 +2247,7 @@ fn zirDeclRef(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) CompileErr
     const src = inst_data.src();
     const decl_name = inst_data.get(sema.code);
     const decl = try sema.lookupIdentifier(block, src, decl_name);
-    return sema.analyzeDeclRef(block, src, decl);
+    return sema.analyzeDeclRef(decl);
 }
 
 fn zirDeclVal(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
@@ -2978,14 +3031,9 @@ fn zirErrUnionPayloadPtr(
         if (val.getError()) |name| {
             return sema.mod.fail(&block.base, src, "caught unexpected error '{s}'", .{name});
         }
-        const data = val.castTag(.error_union).?.data;
-        // The same Value represents the pointer to the error union and the payload.
         return sema.addConstant(
             operand_pointer_ty,
-            try Value.Tag.ref_val.create(
-                sema.arena,
-                data,
-            ),
+            try Value.Tag.eu_payload_ptr.create(sema.arena, pointer_val),
         );
     }
 
@@ -6296,7 +6344,7 @@ fn zirFuncExtended(
         const cc_ref = @intToEnum(Zir.Inst.Ref, sema.code.extra[extra_index]);
         extra_index += 1;
         const cc_tv = try sema.resolveInstConst(block, cc_src, cc_ref);
-        break :blk cc_tv.val.toEnum(cc_tv.ty, std.builtin.CallingConvention);
+        break :blk cc_tv.val.toEnum(std.builtin.CallingConvention);
     } else .Unspecified;
 
     const align_val: Value = if (small.has_align) blk: {
@@ -6554,7 +6602,7 @@ fn safetyPanic(
         });
         errdefer sema.mod.deleteAnonDecl(&block.base, new_decl);
         try new_decl.finalizeNewArena(&new_decl_arena);
-        break :msg_inst try sema.analyzeDeclRef(block, .unneeded, new_decl);
+        break :msg_inst try sema.analyzeDeclRef(new_decl);
     };
 
     const casted_msg_inst = try sema.coerce(block, Type.initTag(.const_slice_u8), msg_inst, src);
@@ -6761,11 +6809,16 @@ fn fieldPtr(
     switch (object_ty.zigTypeTag()) {
         .Array => {
             if (mem.eql(u8, field_name, "len")) {
+                var anon_decl = try block.startAnonDecl();
+                defer anon_decl.deinit();
                 return sema.addConstant(
                     Type.initTag(.single_const_pointer_to_comptime_int),
-                    try Value.Tag.ref_val.create(
+                    try Value.Tag.decl_ref.create(
                         arena,
-                        try Value.Tag.int_u64.create(arena, object_ty.arrayLen()),
+                        try anon_decl.finish(
+                            Type.initTag(.comptime_int),
+                            try Value.Tag.int_u64.create(anon_decl.arena(), object_ty.arrayLen()),
+                        ),
                     ),
                 );
             } else {
@@ -6780,18 +6833,25 @@ fn fieldPtr(
         .Pointer => {
             const ptr_child = object_ty.elemType();
             if (ptr_child.isSlice()) {
+                // Here for the ptr and len fields what we need to do is the situation
+                // when a temporary has its address taken, e.g. `&a[c..d].len`.
+                // This value may be known at compile-time or runtime. In the former
+                // case, it should create an anonymous Decl and return a decl_ref to it.
+                // In the latter case, it should add an `alloc` instruction, store
+                // the runtime value to it, and then return the `alloc`.
+                // In both cases the pointer should be const.
                 if (mem.eql(u8, field_name, "ptr")) {
                     return mod.fail(
                         &block.base,
                         field_name_src,
-                        "cannot obtain reference to pointer field of slice '{}'",
+                        "TODO: implement reference to 'ptr' field of slice '{}'",
                         .{object_ty},
                     );
                 } else if (mem.eql(u8, field_name, "len")) {
                     return mod.fail(
                         &block.base,
                         field_name_src,
-                        "cannot obtain reference to length field of slice '{}'",
+                        "TODO: implement reference to 'len' field of slice '{}'",
                         .{object_ty},
                     );
                 } else {
@@ -6805,11 +6865,16 @@ fn fieldPtr(
             } else switch (ptr_child.zigTypeTag()) {
                 .Array => {
                     if (mem.eql(u8, field_name, "len")) {
+                        var anon_decl = try block.startAnonDecl();
+                        defer anon_decl.deinit();
                         return sema.addConstant(
                             Type.initTag(.single_const_pointer_to_comptime_int),
-                            try Value.Tag.ref_val.create(
+                            try Value.Tag.decl_ref.create(
                                 arena,
-                                try Value.Tag.int_u64.create(arena, ptr_child.arrayLen()),
+                                try anon_decl.finish(
+                                    Type.initTag(.comptime_int),
+                                    try Value.Tag.int_u64.create(anon_decl.arena(), ptr_child.arrayLen()),
+                                ),
                             ),
                         );
                     } else {
@@ -6848,13 +6913,16 @@ fn fieldPtr(
                         });
                     } else (try mod.getErrorValue(field_name)).key;
 
+                    var anon_decl = try block.startAnonDecl();
+                    defer anon_decl.deinit();
                     return sema.addConstant(
                         try Module.simplePtrType(arena, child_type, false, .One),
-                        try Value.Tag.ref_val.create(
+                        try Value.Tag.decl_ref.create(
                             arena,
-                            try Value.Tag.@"error".create(arena, .{
-                                .name = name,
-                            }),
+                            try anon_decl.finish(
+                                child_type,
+                                try Value.Tag.@"error".create(anon_decl.arena(), .{ .name = name }),
+                            ),
                         ),
                     );
                 },
@@ -6901,10 +6969,17 @@ fn fieldPtr(
                         return mod.failWithOwnedErrorMsg(&block.base, msg);
                     };
                     const field_index_u32 = @intCast(u32, field_index);
-                    const enum_val = try Value.Tag.enum_field_index.create(arena, field_index_u32);
+                    var anon_decl = try block.startAnonDecl();
+                    defer anon_decl.deinit();
                     return sema.addConstant(
                         try Module.simplePtrType(arena, child_type, false, .One),
-                        try Value.Tag.ref_val.create(arena, enum_val),
+                        try Value.Tag.decl_ref.create(
+                            arena,
+                            try anon_decl.finish(
+                                child_type,
+                                try Value.Tag.enum_field_index.create(anon_decl.arena(), field_index_u32),
+                            ),
+                        ),
                     );
                 },
                 else => return mod.fail(&block.base, src, "type '{}' has no members", .{child_type}),
@@ -6951,7 +7026,7 @@ fn namespaceLookupRef(
     decl_name: []const u8,
 ) CompileError!?Air.Inst.Ref {
     const decl = (try sema.namespaceLookup(block, src, namespace, decl_name)) orelse return null;
-    return try sema.analyzeDeclRef(block, src, decl);
+    return try sema.analyzeDeclRef(decl);
 }
 
 fn structFieldPtr(
@@ -7207,13 +7282,15 @@ fn elemPtrArray(
 fn coerce(
     sema: *Sema,
     block: *Scope.Block,
-    dest_type: Type,
+    dest_type_unresolved: Type,
     inst: Air.Inst.Ref,
     inst_src: LazySrcLoc,
 ) CompileError!Air.Inst.Ref {
-    if (dest_type.tag() == .var_args_param) {
+    if (dest_type_unresolved.tag() == .var_args_param) {
         return sema.coerceVarArgParam(block, inst, inst_src);
     }
+    const dest_type_src = inst_src; // TODO better source location
+    const dest_type = try sema.resolveTypeFields(block, dest_type_src, dest_type_unresolved);
 
     const inst_ty = sema.typeOf(inst);
     // If the types are the same, we can return the operand.
@@ -7554,17 +7631,17 @@ fn analyzeDeclVal(
     if (sema.decl_val_table.get(decl)) |result| {
         return result;
     }
-    const decl_ref = try sema.analyzeDeclRef(block, src, decl);
+    const decl_ref = try sema.analyzeDeclRef(decl);
     const result = try sema.analyzeLoad(block, src, decl_ref, src);
     if (Air.refToIndex(result)) |index| {
         if (sema.air_instructions.items(.tag)[index] == .constant) {
-            sema.decl_val_table.put(sema.gpa, decl, result) catch {};
+            try sema.decl_val_table.put(sema.gpa, decl, result);
         }
     }
     return result;
 }
 
-fn analyzeDeclRef(sema: *Sema, block: *Scope.Block, src: LazySrcLoc, decl: *Decl) CompileError!Air.Inst.Ref {
+fn analyzeDeclRef(sema: *Sema, decl: *Decl) CompileError!Air.Inst.Ref {
     try sema.mod.declareDeclDependency(sema.owner_decl, decl);
     sema.mod.ensureDeclAnalyzed(decl) catch |err| {
         if (sema.func) |func| {
@@ -7576,8 +7653,10 @@ fn analyzeDeclRef(sema: *Sema, block: *Scope.Block, src: LazySrcLoc, decl: *Decl
     };
 
     const decl_tv = try decl.typedValue();
-    if (decl_tv.val.tag() == .variable) {
-        return sema.analyzeVarRef(block, src, decl_tv);
+    if (decl_tv.val.castTag(.variable)) |payload| {
+        const variable = payload.data;
+        const ty = try Module.simplePtrType(sema.arena, decl_tv.ty, variable.is_mutable, .One);
+        return sema.addConstant(ty, try Value.Tag.decl_ref.create(sema.arena, decl));
     }
     return sema.addConstant(
         try Module.simplePtrType(sema.arena, decl_tv.ty, false, .One),
@@ -7585,26 +7664,6 @@ fn analyzeDeclRef(sema: *Sema, block: *Scope.Block, src: LazySrcLoc, decl: *Decl
     );
 }
 
-fn analyzeVarRef(sema: *Sema, block: *Scope.Block, src: LazySrcLoc, tv: TypedValue) CompileError!Air.Inst.Ref {
-    const variable = tv.val.castTag(.variable).?.data;
-
-    const ty = try Module.simplePtrType(sema.arena, tv.ty, variable.is_mutable, .One);
-    if (!variable.is_mutable and !variable.is_extern) {
-        return sema.addConstant(ty, try Value.Tag.ref_val.create(sema.arena, variable.init));
-    }
-
-    const gpa = sema.gpa;
-    try sema.requireRuntimeBlock(block, src);
-    try sema.air_variables.append(gpa, variable);
-    return block.addInst(.{
-        .tag = .varptr,
-        .data = .{ .ty_pl = .{
-            .ty = try sema.addType(ty),
-            .payload = @intCast(u32, sema.air_variables.items.len - 1),
-        } },
-    });
-}
-
 fn analyzeRef(
     sema: *Sema,
     block: *Scope.Block,
@@ -7615,11 +7674,21 @@ fn analyzeRef(
     const ptr_type = try Module.simplePtrType(sema.arena, operand_ty, false, .One);
 
     if (try sema.resolveMaybeUndefVal(block, src, operand)) |val| {
-        return sema.addConstant(ptr_type, try Value.Tag.ref_val.create(sema.arena, val));
+        var anon_decl = try block.startAnonDecl();
+        defer anon_decl.deinit();
+        return sema.addConstant(
+            ptr_type,
+            try Value.Tag.decl_ref.create(
+                sema.arena,
+                try anon_decl.finish(operand_ty, try val.copy(anon_decl.arena())),
+            ),
+        );
     }
 
     try sema.requireRuntimeBlock(block, src);
-    return block.addTyOp(.ref, ptr_type, operand);
+    const alloc = try block.addTy(.alloc, ptr_type);
+    try sema.storePtr(block, src, alloc, operand);
+    return alloc;
 }
 
 fn analyzeLoad(
@@ -8447,12 +8516,12 @@ fn getTmpAir(sema: Sema) Air {
         .instructions = sema.air_instructions.slice(),
         .extra = sema.air_extra.items,
         .values = sema.air_values.items,
-        .variables = sema.air_variables.items,
     };
 }
 
 pub fn addType(sema: *Sema, ty: Type) !Air.Inst.Ref {
     switch (ty.tag()) {
+        .u1 => return .u1_type,
         .u8 => return .u8_type,
         .i8 => return .i8_type,
         .u16 => return .u16_type,
diff --git a/src/codegen.zig b/src/codegen.zig
index 3b822c0f88..b7ba367d54 100644
--- a/src/codegen.zig
+++ b/src/codegen.zig
@@ -848,13 +848,11 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
                     .loop            => try self.airLoop(inst),
                     .not             => try self.airNot(inst),
                     .ptrtoint        => try self.airPtrToInt(inst),
-                    .ref             => try self.airRef(inst),
                     .ret             => try self.airRet(inst),
                     .store           => try self.airStore(inst),
                     .struct_field_ptr=> try self.airStructFieldPtr(inst),
                     .struct_field_val=> try self.airStructFieldVal(inst),
                     .switch_br       => try self.airSwitch(inst),
-                    .varptr          => try self.airVarPtr(inst),
                     .slice_ptr       => try self.airSlicePtr(inst),
                     .slice_len       => try self.airSliceLen(inst),
 
@@ -1340,13 +1338,6 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
             return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
         }
 
-        fn airVarPtr(self: *Self, inst: Air.Inst.Index) !void {
-            const result: MCValue = if (self.liveness.isUnused(inst)) .dead else switch (arch) {
-                else => return self.fail("TODO implement varptr for {}", .{self.target.cpu.arch}),
-            };
-            return self.finishAir(inst, result, .{ .none, .none, .none });
-        }
-
         fn airSlicePtr(self: *Self, inst: Air.Inst.Index) !void {
             const ty_op = self.air.instructions.items(.data)[inst].ty_op;
             const result: MCValue = if (self.liveness.isUnused(inst)) .dead else switch (arch) {
@@ -2833,38 +2824,6 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
             return bt.finishAir(result);
         }
 
-        fn airRef(self: *Self, inst: Air.Inst.Index) !void {
-            const ty_op = self.air.instructions.items(.data)[inst].ty_op;
-            const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
-                const operand_ty = self.air.typeOf(ty_op.operand);
-                const operand = try self.resolveInst(ty_op.operand);
-                switch (operand) {
-                    .unreach => unreachable,
-                    .dead => unreachable,
-                    .none => break :result MCValue{ .none = {} },
-
-                    .immediate,
-                    .register,
-                    .ptr_stack_offset,
-                    .ptr_embedded_in_code,
-                    .compare_flags_unsigned,
-                    .compare_flags_signed,
-                    => {
-                        const stack_offset = try self.allocMemPtr(inst);
-                        try self.genSetStack(operand_ty, stack_offset, operand);
-                        break :result MCValue{ .ptr_stack_offset = stack_offset };
-                    },
-
-                    .stack_offset => |offset| break :result MCValue{ .ptr_stack_offset = offset },
-                    .embedded_in_code => |offset| break :result MCValue{ .ptr_embedded_in_code = offset },
-                    .memory => |vaddr| break :result MCValue{ .immediate = vaddr },
-
-                    .undef => return self.fail("TODO implement ref on an undefined value", .{}),
-                }
-            };
-            return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
-        }
-
         fn ret(self: *Self, mcv: MCValue) !void {
             const ret_ty = self.fn_type.fnReturnType();
             try self.setRegOrMem(ret_ty, self.ret_mcv, mcv);
diff --git a/src/codegen/c.zig b/src/codegen/c.zig
index 7299b21a61..a8ec677753 100644
--- a/src/codegen/c.zig
+++ b/src/codegen/c.zig
@@ -283,22 +283,7 @@ pub const DeclGen = struct {
                     },
                     else => switch (t.ptrSize()) {
                         .Slice => unreachable,
-                        .Many => {
-                            if (val.castTag(.ref_val)) |ref_val_payload| {
-                                const sub_val = ref_val_payload.data;
-                                if (sub_val.castTag(.bytes)) |bytes_payload| {
-                                    const bytes = bytes_payload.data;
-                                    try writer.writeByte('(');
-                                    try dg.renderType(writer, t);
-                                    // TODO: make our own C string escape instead of using std.zig.fmtEscapes
-                                    try writer.print(")\"{}\"", .{std.zig.fmtEscapes(bytes)});
-                                } else {
-                                    unreachable;
-                                }
-                            } else {
-                                unreachable;
-                            }
-                        },
+                        .Many => unreachable,
                         .One => {
                             var arena = std.heap.ArenaAllocator.init(dg.module.gpa);
                             defer arena.deinit();
@@ -934,10 +919,8 @@ fn genBody(o: *Object, body: []const Air.Inst.Index) error{ AnalysisFail, OutOfM
             .br               => try airBr(o, inst),
             .switch_br        => try airSwitchBr(o, inst),
             .wrap_optional    => try airWrapOptional(o, inst),
-            .ref              => try airRef(o, inst),
             .struct_field_ptr => try airStructFieldPtr(o, inst),
             .struct_field_val => try airStructFieldVal(o, inst),
-            .varptr           => try airVarPtr(o, inst),
             .slice_ptr        => try airSliceField(o, inst, ".ptr;\n"),
             .slice_len        => try airSliceField(o, inst, ".len;\n"),
 
@@ -996,12 +979,6 @@ fn airSliceElemVal(o: *Object, inst: Air.Inst.Index, prefix: []const u8) !CValue
     return local;
 }
 
-fn airVarPtr(o: *Object, inst: Air.Inst.Index) !CValue {
-    const ty_pl = o.air.instructions.items(.data)[inst].ty_pl;
-    const variable = o.air.variables[ty_pl.payload];
-    return CValue{ .decl_ref = variable.owner_decl };
-}
-
 fn airAlloc(o: *Object, inst: Air.Inst.Index) !CValue {
     const writer = o.writer();
     const inst_ty = o.air.typeOfIndex(inst);
@@ -1653,22 +1630,6 @@ fn airOptionalPayload(o: *Object, inst: Air.Inst.Index) !CValue {
     return local;
 }
 
-fn airRef(o: *Object, inst: Air.Inst.Index) !CValue {
-    if (o.liveness.isUnused(inst))
-        return CValue.none;
-
-    const ty_op = o.air.instructions.items(.data)[inst].ty_op;
-    const writer = o.writer();
-    const operand = try o.resolveInst(ty_op.operand);
-
-    const inst_ty = o.air.typeOfIndex(inst);
-    const local = try o.allocLocal(inst_ty, .Const);
-    try writer.writeAll(" = ");
-    try o.writeCValue(writer, operand);
-    try writer.writeAll(";\n");
-    return local;
-}
-
 fn airStructFieldPtr(o: *Object, inst: Air.Inst.Index) !CValue {
     if (o.liveness.isUnused(inst))
         return CValue.none;
diff --git a/src/codegen/llvm.zig b/src/codegen/llvm.zig
index 22f117aa1c..0e9a572bea 100644
--- a/src/codegen/llvm.zig
+++ b/src/codegen/llvm.zig
@@ -699,29 +699,12 @@ pub const DeclGen = struct {
                 .decl_ref => {
                     const decl = tv.val.castTag(.decl_ref).?.data;
                     const val = try self.resolveGlobalDecl(decl);
-
-                    const usize_type = try self.llvmType(Type.initTag(.usize));
-
-                    // TODO: second index should be the index into the memory!
-                    var indices: [2]*const llvm.Value = .{
-                        usize_type.constNull(),
-                        usize_type.constNull(),
-                    };
-
-                    return val.constInBoundsGEP(&indices, indices.len);
-                },
-                .ref_val => {
-                    //const elem_value = tv.val.castTag(.ref_val).?.data;
-                    //const elem_type = tv.ty.castPointer().?.data;
-                    //const alloca = fg.?.buildAlloca(try self.llvmType(elem_type));
-                    //_ = fg.?.builder.buildStore(try self.genTypedValue(.{ .ty = elem_type, .val = elem_value }, fg), alloca);
-                    //return alloca;
-                    // TODO eliminate the ref_val Value Tag
-                    return self.todo("implement const of pointer tag ref_val", .{});
+                    return val.constBitCast(llvm_type);
                 },
                 .variable => {
                     const variable = tv.val.castTag(.variable).?.data;
-                    return self.resolveGlobalDecl(variable.owner_decl);
+                    const val = try self.resolveGlobalDecl(variable.owner_decl);
+                    return val.constBitCast(llvm_type);
                 },
                 .slice => {
                     const slice = tv.val.castTag(.slice).?.data;
@@ -977,7 +960,6 @@ pub const FuncGen = struct {
                 .ret        => try self.airRet(inst),
                 .store      => try self.airStore(inst),
                 .assembly   => try self.airAssembly(inst),
-                .varptr     => try self.airVarPtr(inst),
                 .slice_ptr  => try self.airSliceField(inst, 0),
                 .slice_len  => try self.airSliceField(inst, 1),
 
@@ -1001,7 +983,6 @@ pub const FuncGen = struct {
 
                 .constant => unreachable,
                 .const_ty => unreachable,
-                .ref => unreachable, // TODO eradicate this instruction
                 .unreach  => self.airUnreach(inst),
                 .dbg_stmt => blk: {
                     // TODO: implement debug info
@@ -1180,16 +1161,6 @@ pub const FuncGen = struct {
         return null;
     }
 
-    fn airVarPtr(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
-        if (self.liveness.isUnused(inst))
-            return null;
-
-        const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
-        const variable = self.air.variables[ty_pl.payload];
-        const decl_llvm_value = self.dg.resolveGlobalDecl(variable.owner_decl);
-        return decl_llvm_value;
-    }
-
     fn airSliceField(self: *FuncGen, inst: Air.Inst.Index, index: c_uint) !?*const llvm.Value {
         if (self.liveness.isUnused(inst))
             return null;
diff --git a/src/codegen/llvm/bindings.zig b/src/codegen/llvm/bindings.zig
index 6d09d69447..0977d6128d 100644
--- a/src/codegen/llvm/bindings.zig
+++ b/src/codegen/llvm/bindings.zig
@@ -112,6 +112,9 @@ pub const Value = opaque {
         ConstantIndices: [*]const *const Value,
         NumIndices: c_uint,
     ) *const Value;
+
+    pub const constBitCast = LLVMConstBitCast;
+    extern fn LLVMConstBitCast(ConstantVal: *const Value, ToType: *const Type) *const Value;
 };
 
 pub const Type = opaque {
diff --git a/src/codegen/wasm.zig b/src/codegen/wasm.zig
index bf9010fbff..37cc6bc59c 100644
--- a/src/codegen/wasm.zig
+++ b/src/codegen/wasm.zig
@@ -754,22 +754,21 @@ pub const Context = struct {
     }
 
     /// Generates the wasm bytecode for the declaration belonging to `Context`
-    pub fn gen(self: *Context, typed_value: TypedValue) InnerError!Result {
-        switch (typed_value.ty.zigTypeTag()) {
+    pub fn gen(self: *Context, ty: Type, val: Value) InnerError!Result {
+        switch (ty.zigTypeTag()) {
             .Fn => {
                 try self.genFunctype();
-                if (typed_value.val.castTag(.extern_fn)) |_| return Result.appended; // don't need code body for extern functions
+                if (val.tag() == .extern_fn) {
+                    return Result.appended; // don't need code body for extern functions
+                }
                 return self.fail("TODO implement wasm codegen for function pointers", .{});
             },
             .Array => {
-                if (typed_value.val.castTag(.bytes)) |payload| {
-                    if (typed_value.ty.sentinel()) |sentinel| {
+                if (val.castTag(.bytes)) |payload| {
+                    if (ty.sentinel()) |sentinel| {
                         try self.code.appendSlice(payload.data);
 
-                        switch (try self.gen(.{
-                            .ty = typed_value.ty.elemType(),
-                            .val = sentinel,
-                        })) {
+                        switch (try self.gen(ty.elemType(), sentinel)) {
                             .appended => return Result.appended,
                             .externally_managed => |data| {
                                 try self.code.appendSlice(data);
@@ -781,13 +780,17 @@ pub const Context = struct {
                 } else return self.fail("TODO implement gen for more kinds of arrays", .{});
             },
             .Int => {
-                const info = typed_value.ty.intInfo(self.target);
+                const info = ty.intInfo(self.target);
                 if (info.bits == 8 and info.signedness == .unsigned) {
-                    const int_byte = typed_value.val.toUnsignedInt();
+                    const int_byte = val.toUnsignedInt();
                     try self.code.append(@intCast(u8, int_byte));
                     return Result.appended;
                 }
-                return self.fail("TODO: Implement codegen for int type: '{}'", .{typed_value.ty});
+                return self.fail("TODO: Implement codegen for int type: '{}'", .{ty});
+            },
+            .Enum => {
+                try self.emitConstant(val, ty);
+                return Result.appended;
             },
             else => |tag| return self.fail("TODO: Implement zig type codegen for type: '{s}'", .{tag}),
         }
@@ -969,7 +972,7 @@ pub const Context = struct {
         return WValue{ .code_offset = offset };
     }
 
-    fn emitConstant(self: *Context, value: Value, ty: Type) InnerError!void {
+    fn emitConstant(self: *Context, val: Value, ty: Type) InnerError!void {
         const writer = self.code.writer();
         switch (ty.zigTypeTag()) {
             .Int => {
@@ -982,10 +985,10 @@ pub const Context = struct {
                 const int_info = ty.intInfo(self.target);
                 // write constant
                 switch (int_info.signedness) {
-                    .signed => try leb.writeILEB128(writer, value.toSignedInt()),
+                    .signed => try leb.writeILEB128(writer, val.toSignedInt()),
                     .unsigned => switch (int_info.bits) {
-                        0...32 => try leb.writeILEB128(writer, @bitCast(i32, @intCast(u32, value.toUnsignedInt()))),
-                        33...64 => try leb.writeILEB128(writer, @bitCast(i64, value.toUnsignedInt())),
+                        0...32 => try leb.writeILEB128(writer, @bitCast(i32, @intCast(u32, val.toUnsignedInt()))),
+                        33...64 => try leb.writeILEB128(writer, @bitCast(i64, val.toUnsignedInt())),
                         else => |bits| return self.fail("Wasm TODO: emitConstant for integer with {d} bits", .{bits}),
                     },
                 }
@@ -994,7 +997,7 @@ pub const Context = struct {
                 // write opcode
                 try writer.writeByte(wasm.opcode(.i32_const));
                 // write constant
-                try leb.writeILEB128(writer, value.toSignedInt());
+                try leb.writeILEB128(writer, val.toSignedInt());
             },
             .Float => {
                 // write opcode
@@ -1005,13 +1008,13 @@ pub const Context = struct {
                 try writer.writeByte(wasm.opcode(opcode));
                 // write constant
                 switch (ty.floatBits(self.target)) {
-                    0...32 => try writer.writeIntLittle(u32, @bitCast(u32, value.toFloat(f32))),
-                    64 => try writer.writeIntLittle(u64, @bitCast(u64, value.toFloat(f64))),
+                    0...32 => try writer.writeIntLittle(u32, @bitCast(u32, val.toFloat(f32))),
+                    64 => try writer.writeIntLittle(u64, @bitCast(u64, val.toFloat(f64))),
                     else => |bits| return self.fail("Wasm TODO: emitConstant for float with {d} bits", .{bits}),
                 }
             },
             .Pointer => {
-                if (value.castTag(.decl_ref)) |payload| {
+                if (val.castTag(.decl_ref)) |payload| {
                     const decl = payload.data;
 
                     // offset into the offset table within the 'data' section
@@ -1024,11 +1027,11 @@ pub const Context = struct {
                     try writer.writeByte(wasm.opcode(.i32_load));
                     try leb.writeULEB128(writer, @as(u32, 0));
                     try leb.writeULEB128(writer, @as(u32, 0));
-                } else return self.fail("Wasm TODO: emitConstant for other const pointer tag {s}", .{value.tag()});
+                } else return self.fail("Wasm TODO: emitConstant for other const pointer tag {s}", .{val.tag()});
             },
             .Void => {},
             .Enum => {
-                if (value.castTag(.enum_field_index)) |field_index| {
+                if (val.castTag(.enum_field_index)) |field_index| {
                     switch (ty.tag()) {
                         .enum_simple => {
                             try writer.writeByte(wasm.opcode(.i32_const));
@@ -1049,20 +1052,20 @@ pub const Context = struct {
                 } else {
                     var int_tag_buffer: Type.Payload.Bits = undefined;
                     const int_tag_ty = ty.intTagType(&int_tag_buffer);
-                    try self.emitConstant(value, int_tag_ty);
+                    try self.emitConstant(val, int_tag_ty);
                 }
             },
             .ErrorSet => {
-                const error_index = self.global_error_set.get(value.getError().?).?;
+                const error_index = self.global_error_set.get(val.getError().?).?;
                 try writer.writeByte(wasm.opcode(.i32_const));
                 try leb.writeULEB128(writer, error_index);
             },
             .ErrorUnion => {
-                const data = value.castTag(.error_union).?.data;
+                const data = val.castTag(.error_union).?.data;
                 const error_type = ty.errorUnionSet();
                 const payload_type = ty.errorUnionPayload();
-                if (value.getError()) |_| {
-                    // write the error value
+                if (val.getError()) |_| {
+                    // write the error val
                     try self.emitConstant(data, error_type);
 
                     // no payload, so write a '0' const
@@ -1085,7 +1088,7 @@ pub const Context = struct {
     }
 
     /// Returns a `Value` as a signed 32 bit value.
-    /// It's illegale to provide a value with a type that cannot be represented
+    /// It's illegal to provide a value with a type that cannot be represented
     /// as an integer value.
     fn valueAsI32(self: Context, val: Value, ty: Type) i32 {
         switch (ty.zigTypeTag()) {
diff --git a/src/link/Wasm.zig b/src/link/Wasm.zig
index 23d0543494..3c3cd4eef3 100644
--- a/src/link/Wasm.zig
+++ b/src/link/Wasm.zig
@@ -275,7 +275,7 @@ pub fn updateDecl(self: *Wasm, module: *Module, decl: *Module.Decl) !void {
     defer context.deinit();
 
     // generate the 'code' section for the function declaration
-    const result = context.gen(.{ .ty = decl.ty, .val = decl.val }) catch |err| switch (err) {
+    const result = context.gen(decl.ty, decl.val) catch |err| switch (err) {
         error.CodegenFail => {
             decl.analysis = .codegen_failure;
             try module.failed_decls.put(module.gpa, decl, context.err_msg);
diff --git a/src/print_air.zig b/src/print_air.zig
index 2d5d6b588e..5d77c303bb 100644
--- a/src/print_air.zig
+++ b/src/print_air.zig
@@ -15,12 +15,11 @@ pub fn dump(gpa: *Allocator, air: Air, zir: Zir, liveness: Liveness) void {
         (@sizeOf(Air.Inst.Tag) + 8);
     const extra_bytes = air.extra.len * @sizeOf(u32);
     const values_bytes = air.values.len * @sizeOf(Value);
-    const variables_bytes = air.variables.len * @sizeOf(*Module.Var);
     const tomb_bytes = liveness.tomb_bits.len * @sizeOf(usize);
     const liveness_extra_bytes = liveness.extra.len * @sizeOf(u32);
     const liveness_special_bytes = liveness.special.count() * 8;
     const total_bytes = @sizeOf(Air) + instruction_bytes + extra_bytes +
-        values_bytes * variables_bytes + @sizeOf(Liveness) + liveness_extra_bytes +
+        values_bytes + @sizeOf(Liveness) + liveness_extra_bytes +
         liveness_special_bytes + tomb_bytes;
 
     // zig fmt: off
@@ -29,7 +28,6 @@ pub fn dump(gpa: *Allocator, air: Air, zir: Zir, liveness: Liveness) void {
         \\# AIR Instructions:         {d} ({})
         \\# AIR Extra Data:           {d} ({})
         \\# AIR Values Bytes:         {d} ({})
-        \\# AIR Variables Bytes:      {d} ({})
         \\# Liveness tomb_bits:       {}
         \\# Liveness Extra Data:      {d} ({})
         \\# Liveness special table:   {d} ({})
@@ -39,7 +37,6 @@ pub fn dump(gpa: *Allocator, air: Air, zir: Zir, liveness: Liveness) void {
         air.instructions.len, fmtIntSizeBin(instruction_bytes),
         air.extra.len, fmtIntSizeBin(extra_bytes),
         air.values.len, fmtIntSizeBin(values_bytes),
-        air.variables.len, fmtIntSizeBin(variables_bytes),
         fmtIntSizeBin(tomb_bytes),
         liveness.extra.len, fmtIntSizeBin(liveness_extra_bytes),
         liveness.special.count(), fmtIntSizeBin(liveness_special_bytes),
@@ -152,7 +149,6 @@ const Writer = struct {
             .not,
             .bitcast,
             .load,
-            .ref,
             .floatcast,
             .intcast,
             .optional_payload,
@@ -174,7 +170,6 @@ const Writer = struct {
 
             .struct_field_ptr => try w.writeStructField(s, inst),
             .struct_field_val => try w.writeStructField(s, inst),
-            .varptr => try w.writeVarPtr(s, inst),
             .constant => try w.writeConstant(s, inst),
             .assembly => try w.writeAssembly(s, inst),
             .dbg_stmt => try w.writeDbgStmt(s, inst),
@@ -243,12 +238,6 @@ const Writer = struct {
         try s.print(", {d}", .{extra.data.field_index});
     }
 
-    fn writeVarPtr(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
-        _ = w;
-        _ = inst;
-        try s.writeAll("TODO");
-    }
-
     fn writeConstant(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
         const ty_pl = w.air.instructions.items(.data)[inst].ty_pl;
         const val = w.air.values[ty_pl.payload];
diff --git a/src/value.zig b/src/value.zig
index 5d9fd27414..d3317ef31d 100644
--- a/src/value.zig
+++ b/src/value.zig
@@ -100,8 +100,6 @@ pub const Value = extern union {
         function,
         extern_fn,
         variable,
-        /// Represents a pointer to another immutable value.
-        ref_val,
         /// Represents a comptime variables storage.
         comptime_alloc,
         /// Represents a pointer to a decl, not the value of the decl.
@@ -126,6 +124,8 @@ pub const Value = extern union {
         enum_field_index,
         @"error",
         error_union,
+        /// A pointer to the payload of an error union, based on a pointer to an error union.
+        eu_payload_ptr,
         /// An instance of a struct.
         @"struct",
         /// An instance of a union.
@@ -214,9 +214,9 @@ pub const Value = extern union {
                 .decl_ref,
                 => Payload.Decl,
 
-                .ref_val,
                 .repeated,
                 .error_union,
+                .eu_payload_ptr,
                 => Payload.SubValue,
 
                 .bytes,
@@ -407,15 +407,6 @@ pub const Value = extern union {
             .function => return self.copyPayloadShallow(allocator, Payload.Function),
             .extern_fn => return self.copyPayloadShallow(allocator, Payload.Decl),
             .variable => return self.copyPayloadShallow(allocator, Payload.Variable),
-            .ref_val => {
-                const payload = self.castTag(.ref_val).?;
-                const new_payload = try allocator.create(Payload.SubValue);
-                new_payload.* = .{
-                    .base = payload.base,
-                    .data = try payload.data.copy(allocator),
-                };
-                return Value{ .ptr_otherwise = &new_payload.base };
-            },
             .comptime_alloc => return self.copyPayloadShallow(allocator, Payload.ComptimeAlloc),
             .decl_ref => return self.copyPayloadShallow(allocator, Payload.Decl),
             .elem_ptr => {
@@ -443,8 +434,8 @@ pub const Value = extern union {
                 return Value{ .ptr_otherwise = &new_payload.base };
             },
             .bytes => return self.copyPayloadShallow(allocator, Payload.Bytes),
-            .repeated => {
-                const payload = self.castTag(.repeated).?;
+            .repeated, .error_union, .eu_payload_ptr => {
+                const payload = self.cast(Payload.SubValue).?;
                 const new_payload = try allocator.create(Payload.SubValue);
                 new_payload.* = .{
                     .base = payload.base,
@@ -489,15 +480,6 @@ pub const Value = extern union {
             },
             .enum_field_index => return self.copyPayloadShallow(allocator, Payload.U32),
             .@"error" => return self.copyPayloadShallow(allocator, Payload.Error),
-            .error_union => {
-                const payload = self.castTag(.error_union).?;
-                const new_payload = try allocator.create(Payload.SubValue);
-                new_payload.* = .{
-                    .base = payload.base,
-                    .data = try payload.data.copy(allocator),
-                };
-                return Value{ .ptr_otherwise = &new_payload.base };
-            },
             .@"struct" => @panic("TODO can't copy struct value without knowing the type"),
             .@"union" => @panic("TODO can't copy union value without knowing the type"),
 
@@ -609,11 +591,6 @@ pub const Value = extern union {
             .function => return out_stream.print("(function '{s}')", .{val.castTag(.function).?.data.owner_decl.name}),
             .extern_fn => return out_stream.writeAll("(extern function)"),
             .variable => return out_stream.writeAll("(variable)"),
-            .ref_val => {
-                const ref_val = val.castTag(.ref_val).?.data;
-                try out_stream.writeAll("&const ");
-                val = ref_val;
-            },
             .comptime_alloc => {
                 const ref_val = val.castTag(.comptime_alloc).?.data.val;
                 try out_stream.writeAll("&");
@@ -648,6 +625,10 @@ pub const Value = extern union {
             // TODO to print this it should be error{ Set, Items }!T(val), but we need the type for that
             .error_union => return out_stream.print("error_union_val({})", .{val.castTag(.error_union).?.data}),
             .inferred_alloc => return out_stream.writeAll("(inferred allocation value)"),
+            .eu_payload_ptr => {
+                try out_stream.writeAll("(eu_payload_ptr)");
+                val = val.castTag(.eu_payload_ptr).?.data;
+            },
         };
     }
 
@@ -758,7 +739,6 @@ pub const Value = extern union {
             .function,
             .extern_fn,
             .variable,
-            .ref_val,
             .comptime_alloc,
             .decl_ref,
             .elem_ptr,
@@ -780,18 +760,21 @@ pub const Value = extern union {
             .@"union",
             .inferred_alloc,
             .abi_align_default,
+            .eu_payload_ptr,
             => unreachable,
         };
     }
 
     /// Asserts the type is an enum type.
-    pub fn toEnum(val: Value, enum_ty: Type, comptime E: type) E {
-        _ = enum_ty;
-        // TODO this needs to resolve other kinds of Value tags rather than
-        // assuming the tag will be .enum_field_index.
-        const field_index = val.castTag(.enum_field_index).?.data;
-        // TODO should `@intToEnum` do this `@intCast` for you?
-        return @intToEnum(E, @intCast(@typeInfo(E).Enum.tag_type, field_index));
+    pub fn toEnum(val: Value, comptime E: type) E {
+        switch (val.tag()) {
+            .enum_field_index => {
+                const field_index = val.castTag(.enum_field_index).?.data;
+                // TODO should `@intToEnum` do this `@intCast` for you?
+                return @intToEnum(E, @intCast(@typeInfo(E).Enum.tag_type, field_index));
+            },
+            else => unreachable,
+        }
     }
 
     /// Asserts the value is an integer.
@@ -1255,6 +1238,9 @@ pub const Value = extern union {
             .slice => {
                 @panic("TODO Value.hash for slice");
             },
+            .eu_payload_ptr => {
+                @panic("TODO Value.hash for eu_payload_ptr");
+            },
             .int_u64 => {
                 const payload = self.castTag(.int_u64).?;
                 std.hash.autoHash(&hasher, payload.data);
@@ -1263,10 +1249,6 @@ pub const Value = extern union {
                 const payload = self.castTag(.int_i64).?;
                 std.hash.autoHash(&hasher, payload.data);
             },
-            .ref_val => {
-                const payload = self.castTag(.ref_val).?;
-                std.hash.autoHash(&hasher, payload.data.hash());
-            },
             .comptime_alloc => {
                 const payload = self.castTag(.comptime_alloc).?;
                 std.hash.autoHash(&hasher, payload.data.val.hash());
@@ -1367,7 +1349,6 @@ pub const Value = extern union {
     pub fn pointerDeref(self: Value, allocator: *Allocator) error{ AnalysisFail, OutOfMemory }!Value {
         return switch (self.tag()) {
             .comptime_alloc => self.castTag(.comptime_alloc).?.data.val,
-            .ref_val => self.castTag(.ref_val).?.data,
             .decl_ref => self.castTag(.decl_ref).?.data.value(),
             .elem_ptr => {
                 const elem_ptr = self.castTag(.elem_ptr).?.data;
@@ -1379,6 +1360,11 @@ pub const Value = extern union {
                 const container_val = try field_ptr.container_ptr.pointerDeref(allocator);
                 return container_val.fieldValue(allocator, field_ptr.field_index);
             },
+            .eu_payload_ptr => {
+                const err_union_ptr = self.castTag(.eu_payload_ptr).?.data;
+                const err_union_val = try err_union_ptr.pointerDeref(allocator);
+                return err_union_val.castTag(.error_union).?.data;
+            },
 
             else => unreachable,
         };
@@ -1390,7 +1376,6 @@ pub const Value = extern union {
             .bytes => val.castTag(.bytes).?.data.len,
             .array => val.castTag(.array).?.data.len,
             .slice => val.castTag(.slice).?.data.len.toUnsignedInt(),
-            .ref_val => sliceLen(val.castTag(.ref_val).?.data),
             .decl_ref => {
                 const decl = val.castTag(.decl_ref).?.data;
                 if (decl.ty.zigTypeTag() == .Array) {
@@ -1576,7 +1561,6 @@ pub const Value = extern union {
             .int_i64,
             .int_big_positive,
             .int_big_negative,
-            .ref_val,
             .comptime_alloc,
             .decl_ref,
             .elem_ptr,
@@ -1599,6 +1583,7 @@ pub const Value = extern union {
             .@"union",
             .null_value,
             .abi_align_default,
+            .eu_payload_ptr,
             => false,
 
             .undef => unreachable,
diff --git a/test/cases.zig b/test/cases.zig
index f235992f71..840ee7a4ac 100644
--- a/test/cases.zig
+++ b/test/cases.zig
@@ -1182,10 +1182,11 @@ pub fn addCases(ctx: *TestContext) !void {
         var case = ctx.obj("extern variable has no type", linux_x64);
         case.addError(
             \\comptime {
-            \\    _ = foo;
+            \\    const x = foo + foo;
+            \\    _ = x;
             \\}
             \\extern var foo: i32;
-        , &[_][]const u8{":2:9: error: unable to resolve comptime value"});
+        , &[_][]const u8{":2:15: error: unable to resolve comptime value"});
         case.addError(
             \\export fn entry() void {
             \\    _ = foo;

From 040c6eaaa03bbcfcdeadbe835c1c2f209e9f401e Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Thu, 29 Jul 2021 19:30:37 -0700
Subject: [PATCH 30/96] stage2: garbage collect unused anon decls

After this change, the frontend and backend cooperate to keep track of
which Decls are actually emitted into the machine code. When any backend
sees a `decl_ref` Value, it must mark the corresponding Decl `alive`
field to true.

This prevents unused comptime data from spilling into the output object
files. For example, if you do an `inline for` loop, previously, any
intermediate value calculations would have gone into the object file.
Now they are garbage collected immediately after the owner Decl has its
machine code generated.

In the frontend, when it is time to send a Decl to the linker, if it has
not been marked "alive" then it is deleted instead.

Additional improvements:
 * Resolve type ABI layouts after successful semantic analysis of a
   Decl. This is needed so that the backend has access to struct fields.
 * Sema: fix incorrect logic in resolveMaybeUndefVal. It should return
   "not comptime known" instead of a compile error for global variables.
 * `Value.pointerDeref` now returns `null` in the case that the pointer
   deref cannot happen at compile-time. This is true for global
   variables, for example. Another example is if a comptime known
   pointer has a hard coded address value.
 * Binary arithmetic sets the requireRuntimeBlock source location to the
   lhs_src or rhs_src as appropriate instead of on the operator node.
 * Fix LLVM codegen for slice_elem_val which had the wrong logic for
   when the operand was not a pointer.

As noted in the comment in the implementation of deleteUnusedDecl, a
future improvement will be to rework the frontend/linker interface to
remove the frontend's responsibility of calling allocateDeclIndexes.

I discovered some issues with the plan9 linker backend that are related
to this, and worked around them for now.
---
 src/Compilation.zig  |  10 ++-
 src/Module.zig       |  60 ++++++++++++++---
 src/Sema.zig         | 154 ++++++++++++++++++++++---------------------
 src/codegen.zig      |   7 +-
 src/codegen/c.zig    |  24 ++-----
 src/codegen/llvm.zig |  51 +++++++++-----
 src/codegen/wasm.zig |   1 +
 src/link/Plan9.zig   |  19 ++++--
 src/value.zig        |  45 +++++++++----
 test/stage2/cbe.zig  |   2 +-
 10 files changed, 234 insertions(+), 139 deletions(-)

diff --git a/src/Compilation.zig b/src/Compilation.zig
index 8672a346c3..f8f8cea328 100644
--- a/src/Compilation.zig
+++ b/src/Compilation.zig
@@ -2061,11 +2061,19 @@ pub fn performAllTheWork(self: *Compilation) error{ TimerUnsupported, OutOfMemor
             .complete, .codegen_failure_retryable => {
                 if (build_options.omit_stage2)
                     @panic("sadly stage2 is omitted from this build to save memory on the CI server");
+
                 const module = self.bin_file.options.module.?;
                 assert(decl.has_tv);
                 assert(decl.ty.hasCodeGenBits());
 
-                try module.linkerUpdateDecl(decl);
+                if (decl.alive) {
+                    try module.linkerUpdateDecl(decl);
+                    continue;
+                }
+
+                // Instead of sending this decl to the linker, we actually will delete it
+                // because we found out that it in fact was never referenced.
+                module.deleteUnusedDecl(decl);
             },
         },
         .codegen_func => |func| switch (func.owner_decl.analysis) {
diff --git a/src/Module.zig b/src/Module.zig
index f89f72bc65..909e54ffa2 100644
--- a/src/Module.zig
+++ b/src/Module.zig
@@ -255,6 +255,15 @@ pub const Decl = struct {
     has_align: bool,
     /// Whether the ZIR code provides a linksection instruction.
     has_linksection: bool,
+    /// Flag used by garbage collection to mark and sweep.
+    /// Decls which correspond to an AST node always have this field set to `true`.
+    /// Anonymous Decls are initialized with this field set to `false` and then it
+    /// is the responsibility of machine code backends to mark it `true` whenever
+    /// a `decl_ref` Value is encountered that points to this Decl.
+    /// When the `codegen_decl` job is encountered in the main work queue, if the
+    /// Decl is marked alive, then it sends the Decl to the linker. Otherwise it
+    /// deletes the Decl on the spot.
+    alive: bool,
 
     /// Represents the position of the code in the output file.
     /// This is populated regardless of semantic analysis and code generation.
@@ -2869,6 +2878,7 @@ pub fn semaFile(mod: *Module, file: *Scope.File) SemaError!void {
     new_decl.val = struct_val;
     new_decl.has_tv = true;
     new_decl.owns_tv = true;
+    new_decl.alive = true; // This Decl corresponds to a File and is therefore always alive.
     new_decl.analysis = .in_progress;
     new_decl.generation = mod.generation;
 
@@ -2990,6 +3000,7 @@ fn semaDecl(mod: *Module, decl: *Decl) !bool {
         if (linksection_ref == .none) break :blk Value.initTag(.null_value);
         break :blk (try sema.resolveInstConst(&block_scope, src, linksection_ref)).val;
     };
+    try sema.resolveTypeLayout(&block_scope, src, decl_tv.ty);
 
     // We need the memory for the Type to go into the arena for the Decl
     var decl_arena = std.heap.ArenaAllocator.init(gpa);
@@ -3027,8 +3038,8 @@ fn semaDecl(mod: *Module, decl: *Decl) !bool {
             const is_inline = decl_tv.ty.fnCallingConvention() == .Inline;
             if (!is_inline and decl_tv.ty.hasCodeGenBits()) {
                 // We don't fully codegen the decl until later, but we do need to reserve a global
-                // offset table index for it. This allows us to codegen decls out of dependency order,
-                // increasing how many computations can be done in parallel.
+                // offset table index for it. This allows us to codegen decls out of dependency
+                // order, increasing how many computations can be done in parallel.
                 try mod.comp.bin_file.allocateDeclIndexes(decl);
                 try mod.comp.work_queue.writeItem(.{ .codegen_func = func });
                 if (type_changed and mod.emit_h != null) {
@@ -3387,6 +3398,7 @@ fn scanDecl(iter: *ScanDeclIter, decl_sub_index: usize, flags: u4) SemaError!voi
         new_decl.has_align = has_align;
         new_decl.has_linksection = has_linksection;
         new_decl.zir_decl_index = @intCast(u32, decl_sub_index);
+        new_decl.alive = true; // This Decl corresponds to an AST node and therefore always alive.
         return;
     }
     gpa.free(decl_name);
@@ -3526,6 +3538,43 @@ pub fn clearDecl(
     decl.analysis = .unreferenced;
 }
 
+pub fn deleteUnusedDecl(mod: *Module, decl: *Decl) void {
+    log.debug("deleteUnusedDecl {*} ({s})", .{ decl, decl.name });
+
+    // TODO: remove `allocateDeclIndexes` and make the API that the linker backends
+    // are required to notice the first time `updateDecl` happens and keep track
+    // of it themselves. However they can rely on getting a `freeDecl` call if any
+    // `updateDecl` or `updateFunc` calls happen. This will allow us to avoid any call
+    // into the linker backend here, since the linker backend will never have been told
+    // about the Decl in the first place.
+    // Until then, we did call `allocateDeclIndexes` on this anonymous Decl and so we
+    // must call `freeDecl` in the linker backend now.
+    if (decl.has_tv) {
+        if (decl.ty.hasCodeGenBits()) {
+            mod.comp.bin_file.freeDecl(decl);
+        }
+    }
+
+    const dependants = decl.dependants.keys();
+    assert(dependants[0].namespace.anon_decls.swapRemove(decl));
+
+    for (dependants) |dep| {
+        dep.removeDependency(decl);
+    }
+
+    for (decl.dependencies.keys()) |dep| {
+        dep.removeDependant(decl);
+    }
+    decl.destroy(mod);
+}
+
+pub fn deleteAnonDecl(mod: *Module, scope: *Scope, decl: *Decl) void {
+    log.debug("deleteAnonDecl {*} ({s})", .{ decl, decl.name });
+    const scope_decl = scope.ownerDecl().?;
+    assert(scope_decl.namespace.anon_decls.swapRemove(decl));
+    decl.destroy(mod);
+}
+
 /// Delete all the Export objects that are caused by this Decl. Re-analysis of
 /// this Decl will cause them to be re-created (or not).
 fn deleteDeclExports(mod: *Module, decl: *Decl) void {
@@ -3713,6 +3762,7 @@ fn allocateNewDecl(mod: *Module, namespace: *Scope.Namespace, src_node: ast.Node
         .is_exported = false,
         .has_linksection = false,
         .has_align = false,
+        .alive = false,
     };
     return new_decl;
 }
@@ -3802,12 +3852,6 @@ pub fn analyzeExport(
     errdefer de_gop.value_ptr.* = mod.gpa.shrink(de_gop.value_ptr.*, de_gop.value_ptr.len - 1);
 }
 
-pub fn deleteAnonDecl(mod: *Module, scope: *Scope, decl: *Decl) void {
-    const scope_decl = scope.ownerDecl().?;
-    assert(scope_decl.namespace.anon_decls.swapRemove(decl));
-    decl.destroy(mod);
-}
-
 /// Takes ownership of `name` even if it returns an error.
 pub fn createAnonymousDeclNamed(
     mod: *Module,
diff --git a/src/Sema.zig b/src/Sema.zig
index 95baae7e92..0da38d9a76 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -696,7 +696,7 @@ fn resolveMaybeUndefVal(
 ) CompileError!?Value {
     const val = (try sema.resolveMaybeUndefValAllowVariables(block, src, inst)) orelse return null;
     if (val.tag() == .variable) {
-        return sema.failWithNeededComptime(block, src);
+        return null;
     }
     return val;
 }
@@ -2917,12 +2917,13 @@ fn zirOptionalPayloadPtr(
     const child_pointer = try Module.simplePtrType(sema.arena, child_type, !optional_ptr_ty.isConstPtr(), .One);
 
     if (try sema.resolveDefinedValue(block, src, optional_ptr)) |pointer_val| {
-        const val = try pointer_val.pointerDeref(sema.arena);
-        if (val.isNull()) {
-            return sema.mod.fail(&block.base, src, "unable to unwrap null", .{});
+        if (try pointer_val.pointerDeref(sema.arena)) |val| {
+            if (val.isNull()) {
+                return sema.mod.fail(&block.base, src, "unable to unwrap null", .{});
+            }
+            // The same Value represents the pointer to the optional and the payload.
+            return sema.addConstant(child_pointer, pointer_val);
         }
-        // The same Value represents the pointer to the optional and the payload.
-        return sema.addConstant(child_pointer, pointer_val);
     }
 
     try sema.requireRuntimeBlock(block, src);
@@ -3027,14 +3028,15 @@ fn zirErrUnionPayloadPtr(
     const operand_pointer_ty = try Module.simplePtrType(sema.arena, payload_ty, !operand_ty.isConstPtr(), .One);
 
     if (try sema.resolveDefinedValue(block, src, operand)) |pointer_val| {
-        const val = try pointer_val.pointerDeref(sema.arena);
-        if (val.getError()) |name| {
-            return sema.mod.fail(&block.base, src, "caught unexpected error '{s}'", .{name});
+        if (try pointer_val.pointerDeref(sema.arena)) |val| {
+            if (val.getError()) |name| {
+                return sema.mod.fail(&block.base, src, "caught unexpected error '{s}'", .{name});
+            }
+            return sema.addConstant(
+                operand_pointer_ty,
+                try Value.Tag.eu_payload_ptr.create(sema.arena, pointer_val),
+            );
         }
-        return sema.addConstant(
-            operand_pointer_ty,
-            try Value.Tag.eu_payload_ptr.create(sema.arena, pointer_val),
-        );
     }
 
     try sema.requireRuntimeBlock(block, src);
@@ -3086,10 +3088,11 @@ fn zirErrUnionCodePtr(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) Co
     const result_ty = operand_ty.elemType().errorUnionSet();
 
     if (try sema.resolveDefinedValue(block, src, operand)) |pointer_val| {
-        const val = try pointer_val.pointerDeref(sema.arena);
-        assert(val.getError() != null);
-        const data = val.castTag(.error_union).?.data;
-        return sema.addConstant(result_ty, data);
+        if (try pointer_val.pointerDeref(sema.arena)) |val| {
+            assert(val.getError() != null);
+            const data = val.castTag(.error_union).?.data;
+            return sema.addConstant(result_ty, data);
+        }
     }
 
     try sema.requireRuntimeBlock(block, src);
@@ -4920,10 +4923,13 @@ fn analyzeArithmetic(
             log.debug("{s}({}, {}) result: {}", .{ @tagName(zir_tag), lhs_val, rhs_val, value });
 
             return sema.addConstant(scalar_type, value);
+        } else {
+            try sema.requireRuntimeBlock(block, rhs_src);
         }
+    } else {
+        try sema.requireRuntimeBlock(block, lhs_src);
     }
 
-    try sema.requireRuntimeBlock(block, src);
     const air_tag: Air.Inst.Tag = switch (zir_tag) {
         .add => .add,
         .addwrap => .addwrap,
@@ -6811,16 +6817,10 @@ fn fieldPtr(
             if (mem.eql(u8, field_name, "len")) {
                 var anon_decl = try block.startAnonDecl();
                 defer anon_decl.deinit();
-                return sema.addConstant(
-                    Type.initTag(.single_const_pointer_to_comptime_int),
-                    try Value.Tag.decl_ref.create(
-                        arena,
-                        try anon_decl.finish(
-                            Type.initTag(.comptime_int),
-                            try Value.Tag.int_u64.create(anon_decl.arena(), object_ty.arrayLen()),
-                        ),
-                    ),
-                );
+                return sema.analyzeDeclRef(try anon_decl.finish(
+                    Type.initTag(.comptime_int),
+                    try Value.Tag.int_u64.create(anon_decl.arena(), object_ty.arrayLen()),
+                ));
             } else {
                 return mod.fail(
                     &block.base,
@@ -6867,16 +6867,10 @@ fn fieldPtr(
                     if (mem.eql(u8, field_name, "len")) {
                         var anon_decl = try block.startAnonDecl();
                         defer anon_decl.deinit();
-                        return sema.addConstant(
-                            Type.initTag(.single_const_pointer_to_comptime_int),
-                            try Value.Tag.decl_ref.create(
-                                arena,
-                                try anon_decl.finish(
-                                    Type.initTag(.comptime_int),
-                                    try Value.Tag.int_u64.create(anon_decl.arena(), ptr_child.arrayLen()),
-                                ),
-                            ),
-                        );
+                        return sema.analyzeDeclRef(try anon_decl.finish(
+                            Type.initTag(.comptime_int),
+                            try Value.Tag.int_u64.create(anon_decl.arena(), ptr_child.arrayLen()),
+                        ));
                     } else {
                         return mod.fail(
                             &block.base,
@@ -6915,16 +6909,10 @@ fn fieldPtr(
 
                     var anon_decl = try block.startAnonDecl();
                     defer anon_decl.deinit();
-                    return sema.addConstant(
-                        try Module.simplePtrType(arena, child_type, false, .One),
-                        try Value.Tag.decl_ref.create(
-                            arena,
-                            try anon_decl.finish(
-                                child_type,
-                                try Value.Tag.@"error".create(anon_decl.arena(), .{ .name = name }),
-                            ),
-                        ),
-                    );
+                    return sema.analyzeDeclRef(try anon_decl.finish(
+                        child_type,
+                        try Value.Tag.@"error".create(anon_decl.arena(), .{ .name = name }),
+                    ));
                 },
                 .Struct, .Opaque, .Union => {
                     if (child_type.getNamespace()) |namespace| {
@@ -6971,16 +6959,10 @@ fn fieldPtr(
                     const field_index_u32 = @intCast(u32, field_index);
                     var anon_decl = try block.startAnonDecl();
                     defer anon_decl.deinit();
-                    return sema.addConstant(
-                        try Module.simplePtrType(arena, child_type, false, .One),
-                        try Value.Tag.decl_ref.create(
-                            arena,
-                            try anon_decl.finish(
-                                child_type,
-                                try Value.Tag.enum_field_index.create(anon_decl.arena(), field_index_u32),
-                            ),
-                        ),
-                    );
+                    return sema.analyzeDeclRef(try anon_decl.finish(
+                        child_type,
+                        try Value.Tag.enum_field_index.create(anon_decl.arena(), field_index_u32),
+                    ));
                 },
                 else => return mod.fail(&block.base, src, "type '{}' has no members", .{child_type}),
             }
@@ -7671,21 +7653,18 @@ fn analyzeRef(
     operand: Air.Inst.Ref,
 ) CompileError!Air.Inst.Ref {
     const operand_ty = sema.typeOf(operand);
-    const ptr_type = try Module.simplePtrType(sema.arena, operand_ty, false, .One);
 
     if (try sema.resolveMaybeUndefVal(block, src, operand)) |val| {
         var anon_decl = try block.startAnonDecl();
         defer anon_decl.deinit();
-        return sema.addConstant(
-            ptr_type,
-            try Value.Tag.decl_ref.create(
-                sema.arena,
-                try anon_decl.finish(operand_ty, try val.copy(anon_decl.arena())),
-            ),
-        );
+        return sema.analyzeDeclRef(try anon_decl.finish(
+            operand_ty,
+            try val.copy(anon_decl.arena()),
+        ));
     }
 
     try sema.requireRuntimeBlock(block, src);
+    const ptr_type = try Module.simplePtrType(sema.arena, operand_ty, false, .One);
     const alloc = try block.addTy(.alloc, ptr_type);
     try sema.storePtr(block, src, alloc, operand);
     return alloc;
@@ -7703,11 +7682,10 @@ fn analyzeLoad(
         .Pointer => ptr_ty.elemType(),
         else => return sema.mod.fail(&block.base, ptr_src, "expected pointer, found '{}'", .{ptr_ty}),
     };
-    if (try sema.resolveDefinedValue(block, ptr_src, ptr)) |ptr_val| blk: {
-        if (ptr_val.tag() == .int_u64)
-            break :blk; // do it at runtime
-
-        return sema.addConstant(elem_ty, try ptr_val.pointerDeref(sema.arena));
+    if (try sema.resolveDefinedValue(block, ptr_src, ptr)) |ptr_val| {
+        if (try ptr_val.pointerDeref(sema.arena)) |elem_val| {
+            return sema.addConstant(elem_ty, elem_val);
+        }
     }
 
     try sema.requireRuntimeBlock(block, src);
@@ -8215,6 +8193,36 @@ fn resolvePeerTypes(
     return sema.typeOf(chosen);
 }
 
+pub fn resolveTypeLayout(
+    sema: *Sema,
+    block: *Scope.Block,
+    src: LazySrcLoc,
+    ty: Type,
+) CompileError!void {
+    switch (ty.zigTypeTag()) {
+        .Pointer => {
+            return sema.resolveTypeLayout(block, src, ty.elemType());
+        },
+        .Struct => {
+            const resolved_ty = try sema.resolveTypeFields(block, src, ty);
+            const struct_obj = resolved_ty.castTag(.@"struct").?.data;
+            switch (struct_obj.status) {
+                .none, .have_field_types => {},
+                .field_types_wip, .layout_wip => {
+                    return sema.mod.fail(&block.base, src, "struct {} depends on itself", .{ty});
+                },
+                .have_layout => return,
+            }
+            struct_obj.status = .layout_wip;
+            for (struct_obj.fields.values()) |field| {
+                try sema.resolveTypeLayout(block, src, field.ty);
+            }
+            struct_obj.status = .have_layout;
+        },
+        else => {},
+    }
+}
+
 fn resolveTypeFields(sema: *Sema, block: *Scope.Block, src: LazySrcLoc, ty: Type) CompileError!Type {
     switch (ty.tag()) {
         .@"struct" => {
@@ -8222,9 +8230,7 @@ fn resolveTypeFields(sema: *Sema, block: *Scope.Block, src: LazySrcLoc, ty: Type
             switch (struct_obj.status) {
                 .none => {},
                 .field_types_wip => {
-                    return sema.mod.fail(&block.base, src, "struct {} depends on itself", .{
-                        ty,
-                    });
+                    return sema.mod.fail(&block.base, src, "struct {} depends on itself", .{ty});
                 },
                 .have_field_types, .have_layout, .layout_wip => return ty,
             }
diff --git a/src/codegen.zig b/src/codegen.zig
index b7ba367d54..d16a87adca 100644
--- a/src/codegen.zig
+++ b/src/codegen.zig
@@ -184,6 +184,7 @@ pub fn generateSymbol(
                 if (typed_value.val.castTag(.decl_ref)) |payload| {
                     const decl = payload.data;
                     if (decl.analysis != .complete) return error.AnalysisFail;
+                    decl.alive = true;
                     // TODO handle the dependency of this symbol on the decl's vaddr.
                     // If the decl changes vaddr, then this symbol needs to get regenerated.
                     const vaddr = bin_file.getDeclVAddr(decl);
@@ -4680,13 +4681,13 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
                     },
                     else => {
                         if (typed_value.val.castTag(.decl_ref)) |payload| {
+                            const decl = payload.data;
+                            decl.alive = true;
                             if (self.bin_file.cast(link.File.Elf)) |elf_file| {
-                                const decl = payload.data;
                                 const got = &elf_file.program_headers.items[elf_file.phdr_got_index.?];
                                 const got_addr = got.p_vaddr + decl.link.elf.offset_table_index * ptr_bytes;
                                 return MCValue{ .memory = got_addr };
                             } else if (self.bin_file.cast(link.File.MachO)) |macho_file| {
-                                const decl = payload.data;
                                 const got_addr = blk: {
                                     const seg = macho_file.load_commands.items[macho_file.data_const_segment_cmd_index.?].Segment;
                                     const got = seg.sections.items[macho_file.got_section_index.?];
@@ -4698,11 +4699,9 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
                                 };
                                 return MCValue{ .memory = got_addr };
                             } else if (self.bin_file.cast(link.File.Coff)) |coff_file| {
-                                const decl = payload.data;
                                 const got_addr = coff_file.offset_table_virtual_address + decl.link.coff.offset_table_index * ptr_bytes;
                                 return MCValue{ .memory = got_addr };
                             } else if (self.bin_file.cast(link.File.Plan9)) |p9| {
-                                const decl = payload.data;
                                 const got_addr = p9.bases.data + decl.link.plan9.got_index.? * ptr_bytes;
                                 return MCValue{ .memory = got_addr };
                             } else {
diff --git a/src/codegen/c.zig b/src/codegen/c.zig
index a8ec677753..826b73317c 100644
--- a/src/codegen/c.zig
+++ b/src/codegen/c.zig
@@ -262,6 +262,7 @@ pub const DeclGen = struct {
                     .one => try writer.writeAll("1"),
                     .decl_ref => {
                         const decl = val.castTag(.decl_ref).?.data;
+                        decl.alive = true;
 
                         // Determine if we must pointer cast.
                         assert(decl.has_tv);
@@ -281,21 +282,7 @@ pub const DeclGen = struct {
                         const decl = val.castTag(.extern_fn).?.data;
                         try writer.print("{s}", .{decl.name});
                     },
-                    else => switch (t.ptrSize()) {
-                        .Slice => unreachable,
-                        .Many => unreachable,
-                        .One => {
-                            var arena = std.heap.ArenaAllocator.init(dg.module.gpa);
-                            defer arena.deinit();
-
-                            const elem_ty = t.elemType();
-                            const elem_val = try val.pointerDeref(&arena.allocator);
-
-                            try writer.writeAll("&");
-                            try dg.renderValue(writer, elem_ty, elem_val);
-                        },
-                        .C => unreachable,
-                    },
+                    else => unreachable,
                 },
             },
             .Array => {
@@ -421,6 +408,7 @@ pub const DeclGen = struct {
                 .one => try writer.writeAll("1"),
                 .decl_ref => {
                     const decl = val.castTag(.decl_ref).?.data;
+                    decl.alive = true;
 
                     // Determine if we must pointer cast.
                     assert(decl.has_tv);
@@ -433,11 +421,13 @@ pub const DeclGen = struct {
                     }
                 },
                 .function => {
-                    const func = val.castTag(.function).?.data;
-                    try writer.print("{s}", .{func.owner_decl.name});
+                    const decl = val.castTag(.function).?.data.owner_decl;
+                    decl.alive = true;
+                    try writer.print("{s}", .{decl.name});
                 },
                 .extern_fn => {
                     const decl = val.castTag(.extern_fn).?.data;
+                    decl.alive = true;
                     try writer.print("{s}", .{decl.name});
                 },
                 else => unreachable,
diff --git a/src/codegen/llvm.zig b/src/codegen/llvm.zig
index 0e9a572bea..961ed7ee99 100644
--- a/src/codegen/llvm.zig
+++ b/src/codegen/llvm.zig
@@ -673,17 +673,21 @@ pub const DeclGen = struct {
     }
 
     fn genTypedValue(self: *DeclGen, tv: TypedValue) error{ OutOfMemory, CodegenFail }!*const llvm.Value {
-        const llvm_type = try self.llvmType(tv.ty);
-
-        if (tv.val.isUndef())
+        if (tv.val.isUndef()) {
+            const llvm_type = try self.llvmType(tv.ty);
             return llvm_type.getUndef();
+        }
 
         switch (tv.ty.zigTypeTag()) {
-            .Bool => return if (tv.val.toBool()) llvm_type.constAllOnes() else llvm_type.constNull(),
+            .Bool => {
+                const llvm_type = try self.llvmType(tv.ty);
+                return if (tv.val.toBool()) llvm_type.constAllOnes() else llvm_type.constNull();
+            },
             .Int => {
                 var bigint_space: Value.BigIntSpace = undefined;
                 const bigint = tv.val.toBigInt(&bigint_space);
 
+                const llvm_type = try self.llvmType(tv.ty);
                 if (bigint.eqZero()) return llvm_type.constNull();
 
                 if (bigint.limbs.len != 1) {
@@ -698,12 +702,17 @@ pub const DeclGen = struct {
             .Pointer => switch (tv.val.tag()) {
                 .decl_ref => {
                     const decl = tv.val.castTag(.decl_ref).?.data;
+                    decl.alive = true;
                     const val = try self.resolveGlobalDecl(decl);
+                    const llvm_type = try self.llvmType(tv.ty);
                     return val.constBitCast(llvm_type);
                 },
                 .variable => {
-                    const variable = tv.val.castTag(.variable).?.data;
-                    const val = try self.resolveGlobalDecl(variable.owner_decl);
+                    const decl = tv.val.castTag(.variable).?.data.owner_decl;
+                    decl.alive = true;
+                    const val = try self.resolveGlobalDecl(decl);
+                    const llvm_var_type = try self.llvmType(tv.ty);
+                    const llvm_type = llvm_var_type.pointerType(0);
                     return val.constBitCast(llvm_type);
                 },
                 .slice => {
@@ -783,6 +792,7 @@ pub const DeclGen = struct {
                     .decl_ref => tv.val.castTag(.decl_ref).?.data,
                     else => unreachable,
                 };
+                fn_decl.alive = true;
                 return self.resolveLlvmFunction(fn_decl);
             },
             .ErrorSet => {
@@ -903,9 +913,7 @@ pub const FuncGen = struct {
             return self.dg.genTypedValue(.{ .ty = self.air.typeOf(inst), .val = val });
         }
         const inst_index = Air.refToIndex(inst).?;
-        if (self.func_inst_table.get(inst_index)) |value| return value;
-
-        return self.todo("implement global llvm values (or the value is not in the func_inst_table table)", .{});
+        return self.func_inst_table.get(inst_index).?;
     }
 
     fn genBody(self: *FuncGen, body: []const Air.Inst.Index) error{ OutOfMemory, CodegenFail }!void {
@@ -966,8 +974,8 @@ pub const FuncGen = struct {
                 .struct_field_ptr => try self.airStructFieldPtr(inst),
                 .struct_field_val => try self.airStructFieldVal(inst),
 
-                .slice_elem_val     => try self.airSliceElemVal(inst, false),
-                .ptr_slice_elem_val => try self.airSliceElemVal(inst, true),
+                .slice_elem_val     => try self.airSliceElemVal(inst),
+                .ptr_slice_elem_val => try self.airPtrSliceElemVal(inst),
 
                 .optional_payload     => try self.airOptionalPayload(inst, false),
                 .optional_payload_ptr => try self.airOptionalPayload(inst, true),
@@ -1170,11 +1178,20 @@ pub const FuncGen = struct {
         return self.builder.buildExtractValue(operand, index, "");
     }
 
-    fn airSliceElemVal(
-        self: *FuncGen,
-        inst: Air.Inst.Index,
-        operand_is_ptr: bool,
-    ) !?*const llvm.Value {
+    fn airSliceElemVal(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+        if (self.liveness.isUnused(inst))
+            return null;
+
+        const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+        const lhs = try self.resolveInst(bin_op.lhs);
+        const rhs = try self.resolveInst(bin_op.rhs);
+        const base_ptr = self.builder.buildExtractValue(lhs, 0, "");
+        const indices: [1]*const llvm.Value = .{rhs};
+        const ptr = self.builder.buildInBoundsGEP(base_ptr, &indices, indices.len, "");
+        return self.builder.buildLoad(ptr, "");
+    }
+
+    fn airPtrSliceElemVal(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
         if (self.liveness.isUnused(inst))
             return null;
 
@@ -1182,7 +1199,7 @@ pub const FuncGen = struct {
         const lhs = try self.resolveInst(bin_op.lhs);
         const rhs = try self.resolveInst(bin_op.rhs);
 
-        const base_ptr = if (!operand_is_ptr) lhs else ptr: {
+        const base_ptr = ptr: {
             const index_type = self.context.intType(32);
             const indices: [2]*const llvm.Value = .{
                 index_type.constNull(),
diff --git a/src/codegen/wasm.zig b/src/codegen/wasm.zig
index 37cc6bc59c..2f1632e0fc 100644
--- a/src/codegen/wasm.zig
+++ b/src/codegen/wasm.zig
@@ -1016,6 +1016,7 @@ pub const Context = struct {
             .Pointer => {
                 if (val.castTag(.decl_ref)) |payload| {
                     const decl = payload.data;
+                    decl.alive = true;
 
                     // offset into the offset table within the 'data' section
                     const ptr_width = self.target.cpu.arch.ptrBitWidth() / 8;
diff --git a/src/link/Plan9.zig b/src/link/Plan9.zig
index 135b59f82b..3b2aae85bc 100644
--- a/src/link/Plan9.zig
+++ b/src/link/Plan9.zig
@@ -224,7 +224,9 @@ pub fn flushModule(self: *Plan9, comp: *Compilation) !void {
 
     const mod = self.base.options.module orelse return error.LinkingWithoutZigSourceUnimplemented;
 
-    assert(self.got_len == self.fn_decl_table.count() + self.data_decl_table.count());
+    // TODO I changed this assert from == to >= but this code all needs to be audited; see
+    // the comment in `freeDecl`.
+    assert(self.got_len >= self.fn_decl_table.count() + self.data_decl_table.count());
     const got_size = self.got_len * if (!self.sixtyfour_bit) @as(u32, 4) else 8;
     var got_table = try self.base.allocator.alloc(u8, got_size);
     defer self.base.allocator.free(got_table);
@@ -358,11 +360,18 @@ fn addDeclExports(
 }
 
 pub fn freeDecl(self: *Plan9, decl: *Module.Decl) void {
+    // TODO this is not the correct check for being function body,
+    // it could just be a function pointer.
+    // TODO audit the lifetimes of decls table entries. It's possible to get
+    // allocateDeclIndexes and then freeDecl without any updateDecl in between.
+    // However that is planned to change, see the TODO comment in Module.zig
+    // in the deleteUnusedDecl function.
     const is_fn = (decl.ty.zigTypeTag() == .Fn);
-    if (is_fn)
-        assert(self.fn_decl_table.swapRemove(decl))
-    else
-        assert(self.data_decl_table.swapRemove(decl));
+    if (is_fn) {
+        _ = self.fn_decl_table.swapRemove(decl);
+    } else {
+        _ = self.data_decl_table.swapRemove(decl);
+    }
 }
 
 pub fn updateDeclExports(
diff --git a/src/value.zig b/src/value.zig
index d3317ef31d..32be34ee2c 100644
--- a/src/value.zig
+++ b/src/value.zig
@@ -103,6 +103,7 @@ pub const Value = extern union {
         /// Represents a comptime variables storage.
         comptime_alloc,
         /// Represents a pointer to a decl, not the value of the decl.
+        /// When machine codegen backend sees this, it must set the Decl's `alive` field to true.
         decl_ref,
         elem_ptr,
         field_ptr,
@@ -1346,28 +1347,48 @@ pub const Value = extern union {
 
     /// Asserts the value is a pointer and dereferences it.
     /// Returns error.AnalysisFail if the pointer points to a Decl that failed semantic analysis.
-    pub fn pointerDeref(self: Value, allocator: *Allocator) error{ AnalysisFail, OutOfMemory }!Value {
-        return switch (self.tag()) {
+    pub fn pointerDeref(
+        self: Value,
+        allocator: *Allocator,
+    ) error{ AnalysisFail, OutOfMemory }!?Value {
+        const sub_val: Value = switch (self.tag()) {
             .comptime_alloc => self.castTag(.comptime_alloc).?.data.val,
-            .decl_ref => self.castTag(.decl_ref).?.data.value(),
-            .elem_ptr => {
+            .decl_ref => try self.castTag(.decl_ref).?.data.value(),
+            .elem_ptr => blk: {
                 const elem_ptr = self.castTag(.elem_ptr).?.data;
-                const array_val = try elem_ptr.array_ptr.pointerDeref(allocator);
-                return array_val.elemValue(allocator, elem_ptr.index);
+                const array_val = (try elem_ptr.array_ptr.pointerDeref(allocator)) orelse return null;
+                break :blk try array_val.elemValue(allocator, elem_ptr.index);
             },
-            .field_ptr => {
+            .field_ptr => blk: {
                 const field_ptr = self.castTag(.field_ptr).?.data;
-                const container_val = try field_ptr.container_ptr.pointerDeref(allocator);
-                return container_val.fieldValue(allocator, field_ptr.field_index);
+                const container_val = (try field_ptr.container_ptr.pointerDeref(allocator)) orelse return null;
+                break :blk try container_val.fieldValue(allocator, field_ptr.field_index);
             },
-            .eu_payload_ptr => {
+            .eu_payload_ptr => blk: {
                 const err_union_ptr = self.castTag(.eu_payload_ptr).?.data;
-                const err_union_val = try err_union_ptr.pointerDeref(allocator);
-                return err_union_val.castTag(.error_union).?.data;
+                const err_union_val = (try err_union_ptr.pointerDeref(allocator)) orelse return null;
+                break :blk err_union_val.castTag(.error_union).?.data;
             },
 
+            .zero,
+            .one,
+            .int_u64,
+            .int_i64,
+            .int_big_positive,
+            .int_big_negative,
+            .variable,
+            .extern_fn,
+            .function,
+            => return null,
+
             else => unreachable,
         };
+        if (sub_val.tag() == .variable) {
+            // This would be loading a runtime value at compile-time so we return
+            // the indicator that this pointer dereference requires being done at runtime.
+            return null;
+        }
+        return sub_val;
     }
 
     pub fn sliceLen(val: Value) u64 {
diff --git a/test/stage2/cbe.zig b/test/stage2/cbe.zig
index 6427e2e3b8..4f7d80d1fa 100644
--- a/test/stage2/cbe.zig
+++ b/test/stage2/cbe.zig
@@ -49,7 +49,7 @@ pub fn addCases(ctx: *TestContext) !void {
             \\export fn foo() callconv(y) c_int {
             \\    return 0;
             \\}
-            \\var y: i32 = 1234;
+            \\var y: @import("std").builtin.CallingConvention = .C;
         , &.{
             ":2:22: error: unable to resolve comptime value",
             ":5:26: error: unable to resolve comptime value",

From f6b1fa9e29ccab77a54e92dc13a7eb8e407bdbbc Mon Sep 17 00:00:00 2001
From: joachimschmidt557 <joachim.schmidt557@outlook.com>
Date: Fri, 30 Jul 2021 11:43:17 +0200
Subject: [PATCH 31/96] stage2 codegen: genTypedValue for error unions and
 error sets

---
 src/codegen.zig | 28 +++++++++++++++++++++++++++-
 1 file changed, 27 insertions(+), 1 deletion(-)

diff --git a/src/codegen.zig b/src/codegen.zig
index d16a87adca..0917f2c847 100644
--- a/src/codegen.zig
+++ b/src/codegen.zig
@@ -19,7 +19,6 @@ const DW = std.dwarf;
 const leb128 = std.leb;
 const log = std.log.scoped(.codegen);
 const build_options = @import("build_options");
-const LazySrcLoc = Module.LazySrcLoc;
 const RegisterManager = @import("register_manager.zig").RegisterManager;
 
 const X8664Encoder = @import("codegen/x86_64.zig").Encoder;
@@ -4741,6 +4740,33 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
                     }
                     return self.fail("TODO non pointer optionals", .{});
                 },
+                .ErrorSet => {
+                    switch (typed_value.val.tag()) {
+                        .@"error" => {
+                            const err_name = typed_value.val.castTag(.@"error").?.data.name;
+                            const module = self.bin_file.options.module.?;
+                            const global_error_set = module.global_error_set;
+                            const error_index = global_error_set.get(err_name).?;
+                            return MCValue{ .immediate = error_index };
+                        },
+                        else => {
+                            // In this case we are rendering an error union which has a 0 bits payload.
+                            return MCValue{ .immediate = 0 };
+                        },
+                    }
+                },
+                .ErrorUnion => {
+                    const error_type = typed_value.ty.errorUnionSet();
+                    const payload_type = typed_value.ty.errorUnionPayload();
+                    const sub_val = typed_value.val.castTag(.error_union).?.data;
+
+                    if (!payload_type.hasCodeGenBits()) {
+                        // We use the error type directly as the type.
+                        return self.genTypedValue(.{ .ty = error_type, .val = sub_val });
+                    }
+
+                    return self.fail("TODO implement error union const of type '{}'", .{typed_value.ty});
+                },
                 else => return self.fail("TODO implement const of type '{}'", .{typed_value.ty}),
             }
         }

From 7aaea20e7e5e98bc5b2c4c8ddcf8f6aaa4a9c55d Mon Sep 17 00:00:00 2001
From: Koakuma <koachan@protonmail.com>
Date: Fri, 30 Jul 2021 21:45:28 +0700
Subject: [PATCH 32/96] Add freeAndExit() implementation for Linux/SPARCv9

---
 lib/std/Thread.zig | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)

diff --git a/lib/std/Thread.zig b/lib/std/Thread.zig
index 2584b38072..e10e67c250 100644
--- a/lib/std/Thread.zig
+++ b/lib/std/Thread.zig
@@ -798,6 +798,32 @@ const LinuxThreadImpl = struct {
                       [len] "r" (self.mapped.len)
                     : "memory"
                 ),
+                .sparcv9 => asm volatile (
+                    \\ # SPARCs really don't like it when active stack frames
+                    \\ # is unmapped (it will result in a segfault), so we
+                    \\ # force-deactivate it by running `restore` until
+                    \\ # all frames are cleared.
+                    \\  1:
+                    \\  cmp %%sp, 0
+                    \\  beq 2f
+                    \\  restore
+                    \\  ba 1f
+                    \\  2:
+                    \\  mov 73, %%g1
+                    \\  mov %[ptr], %%o0
+                    \\  mov %[len], %%o1
+                    \\  # Flush register window contents to prevent background
+                    \\  # memory access before unmapping the stack.
+                    \\  flushw
+                    \\  t 0x6d
+                    \\  mov 1, %%g1
+                    \\  mov 1, %%o0
+                    \\  t 0x6d
+                    :
+                    : [ptr] "r" (@ptrToInt(self.mapped.ptr)),
+                      [len] "r" (self.mapped.len)
+                    : "memory"
+                ),
                 else => |cpu_arch| @compileError("Unsupported linux arch: " ++ @tagName(cpu_arch)),
             }
             unreachable;

From 84039a57e4684e8df10e657bb76c6acb3fb89238 Mon Sep 17 00:00:00 2001
From: joachimschmidt557 <joachim.schmidt557@outlook.com>
Date: Fri, 30 Jul 2021 22:48:20 +0200
Subject: [PATCH 33/96] stage2 codegen: Implement genTypedValue for enums

---
 src/codegen.zig     | 23 +++++++++++++++++++++++
 test/stage2/arm.zig | 22 ++++++++++++++++++++++
 2 files changed, 45 insertions(+)

diff --git a/src/codegen.zig b/src/codegen.zig
index 0917f2c847..bc3ff6257c 100644
--- a/src/codegen.zig
+++ b/src/codegen.zig
@@ -4740,6 +4740,29 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
                     }
                     return self.fail("TODO non pointer optionals", .{});
                 },
+                .Enum => {
+                    if (typed_value.val.castTag(.enum_field_index)) |field_index| {
+                        switch (typed_value.ty.tag()) {
+                            .enum_simple => {
+                                return MCValue{ .immediate = field_index.data };
+                            },
+                            .enum_full, .enum_nonexhaustive => {
+                                const enum_full = typed_value.ty.cast(Type.Payload.EnumFull).?.data;
+                                if (enum_full.values.count() != 0) {
+                                    const tag_val = enum_full.values.keys()[field_index.data];
+                                    return self.genTypedValue(.{ .ty = enum_full.tag_ty, .val = tag_val });
+                                } else {
+                                    return MCValue{ .immediate = field_index.data };
+                                }
+                            },
+                            else => unreachable,
+                        }
+                    } else {
+                        var int_tag_buffer: Type.Payload.Bits = undefined;
+                        const int_tag_ty = typed_value.ty.intTagType(&int_tag_buffer);
+                        return self.genTypedValue(.{ .ty = int_tag_ty, .val = typed_value.val });
+                    }
+                },
                 .ErrorSet => {
                     switch (typed_value.val.tag()) {
                         .@"error" => {
diff --git a/test/stage2/arm.zig b/test/stage2/arm.zig
index 6b4f569757..103b058a54 100644
--- a/test/stage2/arm.zig
+++ b/test/stage2/arm.zig
@@ -299,6 +299,28 @@ pub fn addCases(ctx: *TestContext) !void {
         );
     }
 
+    {
+        var case = ctx.exe("enums", linux_arm);
+        case.addCompareOutput(
+            \\const Number = enum { one, two, three };
+            \\
+            \\pub fn main() void {
+            \\    var x: Number = .one;
+            \\    var y = Number.two;
+            \\    var z = @intToEnum(Number, 2);
+            \\    assert(@enumToInt(x) == 0);
+            \\    assert(@enumToInt(y) == 1);
+            \\    assert(@enumToInt(z) == 2);
+            \\}
+            \\
+            \\fn assert(ok: bool) void {
+            \\    if (!ok) unreachable; // assertion failure
+            \\}
+        ,
+            "",
+        );
+    }
+
     {
         var case = ctx.exe("recursive fibonacci", linux_arm);
         case.addCompareOutput(

From 507dc1f2e7fac212e79f152e557cbec98a3c30e9 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Fri, 30 Jul 2021 16:05:46 -0700
Subject: [PATCH 34/96] stage2: fix hashing and comparison design flaw with
 Value

 * `Value.toType` accepts a buffer parameter instead of an allocator
   parameter and can no longer fail.
 * Module: remove the unused `mod: *Module` parameter from various
   functions.
 * `Value.compare` now accepts a `Type` parameter which indicates the
   type of both operands. There is also a `Value.compareHetero` which
   accepts only Value parameters and supports comparing mixed types.
   Likewise, `Value.eql` requires a `Type` parameter.
 * `Value.hash` is removed; instead the hash map context structs now
   have a `ty: Type` field, and the hash function lives there, where it
   has access to a Value's Type when it computes a hash.
   - This allowed the hash function to be greatly simplified and sound
     in the sense that the same Values, even with different
     representations, always hash to the same thing.
 * Sema: Fix source location of zirCmp when an operand is runtime known
   but needs to be comptime known.
 * Remove unused target parameter from `Value.floatCast`.
---
 src/Air.zig      |   3 +-
 src/Module.zig   |  11 +-
 src/RangeSet.zig |  23 ++-
 src/Sema.zig     | 134 ++++++++------
 src/type.zig     |  43 +++--
 src/value.zig    | 459 +++++++++++------------------------------------
 6 files changed, 230 insertions(+), 443 deletions(-)

diff --git a/src/Air.zig b/src/Air.zig
index fb95d60d00..d202c079bc 100644
--- a/src/Air.zig
+++ b/src/Air.zig
@@ -503,7 +503,8 @@ pub fn typeOfIndex(air: Air, inst: Air.Inst.Index) Type {
 pub fn getRefType(air: Air, ref: Air.Inst.Ref) Type {
     const ref_int = @enumToInt(ref);
     if (ref_int < Air.Inst.Ref.typed_value_map.len) {
-        return Air.Inst.Ref.typed_value_map[ref_int].val.toType(undefined) catch unreachable;
+        var buffer: Value.ToTypeBuffer = undefined;
+        return Air.Inst.Ref.typed_value_map[ref_int].val.toType(&buffer);
     }
     const inst_index = ref_int - Air.Inst.Ref.typed_value_map.len;
     const air_tags = air.instructions.items(.tag);
diff --git a/src/Module.zig b/src/Module.zig
index 909e54ffa2..d87f20621c 100644
--- a/src/Module.zig
+++ b/src/Module.zig
@@ -4299,7 +4299,6 @@ pub fn simplePtrType(
 }
 
 pub fn ptrType(
-    mod: *Module,
     arena: *Allocator,
     elem_ty: Type,
     sentinel: ?Value,
@@ -4311,7 +4310,6 @@ pub fn ptrType(
     @"volatile": bool,
     size: std.builtin.TypeInfo.Pointer.Size,
 ) Allocator.Error!Type {
-    _ = mod;
     assert(host_size == 0 or bit_offset < host_size * 8);
 
     // TODO check if type can be represented by simplePtrType
@@ -4328,8 +4326,7 @@ pub fn ptrType(
     });
 }
 
-pub fn optionalType(mod: *Module, arena: *Allocator, child_type: Type) Allocator.Error!Type {
-    _ = mod;
+pub fn optionalType(arena: *Allocator, child_type: Type) Allocator.Error!Type {
     switch (child_type.tag()) {
         .single_const_pointer => return Type.Tag.optional_single_const_pointer.create(
             arena,
@@ -4344,16 +4341,14 @@ pub fn optionalType(mod: *Module, arena: *Allocator, child_type: Type) Allocator
 }
 
 pub fn arrayType(
-    mod: *Module,
     arena: *Allocator,
     len: u64,
     sentinel: ?Value,
     elem_type: Type,
 ) Allocator.Error!Type {
-    _ = mod;
     if (elem_type.eql(Type.initTag(.u8))) {
         if (sentinel) |some| {
-            if (some.eql(Value.initTag(.zero))) {
+            if (some.eql(Value.initTag(.zero), elem_type)) {
                 return Type.Tag.array_u8_sentinel_0.create(arena, len);
             }
         } else {
@@ -4376,12 +4371,10 @@ pub fn arrayType(
 }
 
 pub fn errorUnionType(
-    mod: *Module,
     arena: *Allocator,
     error_set: Type,
     payload: Type,
 ) Allocator.Error!Type {
-    _ = mod;
     assert(error_set.zigTypeTag() == .ErrorSet);
     if (error_set.eql(Type.initTag(.anyerror)) and payload.eql(Type.initTag(.void))) {
         return Type.initTag(.anyerror_void_error_union);
diff --git a/src/RangeSet.zig b/src/RangeSet.zig
index fd258d55b0..2a8a55a077 100644
--- a/src/RangeSet.zig
+++ b/src/RangeSet.zig
@@ -1,5 +1,6 @@
 const std = @import("std");
 const Order = std.math.Order;
+const Type = @import("type.zig").Type;
 const Value = @import("value.zig").Value;
 const RangeSet = @This();
 const SwitchProngSrc = @import("Module.zig").SwitchProngSrc;
@@ -22,9 +23,15 @@ pub fn deinit(self: *RangeSet) void {
     self.ranges.deinit();
 }
 
-pub fn add(self: *RangeSet, first: Value, last: Value, src: SwitchProngSrc) !?SwitchProngSrc {
+pub fn add(
+    self: *RangeSet,
+    first: Value,
+    last: Value,
+    ty: Type,
+    src: SwitchProngSrc,
+) !?SwitchProngSrc {
     for (self.ranges.items) |range| {
-        if (last.compare(.gte, range.first) and first.compare(.lte, range.last)) {
+        if (last.compare(.gte, range.first, ty) and first.compare(.lte, range.last, ty)) {
             return range.src; // They overlap.
         }
     }
@@ -37,18 +44,18 @@ pub fn add(self: *RangeSet, first: Value, last: Value, src: SwitchProngSrc) !?Sw
 }
 
 /// Assumes a and b do not overlap
-fn lessThan(_: void, a: Range, b: Range) bool {
-    return a.first.compare(.lt, b.first);
+fn lessThan(ty: Type, a: Range, b: Range) bool {
+    return a.first.compare(.lt, b.first, ty);
 }
 
-pub fn spans(self: *RangeSet, first: Value, last: Value) !bool {
+pub fn spans(self: *RangeSet, first: Value, last: Value, ty: Type) !bool {
     if (self.ranges.items.len == 0)
         return false;
 
-    std.sort.sort(Range, self.ranges.items, {}, lessThan);
+    std.sort.sort(Range, self.ranges.items, ty, lessThan);
 
-    if (!self.ranges.items[0].first.eql(first) or
-        !self.ranges.items[self.ranges.items.len - 1].last.eql(last))
+    if (!self.ranges.items[0].first.eql(first, ty) or
+        !self.ranges.items[self.ranges.items.len - 1].last.eql(last, ty))
     {
         return false;
     }
diff --git a/src/Sema.zig b/src/Sema.zig
index 0da38d9a76..97a6f8323e 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -634,7 +634,9 @@ fn analyzeAsType(
     const wanted_type = Type.initTag(.@"type");
     const coerced_inst = try sema.coerce(block, wanted_type, air_inst, src);
     const val = try sema.resolveConstValue(block, src, coerced_inst);
-    return val.toType(sema.arena);
+    var buffer: Value.ToTypeBuffer = undefined;
+    const ty = val.toType(&buffer);
+    return ty.copy(sema.arena);
 }
 
 /// May return Value Tags: `variable`, `undef`.
@@ -1022,7 +1024,9 @@ fn zirEnumDecl(
         if (bag != 0) break true;
     } else false;
     if (any_values) {
-        try enum_obj.values.ensureCapacity(&new_decl_arena.allocator, fields_len);
+        try enum_obj.values.ensureTotalCapacityContext(&new_decl_arena.allocator, fields_len, .{
+            .ty = tag_ty,
+        });
     }
 
     {
@@ -1100,10 +1104,10 @@ fn zirEnumDecl(
             // that points to this default value expression rather than the struct.
             // But only resolve the source location if we need to emit a compile error.
             const tag_val = (try sema.resolveInstConst(block, src, tag_val_ref)).val;
-            enum_obj.values.putAssumeCapacityNoClobber(tag_val, {});
+            enum_obj.values.putAssumeCapacityNoClobberContext(tag_val, {}, .{ .ty = tag_ty });
         } else if (any_values) {
             const tag_val = try Value.Tag.int_u64.create(&new_decl_arena.allocator, field_i);
-            enum_obj.values.putAssumeCapacityNoClobber(tag_val, {});
+            enum_obj.values.putAssumeCapacityNoClobberContext(tag_val, {}, .{ .ty = tag_ty });
         }
     }
 
@@ -2516,7 +2520,7 @@ fn zirOptionalType(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) Compi
     const inst_data = sema.code.instructions.items(.data)[inst].un_node;
     const src = inst_data.src();
     const child_type = try sema.resolveType(block, src, inst_data.operand);
-    const opt_type = try sema.mod.optionalType(sema.arena, child_type);
+    const opt_type = try Module.optionalType(sema.arena, child_type);
 
     return sema.addType(opt_type);
 }
@@ -2547,11 +2551,10 @@ fn zirArrayType(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) CompileE
     const tracy = trace(@src());
     defer tracy.end();
 
-    // TODO these should be lazily evaluated
     const bin_inst = sema.code.instructions.items(.data)[inst].bin;
     const len = try sema.resolveInstConst(block, .unneeded, bin_inst.lhs);
     const elem_type = try sema.resolveType(block, .unneeded, bin_inst.rhs);
-    const array_ty = try sema.mod.arrayType(sema.arena, len.val.toUnsignedInt(), null, elem_type);
+    const array_ty = try Module.arrayType(sema.arena, len.val.toUnsignedInt(), null, elem_type);
 
     return sema.addType(array_ty);
 }
@@ -2560,13 +2563,12 @@ fn zirArrayTypeSentinel(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index)
     const tracy = trace(@src());
     defer tracy.end();
 
-    // TODO these should be lazily evaluated
     const inst_data = sema.code.instructions.items(.data)[inst].array_type_sentinel;
     const len = try sema.resolveInstConst(block, .unneeded, inst_data.len);
     const extra = sema.code.extraData(Zir.Inst.ArrayTypeSentinel, inst_data.payload_index).data;
     const sentinel = try sema.resolveInstConst(block, .unneeded, extra.sentinel);
     const elem_type = try sema.resolveType(block, .unneeded, extra.elem_type);
-    const array_ty = try sema.mod.arrayType(sema.arena, len.val.toUnsignedInt(), sentinel.val, elem_type);
+    const array_ty = try Module.arrayType(sema.arena, len.val.toUnsignedInt(), sentinel.val, elem_type);
 
     return sema.addType(array_ty);
 }
@@ -2599,7 +2601,7 @@ fn zirErrorUnionType(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) Com
             error_union.elemType(),
         });
     }
-    const err_union_ty = try sema.mod.errorUnionType(sema.arena, error_union, payload);
+    const err_union_ty = try Module.errorUnionType(sema.arena, error_union, payload);
     return sema.addType(err_union_ty);
 }
 
@@ -3890,6 +3892,7 @@ fn analyzeSwitch(
                         block,
                         &range_set,
                         item_ref,
+                        operand_ty,
                         src_node_offset,
                         .{ .scalar = scalar_i },
                     );
@@ -3912,6 +3915,7 @@ fn analyzeSwitch(
                             block,
                             &range_set,
                             item_ref,
+                            operand_ty,
                             src_node_offset,
                             .{ .multi = .{ .prong = multi_i, .item = @intCast(u32, item_i) } },
                         );
@@ -3929,6 +3933,7 @@ fn analyzeSwitch(
                             &range_set,
                             item_first,
                             item_last,
+                            operand_ty,
                             src_node_offset,
                             .{ .range = .{ .prong = multi_i, .item = range_i } },
                         );
@@ -3945,7 +3950,7 @@ fn analyzeSwitch(
 
                     const min_int = try operand_ty.minInt(&arena, mod.getTarget());
                     const max_int = try operand_ty.maxInt(&arena, mod.getTarget());
-                    if (try range_set.spans(min_int, max_int)) {
+                    if (try range_set.spans(min_int, max_int, operand_ty)) {
                         if (special_prong == .@"else") {
                             return mod.fail(
                                 &block.base,
@@ -4050,7 +4055,7 @@ fn analyzeSwitch(
                 );
             }
 
-            var seen_values = ValueSrcMap.init(gpa);
+            var seen_values = ValueSrcMap.initContext(gpa, .{ .ty = operand_ty });
             defer seen_values.deinit();
 
             var extra_index: usize = special.end;
@@ -4161,7 +4166,7 @@ fn analyzeSwitch(
                 const item = sema.resolveInst(item_ref);
                 // Validation above ensured these will succeed.
                 const item_val = sema.resolveConstValue(&child_block, .unneeded, item) catch unreachable;
-                if (operand_val.eql(item_val)) {
+                if (operand_val.eql(item_val, operand_ty)) {
                     return sema.resolveBlockBody(block, src, &child_block, body, merges);
                 }
             }
@@ -4183,7 +4188,7 @@ fn analyzeSwitch(
                     const item = sema.resolveInst(item_ref);
                     // Validation above ensured these will succeed.
                     const item_val = sema.resolveConstValue(&child_block, .unneeded, item) catch unreachable;
-                    if (operand_val.eql(item_val)) {
+                    if (operand_val.eql(item_val, operand_ty)) {
                         return sema.resolveBlockBody(block, src, &child_block, body, merges);
                     }
                 }
@@ -4198,8 +4203,8 @@ fn analyzeSwitch(
                     // Validation above ensured these will succeed.
                     const first_tv = sema.resolveInstConst(&child_block, .unneeded, item_first) catch unreachable;
                     const last_tv = sema.resolveInstConst(&child_block, .unneeded, item_last) catch unreachable;
-                    if (Value.compare(operand_val, .gte, first_tv.val) and
-                        Value.compare(operand_val, .lte, last_tv.val))
+                    if (Value.compare(operand_val, .gte, first_tv.val, operand_ty) and
+                        Value.compare(operand_val, .lte, last_tv.val, operand_ty))
                     {
                         return sema.resolveBlockBody(block, src, &child_block, body, merges);
                     }
@@ -4450,12 +4455,13 @@ fn validateSwitchRange(
     range_set: *RangeSet,
     first_ref: Zir.Inst.Ref,
     last_ref: Zir.Inst.Ref,
+    operand_ty: Type,
     src_node_offset: i32,
     switch_prong_src: Module.SwitchProngSrc,
 ) CompileError!void {
     const first_val = (try sema.resolveSwitchItemVal(block, first_ref, src_node_offset, switch_prong_src, .first)).val;
     const last_val = (try sema.resolveSwitchItemVal(block, last_ref, src_node_offset, switch_prong_src, .last)).val;
-    const maybe_prev_src = try range_set.add(first_val, last_val, switch_prong_src);
+    const maybe_prev_src = try range_set.add(first_val, last_val, operand_ty, switch_prong_src);
     return sema.validateSwitchDupe(block, maybe_prev_src, switch_prong_src, src_node_offset);
 }
 
@@ -4464,11 +4470,12 @@ fn validateSwitchItem(
     block: *Scope.Block,
     range_set: *RangeSet,
     item_ref: Zir.Inst.Ref,
+    operand_ty: Type,
     src_node_offset: i32,
     switch_prong_src: Module.SwitchProngSrc,
 ) CompileError!void {
     const item_val = (try sema.resolveSwitchItemVal(block, item_ref, src_node_offset, switch_prong_src, .none)).val;
-    const maybe_prev_src = try range_set.add(item_val, item_val, switch_prong_src);
+    const maybe_prev_src = try range_set.add(item_val, item_val, operand_ty, switch_prong_src);
     return sema.validateSwitchDupe(block, maybe_prev_src, switch_prong_src, src_node_offset);
 }
 
@@ -5137,20 +5144,26 @@ fn zirCmp(
     const casted_lhs = try sema.coerce(block, resolved_type, lhs, lhs_src);
     const casted_rhs = try sema.coerce(block, resolved_type, rhs, rhs_src);
 
-    if (try sema.resolveMaybeUndefVal(block, lhs_src, casted_lhs)) |lhs_val| {
-        if (try sema.resolveMaybeUndefVal(block, rhs_src, casted_rhs)) |rhs_val| {
-            if (lhs_val.isUndef() or rhs_val.isUndef()) {
-                return sema.addConstUndef(resolved_type);
-            }
-            if (lhs_val.compare(op, rhs_val)) {
-                return Air.Inst.Ref.bool_true;
+    const runtime_src: LazySrcLoc = src: {
+        if (try sema.resolveMaybeUndefVal(block, lhs_src, casted_lhs)) |lhs_val| {
+            if (try sema.resolveMaybeUndefVal(block, rhs_src, casted_rhs)) |rhs_val| {
+                if (lhs_val.isUndef() or rhs_val.isUndef()) {
+                    return sema.addConstUndef(resolved_type);
+                }
+                if (lhs_val.compare(op, rhs_val, resolved_type)) {
+                    return Air.Inst.Ref.bool_true;
+                } else {
+                    return Air.Inst.Ref.bool_false;
+                }
             } else {
-                return Air.Inst.Ref.bool_false;
+                break :src rhs_src;
             }
+        } else {
+            break :src lhs_src;
         }
-    }
+    };
+    try sema.requireRuntimeBlock(block, runtime_src);
 
-    try sema.requireRuntimeBlock(block, src);
     const tag: Air.Inst.Tag = switch (op) {
         .lt => .cmp_lt,
         .lte => .cmp_lte,
@@ -5626,7 +5639,7 @@ fn zirPtrTypeSimple(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) Comp
 
     const inst_data = sema.code.instructions.items(.data)[inst].ptr_type_simple;
     const elem_type = try sema.resolveType(block, .unneeded, inst_data.elem_type);
-    const ty = try sema.mod.ptrType(
+    const ty = try Module.ptrType(
         sema.arena,
         elem_type,
         null,
@@ -5680,7 +5693,7 @@ fn zirPtrType(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) CompileErr
 
     const elem_type = try sema.resolveType(block, .unneeded, extra.data.elem_type);
 
-    const ty = try sema.mod.ptrType(
+    const ty = try Module.ptrType(
         sema.arena,
         elem_type,
         sentinel,
@@ -6569,7 +6582,7 @@ fn panicWithMsg(
     const stack_trace_ty = try sema.resolveTypeFields(block, src, unresolved_stack_trace_ty);
     const ptr_stack_trace_ty = try Module.simplePtrType(arena, stack_trace_ty, true, .One);
     const null_stack_trace = try sema.addConstant(
-        try mod.optionalType(arena, ptr_stack_trace_ty),
+        try Module.optionalType(arena, ptr_stack_trace_ty),
         Value.initTag(.null_value),
     );
     const args = try arena.create([2]Air.Inst.Ref);
@@ -6713,7 +6726,8 @@ fn fieldVal(
         },
         .Type => {
             const val = (try sema.resolveDefinedValue(block, object_src, object)).?;
-            const child_type = try val.toType(arena);
+            var to_type_buffer: Value.ToTypeBuffer = undefined;
+            const child_type = val.toType(&to_type_buffer);
             switch (child_type.zigTypeTag()) {
                 .ErrorSet => {
                     // TODO resolve inferred error sets
@@ -6733,7 +6747,7 @@ fn fieldVal(
                     } else (try mod.getErrorValue(field_name)).key;
 
                     return sema.addConstant(
-                        child_type,
+                        try child_type.copy(arena),
                         try Value.Tag.@"error".create(arena, .{ .name = name }),
                     );
                 },
@@ -6781,7 +6795,7 @@ fn fieldVal(
                     };
                     const field_index_u32 = @intCast(u32, field_index);
                     const enum_val = try Value.Tag.enum_field_index.create(arena, field_index_u32);
-                    return sema.addConstant(child_type, enum_val);
+                    return sema.addConstant(try child_type.copy(arena), enum_val);
                 },
                 else => return mod.fail(&block.base, src, "type '{}' has no members", .{child_type}),
             }
@@ -6805,7 +6819,6 @@ fn fieldPtr(
     // in `fieldVal`. This function takes a pointer and returns a pointer.
 
     const mod = sema.mod;
-    const arena = sema.arena;
     const object_ptr_src = src; // TODO better source location
     const object_ptr_ty = sema.typeOf(object_ptr);
     const object_ty = switch (object_ptr_ty.zigTypeTag()) {
@@ -6887,7 +6900,8 @@ fn fieldPtr(
             _ = try sema.resolveConstValue(block, object_ptr_src, object_ptr);
             const result = try sema.analyzeLoad(block, src, object_ptr, object_ptr_src);
             const val = (sema.resolveDefinedValue(block, src, result) catch unreachable).?;
-            const child_type = try val.toType(arena);
+            var to_type_buffer: Value.ToTypeBuffer = undefined;
+            const child_type = val.toType(&to_type_buffer);
             switch (child_type.zigTypeTag()) {
                 .ErrorSet => {
                     // TODO resolve inferred error sets
@@ -6902,15 +6916,14 @@ fn fieldPtr(
                             }
                         }
                         return mod.fail(&block.base, src, "no error named '{s}' in '{}'", .{
-                            field_name,
-                            child_type,
+                            field_name, child_type,
                         });
                     } else (try mod.getErrorValue(field_name)).key;
 
                     var anon_decl = try block.startAnonDecl();
                     defer anon_decl.deinit();
                     return sema.analyzeDeclRef(try anon_decl.finish(
-                        child_type,
+                        try child_type.copy(anon_decl.arena()),
                         try Value.Tag.@"error".create(anon_decl.arena(), .{ .name = name }),
                     ));
                 },
@@ -6960,7 +6973,7 @@ fn fieldPtr(
                     var anon_decl = try block.startAnonDecl();
                     defer anon_decl.deinit();
                     return sema.analyzeDeclRef(try anon_decl.finish(
-                        child_type,
+                        try child_type.copy(anon_decl.arena()),
                         try Value.Tag.enum_field_index.create(anon_decl.arena(), field_index_u32),
                     ));
                 },
@@ -7352,7 +7365,7 @@ fn coerce(
 
                         if (src_sentinel) |src_s| {
                             if (dst_sentinel) |dst_s| {
-                                if (src_s.eql(dst_s)) {
+                                if (src_s.eql(dst_s, dst_elem_type)) {
                                     return sema.coerceArrayPtrToMany(block, dest_type, inst, inst_src);
                                 }
                             }
@@ -7474,7 +7487,7 @@ fn coerceNum(
         }
     } else if (dst_zig_tag == .ComptimeFloat or dst_zig_tag == .Float) {
         if (src_zig_tag == .Float or src_zig_tag == .ComptimeFloat) {
-            const res = val.floatCast(sema.arena, dest_type, target) catch |err| switch (err) {
+            const res = val.floatCast(sema.arena, dest_type) catch |err| switch (err) {
                 error.Overflow => return sema.mod.fail(
                     &block.base,
                     inst_src,
@@ -7813,12 +7826,12 @@ fn analyzeSlice(
                     array_type.sentinel()
                 else
                     slice_sentinel;
-                return_elem_type = try sema.mod.arrayType(sema.arena, len, array_sentinel, elem_type);
+                return_elem_type = try Module.arrayType(sema.arena, len, array_sentinel, elem_type);
                 return_ptr_size = .One;
             }
         }
     }
-    const return_type = try sema.mod.ptrType(
+    const return_type = try Module.ptrType(
         sema.arena,
         return_elem_type,
         if (end_opt == .none) slice_sentinel else null,
@@ -7858,39 +7871,42 @@ fn cmpNumeric(
     if (lhs_ty_tag == .Vector and rhs_ty_tag == .Vector) {
         if (lhs_ty.arrayLen() != rhs_ty.arrayLen()) {
             return sema.mod.fail(&block.base, src, "vector length mismatch: {d} and {d}", .{
-                lhs_ty.arrayLen(),
-                rhs_ty.arrayLen(),
+                lhs_ty.arrayLen(), rhs_ty.arrayLen(),
             });
         }
         return sema.mod.fail(&block.base, src, "TODO implement support for vectors in cmpNumeric", .{});
     } else if (lhs_ty_tag == .Vector or rhs_ty_tag == .Vector) {
         return sema.mod.fail(&block.base, src, "mixed scalar and vector operands to comparison operator: '{}' and '{}'", .{
-            lhs_ty,
-            rhs_ty,
+            lhs_ty, rhs_ty,
         });
     }
 
-    if (try sema.resolveMaybeUndefVal(block, lhs_src, lhs)) |lhs_val| {
-        if (try sema.resolveMaybeUndefVal(block, rhs_src, rhs)) |rhs_val| {
-            if (lhs_val.isUndef() or rhs_val.isUndef()) {
-                return sema.addConstUndef(Type.initTag(.bool));
-            }
-            if (Value.compare(lhs_val, op, rhs_val)) {
-                return Air.Inst.Ref.bool_true;
+    const runtime_src: LazySrcLoc = src: {
+        if (try sema.resolveMaybeUndefVal(block, lhs_src, lhs)) |lhs_val| {
+            if (try sema.resolveMaybeUndefVal(block, rhs_src, rhs)) |rhs_val| {
+                if (lhs_val.isUndef() or rhs_val.isUndef()) {
+                    return sema.addConstUndef(Type.initTag(.bool));
+                }
+                if (Value.compareHetero(lhs_val, op, rhs_val)) {
+                    return Air.Inst.Ref.bool_true;
+                } else {
+                    return Air.Inst.Ref.bool_false;
+                }
             } else {
-                return Air.Inst.Ref.bool_false;
+                break :src rhs_src;
             }
+        } else {
+            break :src lhs_src;
         }
-    }
+    };
 
     // TODO handle comparisons against lazy zero values
     // Some values can be compared against zero without being runtime known or without forcing
     // a full resolution of their value, for example `@sizeOf(@Frame(function))` is known to
     // always be nonzero, and we benefit from not forcing the full evaluation and stack frame layout
     // of this function if we don't need to.
+    try sema.requireRuntimeBlock(block, runtime_src);
 
-    // It must be a runtime comparison.
-    try sema.requireRuntimeBlock(block, src);
     // For floats, emit a float comparison instruction.
     const lhs_is_float = switch (lhs_ty_tag) {
         .Float, .ComptimeFloat => true,
diff --git a/src/type.zig b/src/type.zig
index d828df550b..82c28ef398 100644
--- a/src/type.zig
+++ b/src/type.zig
@@ -426,7 +426,7 @@ pub const Type = extern union {
                 const sentinel_b = info_b.sentinel;
                 if (sentinel_a) |sa| {
                     if (sentinel_b) |sb| {
-                        if (!sa.eql(sb))
+                        if (!sa.eql(sb, info_a.pointee_type))
                             return false;
                     } else {
                         return false;
@@ -455,13 +455,14 @@ pub const Type = extern union {
             .Array, .Vector => {
                 if (a.arrayLen() != b.arrayLen())
                     return false;
-                if (!a.elemType().eql(b.elemType()))
+                const elem_ty = a.elemType();
+                if (!elem_ty.eql(b.elemType()))
                     return false;
                 const sentinel_a = a.sentinel();
                 const sentinel_b = b.sentinel();
                 if (sentinel_a) |sa| {
                     if (sentinel_b) |sb| {
-                        return sa.eql(sb);
+                        return sa.eql(sb, elem_ty);
                     } else {
                         return false;
                     }
@@ -2744,29 +2745,37 @@ pub const Type = extern union {
             return @as(usize, payload.data);
         }
         const S = struct {
-            fn fieldWithRange(int_val: Value, end: usize) ?usize {
+            fn fieldWithRange(int_ty: Type, int_val: Value, end: usize) ?usize {
                 if (int_val.compareWithZero(.lt)) return null;
                 var end_payload: Value.Payload.U64 = .{
                     .base = .{ .tag = .int_u64 },
                     .data = end,
                 };
                 const end_val = Value.initPayload(&end_payload.base);
-                if (int_val.compare(.gte, end_val)) return null;
+                if (int_val.compare(.gte, end_val, int_ty)) return null;
                 return @intCast(usize, int_val.toUnsignedInt());
             }
         };
         switch (ty.tag()) {
             .enum_full, .enum_nonexhaustive => {
                 const enum_full = ty.cast(Payload.EnumFull).?.data;
+                const tag_ty = enum_full.tag_ty;
                 if (enum_full.values.count() == 0) {
-                    return S.fieldWithRange(enum_tag, enum_full.fields.count());
+                    return S.fieldWithRange(tag_ty, enum_tag, enum_full.fields.count());
                 } else {
-                    return enum_full.values.getIndex(enum_tag);
+                    return enum_full.values.getIndexContext(enum_tag, .{ .ty = tag_ty });
                 }
             },
             .enum_simple => {
                 const enum_simple = ty.castTag(.enum_simple).?.data;
-                return S.fieldWithRange(enum_tag, enum_simple.fields.count());
+                const fields_len = enum_simple.fields.count();
+                const bits = std.math.log2_int_ceil(usize, fields_len);
+                var buffer: Payload.Bits = .{
+                    .base = .{ .tag = .int_unsigned },
+                    .data = bits,
+                };
+                const tag_ty = Type.initPayload(&buffer.base);
+                return S.fieldWithRange(tag_ty, enum_tag, fields_len);
             },
             .atomic_ordering,
             .atomic_rmw_op,
@@ -2875,14 +2884,14 @@ pub const Type = extern union {
     /// Asserts the type is an enum.
     pub fn enumHasInt(ty: Type, int: Value, target: Target) bool {
         const S = struct {
-            fn intInRange(int_val: Value, end: usize) bool {
+            fn intInRange(tag_ty: Type, int_val: Value, end: usize) bool {
                 if (int_val.compareWithZero(.lt)) return false;
                 var end_payload: Value.Payload.U64 = .{
                     .base = .{ .tag = .int_u64 },
                     .data = end,
                 };
                 const end_val = Value.initPayload(&end_payload.base);
-                if (int_val.compare(.gte, end_val)) return false;
+                if (int_val.compare(.gte, end_val, tag_ty)) return false;
                 return true;
             }
         };
@@ -2890,15 +2899,23 @@ pub const Type = extern union {
             .enum_nonexhaustive => return int.intFitsInType(ty, target),
             .enum_full => {
                 const enum_full = ty.castTag(.enum_full).?.data;
+                const tag_ty = enum_full.tag_ty;
                 if (enum_full.values.count() == 0) {
-                    return S.intInRange(int, enum_full.fields.count());
+                    return S.intInRange(tag_ty, int, enum_full.fields.count());
                 } else {
-                    return enum_full.values.contains(int);
+                    return enum_full.values.containsContext(int, .{ .ty = tag_ty });
                 }
             },
             .enum_simple => {
                 const enum_simple = ty.castTag(.enum_simple).?.data;
-                return S.intInRange(int, enum_simple.fields.count());
+                const fields_len = enum_simple.fields.count();
+                const bits = std.math.log2_int_ceil(usize, fields_len);
+                var buffer: Payload.Bits = .{
+                    .base = .{ .tag = .int_unsigned },
+                    .data = bits,
+                };
+                const tag_ty = Type.initPayload(&buffer.base);
+                return S.intInRange(tag_ty, int, fields_len);
             },
             .atomic_ordering,
             .atomic_rmw_op,
diff --git a/src/value.zig b/src/value.zig
index 32be34ee2c..93d6625e7c 100644
--- a/src/value.zig
+++ b/src/value.zig
@@ -653,8 +653,10 @@ pub const Value = extern union {
         unreachable;
     }
 
+    pub const ToTypeBuffer = Type.Payload.Bits;
+
     /// Asserts that the value is representable as a type.
-    pub fn toType(self: Value, allocator: *Allocator) !Type {
+    pub fn toType(self: Value, buffer: *ToTypeBuffer) Type {
         return switch (self.tag()) {
             .ty => self.castTag(.ty).?.data,
             .u1_type => Type.initTag(.u1),
@@ -714,14 +716,13 @@ pub const Value = extern union {
 
             .int_type => {
                 const payload = self.castTag(.int_type).?.data;
-                const new = try allocator.create(Type.Payload.Bits);
-                new.* = .{
+                buffer.* = .{
                     .base = .{
                         .tag = if (payload.signed) .int_signed else .int_unsigned,
                     },
                     .data = payload.bits,
                 };
-                return Type.initPayload(&new.base);
+                return Type.initPayload(&buffer.base);
             },
 
             .undef,
@@ -958,9 +959,8 @@ pub const Value = extern union {
 
     /// Converts an integer or a float to a float.
     /// Returns `error.Overflow` if the value does not fit in the new type.
-    pub fn floatCast(self: Value, allocator: *Allocator, ty: Type, target: Target) !Value {
-        _ = target;
-        switch (ty.tag()) {
+    pub fn floatCast(self: Value, allocator: *Allocator, dest_ty: Type) !Value {
+        switch (dest_ty.tag()) {
             .f16 => {
                 @panic("TODO add __trunctfhf2 to compiler-rt");
                 //const res = try Value.Tag.float_16.create(allocator, self.toFloat(f16));
@@ -970,13 +970,13 @@ pub const Value = extern union {
             },
             .f32 => {
                 const res = try Value.Tag.float_32.create(allocator, self.toFloat(f32));
-                if (!self.eql(res))
+                if (!self.eql(res, dest_ty))
                     return error.Overflow;
                 return res;
             },
             .f64 => {
                 const res = try Value.Tag.float_64.create(allocator, self.toFloat(f64));
-                if (!self.eql(res))
+                if (!self.eql(res, dest_ty))
                     return error.Overflow;
                 return res;
             },
@@ -1083,12 +1083,18 @@ pub const Value = extern union {
         return lhs_bigint.order(rhs_bigint);
     }
 
-    /// Asserts the value is comparable.
-    pub fn compare(lhs: Value, op: std.math.CompareOperator, rhs: Value) bool {
+    /// Asserts the value is comparable. Does not take a type parameter because it supports
+    /// comparisons between heterogeneous types.
+    pub fn compareHetero(lhs: Value, op: std.math.CompareOperator, rhs: Value) bool {
+        return order(lhs, rhs).compare(op);
+    }
+
+    /// Asserts the value is comparable. Both operands have type `ty`.
+    pub fn compare(lhs: Value, op: std.math.CompareOperator, rhs: Value, ty: Type) bool {
         return switch (op) {
-            .eq => lhs.eql(rhs),
-            .neq => !lhs.eql(rhs),
-            else => order(lhs, rhs).compare(op),
+            .eq => lhs.eql(rhs, ty),
+            .neq => !lhs.eql(rhs, ty),
+            else => compareHetero(lhs, op, rhs),
         };
     }
 
@@ -1097,11 +1103,11 @@ pub const Value = extern union {
         return orderAgainstZero(lhs).compare(op);
     }
 
-    /// TODO we can't compare value equality without also knowing the type to treat
-    /// the values as
-    pub fn eql(a: Value, b: Value) bool {
+    pub fn eql(a: Value, b: Value, ty: Type) bool {
         const a_tag = a.tag();
         const b_tag = b.tag();
+        assert(a_tag != .undef);
+        assert(b_tag != .undef);
         if (a_tag == b_tag) {
             switch (a_tag) {
                 .void_value, .null_value => return true,
@@ -1118,230 +1124,106 @@ pub const Value = extern union {
                 else => {},
             }
         }
-        if (a.isType() and b.isType()) {
-            // 128 bytes should be enough to hold both types
-            var buf: [128]u8 = undefined;
-            var fib = std.heap.FixedBufferAllocator.init(&buf);
-            const a_type = a.toType(&fib.allocator) catch unreachable;
-            const b_type = b.toType(&fib.allocator) catch unreachable;
+        if (ty.zigTypeTag() == .Type) {
+            var buf_a: ToTypeBuffer = undefined;
+            var buf_b: ToTypeBuffer = undefined;
+            const a_type = a.toType(&buf_a);
+            const b_type = b.toType(&buf_b);
             return a_type.eql(b_type);
         }
         return order(a, b).compare(.eq);
     }
 
-    pub fn hash_u32(self: Value) u32 {
-        return @truncate(u32, self.hash());
-    }
+    pub const ArrayHashContext = struct {
+        ty: Type,
 
-    /// TODO we can't hash without also knowing the type of the value.
-    /// we have to hash as if there were a canonical value memory layout.
-    pub fn hash(self: Value) u64 {
-        var hasher = std.hash.Wyhash.init(0);
+        pub fn hash(self: @This(), v: Value) u32 {
+            const other_context: HashContext = .{ .ty = self.ty };
+            return @truncate(u32, other_context.hash(v));
+        }
+        pub fn eql(self: @This(), a: Value, b: Value) bool {
+            return a.eql(b, self.ty);
+        }
+    };
 
-        switch (self.tag()) {
-            .u1_type,
-            .u8_type,
-            .i8_type,
-            .u16_type,
-            .i16_type,
-            .u32_type,
-            .i32_type,
-            .u64_type,
-            .i64_type,
-            .u128_type,
-            .i128_type,
-            .usize_type,
-            .isize_type,
-            .c_short_type,
-            .c_ushort_type,
-            .c_int_type,
-            .c_uint_type,
-            .c_long_type,
-            .c_ulong_type,
-            .c_longlong_type,
-            .c_ulonglong_type,
-            .c_longdouble_type,
-            .f16_type,
-            .f32_type,
-            .f64_type,
-            .f128_type,
-            .c_void_type,
-            .bool_type,
-            .void_type,
-            .type_type,
-            .anyerror_type,
-            .comptime_int_type,
-            .comptime_float_type,
-            .noreturn_type,
-            .null_type,
-            .undefined_type,
-            .fn_noreturn_no_args_type,
-            .fn_void_no_args_type,
-            .fn_naked_noreturn_no_args_type,
-            .fn_ccc_void_no_args_type,
-            .single_const_pointer_to_comptime_int_type,
-            .anyframe_type,
-            .const_slice_u8_type,
-            .enum_literal_type,
-            .ty,
-            .abi_align_default,
-            => {
-                // Directly return Type.hash, toType can only fail for .int_type.
-                var allocator = std.heap.FixedBufferAllocator.init(&[_]u8{});
-                return (self.toType(&allocator.allocator) catch unreachable).hash();
-            },
-            .int_type => {
-                const payload = self.castTag(.int_type).?.data;
-                var int_payload = Type.Payload.Bits{
-                    .base = .{
-                        .tag = if (payload.signed) .int_signed else .int_unsigned,
-                    },
-                    .data = payload.bits,
-                };
-                return Type.initPayload(&int_payload.base).hash();
-            },
+    pub const HashContext = struct {
+        ty: Type,
 
-            .empty_struct_value,
-            .empty_array,
-            => {},
+        pub fn hash(self: @This(), v: Value) u64 {
+            var hasher = std.hash.Wyhash.init(0);
 
-            .undef,
-            .null_value,
-            .void_value,
-            .unreachable_value,
-            => std.hash.autoHash(&hasher, self.tag()),
+            switch (self.ty.zigTypeTag()) {
+                .BoundFn => unreachable, // TODO remove this from the language
 
-            .zero, .bool_false => std.hash.autoHash(&hasher, @as(u64, 0)),
-            .one, .bool_true => std.hash.autoHash(&hasher, @as(u64, 1)),
+                .Void,
+                .NoReturn,
+                .Undefined,
+                .Null,
+                => {},
 
-            .float_16, .float_32, .float_64, .float_128 => {
-                @panic("TODO implement Value.hash for floats");
-            },
-
-            .enum_literal => {
-                const payload = self.castTag(.enum_literal).?;
-                hasher.update(payload.data);
-            },
-            .enum_field_index => {
-                const payload = self.castTag(.enum_field_index).?;
-                std.hash.autoHash(&hasher, payload.data);
-            },
-            .bytes => {
-                const payload = self.castTag(.bytes).?;
-                hasher.update(payload.data);
-            },
-            .repeated => {
-                @panic("TODO Value.hash for repeated");
-            },
-            .array => {
-                @panic("TODO Value.hash for array");
-            },
-            .slice => {
-                @panic("TODO Value.hash for slice");
-            },
-            .eu_payload_ptr => {
-                @panic("TODO Value.hash for eu_payload_ptr");
-            },
-            .int_u64 => {
-                const payload = self.castTag(.int_u64).?;
-                std.hash.autoHash(&hasher, payload.data);
-            },
-            .int_i64 => {
-                const payload = self.castTag(.int_i64).?;
-                std.hash.autoHash(&hasher, payload.data);
-            },
-            .comptime_alloc => {
-                const payload = self.castTag(.comptime_alloc).?;
-                std.hash.autoHash(&hasher, payload.data.val.hash());
-            },
-            .int_big_positive, .int_big_negative => {
-                var space: BigIntSpace = undefined;
-                const big = self.toBigInt(&space);
-                if (big.limbs.len == 1) {
-                    // handle like {u,i}64 to ensure same hash as with Int{i,u}64
-                    if (big.positive) {
-                        std.hash.autoHash(&hasher, @as(u64, big.limbs[0]));
-                    } else {
-                        std.hash.autoHash(&hasher, @as(u64, @bitCast(usize, -@bitCast(isize, big.limbs[0]))));
-                    }
-                } else {
+                .Type => {
+                    var buf: ToTypeBuffer = undefined;
+                    return v.toType(&buf).hash();
+                },
+                .Bool => {
+                    std.hash.autoHash(&hasher, v.toBool());
+                },
+                .Int, .ComptimeInt => {
+                    var space: BigIntSpace = undefined;
+                    const big = v.toBigInt(&space);
                     std.hash.autoHash(&hasher, big.positive);
                     for (big.limbs) |limb| {
                         std.hash.autoHash(&hasher, limb);
                     }
-                }
-            },
-            .elem_ptr => {
-                const payload = self.castTag(.elem_ptr).?.data;
-                std.hash.autoHash(&hasher, payload.array_ptr.hash());
-                std.hash.autoHash(&hasher, payload.index);
-            },
-            .field_ptr => {
-                const payload = self.castTag(.field_ptr).?.data;
-                std.hash.autoHash(&hasher, payload.container_ptr.hash());
-                std.hash.autoHash(&hasher, payload.field_index);
-            },
-            .decl_ref => {
-                const decl = self.castTag(.decl_ref).?.data;
-                std.hash.autoHash(&hasher, decl);
-            },
-            .function => {
-                const func = self.castTag(.function).?.data;
-                std.hash.autoHash(&hasher, func);
-            },
-            .extern_fn => {
-                const decl = self.castTag(.extern_fn).?.data;
-                std.hash.autoHash(&hasher, decl);
-            },
-            .variable => {
-                const variable = self.castTag(.variable).?.data;
-                std.hash.autoHash(&hasher, variable);
-            },
-            .@"error" => {
-                const payload = self.castTag(.@"error").?.data;
-                hasher.update(payload.name);
-            },
-            .error_union => {
-                const payload = self.castTag(.error_union).?.data;
-                std.hash.autoHash(&hasher, payload.hash());
-            },
-            .inferred_alloc => unreachable,
+                },
+                .Float, .ComptimeFloat => {
+                    @panic("TODO implement hashing float values");
+                },
+                .Pointer => {
+                    @panic("TODO implement hashing pointer values");
+                },
+                .Array, .Vector => {
+                    @panic("TODO implement hashing array/vector values");
+                },
+                .Struct => {
+                    @panic("TODO implement hashing struct values");
+                },
+                .Optional => {
+                    @panic("TODO implement hashing optional values");
+                },
+                .ErrorUnion => {
+                    @panic("TODO implement hashing error union values");
+                },
+                .ErrorSet => {
+                    @panic("TODO implement hashing error set values");
+                },
+                .Enum => {
+                    @panic("TODO implement hashing enum values");
+                },
+                .Union => {
+                    @panic("TODO implement hashing union values");
+                },
+                .Fn => {
+                    @panic("TODO implement hashing function values");
+                },
+                .Opaque => {
+                    @panic("TODO implement hashing opaque values");
+                },
+                .Frame => {
+                    @panic("TODO implement hashing frame values");
+                },
+                .AnyFrame => {
+                    @panic("TODO implement hashing anyframe values");
+                },
+                .EnumLiteral => {
+                    @panic("TODO implement hashing enum literal values");
+                },
+            }
+            return hasher.final();
+        }
 
-            .manyptr_u8_type,
-            .manyptr_const_u8_type,
-            .atomic_ordering_type,
-            .atomic_rmw_op_type,
-            .calling_convention_type,
-            .float_mode_type,
-            .reduce_op_type,
-            .call_options_type,
-            .export_options_type,
-            .extern_options_type,
-            .@"struct",
-            .@"union",
-            => @panic("TODO this hash function looks pretty broken. audit it"),
-        }
-        return hasher.final();
-    }
-
-    pub const ArrayHashContext = struct {
-        pub fn hash(self: @This(), v: Value) u32 {
-            _ = self;
-            return v.hash_u32();
-        }
         pub fn eql(self: @This(), a: Value, b: Value) bool {
-            _ = self;
-            return a.eql(b);
-        }
-    };
-    pub const HashContext = struct {
-        pub fn hash(self: @This(), v: Value) u64 {
-            _ = self;
-            return v.hash();
-        }
-        pub fn eql(self: @This(), a: Value, b: Value) bool {
-            _ = self;
-            return a.eql(b);
+            return a.eql(b, self.ty);
         }
     };
 
@@ -1508,111 +1390,6 @@ pub const Value = extern union {
         };
     }
 
-    /// Valid for all types. Asserts the value is not undefined.
-    /// TODO this function is a code smell and should be deleted
-    fn isType(self: Value) bool {
-        return switch (self.tag()) {
-            .ty,
-            .int_type,
-            .u1_type,
-            .u8_type,
-            .i8_type,
-            .u16_type,
-            .i16_type,
-            .u32_type,
-            .i32_type,
-            .u64_type,
-            .i64_type,
-            .u128_type,
-            .i128_type,
-            .usize_type,
-            .isize_type,
-            .c_short_type,
-            .c_ushort_type,
-            .c_int_type,
-            .c_uint_type,
-            .c_long_type,
-            .c_ulong_type,
-            .c_longlong_type,
-            .c_ulonglong_type,
-            .c_longdouble_type,
-            .f16_type,
-            .f32_type,
-            .f64_type,
-            .f128_type,
-            .c_void_type,
-            .bool_type,
-            .void_type,
-            .type_type,
-            .anyerror_type,
-            .comptime_int_type,
-            .comptime_float_type,
-            .noreturn_type,
-            .null_type,
-            .undefined_type,
-            .fn_noreturn_no_args_type,
-            .fn_void_no_args_type,
-            .fn_naked_noreturn_no_args_type,
-            .fn_ccc_void_no_args_type,
-            .single_const_pointer_to_comptime_int_type,
-            .anyframe_type,
-            .const_slice_u8_type,
-            .enum_literal_type,
-            .manyptr_u8_type,
-            .manyptr_const_u8_type,
-            .atomic_ordering_type,
-            .atomic_rmw_op_type,
-            .calling_convention_type,
-            .float_mode_type,
-            .reduce_op_type,
-            .call_options_type,
-            .export_options_type,
-            .extern_options_type,
-            => true,
-
-            .zero,
-            .one,
-            .empty_array,
-            .bool_true,
-            .bool_false,
-            .function,
-            .extern_fn,
-            .variable,
-            .int_u64,
-            .int_i64,
-            .int_big_positive,
-            .int_big_negative,
-            .comptime_alloc,
-            .decl_ref,
-            .elem_ptr,
-            .field_ptr,
-            .bytes,
-            .repeated,
-            .array,
-            .slice,
-            .float_16,
-            .float_32,
-            .float_64,
-            .float_128,
-            .void_value,
-            .enum_literal,
-            .enum_field_index,
-            .@"error",
-            .error_union,
-            .empty_struct_value,
-            .@"struct",
-            .@"union",
-            .null_value,
-            .abi_align_default,
-            .eu_payload_ptr,
-            => false,
-
-            .undef => unreachable,
-            .unreachable_value => unreachable,
-            .inferred_alloc => unreachable,
-        };
-    }
-
     /// This type is not copyable since it may contain pointers to its inner data.
     pub const Payload = struct {
         tag: Tag,
@@ -1806,27 +1583,3 @@ pub const Value = extern union {
         limbs: [(@sizeOf(u64) / @sizeOf(std.math.big.Limb)) + 1]std.math.big.Limb,
     };
 };
-
-test "hash same value different representation" {
-    const zero_1 = Value.initTag(.zero);
-    var payload_1 = Value.Payload.U64{
-        .base = .{ .tag = .int_u64 },
-        .data = 0,
-    };
-    const zero_2 = Value.initPayload(&payload_1.base);
-    try std.testing.expectEqual(zero_1.hash(), zero_2.hash());
-
-    var payload_2 = Value.Payload.I64{
-        .base = .{ .tag = .int_i64 },
-        .data = 0,
-    };
-    const zero_3 = Value.initPayload(&payload_2.base);
-    try std.testing.expectEqual(zero_2.hash(), zero_3.hash());
-
-    var payload_3 = Value.Payload.BigInt{
-        .base = .{ .tag = .int_big_negative },
-        .data = &[_]std.math.big.Limb{0},
-    };
-    const zero_4 = Value.initPayload(&payload_3.base);
-    try std.testing.expectEqual(zero_3.hash(), zero_4.hash());
-}

From 6e78c007dff96de98c44c52da890cdae3d6e1389 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Fri, 30 Jul 2021 17:40:30 -0700
Subject: [PATCH 35/96] Sema: improved AIR when one operand of bool cmp is
 known

When doing `x == true` or `x == false` it is now lowered as either a
no-op or a not, respectively, rather than a cmp instruction.

This commit also extracts a zirCmpEq function out from zirCmp, reducing
the amount of branching (on is_equality_cmp) in both functions.
---
 src/Sema.zig | 226 +++++++++++++++++++++++++++++++++------------------
 1 file changed, 147 insertions(+), 79 deletions(-)

diff --git a/src/Sema.zig b/src/Sema.zig
index 97a6f8323e..4fa59c4744 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -193,12 +193,12 @@ pub fn analyzeBody(
             .call_compile_time            => try sema.zirCall(block, inst, .compile_time, false),
             .call_nosuspend               => try sema.zirCall(block, inst, .no_async, false),
             .call_async                   => try sema.zirCall(block, inst, .async_kw, false),
-            .cmp_eq                       => try sema.zirCmp(block, inst, .eq),
-            .cmp_gt                       => try sema.zirCmp(block, inst, .gt),
-            .cmp_gte                      => try sema.zirCmp(block, inst, .gte),
             .cmp_lt                       => try sema.zirCmp(block, inst, .lt),
             .cmp_lte                      => try sema.zirCmp(block, inst, .lte),
-            .cmp_neq                      => try sema.zirCmp(block, inst, .neq),
+            .cmp_eq                       => try sema.zirCmpEq(block, inst, .eq, .cmp_eq),
+            .cmp_gte                      => try sema.zirCmp(block, inst, .gte),
+            .cmp_gt                       => try sema.zirCmp(block, inst, .gt),
+            .cmp_neq                      => try sema.zirCmpEq(block, inst, .neq, .cmp_neq),
             .coerce_result_ptr            => try sema.zirCoerceResultPtr(block, inst),
             .decl_ref                     => try sema.zirDeclRef(block, inst),
             .decl_val                     => try sema.zirDeclVal(block, inst),
@@ -5040,6 +5040,97 @@ fn zirAsm(
     return asm_air;
 }
 
+/// Only called for equality operators. See also `zirCmp`.
+fn zirCmpEq(
+    sema: *Sema,
+    block: *Scope.Block,
+    inst: Zir.Inst.Index,
+    op: std.math.CompareOperator,
+    air_tag: Air.Inst.Tag,
+) CompileError!Air.Inst.Ref {
+    const tracy = trace(@src());
+    defer tracy.end();
+
+    const mod = sema.mod;
+    const inst_data = sema.code.instructions.items(.data)[inst].pl_node;
+    const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data;
+    const src: LazySrcLoc = inst_data.src();
+    const lhs_src: LazySrcLoc = .{ .node_offset_bin_lhs = inst_data.src_node };
+    const rhs_src: LazySrcLoc = .{ .node_offset_bin_rhs = inst_data.src_node };
+    const lhs = sema.resolveInst(extra.lhs);
+    const rhs = sema.resolveInst(extra.rhs);
+
+    const lhs_ty = sema.typeOf(lhs);
+    const rhs_ty = sema.typeOf(rhs);
+    const lhs_ty_tag = lhs_ty.zigTypeTag();
+    const rhs_ty_tag = rhs_ty.zigTypeTag();
+    if (lhs_ty_tag == .Null and rhs_ty_tag == .Null) {
+        // null == null, null != null
+        if (op == .eq) {
+            return Air.Inst.Ref.bool_true;
+        } else {
+            return Air.Inst.Ref.bool_false;
+        }
+    }
+    if (((lhs_ty_tag == .Null and rhs_ty_tag == .Optional) or
+        rhs_ty_tag == .Null and lhs_ty_tag == .Optional))
+    {
+        // comparing null with optionals
+        const opt_operand = if (lhs_ty_tag == .Optional) lhs else rhs;
+        return sema.analyzeIsNull(block, src, opt_operand, op == .neq);
+    }
+    if (((lhs_ty_tag == .Null and rhs_ty.isCPtr()) or (rhs_ty_tag == .Null and lhs_ty.isCPtr()))) {
+        return mod.fail(&block.base, src, "TODO implement C pointer cmp", .{});
+    }
+    if (lhs_ty_tag == .Null or rhs_ty_tag == .Null) {
+        const non_null_type = if (lhs_ty_tag == .Null) rhs_ty else lhs_ty;
+        return mod.fail(&block.base, src, "comparison of '{}' with null", .{non_null_type});
+    }
+    if (((lhs_ty_tag == .EnumLiteral and rhs_ty_tag == .Union) or
+        (rhs_ty_tag == .EnumLiteral and lhs_ty_tag == .Union)))
+    {
+        return mod.fail(&block.base, src, "TODO implement equality comparison between a union's tag value and an enum literal", .{});
+    }
+    if (lhs_ty_tag == .ErrorSet and rhs_ty_tag == .ErrorSet) {
+        const runtime_src: LazySrcLoc = src: {
+            if (try sema.resolveMaybeUndefVal(block, lhs_src, lhs)) |lval| {
+                if (try sema.resolveMaybeUndefVal(block, rhs_src, rhs)) |rval| {
+                    if (lval.isUndef() or rval.isUndef()) {
+                        return sema.addConstUndef(Type.initTag(.bool));
+                    }
+                    // TODO optimisation opportunity: evaluate if mem.eql is faster with the names,
+                    // or calling to Module.getErrorValue to get the values and then compare them is
+                    // faster.
+                    const lhs_name = lval.castTag(.@"error").?.data.name;
+                    const rhs_name = rval.castTag(.@"error").?.data.name;
+                    if (mem.eql(u8, lhs_name, rhs_name) == (op == .eq)) {
+                        return Air.Inst.Ref.bool_true;
+                    } else {
+                        return Air.Inst.Ref.bool_false;
+                    }
+                } else {
+                    break :src rhs_src;
+                }
+            } else {
+                break :src lhs_src;
+            }
+        };
+        try sema.requireRuntimeBlock(block, runtime_src);
+        return block.addBinOp(air_tag, lhs, rhs);
+    }
+    if (lhs_ty_tag == .Type and rhs_ty_tag == .Type) {
+        const lhs_as_type = try sema.analyzeAsType(block, lhs_src, lhs);
+        const rhs_as_type = try sema.analyzeAsType(block, rhs_src, rhs);
+        if (lhs_as_type.eql(rhs_as_type) == (op == .eq)) {
+            return Air.Inst.Ref.bool_true;
+        } else {
+            return Air.Inst.Ref.bool_false;
+        }
+    }
+    return sema.analyzeCmp(block, src, lhs, rhs, op, lhs_src, rhs_src, true);
+}
+
+/// Only called for non-equality operators. See also `zirCmpEq`.
 fn zirCmp(
     sema: *Sema,
     block: *Scope.Block,
@@ -5049,8 +5140,6 @@ fn zirCmp(
     const tracy = trace(@src());
     defer tracy.end();
 
-    const mod = sema.mod;
-
     const inst_data = sema.code.instructions.items(.data)[inst].pl_node;
     const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data;
     const src: LazySrcLoc = inst_data.src();
@@ -5058,87 +5147,34 @@ fn zirCmp(
     const rhs_src: LazySrcLoc = .{ .node_offset_bin_rhs = inst_data.src_node };
     const lhs = sema.resolveInst(extra.lhs);
     const rhs = sema.resolveInst(extra.rhs);
+    return sema.analyzeCmp(block, src, lhs, rhs, op, lhs_src, rhs_src, false);
+}
 
-    const is_equality_cmp = switch (op) {
-        .eq, .neq => true,
-        else => false,
-    };
+fn analyzeCmp(
+    sema: *Sema,
+    block: *Scope.Block,
+    src: LazySrcLoc,
+    lhs: Air.Inst.Ref,
+    rhs: Air.Inst.Ref,
+    op: std.math.CompareOperator,
+    lhs_src: LazySrcLoc,
+    rhs_src: LazySrcLoc,
+    is_equality_cmp: bool,
+) CompileError!Air.Inst.Ref {
     const lhs_ty = sema.typeOf(lhs);
     const rhs_ty = sema.typeOf(rhs);
-    const lhs_ty_tag = lhs_ty.zigTypeTag();
-    const rhs_ty_tag = rhs_ty.zigTypeTag();
-    if (is_equality_cmp and lhs_ty_tag == .Null and rhs_ty_tag == .Null) {
-        // null == null, null != null
-        if (op == .eq) {
-            return Air.Inst.Ref.bool_true;
-        } else {
-            return Air.Inst.Ref.bool_false;
-        }
-    } else if (is_equality_cmp and
-        ((lhs_ty_tag == .Null and rhs_ty_tag == .Optional) or
-        rhs_ty_tag == .Null and lhs_ty_tag == .Optional))
-    {
-        // comparing null with optionals
-        const opt_operand = if (lhs_ty_tag == .Optional) lhs else rhs;
-        return sema.analyzeIsNull(block, src, opt_operand, op == .neq);
-    } else if (is_equality_cmp and
-        ((lhs_ty_tag == .Null and rhs_ty.isCPtr()) or (rhs_ty_tag == .Null and lhs_ty.isCPtr())))
-    {
-        return mod.fail(&block.base, src, "TODO implement C pointer cmp", .{});
-    } else if (lhs_ty_tag == .Null or rhs_ty_tag == .Null) {
-        const non_null_type = if (lhs_ty_tag == .Null) rhs_ty else lhs_ty;
-        return mod.fail(&block.base, src, "comparison of '{}' with null", .{non_null_type});
-    } else if (is_equality_cmp and
-        ((lhs_ty_tag == .EnumLiteral and rhs_ty_tag == .Union) or
-        (rhs_ty_tag == .EnumLiteral and lhs_ty_tag == .Union)))
-    {
-        return mod.fail(&block.base, src, "TODO implement equality comparison between a union's tag value and an enum literal", .{});
-    } else if (lhs_ty_tag == .ErrorSet and rhs_ty_tag == .ErrorSet) {
-        if (!is_equality_cmp) {
-            return mod.fail(&block.base, src, "{s} operator not allowed for errors", .{@tagName(op)});
-        }
-        if (try sema.resolveMaybeUndefVal(block, lhs_src, lhs)) |lval| {
-            if (try sema.resolveMaybeUndefVal(block, rhs_src, rhs)) |rval| {
-                if (lval.isUndef() or rval.isUndef()) {
-                    return sema.addConstUndef(Type.initTag(.bool));
-                }
-                // TODO optimisation opportunity: evaluate if mem.eql is faster with the names,
-                // or calling to Module.getErrorValue to get the values and then compare them is
-                // faster.
-                const lhs_name = lval.castTag(.@"error").?.data.name;
-                const rhs_name = rval.castTag(.@"error").?.data.name;
-                if (mem.eql(u8, lhs_name, rhs_name) == (op == .eq)) {
-                    return Air.Inst.Ref.bool_true;
-                } else {
-                    return Air.Inst.Ref.bool_false;
-                }
-            }
-        }
-        try sema.requireRuntimeBlock(block, src);
-        const tag: Air.Inst.Tag = if (op == .eq) .cmp_eq else .cmp_neq;
-        return block.addBinOp(tag, lhs, rhs);
-    } else if (lhs_ty.isNumeric() and rhs_ty.isNumeric()) {
+    if (lhs_ty.isNumeric() and rhs_ty.isNumeric()) {
         // This operation allows any combination of integer and float types, regardless of the
         // signed-ness, comptime-ness, and bit-width. So peer type resolution is incorrect for
         // numeric types.
         return sema.cmpNumeric(block, src, lhs, rhs, op, lhs_src, rhs_src);
-    } else if (lhs_ty_tag == .Type and rhs_ty_tag == .Type) {
-        if (!is_equality_cmp) {
-            return mod.fail(&block.base, src, "{s} operator not allowed for types", .{@tagName(op)});
-        }
-        const lhs_as_type = try sema.analyzeAsType(block, lhs_src, lhs);
-        const rhs_as_type = try sema.analyzeAsType(block, rhs_src, rhs);
-        if (lhs_as_type.eql(rhs_as_type) == (op == .eq)) {
-            return Air.Inst.Ref.bool_true;
-        } else {
-            return Air.Inst.Ref.bool_false;
-        }
     }
-
     const instructions = &[_]Air.Inst.Ref{ lhs, rhs };
     const resolved_type = try sema.resolvePeerTypes(block, src, instructions);
     if (!resolved_type.isSelfComparable(is_equality_cmp)) {
-        return mod.fail(&block.base, src, "operator not allowed for type '{}'", .{resolved_type});
+        return sema.mod.fail(&block.base, src, "{s} operator not allowed for type '{}'", .{
+            @tagName(op), resolved_type,
+        });
     }
 
     const casted_lhs = try sema.coerce(block, resolved_type, lhs, lhs_src);
@@ -5146,19 +5182,31 @@ fn zirCmp(
 
     const runtime_src: LazySrcLoc = src: {
         if (try sema.resolveMaybeUndefVal(block, lhs_src, casted_lhs)) |lhs_val| {
+            if (lhs_val.isUndef()) return sema.addConstUndef(resolved_type);
             if (try sema.resolveMaybeUndefVal(block, rhs_src, casted_rhs)) |rhs_val| {
-                if (lhs_val.isUndef() or rhs_val.isUndef()) {
-                    return sema.addConstUndef(resolved_type);
-                }
+                if (rhs_val.isUndef()) return sema.addConstUndef(resolved_type);
+
                 if (lhs_val.compare(op, rhs_val, resolved_type)) {
                     return Air.Inst.Ref.bool_true;
                 } else {
                     return Air.Inst.Ref.bool_false;
                 }
             } else {
+                if (resolved_type.zigTypeTag() == .Bool) {
+                    // We can lower bool eq/neq more efficiently.
+                    return sema.runtimeBoolCmp(block, op, casted_rhs, lhs_val.toBool(), rhs_src);
+                }
                 break :src rhs_src;
             }
         } else {
+            // For bools, we still check the other operand, because we can lower
+            // bool eq/neq more efficiently.
+            if (resolved_type.zigTypeTag() == .Bool) {
+                if (try sema.resolveMaybeUndefVal(block, rhs_src, casted_rhs)) |rhs_val| {
+                    if (rhs_val.isUndef()) return sema.addConstUndef(resolved_type);
+                    return sema.runtimeBoolCmp(block, op, casted_lhs, rhs_val.toBool(), lhs_src);
+                }
+            }
             break :src lhs_src;
         }
     };
@@ -5176,6 +5224,26 @@ fn zirCmp(
     return block.addBinOp(tag, casted_lhs, casted_rhs);
 }
 
+/// cmp_eq (x, false) => not(x)
+/// cmp_eq (x, true ) => x
+/// cmp_neq(x, false) => x
+/// cmp_neq(x, true ) => not(x)
+fn runtimeBoolCmp(
+    sema: *Sema,
+    block: *Scope.Block,
+    op: std.math.CompareOperator,
+    lhs: Air.Inst.Ref,
+    rhs: bool,
+    runtime_src: LazySrcLoc,
+) CompileError!Air.Inst.Ref {
+    if ((op == .neq) == rhs) {
+        try sema.requireRuntimeBlock(block, runtime_src);
+        return block.addTyOp(.not, Type.initTag(.bool), lhs);
+    } else {
+        return lhs;
+    }
+}
+
 fn zirSizeOf(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
     const inst_data = sema.code.instructions.items(.data)[inst].un_node;
     const operand_src: LazySrcLoc = .{ .node_offset_builtin_call_arg0 = inst_data.src_node };

From 1f95c50d9a0c4c057780d387d57ac2ac40df1720 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Fri, 30 Jul 2021 17:48:24 -0700
Subject: [PATCH 36/96] codegen: cmp lowering treats bools the same as unsigned
 int

fixes a crash when lowering `a == b` and they are of type bool.
I'm not worried about floats; I think we will probably add separate AIR
instructions for floats.
---
 src/codegen.zig | 14 ++++++--------
 1 file changed, 6 insertions(+), 8 deletions(-)

diff --git a/src/codegen.zig b/src/codegen.zig
index bc3ff6257c..77672e82b0 100644
--- a/src/codegen.zig
+++ b/src/codegen.zig
@@ -2889,10 +2889,9 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
                     const src_mcv = try self.limitImmediateType(bin_op.rhs, i32);
 
                     try self.genX8664BinMathCode(Type.initTag(.bool), dst_mcv, src_mcv, 7, 0x38);
-                    const info = ty.intInfo(self.target.*);
-                    break :result switch (info.signedness) {
-                        .signed => MCValue{ .compare_flags_signed = op },
-                        .unsigned => MCValue{ .compare_flags_unsigned = op },
+                    break :result switch (ty.isSignedInt()) {
+                        true => MCValue{ .compare_flags_signed = op },
+                        false => MCValue{ .compare_flags_unsigned = op },
                     };
                 },
                 .arm, .armeb => result: {
@@ -2934,10 +2933,9 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
                     // The destination register is not present in the cmp instruction
                     try self.genArmBinOpCode(undefined, lhs_mcv, rhs_mcv, false, .cmp_eq);
 
-                    const info = ty.intInfo(self.target.*);
-                    break :result switch (info.signedness) {
-                        .signed => MCValue{ .compare_flags_signed = op },
-                        .unsigned => MCValue{ .compare_flags_unsigned = op },
+                    break :result switch (ty.isSignedInt()) {
+                        true => MCValue{ .compare_flags_signed = op },
+                        false => MCValue{ .compare_flags_unsigned = op },
                     };
                 },
                 else => return self.fail("TODO implement cmp for {}", .{self.target.cpu.arch}),

From c30cc4dbbfe3e1494160ffac18ce6a9f9a5e5224 Mon Sep 17 00:00:00 2001
From: Jakub Konka <kubkon@jakubkonka.com>
Date: Sat, 31 Jul 2021 10:26:21 +0200
Subject: [PATCH 37/96] macho: don't store allocator in Object

instead, pass it in functions that require it. Also, when parsing
relocs, make Object part of the context struct where we pass in
additional goodies such as `*MachO` or `*Allocator`.
---
 src/link/MachO.zig           |  22 +--
 src/link/MachO/Archive.zig   |   4 +-
 src/link/MachO/Object.zig    | 278 +++++++++++++++++------------------
 src/link/MachO/TextBlock.zig | 133 ++++++++---------
 4 files changed, 215 insertions(+), 222 deletions(-)

diff --git a/src/link/MachO.zig b/src/link/MachO.zig
index 1f2e0616ba..78c926f5f1 100644
--- a/src/link/MachO.zig
+++ b/src/link/MachO.zig
@@ -2004,21 +2004,21 @@ fn resolveSymbolsInObject(self: *MachO, object_id: u16) !void {
         if (symbolIsStab(sym)) {
             log.err("unhandled symbol type: stab", .{});
             log.err("  symbol '{s}'", .{sym_name});
-            log.err("  first definition in '{s}'", .{object.name.?});
+            log.err("  first definition in '{s}'", .{object.name});
             return error.UnhandledSymbolType;
         }
 
         if (symbolIsIndr(sym)) {
             log.err("unhandled symbol type: indirect", .{});
             log.err("  symbol '{s}'", .{sym_name});
-            log.err("  first definition in '{s}'", .{object.name.?});
+            log.err("  first definition in '{s}'", .{object.name});
             return error.UnhandledSymbolType;
         }
 
         if (symbolIsAbs(sym)) {
             log.err("unhandled symbol type: absolute", .{});
             log.err("  symbol '{s}'", .{sym_name});
-            log.err("  first definition in '{s}'", .{object.name.?});
+            log.err("  first definition in '{s}'", .{object.name});
             return error.UnhandledSymbolType;
         }
 
@@ -2068,8 +2068,8 @@ fn resolveSymbolsInObject(self: *MachO, object_id: u16) !void {
                         !(symbolIsWeakDef(global.*) or symbolIsPext(global.*)))
                     {
                         log.err("symbol '{s}' defined multiple times", .{sym_name});
-                        log.err("  first definition in '{s}'", .{self.objects.items[resolv.file].name.?});
-                        log.err("  next definition in '{s}'", .{object.name.?});
+                        log.err("  first definition in '{s}'", .{self.objects.items[resolv.file].name});
+                        log.err("  next definition in '{s}'", .{object.name});
                         return error.MultipleSymbolDefinitions;
                     }
 
@@ -2448,7 +2448,7 @@ fn resolveSymbols(self: *MachO) !void {
         const resolv = self.symbol_resolver.get(sym.n_strx) orelse unreachable;
 
         log.err("undefined reference to symbol '{s}'", .{sym_name});
-        log.err("  first referenced in '{s}'", .{self.objects.items[resolv.file].name.?});
+        log.err("  first referenced in '{s}'", .{self.objects.items[resolv.file].name});
         has_undefined = true;
     }
 
@@ -2457,7 +2457,7 @@ fn resolveSymbols(self: *MachO) !void {
 
 fn parseTextBlocks(self: *MachO) !void {
     for (self.objects.items) |object| {
-        try object.parseTextBlocks(self);
+        try object.parseTextBlocks(self.base.allocator, self);
     }
 }
 
@@ -3190,7 +3190,7 @@ fn writeSymbolTable(self: *MachO) !void {
                 .n_value = 0,
             });
             locals.appendAssumeCapacity(.{
-                .n_strx = try self.makeString(object.name.?),
+                .n_strx = try self.makeString(object.name),
                 .n_type = macho.N_OSO,
                 .n_sect = 0,
                 .n_desc = 1,
@@ -3334,7 +3334,7 @@ pub fn deinit(self: *MachO) void {
     self.symbol_resolver.deinit(self.base.allocator);
 
     for (self.objects.items) |object| {
-        object.deinit();
+        object.deinit(self.base.allocator);
         self.base.allocator.destroy(object);
     }
     self.objects.deinit(self.base.allocator);
@@ -3372,7 +3372,7 @@ pub fn deinit(self: *MachO) void {
 
 pub fn closeFiles(self: MachO) void {
     for (self.objects.items) |object| {
-        object.closeFile();
+        object.file.close();
     }
     for (self.archives.items) |archive| {
         archive.closeFile();
@@ -5913,7 +5913,7 @@ fn printSymtabAndTextBlock(self: *MachO) void {
 
     log.debug("mappings", .{});
     for (self.objects.items) |object| {
-        log.debug("  in object {s}", .{object.name.?});
+        log.debug("  in object {s}", .{object.name});
         for (object.symtab.items) |sym, sym_id| {
             if (object.symbol_mapping.get(@intCast(u32, sym_id))) |local_id| {
                 log.debug("    | {d} => {d}", .{ sym_id, local_id });
diff --git a/src/link/MachO/Archive.zig b/src/link/MachO/Archive.zig
index 4004cdaefc..c5fab6a1d7 100644
--- a/src/link/MachO/Archive.zig
+++ b/src/link/MachO/Archive.zig
@@ -264,14 +264,12 @@ pub fn parseObject(self: Archive, offset: u32) !*Object {
     errdefer self.allocator.destroy(object);
 
     object.* = .{
-        .allocator = self.allocator,
-        .arch = self.arch.?,
         .file = try fs.cwd().openFile(self.name.?, .{}),
         .name = name,
         .file_offset = @intCast(u32, try reader.context.getPos()),
         .mtime = try self.header.?.date(),
     };
-    try object.parse();
+    try object.parse(self.allocator, self.arch.?);
     try reader.context.seekTo(0);
 
     return object;
diff --git a/src/link/MachO/Object.zig b/src/link/MachO/Object.zig
index fc17669e04..1250f015ed 100644
--- a/src/link/MachO/Object.zig
+++ b/src/link/MachO/Object.zig
@@ -10,20 +10,22 @@ const macho = std.macho;
 const math = std.math;
 const mem = std.mem;
 const sort = std.sort;
+const commands = @import("commands.zig");
+const segmentName = commands.segmentName;
+const sectionName = commands.sectionName;
 
 const Allocator = mem.Allocator;
 const Arch = std.Target.Cpu.Arch;
+const LoadCommand = commands.LoadCommand;
 const MachO = @import("../MachO.zig");
 const TextBlock = @import("TextBlock.zig");
 
-usingnamespace @import("commands.zig");
+file: fs.File,
+name: []const u8,
 
-allocator: *Allocator,
-arch: ?Arch = null,
-header: ?macho.mach_header_64 = null,
-file: ?fs.File = null,
 file_offset: ?u32 = null,
-name: ?[]const u8 = null,
+
+header: ?macho.mach_header_64 = null,
 
 load_commands: std.ArrayListUnmanaged(LoadCommand) = .{},
 
@@ -139,15 +141,13 @@ pub fn createAndParseFromPath(allocator: *Allocator, arch: Arch, path: []const u
     errdefer allocator.free(name);
 
     object.* = .{
-        .allocator = allocator,
-        .arch = arch,
         .name = name,
         .file = file,
     };
 
-    object.parse() catch |err| switch (err) {
+    object.parse(allocator, arch) catch |err| switch (err) {
         error.EndOfStream, error.NotObject => {
-            object.deinit();
+            object.deinit(allocator);
             allocator.destroy(object);
             return null;
         },
@@ -157,44 +157,35 @@ pub fn createAndParseFromPath(allocator: *Allocator, arch: Arch, path: []const u
     return object;
 }
 
-pub fn deinit(self: *Object) void {
+pub fn deinit(self: *Object, allocator: *Allocator) void {
     for (self.load_commands.items) |*lc| {
-        lc.deinit(self.allocator);
+        lc.deinit(allocator);
     }
-    self.load_commands.deinit(self.allocator);
-    self.data_in_code_entries.deinit(self.allocator);
-    self.symtab.deinit(self.allocator);
-    self.strtab.deinit(self.allocator);
-    self.text_blocks.deinit(self.allocator);
-    self.sections_as_symbols.deinit(self.allocator);
-    self.symbol_mapping.deinit(self.allocator);
-    self.reverse_symbol_mapping.deinit(self.allocator);
+    self.load_commands.deinit(allocator);
+    self.data_in_code_entries.deinit(allocator);
+    self.symtab.deinit(allocator);
+    self.strtab.deinit(allocator);
+    self.text_blocks.deinit(allocator);
+    self.sections_as_symbols.deinit(allocator);
+    self.symbol_mapping.deinit(allocator);
+    self.reverse_symbol_mapping.deinit(allocator);
+    allocator.free(self.name);
 
     if (self.debug_info) |*db| {
-        db.deinit(self.allocator);
+        db.deinit(allocator);
     }
 
     if (self.tu_name) |n| {
-        self.allocator.free(n);
+        allocator.free(n);
     }
 
     if (self.tu_comp_dir) |n| {
-        self.allocator.free(n);
-    }
-
-    if (self.name) |n| {
-        self.allocator.free(n);
+        allocator.free(n);
     }
 }
 
-pub fn closeFile(self: Object) void {
-    if (self.file) |f| {
-        f.close();
-    }
-}
-
-pub fn parse(self: *Object) !void {
-    var reader = self.file.?.reader();
+pub fn parse(self: *Object, allocator: *Allocator, arch: Arch) !void {
+    var reader = self.file.reader();
     if (self.file_offset) |offset| {
         try reader.context.seekTo(offset);
     }
@@ -214,26 +205,28 @@ pub fn parse(self: *Object) !void {
             return error.UnsupportedCpuArchitecture;
         },
     };
-    if (this_arch != self.arch.?) {
-        log.err("mismatched cpu architecture: expected {s}, found {s}", .{ self.arch.?, this_arch });
+    if (this_arch != arch) {
+        log.err("mismatched cpu architecture: expected {s}, found {s}", .{ arch, this_arch });
         return error.MismatchedCpuArchitecture;
     }
 
     self.header = header;
 
-    try self.readLoadCommands(reader);
-    try self.parseSymtab();
-    try self.parseDataInCode();
-    try self.parseDebugInfo();
+    try self.readLoadCommands(allocator, reader);
+    try self.parseSymtab(allocator);
+    try self.parseDataInCode(allocator);
+    try self.parseDebugInfo(allocator);
 }
 
-pub fn readLoadCommands(self: *Object, reader: anytype) !void {
+pub fn readLoadCommands(self: *Object, allocator: *Allocator, reader: anytype) !void {
+    const header = self.header orelse unreachable; // Unreachable here signifies a fatal unexplored condition.
     const offset = self.file_offset orelse 0;
-    try self.load_commands.ensureCapacity(self.allocator, self.header.?.ncmds);
+
+    try self.load_commands.ensureCapacity(allocator, header.ncmds);
 
     var i: u16 = 0;
-    while (i < self.header.?.ncmds) : (i += 1) {
-        var cmd = try LoadCommand.read(self.allocator, reader);
+    while (i < header.ncmds) : (i += 1) {
+        var cmd = try LoadCommand.read(allocator, reader);
         switch (cmd.cmd()) {
             macho.LC_SEGMENT_64 => {
                 self.segment_cmd_index = i;
@@ -347,26 +340,25 @@ fn filterDice(dices: []macho.data_in_code_entry, start_addr: u64, end_addr: u64)
     return dices[start..end];
 }
 
-const TextBlockParser = struct {
+const Context = struct {
     allocator: *Allocator,
+    object: *Object,
+    macho_file: *MachO,
+    match: MachO.MatchingSection,
+};
+
+const TextBlockParser = struct {
     section: macho.section_64,
     code: []u8,
     relocs: []macho.relocation_info,
-    object: *Object,
-    macho_file: *MachO,
     nlists: []NlistWithIndex,
     index: u32 = 0,
-    match: MachO.MatchingSection,
 
-    fn peek(self: *TextBlockParser) ?NlistWithIndex {
+    fn peek(self: TextBlockParser) ?NlistWithIndex {
         return if (self.index + 1 < self.nlists.len) self.nlists[self.index + 1] else null;
     }
 
-    const SeniorityContext = struct {
-        object: *Object,
-    };
-
-    fn lessThanBySeniority(context: SeniorityContext, lhs: NlistWithIndex, rhs: NlistWithIndex) bool {
+    fn lessThanBySeniority(context: Context, lhs: NlistWithIndex, rhs: NlistWithIndex) bool {
         if (!MachO.symbolIsExt(rhs.nlist)) {
             return MachO.symbolIsTemp(lhs.nlist, context.object.getString(lhs.nlist.n_strx));
         } else if (MachO.symbolIsPext(rhs.nlist) or MachO.symbolIsWeakDef(rhs.nlist)) {
@@ -376,10 +368,10 @@ const TextBlockParser = struct {
         }
     }
 
-    pub fn next(self: *TextBlockParser) !?*TextBlock {
+    pub fn next(self: *TextBlockParser, context: Context) !?*TextBlock {
         if (self.index == self.nlists.len) return null;
 
-        var aliases = std.ArrayList(NlistWithIndex).init(self.allocator);
+        var aliases = std.ArrayList(NlistWithIndex).init(context.allocator);
         defer aliases.deinit();
 
         const next_nlist: ?NlistWithIndex = blk: while (true) {
@@ -397,7 +389,7 @@ const TextBlockParser = struct {
         } else null;
 
         for (aliases.items) |*nlist_with_index| {
-            nlist_with_index.index = self.object.symbol_mapping.get(nlist_with_index.index) orelse unreachable;
+            nlist_with_index.index = context.object.symbol_mapping.get(nlist_with_index.index) orelse unreachable;
         }
 
         if (aliases.items.len > 1) {
@@ -405,14 +397,14 @@ const TextBlockParser = struct {
             sort.sort(
                 NlistWithIndex,
                 aliases.items,
-                SeniorityContext{ .object = self.object },
+                context,
                 TextBlockParser.lessThanBySeniority,
             );
         }
 
         const senior_nlist = aliases.pop();
-        const senior_sym = &self.macho_file.locals.items[senior_nlist.index];
-        senior_sym.n_sect = self.macho_file.section_to_ordinal.get(self.match) orelse unreachable;
+        const senior_sym = &context.macho_file.locals.items[senior_nlist.index];
+        senior_sym.n_sect = context.macho_file.section_to_ordinal.get(context.match) orelse unreachable;
 
         const start_addr = senior_nlist.nlist.n_value - self.section.addr;
         const end_addr = if (next_nlist) |n| n.nlist.n_value - self.section.addr else self.section.size;
@@ -426,7 +418,7 @@ const TextBlockParser = struct {
         else
             max_align;
 
-        const stab: ?TextBlock.Stab = if (self.object.debug_info) |di| blk: {
+        const stab: ?TextBlock.Stab = if (context.object.debug_info) |di| blk: {
             // TODO there has to be a better to handle this.
             for (di.inner.func_list.items) |func| {
                 if (func.pc_range) |range| {
@@ -442,35 +434,37 @@ const TextBlockParser = struct {
             break :blk .static;
         } else null;
 
-        const block = try self.macho_file.base.allocator.create(TextBlock);
+        const block = try context.allocator.create(TextBlock);
         block.* = TextBlock.empty;
         block.local_sym_index = senior_nlist.index;
         block.stab = stab;
         block.size = size;
         block.alignment = actual_align;
-        try self.macho_file.managed_blocks.append(self.macho_file.base.allocator, block);
+        try context.macho_file.managed_blocks.append(context.allocator, block);
 
-        try block.code.appendSlice(self.macho_file.base.allocator, code);
+        try block.code.appendSlice(context.allocator, code);
 
-        try block.aliases.ensureTotalCapacity(self.macho_file.base.allocator, aliases.items.len);
+        try block.aliases.ensureTotalCapacity(context.allocator, aliases.items.len);
         for (aliases.items) |alias| {
             block.aliases.appendAssumeCapacity(alias.index);
-            const sym = &self.macho_file.locals.items[alias.index];
-            sym.n_sect = self.macho_file.section_to_ordinal.get(self.match) orelse unreachable;
+            const sym = &context.macho_file.locals.items[alias.index];
+            sym.n_sect = context.macho_file.section_to_ordinal.get(context.match) orelse unreachable;
         }
 
-        try block.parseRelocsFromObject(self.macho_file.base.allocator, self.relocs, self.object, .{
+        try block.parseRelocs(self.relocs, .{
             .base_addr = start_addr,
-            .macho_file = self.macho_file,
+            .allocator = context.allocator,
+            .object = context.object,
+            .macho_file = context.macho_file,
         });
 
-        if (self.macho_file.has_dices) {
+        if (context.macho_file.has_dices) {
             const dices = filterDice(
-                self.object.data_in_code_entries.items,
+                context.object.data_in_code_entries.items,
                 senior_nlist.nlist.n_value,
                 senior_nlist.nlist.n_value + size,
             );
-            try block.dices.ensureTotalCapacity(self.macho_file.base.allocator, dices.len);
+            try block.dices.ensureTotalCapacity(context.allocator, dices.len);
 
             for (dices) |dice| {
                 block.dices.appendAssumeCapacity(.{
@@ -487,16 +481,16 @@ const TextBlockParser = struct {
     }
 };
 
-pub fn parseTextBlocks(self: *Object, macho_file: *MachO) !void {
+pub fn parseTextBlocks(self: *Object, allocator: *Allocator, macho_file: *MachO) !void {
     const seg = self.load_commands.items[self.segment_cmd_index.?].Segment;
 
-    log.debug("analysing {s}", .{self.name.?});
+    log.debug("analysing {s}", .{self.name});
 
     // You would expect that the symbol table is at least pre-sorted based on symbol's type:
     // local < extern defined < undefined. Unfortunately, this is not guaranteed! For instance,
     // the GO compiler does not necessarily respect that therefore we sort immediately by type
     // and address within.
-    var sorted_all_nlists = std.ArrayList(NlistWithIndex).init(self.allocator);
+    var sorted_all_nlists = std.ArrayList(NlistWithIndex).init(allocator);
     defer sorted_all_nlists.deinit();
     try sorted_all_nlists.ensureTotalCapacity(self.symtab.items.len);
 
@@ -540,14 +534,14 @@ pub fn parseTextBlocks(self: *Object, macho_file: *MachO) !void {
         };
 
         // Read section's code
-        var code = try self.allocator.alloc(u8, @intCast(usize, sect.size));
-        defer self.allocator.free(code);
-        _ = try self.file.?.preadAll(code, sect.offset);
+        var code = try allocator.alloc(u8, @intCast(usize, sect.size));
+        defer allocator.free(code);
+        _ = try self.file.preadAll(code, sect.offset);
 
         // Read section's list of relocations
-        var raw_relocs = try self.allocator.alloc(u8, sect.nreloc * @sizeOf(macho.relocation_info));
-        defer self.allocator.free(raw_relocs);
-        _ = try self.file.?.preadAll(raw_relocs, sect.reloff);
+        var raw_relocs = try allocator.alloc(u8, sect.nreloc * @sizeOf(macho.relocation_info));
+        defer allocator.free(raw_relocs);
+        _ = try self.file.preadAll(raw_relocs, sect.reloff);
         const relocs = mem.bytesAsSlice(macho.relocation_info, raw_relocs);
 
         // Symbols within this section only.
@@ -579,46 +573,48 @@ pub fn parseTextBlocks(self: *Object, macho_file: *MachO) !void {
                 // as a temporary symbol and insert the matching TextBlock.
                 const first_nlist = filtered_nlists[0].nlist;
                 if (first_nlist.n_value > sect.addr) {
-                    const sym_name = try std.fmt.allocPrint(self.allocator, "l_{s}_{s}_{s}", .{
-                        self.name.?,
+                    const sym_name = try std.fmt.allocPrint(allocator, "l_{s}_{s}_{s}", .{
+                        self.name,
                         segmentName(sect),
                         sectionName(sect),
                     });
-                    defer self.allocator.free(sym_name);
+                    defer allocator.free(sym_name);
 
                     const block_local_sym_index = self.sections_as_symbols.get(sect_id) orelse blk: {
                         const block_local_sym_index = @intCast(u32, macho_file.locals.items.len);
-                        try macho_file.locals.append(macho_file.base.allocator, .{
+                        try macho_file.locals.append(allocator, .{
                             .n_strx = try macho_file.makeString(sym_name),
                             .n_type = macho.N_SECT,
                             .n_sect = macho_file.section_to_ordinal.get(match) orelse unreachable,
                             .n_desc = 0,
                             .n_value = sect.addr,
                         });
-                        try self.sections_as_symbols.putNoClobber(self.allocator, sect_id, block_local_sym_index);
+                        try self.sections_as_symbols.putNoClobber(allocator, sect_id, block_local_sym_index);
                         break :blk block_local_sym_index;
                     };
 
                     const block_code = code[0 .. first_nlist.n_value - sect.addr];
                     const block_size = block_code.len;
 
-                    const block = try macho_file.base.allocator.create(TextBlock);
+                    const block = try allocator.create(TextBlock);
                     block.* = TextBlock.empty;
                     block.local_sym_index = block_local_sym_index;
                     block.size = block_size;
                     block.alignment = sect.@"align";
-                    try macho_file.managed_blocks.append(macho_file.base.allocator, block);
+                    try macho_file.managed_blocks.append(allocator, block);
 
-                    try block.code.appendSlice(macho_file.base.allocator, block_code);
+                    try block.code.appendSlice(allocator, block_code);
 
-                    try block.parseRelocsFromObject(self.allocator, relocs, self, .{
+                    try block.parseRelocs(relocs, .{
                         .base_addr = 0,
+                        .allocator = allocator,
+                        .object = self,
                         .macho_file = macho_file,
                     });
 
                     if (macho_file.has_dices) {
                         const dices = filterDice(self.data_in_code_entries.items, sect.addr, sect.addr + block_size);
-                        try block.dices.ensureTotalCapacity(macho_file.base.allocator, dices.len);
+                        try block.dices.ensureTotalCapacity(allocator, dices.len);
 
                         for (dices) |dice| {
                             block.dices.appendAssumeCapacity(.{
@@ -645,24 +641,25 @@ pub fn parseTextBlocks(self: *Object, macho_file: *MachO) !void {
                         block.prev = last.*;
                         last.* = block;
                     } else {
-                        try macho_file.blocks.putNoClobber(macho_file.base.allocator, match, block);
+                        try macho_file.blocks.putNoClobber(allocator, match, block);
                     }
 
-                    try self.text_blocks.append(self.allocator, block);
+                    try self.text_blocks.append(allocator, block);
                 }
 
                 var parser = TextBlockParser{
-                    .allocator = self.allocator,
                     .section = sect,
                     .code = code,
                     .relocs = relocs,
-                    .object = self,
-                    .macho_file = macho_file,
                     .nlists = filtered_nlists,
-                    .match = match,
                 };
 
-                while (try parser.next()) |block| {
+                while (try parser.next(.{
+                    .allocator = allocator,
+                    .object = self,
+                    .macho_file = macho_file,
+                    .match = match,
+                })) |block| {
                     const sym = macho_file.locals.items[block.local_sym_index];
                     const is_ext = blk: {
                         const orig_sym_id = self.reverse_symbol_mapping.get(block.local_sym_index) orelse unreachable;
@@ -675,9 +672,9 @@ pub fn parseTextBlocks(self: *Object, macho_file: *MachO) !void {
                             if (global_object != self) {
                                 log.debug("deduping definition of {s} in {s}", .{
                                     macho_file.getString(sym.n_strx),
-                                    self.name.?,
+                                    self.name,
                                 });
-                                log.debug("  already defined in {s}", .{global_object.name.?});
+                                log.debug("  already defined in {s}", .{global_object.name});
                                 continue;
                             }
                         }
@@ -688,7 +685,7 @@ pub fn parseTextBlocks(self: *Object, macho_file: *MachO) !void {
                             // In x86_64 relocs, it can so happen that the compiler refers to the same
                             // atom by both the actual assigned symbol and the start of the section. In this
                             // case, we need to link the two together so add an alias.
-                            try block.aliases.append(macho_file.base.allocator, alias);
+                            try block.aliases.append(allocator, alias);
                         }
                     }
 
@@ -708,10 +705,10 @@ pub fn parseTextBlocks(self: *Object, macho_file: *MachO) !void {
                         block.prev = last.*;
                         last.* = block;
                     } else {
-                        try macho_file.blocks.putNoClobber(macho_file.base.allocator, match, block);
+                        try macho_file.blocks.putNoClobber(allocator, match, block);
                     }
 
-                    try self.text_blocks.append(self.allocator, block);
+                    try self.text_blocks.append(allocator, block);
                 }
 
                 break :next;
@@ -720,43 +717,45 @@ pub fn parseTextBlocks(self: *Object, macho_file: *MachO) !void {
             // Since there is no symbol to refer to this block, we create
             // a temp one, unless we already did that when working out the relocations
             // of other text blocks.
-            const sym_name = try std.fmt.allocPrint(self.allocator, "l_{s}_{s}_{s}", .{
-                self.name.?,
+            const sym_name = try std.fmt.allocPrint(allocator, "l_{s}_{s}_{s}", .{
+                self.name,
                 segmentName(sect),
                 sectionName(sect),
             });
-            defer self.allocator.free(sym_name);
+            defer allocator.free(sym_name);
 
             const block_local_sym_index = self.sections_as_symbols.get(sect_id) orelse blk: {
                 const block_local_sym_index = @intCast(u32, macho_file.locals.items.len);
-                try macho_file.locals.append(macho_file.base.allocator, .{
+                try macho_file.locals.append(allocator, .{
                     .n_strx = try macho_file.makeString(sym_name),
                     .n_type = macho.N_SECT,
                     .n_sect = macho_file.section_to_ordinal.get(match) orelse unreachable,
                     .n_desc = 0,
                     .n_value = sect.addr,
                 });
-                try self.sections_as_symbols.putNoClobber(self.allocator, sect_id, block_local_sym_index);
+                try self.sections_as_symbols.putNoClobber(allocator, sect_id, block_local_sym_index);
                 break :blk block_local_sym_index;
             };
 
-            const block = try macho_file.base.allocator.create(TextBlock);
+            const block = try allocator.create(TextBlock);
             block.* = TextBlock.empty;
             block.local_sym_index = block_local_sym_index;
             block.size = sect.size;
             block.alignment = sect.@"align";
-            try macho_file.managed_blocks.append(macho_file.base.allocator, block);
+            try macho_file.managed_blocks.append(allocator, block);
 
-            try block.code.appendSlice(macho_file.base.allocator, code);
+            try block.code.appendSlice(allocator, code);
 
-            try block.parseRelocsFromObject(self.allocator, relocs, self, .{
+            try block.parseRelocs(relocs, .{
                 .base_addr = 0,
+                .allocator = allocator,
+                .object = self,
                 .macho_file = macho_file,
             });
 
             if (macho_file.has_dices) {
                 const dices = filterDice(self.data_in_code_entries.items, sect.addr, sect.addr + sect.size);
-                try block.dices.ensureTotalCapacity(macho_file.base.allocator, dices.len);
+                try block.dices.ensureTotalCapacity(allocator, dices.len);
 
                 for (dices) |dice| {
                     block.dices.appendAssumeCapacity(.{
@@ -772,7 +771,7 @@ pub fn parseTextBlocks(self: *Object, macho_file: *MachO) !void {
             // the filtered symbols and note which symbol is contained within so that
             // we can properly allocate addresses down the line.
             // While we're at it, we need to update segment,section mapping of each symbol too.
-            try block.contained.ensureTotalCapacity(self.allocator, filtered_nlists.len);
+            try block.contained.ensureTotalCapacity(allocator, filtered_nlists.len);
 
             for (filtered_nlists) |nlist_with_index| {
                 const nlist = nlist_with_index.nlist;
@@ -819,35 +818,35 @@ pub fn parseTextBlocks(self: *Object, macho_file: *MachO) !void {
                 block.prev = last.*;
                 last.* = block;
             } else {
-                try macho_file.blocks.putNoClobber(macho_file.base.allocator, match, block);
+                try macho_file.blocks.putNoClobber(allocator, match, block);
             }
 
-            try self.text_blocks.append(self.allocator, block);
+            try self.text_blocks.append(allocator, block);
         }
     }
 }
 
-fn parseSymtab(self: *Object) !void {
+fn parseSymtab(self: *Object, allocator: *Allocator) !void {
     const index = self.symtab_cmd_index orelse return;
     const symtab_cmd = self.load_commands.items[index].Symtab;
 
-    var symtab = try self.allocator.alloc(u8, @sizeOf(macho.nlist_64) * symtab_cmd.nsyms);
-    defer self.allocator.free(symtab);
-    _ = try self.file.?.preadAll(symtab, symtab_cmd.symoff);
+    var symtab = try allocator.alloc(u8, @sizeOf(macho.nlist_64) * symtab_cmd.nsyms);
+    defer allocator.free(symtab);
+    _ = try self.file.preadAll(symtab, symtab_cmd.symoff);
     const slice = @alignCast(@alignOf(macho.nlist_64), mem.bytesAsSlice(macho.nlist_64, symtab));
-    try self.symtab.appendSlice(self.allocator, slice);
+    try self.symtab.appendSlice(allocator, slice);
 
-    var strtab = try self.allocator.alloc(u8, symtab_cmd.strsize);
-    defer self.allocator.free(strtab);
-    _ = try self.file.?.preadAll(strtab, symtab_cmd.stroff);
-    try self.strtab.appendSlice(self.allocator, strtab);
+    var strtab = try allocator.alloc(u8, symtab_cmd.strsize);
+    defer allocator.free(strtab);
+    _ = try self.file.preadAll(strtab, symtab_cmd.stroff);
+    try self.strtab.appendSlice(allocator, strtab);
 }
 
-pub fn parseDebugInfo(self: *Object) !void {
-    log.debug("parsing debug info in '{s}'", .{self.name.?});
+pub fn parseDebugInfo(self: *Object, allocator: *Allocator) !void {
+    log.debug("parsing debug info in '{s}'", .{self.name});
 
     var debug_info = blk: {
-        var di = try DebugInfo.parseFromObject(self.allocator, self);
+        var di = try DebugInfo.parseFromObject(allocator, self);
         break :blk di orelse return;
     };
 
@@ -855,7 +854,7 @@ pub fn parseDebugInfo(self: *Object) !void {
     const compile_unit = debug_info.inner.findCompileUnit(0x0) catch |err| switch (err) {
         error.MissingDebugInfo => {
             // TODO audit cases with missing debug info and audit our dwarf.zig module.
-            log.debug("invalid or missing debug info in {s}; skipping", .{self.name.?});
+            log.debug("invalid or missing debug info in {s}; skipping", .{self.name});
             return;
         },
         else => |e| return e,
@@ -864,26 +863,25 @@ pub fn parseDebugInfo(self: *Object) !void {
     const comp_dir = try compile_unit.die.getAttrString(&debug_info.inner, dwarf.AT_comp_dir);
 
     self.debug_info = debug_info;
-    self.tu_name = try self.allocator.dupe(u8, name);
-    self.tu_comp_dir = try self.allocator.dupe(u8, comp_dir);
+    self.tu_name = try allocator.dupe(u8, name);
+    self.tu_comp_dir = try allocator.dupe(u8, comp_dir);
 
     if (self.mtime == null) {
         self.mtime = mtime: {
-            const file = self.file orelse break :mtime 0;
-            const stat = file.stat() catch break :mtime 0;
+            const stat = self.file.stat() catch break :mtime 0;
             break :mtime @intCast(u64, @divFloor(stat.mtime, 1_000_000_000));
         };
     }
 }
 
-pub fn parseDataInCode(self: *Object) !void {
+pub fn parseDataInCode(self: *Object, allocator: *Allocator) !void {
     const index = self.data_in_code_cmd_index orelse return;
     const data_in_code = self.load_commands.items[index].LinkeditData;
 
-    var buffer = try self.allocator.alloc(u8, data_in_code.datasize);
-    defer self.allocator.free(buffer);
+    var buffer = try allocator.alloc(u8, data_in_code.datasize);
+    defer allocator.free(buffer);
 
-    _ = try self.file.?.preadAll(buffer, data_in_code.dataoff);
+    _ = try self.file.preadAll(buffer, data_in_code.dataoff);
 
     var stream = io.fixedBufferStream(buffer);
     var reader = stream.reader();
@@ -892,7 +890,7 @@ pub fn parseDataInCode(self: *Object) !void {
             error.EndOfStream => break,
             else => |e| return e,
         };
-        try self.data_in_code_entries.append(self.allocator, dice);
+        try self.data_in_code_entries.append(allocator, dice);
     }
 }
 
@@ -900,7 +898,7 @@ fn readSection(self: Object, allocator: *Allocator, index: u16) ![]u8 {
     const seg = self.load_commands.items[self.segment_cmd_index.?].Segment;
     const sect = seg.sections.items[index];
     var buffer = try allocator.alloc(u8, @intCast(usize, sect.size));
-    _ = try self.file.?.preadAll(buffer, sect.offset);
+    _ = try self.file.preadAll(buffer, sect.offset);
     return buffer;
 }
 
diff --git a/src/link/MachO/TextBlock.zig b/src/link/MachO/TextBlock.zig
index 8dca7bc37b..ef10d3fe09 100644
--- a/src/link/MachO/TextBlock.zig
+++ b/src/link/MachO/TextBlock.zig
@@ -606,12 +606,14 @@ pub fn freeListEligible(self: TextBlock, macho_file: MachO) bool {
 
 const RelocContext = struct {
     base_addr: u64 = 0,
+    allocator: *Allocator,
+    object: *Object,
     macho_file: *MachO,
 };
 
-fn initRelocFromObject(rel: macho.relocation_info, object: *Object, ctx: RelocContext) !Relocation {
+fn initRelocFromObject(rel: macho.relocation_info, context: RelocContext) !Relocation {
     var parsed_rel = Relocation{
-        .offset = @intCast(u32, @intCast(u64, rel.r_address) - ctx.base_addr),
+        .offset = @intCast(u32, @intCast(u64, rel.r_address) - context.base_addr),
         .where = undefined,
         .where_index = undefined,
         .payload = undefined,
@@ -620,44 +622,44 @@ fn initRelocFromObject(rel: macho.relocation_info, object: *Object, ctx: RelocCo
     if (rel.r_extern == 0) {
         const sect_id = @intCast(u16, rel.r_symbolnum - 1);
 
-        const local_sym_index = object.sections_as_symbols.get(sect_id) orelse blk: {
-            const seg = object.load_commands.items[object.segment_cmd_index.?].Segment;
+        const local_sym_index = context.object.sections_as_symbols.get(sect_id) orelse blk: {
+            const seg = context.object.load_commands.items[context.object.segment_cmd_index.?].Segment;
             const sect = seg.sections.items[sect_id];
-            const match = (try ctx.macho_file.getMatchingSection(sect)) orelse unreachable;
-            const local_sym_index = @intCast(u32, ctx.macho_file.locals.items.len);
-            const sym_name = try std.fmt.allocPrint(ctx.macho_file.base.allocator, "l_{s}_{s}_{s}", .{
-                object.name.?,
+            const match = (try context.macho_file.getMatchingSection(sect)) orelse unreachable;
+            const local_sym_index = @intCast(u32, context.macho_file.locals.items.len);
+            const sym_name = try std.fmt.allocPrint(context.allocator, "l_{s}_{s}_{s}", .{
+                context.object.name,
                 commands.segmentName(sect),
                 commands.sectionName(sect),
             });
-            defer ctx.macho_file.base.allocator.free(sym_name);
+            defer context.allocator.free(sym_name);
 
-            try ctx.macho_file.locals.append(ctx.macho_file.base.allocator, .{
-                .n_strx = try ctx.macho_file.makeString(sym_name),
+            try context.macho_file.locals.append(context.allocator, .{
+                .n_strx = try context.macho_file.makeString(sym_name),
                 .n_type = macho.N_SECT,
-                .n_sect = ctx.macho_file.section_to_ordinal.get(match) orelse unreachable,
+                .n_sect = context.macho_file.section_to_ordinal.get(match) orelse unreachable,
                 .n_desc = 0,
                 .n_value = sect.addr,
             });
-            try object.sections_as_symbols.putNoClobber(object.allocator, sect_id, local_sym_index);
+            try context.object.sections_as_symbols.putNoClobber(context.allocator, sect_id, local_sym_index);
             break :blk local_sym_index;
         };
 
         parsed_rel.where = .local;
         parsed_rel.where_index = local_sym_index;
     } else {
-        const sym = object.symtab.items[rel.r_symbolnum];
-        const sym_name = object.getString(sym.n_strx);
+        const sym = context.object.symtab.items[rel.r_symbolnum];
+        const sym_name = context.object.getString(sym.n_strx);
 
         if (MachO.symbolIsSect(sym) and !MachO.symbolIsExt(sym)) {
-            const where_index = object.symbol_mapping.get(rel.r_symbolnum) orelse unreachable;
+            const where_index = context.object.symbol_mapping.get(rel.r_symbolnum) orelse unreachable;
             parsed_rel.where = .local;
             parsed_rel.where_index = where_index;
         } else {
-            const n_strx = ctx.macho_file.strtab_dir.getAdapted(@as([]const u8, sym_name), MachO.StringSliceAdapter{
-                .strtab = &ctx.macho_file.strtab,
+            const n_strx = context.macho_file.strtab_dir.getAdapted(@as([]const u8, sym_name), MachO.StringSliceAdapter{
+                .strtab = &context.macho_file.strtab,
             }) orelse unreachable;
-            const resolv = ctx.macho_file.symbol_resolver.get(n_strx) orelse unreachable;
+            const resolv = context.macho_file.symbol_resolver.get(n_strx) orelse unreachable;
             switch (resolv.where) {
                 .global => {
                     parsed_rel.where = .local;
@@ -675,29 +677,24 @@ fn initRelocFromObject(rel: macho.relocation_info, object: *Object, ctx: RelocCo
     return parsed_rel;
 }
 
-pub fn parseRelocsFromObject(
-    self: *TextBlock,
-    allocator: *Allocator,
-    relocs: []macho.relocation_info,
-    object: *Object,
-    ctx: RelocContext,
-) !void {
-    const filtered_relocs = filterRelocs(relocs, ctx.base_addr, ctx.base_addr + self.size);
+pub fn parseRelocs(self: *TextBlock, relocs: []macho.relocation_info, context: RelocContext) !void {
+    const filtered_relocs = filterRelocs(relocs, context.base_addr, context.base_addr + self.size);
     var it = RelocIterator{
         .buffer = filtered_relocs,
     };
 
     var addend: u32 = 0;
     var subtractor: ?u32 = null;
+    const arch = context.macho_file.base.options.target.cpu.arch;
 
     while (it.next()) |rel| {
-        if (isAddend(rel, object.arch.?)) {
+        if (isAddend(rel, arch)) {
             // Addend is not a relocation with effect on the TextBlock, so
             // parse it and carry on.
             assert(addend == 0); // Oh no, addend was not reset!
             addend = rel.r_symbolnum;
 
-            // Verify ADDEND is followed by a load.
+            // Verify ADDEND is followed by a PAGE21 or PAGEOFF12.
             const next = @intToEnum(macho.reloc_type_arm64, it.peek().r_type);
             switch (next) {
                 .ARM64_RELOC_PAGE21, .ARM64_RELOC_PAGEOFF12 => {},
@@ -709,28 +706,28 @@ pub fn parseRelocsFromObject(
             continue;
         }
 
-        if (isSubtractor(rel, object.arch.?)) {
+        if (isSubtractor(rel, arch)) {
             // Subtractor is not a relocation with effect on the TextBlock, so
             // parse it and carry on.
             assert(subtractor == null); // Oh no, subtractor was not reset!
             assert(rel.r_extern == 1);
-            const sym = object.symtab.items[rel.r_symbolnum];
-            const sym_name = object.getString(sym.n_strx);
+            const sym = context.object.symtab.items[rel.r_symbolnum];
+            const sym_name = context.object.getString(sym.n_strx);
 
             if (MachO.symbolIsSect(sym) and !MachO.symbolIsExt(sym)) {
-                const where_index = object.symbol_mapping.get(rel.r_symbolnum) orelse unreachable;
+                const where_index = context.object.symbol_mapping.get(rel.r_symbolnum) orelse unreachable;
                 subtractor = where_index;
             } else {
-                const n_strx = ctx.macho_file.strtab_dir.getAdapted(@as([]const u8, sym_name), MachO.StringSliceAdapter{
-                    .strtab = &ctx.macho_file.strtab,
+                const n_strx = context.macho_file.strtab_dir.getAdapted(@as([]const u8, sym_name), MachO.StringSliceAdapter{
+                    .strtab = &context.macho_file.strtab,
                 }) orelse unreachable;
-                const resolv = ctx.macho_file.symbol_resolver.get(n_strx) orelse unreachable;
+                const resolv = context.macho_file.symbol_resolver.get(n_strx) orelse unreachable;
                 assert(resolv.where == .global);
                 subtractor = resolv.local_sym_index;
             }
 
             // Verify SUBTRACTOR is followed by UNSIGNED.
-            switch (object.arch.?) {
+            switch (arch) {
                 .aarch64 => {
                     const next = @intToEnum(macho.reloc_type_arm64, it.peek().r_type);
                     if (next != .ARM64_RELOC_UNSIGNED) {
@@ -750,19 +747,19 @@ pub fn parseRelocsFromObject(
             continue;
         }
 
-        var parsed_rel = try initRelocFromObject(rel, object, ctx);
+        var parsed_rel = try initRelocFromObject(rel, context);
 
-        switch (object.arch.?) {
+        switch (arch) {
             .aarch64 => {
                 const rel_type = @intToEnum(macho.reloc_type_arm64, rel.r_type);
                 switch (rel_type) {
                     .ARM64_RELOC_ADDEND => unreachable,
                     .ARM64_RELOC_SUBTRACTOR => unreachable,
                     .ARM64_RELOC_BRANCH26 => {
-                        self.parseBranch(rel, &parsed_rel, ctx);
+                        self.parseBranch(rel, &parsed_rel, context);
                     },
                     .ARM64_RELOC_UNSIGNED => {
-                        self.parseUnsigned(rel, &parsed_rel, subtractor, ctx);
+                        self.parseUnsigned(rel, &parsed_rel, subtractor, context);
                         subtractor = null;
                     },
                     .ARM64_RELOC_PAGE21,
@@ -790,10 +787,10 @@ pub fn parseRelocsFromObject(
                 switch (@intToEnum(macho.reloc_type_x86_64, rel.r_type)) {
                     .X86_64_RELOC_SUBTRACTOR => unreachable,
                     .X86_64_RELOC_BRANCH => {
-                        self.parseBranch(rel, &parsed_rel, ctx);
+                        self.parseBranch(rel, &parsed_rel, context);
                     },
                     .X86_64_RELOC_UNSIGNED => {
-                        self.parseUnsigned(rel, &parsed_rel, subtractor, ctx);
+                        self.parseUnsigned(rel, &parsed_rel, subtractor, context);
                         subtractor = null;
                     },
                     .X86_64_RELOC_SIGNED,
@@ -801,7 +798,7 @@ pub fn parseRelocsFromObject(
                     .X86_64_RELOC_SIGNED_2,
                     .X86_64_RELOC_SIGNED_4,
                     => {
-                        self.parseSigned(rel, &parsed_rel, ctx);
+                        self.parseSigned(rel, &parsed_rel, context);
                     },
                     .X86_64_RELOC_GOT_LOAD,
                     .X86_64_RELOC_GOT,
@@ -814,7 +811,7 @@ pub fn parseRelocsFromObject(
             else => unreachable,
         }
 
-        try self.relocs.append(allocator, parsed_rel);
+        try self.relocs.append(context.allocator, parsed_rel);
 
         const is_via_got = switch (parsed_rel.payload) {
             .pointer_to_got => true,
@@ -832,23 +829,23 @@ pub fn parseRelocsFromObject(
                 },
                 .where_index = parsed_rel.where_index,
             };
-            if (ctx.macho_file.got_entries_map.contains(key)) break :blk;
+            if (context.macho_file.got_entries_map.contains(key)) break :blk;
 
-            const got_index = @intCast(u32, ctx.macho_file.got_entries.items.len);
-            try ctx.macho_file.got_entries.append(ctx.macho_file.base.allocator, key);
-            try ctx.macho_file.got_entries_map.putNoClobber(ctx.macho_file.base.allocator, key, got_index);
+            const got_index = @intCast(u32, context.macho_file.got_entries.items.len);
+            try context.macho_file.got_entries.append(context.allocator, key);
+            try context.macho_file.got_entries_map.putNoClobber(context.allocator, key, got_index);
         } else if (parsed_rel.payload == .unsigned) {
             switch (parsed_rel.where) {
                 .import => {
-                    try self.bindings.append(allocator, .{
+                    try self.bindings.append(context.allocator, .{
                         .local_sym_index = parsed_rel.where_index,
                         .offset = parsed_rel.offset,
                     });
                 },
                 .local => {
-                    const source_sym = ctx.macho_file.locals.items[self.local_sym_index];
-                    const match = ctx.macho_file.section_ordinals.items[source_sym.n_sect];
-                    const seg = ctx.macho_file.load_commands.items[match.seg].Segment;
+                    const source_sym = context.macho_file.locals.items[self.local_sym_index];
+                    const match = context.macho_file.section_ordinals.items[source_sym.n_sect];
+                    const seg = context.macho_file.load_commands.items[match.seg].Segment;
                     const sect = seg.sections.items[match.sect];
                     const sect_type = commands.sectionType(sect);
 
@@ -858,12 +855,12 @@ pub fn parseRelocsFromObject(
                         // TODO actually, a check similar to what dyld is doing, that is, verifying
                         // that the segment is writable should be enough here.
                         const is_right_segment = blk: {
-                            if (ctx.macho_file.data_segment_cmd_index) |idx| {
+                            if (context.macho_file.data_segment_cmd_index) |idx| {
                                 if (match.seg == idx) {
                                     break :blk true;
                                 }
                             }
-                            if (ctx.macho_file.data_const_segment_cmd_index) |idx| {
+                            if (context.macho_file.data_const_segment_cmd_index) |idx| {
                                 if (match.seg == idx) {
                                     break :blk true;
                                 }
@@ -884,17 +881,17 @@ pub fn parseRelocsFromObject(
                     };
 
                     if (should_rebase) {
-                        try self.rebases.append(allocator, parsed_rel.offset);
+                        try self.rebases.append(context.allocator, parsed_rel.offset);
                     }
                 },
             }
         } else if (parsed_rel.payload == .branch) blk: {
             if (parsed_rel.where != .import) break :blk;
-            if (ctx.macho_file.stubs_map.contains(parsed_rel.where_index)) break :blk;
+            if (context.macho_file.stubs_map.contains(parsed_rel.where_index)) break :blk;
 
-            const stubs_index = @intCast(u32, ctx.macho_file.stubs.items.len);
-            try ctx.macho_file.stubs.append(ctx.macho_file.base.allocator, parsed_rel.where_index);
-            try ctx.macho_file.stubs_map.putNoClobber(ctx.macho_file.base.allocator, parsed_rel.where_index, stubs_index);
+            const stubs_index = @intCast(u32, context.macho_file.stubs.items.len);
+            try context.macho_file.stubs.append(context.allocator, parsed_rel.where_index);
+            try context.macho_file.stubs_map.putNoClobber(context.allocator, parsed_rel.where_index, stubs_index);
         }
     }
 }
@@ -917,7 +914,7 @@ fn parseUnsigned(
     rel: macho.relocation_info,
     out: *Relocation,
     subtractor: ?u32,
-    ctx: RelocContext,
+    context: RelocContext,
 ) void {
     assert(rel.r_pcrel == 0);
 
@@ -934,7 +931,7 @@ fn parseUnsigned(
 
     if (rel.r_extern == 0) {
         assert(out.where == .local);
-        const target_sym = ctx.macho_file.locals.items[out.where_index];
+        const target_sym = context.macho_file.locals.items[out.where_index];
         addend -= @intCast(i64, target_sym.n_value);
     }
 
@@ -947,14 +944,14 @@ fn parseUnsigned(
     };
 }
 
-fn parseBranch(self: TextBlock, rel: macho.relocation_info, out: *Relocation, ctx: RelocContext) void {
+fn parseBranch(self: TextBlock, rel: macho.relocation_info, out: *Relocation, context: RelocContext) void {
     _ = self;
     assert(rel.r_pcrel == 1);
     assert(rel.r_length == 2);
 
     out.payload = .{
         .branch = .{
-            .arch = ctx.macho_file.base.options.target.cpu.arch,
+            .arch = context.macho_file.base.options.target.cpu.arch,
         },
     };
 }
@@ -1015,7 +1012,7 @@ fn parsePointerToGot(self: TextBlock, rel: macho.relocation_info, out: *Relocati
     };
 }
 
-fn parseSigned(self: TextBlock, rel: macho.relocation_info, out: *Relocation, ctx: RelocContext) void {
+fn parseSigned(self: TextBlock, rel: macho.relocation_info, out: *Relocation, context: RelocContext) void {
     assert(rel.r_pcrel == 1);
     assert(rel.r_length == 2);
 
@@ -1030,10 +1027,10 @@ fn parseSigned(self: TextBlock, rel: macho.relocation_info, out: *Relocation, ct
     var addend: i64 = mem.readIntLittle(i32, self.code.items[out.offset..][0..4]) + correction;
 
     if (rel.r_extern == 0) {
-        const source_sym = ctx.macho_file.locals.items[self.local_sym_index];
+        const source_sym = context.macho_file.locals.items[self.local_sym_index];
         const target_sym = switch (out.where) {
-            .local => ctx.macho_file.locals.items[out.where_index],
-            .import => ctx.macho_file.imports.items[out.where_index],
+            .local => context.macho_file.locals.items[out.where_index],
+            .import => context.macho_file.imports.items[out.where_index],
         };
         addend = @intCast(i64, source_sym.n_value + out.offset + 4) + addend - @intCast(i64, target_sym.n_value);
     }

From 586a19e3db7d462559874ce6ac877608f7e50f10 Mon Sep 17 00:00:00 2001
From: Jakub Konka <kubkon@jakubkonka.com>
Date: Sat, 31 Jul 2021 10:41:51 +0200
Subject: [PATCH 38/96] macho: don't store allocator in Archive

instead pass it in functions as an arg when required.
---
 src/link/MachO.zig         | 10 +++--
 src/link/MachO/Archive.zig | 88 ++++++++++++++++----------------------
 2 files changed, 44 insertions(+), 54 deletions(-)

diff --git a/src/link/MachO.zig b/src/link/MachO.zig
index 78c926f5f1..c42bf550ef 100644
--- a/src/link/MachO.zig
+++ b/src/link/MachO.zig
@@ -2228,7 +2228,11 @@ fn resolveSymbols(self: *MachO) !void {
             };
             assert(offsets.items.len > 0);
 
-            const object = try archive.parseObject(offsets.items[0]);
+            const object = try archive.parseObject(
+                self.base.allocator,
+                self.base.options.target.cpu.arch,
+                offsets.items[0],
+            );
             const object_id = @intCast(u16, self.objects.items.len);
             try self.objects.append(self.base.allocator, object);
             try self.resolveSymbolsInObject(object_id);
@@ -3340,7 +3344,7 @@ pub fn deinit(self: *MachO) void {
     self.objects.deinit(self.base.allocator);
 
     for (self.archives.items) |archive| {
-        archive.deinit();
+        archive.deinit(self.base.allocator);
         self.base.allocator.destroy(archive);
     }
     self.archives.deinit(self.base.allocator);
@@ -3375,7 +3379,7 @@ pub fn closeFiles(self: MachO) void {
         object.file.close();
     }
     for (self.archives.items) |archive| {
-        archive.closeFile();
+        archive.file.close();
     }
 }
 
diff --git a/src/link/MachO/Archive.zig b/src/link/MachO/Archive.zig
index c5fab6a1d7..228e8f74b9 100644
--- a/src/link/MachO/Archive.zig
+++ b/src/link/MachO/Archive.zig
@@ -12,13 +12,10 @@ const Allocator = mem.Allocator;
 const Arch = std.Target.Cpu.Arch;
 const Object = @import("Object.zig");
 
-usingnamespace @import("commands.zig");
+file: fs.File,
+name: []const u8,
 
-allocator: *Allocator,
-arch: ?Arch = null,
-file: ?fs.File = null,
 header: ?ar_hdr = null,
-name: ?[]const u8 = null,
 
 // The actual contents we care about linking with will be embedded at
 // an offset within a file if we are linking against a fat lib
@@ -110,15 +107,13 @@ pub fn createAndParseFromPath(allocator: *Allocator, arch: Arch, path: []const u
     errdefer allocator.free(name);
 
     archive.* = .{
-        .allocator = allocator,
-        .arch = arch,
         .name = name,
         .file = file,
     };
 
-    archive.parse() catch |err| switch (err) {
+    archive.parse(allocator, arch) catch |err| switch (err) {
         error.EndOfStream, error.NotArchive => {
-            archive.deinit();
+            archive.deinit(allocator);
             allocator.destroy(archive);
             return null;
         },
@@ -128,32 +123,23 @@ pub fn createAndParseFromPath(allocator: *Allocator, arch: Arch, path: []const u
     return archive;
 }
 
-pub fn deinit(self: *Archive) void {
+pub fn deinit(self: *Archive, allocator: *Allocator) void {
     for (self.toc.keys()) |*key| {
-        self.allocator.free(key.*);
+        allocator.free(key.*);
     }
     for (self.toc.values()) |*value| {
-        value.deinit(self.allocator);
-    }
-    self.toc.deinit(self.allocator);
-
-    if (self.name) |n| {
-        self.allocator.free(n);
+        value.deinit(allocator);
     }
+    self.toc.deinit(allocator);
+    allocator.free(self.name);
 }
 
-pub fn closeFile(self: Archive) void {
-    if (self.file) |f| {
-        f.close();
-    }
-}
+pub fn parse(self: *Archive, allocator: *Allocator, arch: Arch) !void {
+    self.library_offset = try fat.getLibraryOffset(self.file.reader(), arch);
 
-pub fn parse(self: *Archive) !void {
-    self.library_offset = try fat.getLibraryOffset(self.file.?.reader(), self.arch.?);
+    try self.file.seekTo(self.library_offset);
 
-    try self.file.?.seekTo(self.library_offset);
-
-    var reader = self.file.?.reader();
+    var reader = self.file.reader();
     const magic = try reader.readBytesNoEof(SARMAG);
 
     if (!mem.eql(u8, &magic, ARMAG)) {
@@ -168,11 +154,11 @@ pub fn parse(self: *Archive) !void {
         return error.NotArchive;
     }
 
-    var embedded_name = try parseName(self.allocator, self.header.?, reader);
-    log.debug("parsing archive '{s}' at '{s}'", .{ embedded_name, self.name.? });
-    defer self.allocator.free(embedded_name);
+    var embedded_name = try parseName(allocator, self.header.?, reader);
+    log.debug("parsing archive '{s}' at '{s}'", .{ embedded_name, self.name });
+    defer allocator.free(embedded_name);
 
-    try self.parseTableOfContents(reader);
+    try self.parseTableOfContents(allocator, reader);
 
     try reader.context.seekTo(0);
 }
@@ -195,10 +181,10 @@ fn parseName(allocator: *Allocator, header: ar_hdr, reader: anytype) ![]u8 {
     return name;
 }
 
-fn parseTableOfContents(self: *Archive, reader: anytype) !void {
+fn parseTableOfContents(self: *Archive, allocator: *Allocator, reader: anytype) !void {
     const symtab_size = try reader.readIntLittle(u32);
-    var symtab = try self.allocator.alloc(u8, symtab_size);
-    defer self.allocator.free(symtab);
+    var symtab = try allocator.alloc(u8, symtab_size);
+    defer allocator.free(symtab);
 
     reader.readNoEof(symtab) catch {
         log.err("incomplete symbol table: expected symbol table of length 0x{x}", .{symtab_size});
@@ -206,8 +192,8 @@ fn parseTableOfContents(self: *Archive, reader: anytype) !void {
     };
 
     const strtab_size = try reader.readIntLittle(u32);
-    var strtab = try self.allocator.alloc(u8, strtab_size);
-    defer self.allocator.free(strtab);
+    var strtab = try allocator.alloc(u8, strtab_size);
+    defer allocator.free(strtab);
 
     reader.readNoEof(strtab) catch {
         log.err("incomplete symbol table: expected string table of length 0x{x}", .{strtab_size});
@@ -225,21 +211,21 @@ fn parseTableOfContents(self: *Archive, reader: anytype) !void {
         const object_offset = try symtab_reader.readIntLittle(u32);
 
         const sym_name = mem.spanZ(@ptrCast([*:0]const u8, strtab.ptr + n_strx));
-        const owned_name = try self.allocator.dupe(u8, sym_name);
-        const res = try self.toc.getOrPut(self.allocator, owned_name);
-        defer if (res.found_existing) self.allocator.free(owned_name);
+        const owned_name = try allocator.dupe(u8, sym_name);
+        const res = try self.toc.getOrPut(allocator, owned_name);
+        defer if (res.found_existing) allocator.free(owned_name);
 
         if (!res.found_existing) {
             res.value_ptr.* = .{};
         }
 
-        try res.value_ptr.append(self.allocator, object_offset);
+        try res.value_ptr.append(allocator, object_offset);
     }
 }
 
 /// Caller owns the Object instance.
-pub fn parseObject(self: Archive, offset: u32) !*Object {
-    var reader = self.file.?.reader();
+pub fn parseObject(self: Archive, allocator: *Allocator, arch: Arch, offset: u32) !*Object {
+    var reader = self.file.reader();
     try reader.context.seekTo(offset + self.library_offset);
 
     const object_header = try reader.readStruct(ar_hdr);
@@ -249,27 +235,27 @@ pub fn parseObject(self: Archive, offset: u32) !*Object {
         return error.MalformedArchive;
     }
 
-    const object_name = try parseName(self.allocator, object_header, reader);
-    defer self.allocator.free(object_name);
+    const object_name = try parseName(allocator, object_header, reader);
+    defer allocator.free(object_name);
 
-    log.debug("extracting object '{s}' from archive '{s}'", .{ object_name, self.name.? });
+    log.debug("extracting object '{s}' from archive '{s}'", .{ object_name, self.name });
 
     const name = name: {
         var buffer: [std.fs.MAX_PATH_BYTES]u8 = undefined;
-        const path = try std.os.realpath(self.name.?, &buffer);
-        break :name try std.fmt.allocPrint(self.allocator, "{s}({s})", .{ path, object_name });
+        const path = try std.os.realpath(self.name, &buffer);
+        break :name try std.fmt.allocPrint(allocator, "{s}({s})", .{ path, object_name });
     };
 
-    var object = try self.allocator.create(Object);
-    errdefer self.allocator.destroy(object);
+    var object = try allocator.create(Object);
+    errdefer allocator.destroy(object);
 
     object.* = .{
-        .file = try fs.cwd().openFile(self.name.?, .{}),
+        .file = try fs.cwd().openFile(self.name, .{}),
         .name = name,
         .file_offset = @intCast(u32, try reader.context.getPos()),
         .mtime = try self.header.?.date(),
     };
-    try object.parse(self.allocator, self.arch.?);
+    try object.parse(allocator, arch);
     try reader.context.seekTo(0);
 
     return object;

From e73777333dd66570ddacdb7de56a390de01b33c5 Mon Sep 17 00:00:00 2001
From: Jakub Konka <kubkon@jakubkonka.com>
Date: Sat, 31 Jul 2021 10:59:22 +0200
Subject: [PATCH 39/96] macho: don't store allocator in Dylib instance

instead pass it in as an arg to a function that requires it.
---
 src/link/MachO.zig       |   5 +-
 src/link/MachO/Dylib.zig | 162 +++++++++++++++++++--------------------
 2 files changed, 81 insertions(+), 86 deletions(-)

diff --git a/src/link/MachO.zig b/src/link/MachO.zig
index c42bf550ef..aba45b6bd4 100644
--- a/src/link/MachO.zig
+++ b/src/link/MachO.zig
@@ -3350,7 +3350,7 @@ pub fn deinit(self: *MachO) void {
     self.archives.deinit(self.base.allocator);
 
     for (self.dylibs.items) |dylib| {
-        dylib.deinit();
+        dylib.deinit(self.base.allocator);
         self.base.allocator.destroy(dylib);
     }
     self.dylibs.deinit(self.base.allocator);
@@ -3381,6 +3381,9 @@ pub fn closeFiles(self: MachO) void {
     for (self.archives.items) |archive| {
         archive.file.close();
     }
+    for (self.dylibs.items) |dylib| {
+        dylib.file.close();
+    }
 }
 
 fn freeTextBlock(self: *MachO, text_block: *TextBlock) void {
diff --git a/src/link/MachO/Dylib.zig b/src/link/MachO/Dylib.zig
index 0e7f95a3d5..de0d697db3 100644
--- a/src/link/MachO/Dylib.zig
+++ b/src/link/MachO/Dylib.zig
@@ -9,20 +9,18 @@ const macho = std.macho;
 const math = std.math;
 const mem = std.mem;
 const fat = @import("fat.zig");
+const commands = @import("commands.zig");
 
 const Allocator = mem.Allocator;
 const Arch = std.Target.Cpu.Arch;
 const LibStub = @import("../tapi.zig").LibStub;
+const LoadCommand = commands.LoadCommand;
 const MachO = @import("../MachO.zig");
 
-usingnamespace @import("commands.zig");
+file: fs.File,
+name: []const u8,
 
-allocator: *Allocator,
-arch: ?Arch = null,
 header: ?macho.mach_header_64 = null,
-file: ?fs.File = null,
-name: ?[]const u8 = null,
-syslibroot: ?[]const u8 = null,
 
 ordinal: ?u16 = null,
 
@@ -61,7 +59,7 @@ pub const Id = struct {
         };
     }
 
-    pub fn fromLoadCommand(allocator: *Allocator, lc: GenericCommandWithData(macho.dylib_command)) !Id {
+    pub fn fromLoadCommand(allocator: *Allocator, lc: commands.GenericCommandWithData(macho.dylib_command)) !Id {
         const dylib = lc.inner.dylib;
         const dylib_name = @ptrCast([*:0]const u8, lc.data[dylib.name - @sizeOf(macho.dylib_command) ..]);
         const name = try allocator.dupe(u8, mem.spanZ(dylib_name));
@@ -164,25 +162,22 @@ pub fn createAndParseFromPath(
     errdefer allocator.free(name);
 
     dylib.* = .{
-        .allocator = allocator,
-        .arch = arch,
         .name = name,
         .file = file,
-        .syslibroot = opts.syslibroot,
     };
 
-    dylib.parse() catch |err| switch (err) {
+    dylib.parse(allocator, arch) catch |err| switch (err) {
         error.EndOfStream, error.NotDylib => {
             try file.seekTo(0);
 
             var lib_stub = LibStub.loadFromFile(allocator, file) catch {
-                dylib.deinit();
+                dylib.deinit(allocator);
                 allocator.destroy(dylib);
                 return null;
             };
             defer lib_stub.deinit();
 
-            try dylib.parseFromStub(lib_stub);
+            try dylib.parseFromStub(allocator, arch, lib_stub);
         },
         else => |e| return e,
     };
@@ -195,7 +190,7 @@ pub fn createAndParseFromPath(
             log.warn("  | dylib version: {}", .{dylib.id.?.current_version});
 
             // TODO maybe this should be an error and facilitate auto-cleanup?
-            dylib.deinit();
+            dylib.deinit(allocator);
             allocator.destroy(dylib);
             return null;
         }
@@ -205,50 +200,41 @@ pub fn createAndParseFromPath(
     defer dylibs.deinit();
 
     try dylibs.append(dylib);
-    try dylib.parseDependentLibs(&dylibs);
+    try dylib.parseDependentLibs(allocator, arch, &dylibs, opts.syslibroot);
 
     return dylibs.toOwnedSlice();
 }
 
-pub fn deinit(self: *Dylib) void {
+pub fn deinit(self: *Dylib, allocator: *Allocator) void {
     for (self.load_commands.items) |*lc| {
-        lc.deinit(self.allocator);
+        lc.deinit(allocator);
     }
-    self.load_commands.deinit(self.allocator);
+    self.load_commands.deinit(allocator);
 
     for (self.symbols.keys()) |key| {
-        self.allocator.free(key);
+        allocator.free(key);
     }
-    self.symbols.deinit(self.allocator);
+    self.symbols.deinit(allocator);
 
     for (self.dependent_libs.items) |*id| {
-        id.deinit(self.allocator);
-    }
-    self.dependent_libs.deinit(self.allocator);
-
-    if (self.name) |name| {
-        self.allocator.free(name);
+        id.deinit(allocator);
     }
+    self.dependent_libs.deinit(allocator);
+    allocator.free(self.name);
 
     if (self.id) |*id| {
-        id.deinit(self.allocator);
+        id.deinit(allocator);
     }
 }
 
-pub fn closeFile(self: Dylib) void {
-    if (self.file) |file| {
-        file.close();
-    }
-}
+pub fn parse(self: *Dylib, allocator: *Allocator, arch: Arch) !void {
+    log.debug("parsing shared library '{s}'", .{self.name});
 
-pub fn parse(self: *Dylib) !void {
-    log.debug("parsing shared library '{s}'", .{self.name.?});
+    self.library_offset = try fat.getLibraryOffset(self.file.reader(), arch);
 
-    self.library_offset = try fat.getLibraryOffset(self.file.?.reader(), self.arch.?);
+    try self.file.seekTo(self.library_offset);
 
-    try self.file.?.seekTo(self.library_offset);
-
-    var reader = self.file.?.reader();
+    var reader = self.file.reader();
     self.header = try reader.readStruct(macho.mach_header_64);
 
     if (self.header.?.filetype != macho.MH_DYLIB) {
@@ -258,24 +244,24 @@ pub fn parse(self: *Dylib) !void {
 
     const this_arch: Arch = try fat.decodeArch(self.header.?.cputype, true);
 
-    if (this_arch != self.arch.?) {
-        log.err("mismatched cpu architecture: expected {s}, found {s}", .{ self.arch.?, this_arch });
+    if (this_arch != arch) {
+        log.err("mismatched cpu architecture: expected {s}, found {s}", .{ arch, this_arch });
         return error.MismatchedCpuArchitecture;
     }
 
-    try self.readLoadCommands(reader);
-    try self.parseId();
-    try self.parseSymbols();
+    try self.readLoadCommands(allocator, reader);
+    try self.parseId(allocator);
+    try self.parseSymbols(allocator);
 }
 
-fn readLoadCommands(self: *Dylib, reader: anytype) !void {
+fn readLoadCommands(self: *Dylib, allocator: *Allocator, reader: anytype) !void {
     const should_lookup_reexports = self.header.?.flags & macho.MH_NO_REEXPORTED_DYLIBS == 0;
 
-    try self.load_commands.ensureCapacity(self.allocator, self.header.?.ncmds);
+    try self.load_commands.ensureCapacity(allocator, self.header.?.ncmds);
 
     var i: u16 = 0;
     while (i < self.header.?.ncmds) : (i += 1) {
-        var cmd = try LoadCommand.read(self.allocator, reader);
+        var cmd = try LoadCommand.read(allocator, reader);
         switch (cmd.cmd()) {
             macho.LC_SYMTAB => {
                 self.symtab_cmd_index = i;
@@ -289,8 +275,8 @@ fn readLoadCommands(self: *Dylib, reader: anytype) !void {
             macho.LC_REEXPORT_DYLIB => {
                 if (should_lookup_reexports) {
                     // Parse install_name to dependent dylib.
-                    const id = try Id.fromLoadCommand(self.allocator, cmd.Dylib);
-                    try self.dependent_libs.append(self.allocator, id);
+                    const id = try Id.fromLoadCommand(allocator, cmd.Dylib);
+                    try self.dependent_libs.append(allocator, id);
                 }
             },
             else => {
@@ -301,27 +287,27 @@ fn readLoadCommands(self: *Dylib, reader: anytype) !void {
     }
 }
 
-fn parseId(self: *Dylib) !void {
+fn parseId(self: *Dylib, allocator: *Allocator) !void {
     const index = self.id_cmd_index orelse {
         log.debug("no LC_ID_DYLIB load command found; using hard-coded defaults...", .{});
-        self.id = try Id.default(self.allocator, self.name.?);
+        self.id = try Id.default(allocator, self.name);
         return;
     };
-    self.id = try Id.fromLoadCommand(self.allocator, self.load_commands.items[index].Dylib);
+    self.id = try Id.fromLoadCommand(allocator, self.load_commands.items[index].Dylib);
 }
 
-fn parseSymbols(self: *Dylib) !void {
+fn parseSymbols(self: *Dylib, allocator: *Allocator) !void {
     const index = self.symtab_cmd_index orelse return;
     const symtab_cmd = self.load_commands.items[index].Symtab;
 
-    var symtab = try self.allocator.alloc(u8, @sizeOf(macho.nlist_64) * symtab_cmd.nsyms);
-    defer self.allocator.free(symtab);
-    _ = try self.file.?.preadAll(symtab, symtab_cmd.symoff + self.library_offset);
+    var symtab = try allocator.alloc(u8, @sizeOf(macho.nlist_64) * symtab_cmd.nsyms);
+    defer allocator.free(symtab);
+    _ = try self.file.preadAll(symtab, symtab_cmd.symoff + self.library_offset);
     const slice = @alignCast(@alignOf(macho.nlist_64), mem.bytesAsSlice(macho.nlist_64, symtab));
 
-    var strtab = try self.allocator.alloc(u8, symtab_cmd.strsize);
-    defer self.allocator.free(strtab);
-    _ = try self.file.?.preadAll(strtab, symtab_cmd.stroff + self.library_offset);
+    var strtab = try allocator.alloc(u8, symtab_cmd.strsize);
+    defer allocator.free(strtab);
+    _ = try self.file.preadAll(strtab, symtab_cmd.stroff + self.library_offset);
 
     for (slice) |sym| {
         const add_to_symtab = MachO.symbolIsExt(sym) and (MachO.symbolIsSect(sym) or MachO.symbolIsIndr(sym));
@@ -329,8 +315,8 @@ fn parseSymbols(self: *Dylib) !void {
         if (!add_to_symtab) continue;
 
         const sym_name = mem.spanZ(@ptrCast([*:0]const u8, strtab.ptr + sym.n_strx));
-        const name = try self.allocator.dupe(u8, sym_name);
-        try self.symbols.putNoClobber(self.allocator, name, {});
+        const name = try allocator.dupe(u8, sym_name);
+        try self.symbols.putNoClobber(allocator, name, {});
     }
 }
 
@@ -341,26 +327,26 @@ fn hasTarget(targets: []const []const u8, target: []const u8) bool {
     return false;
 }
 
-fn addObjCClassSymbols(self: *Dylib, sym_name: []const u8) !void {
+fn addObjCClassSymbols(self: *Dylib, allocator: *Allocator, sym_name: []const u8) !void {
     const expanded = &[_][]const u8{
-        try std.fmt.allocPrint(self.allocator, "_OBJC_CLASS_$_{s}", .{sym_name}),
-        try std.fmt.allocPrint(self.allocator, "_OBJC_METACLASS_$_{s}", .{sym_name}),
+        try std.fmt.allocPrint(allocator, "_OBJC_CLASS_$_{s}", .{sym_name}),
+        try std.fmt.allocPrint(allocator, "_OBJC_METACLASS_$_{s}", .{sym_name}),
     };
 
     for (expanded) |sym| {
         if (self.symbols.contains(sym)) continue;
-        try self.symbols.putNoClobber(self.allocator, sym, .{});
+        try self.symbols.putNoClobber(allocator, sym, .{});
     }
 }
 
-pub fn parseFromStub(self: *Dylib, lib_stub: LibStub) !void {
+pub fn parseFromStub(self: *Dylib, allocator: *Allocator, arch: Arch, lib_stub: LibStub) !void {
     if (lib_stub.inner.len == 0) return error.EmptyStubFile;
 
-    log.debug("parsing shared library from stub '{s}'", .{self.name.?});
+    log.debug("parsing shared library from stub '{s}'", .{self.name});
 
     const umbrella_lib = lib_stub.inner[0];
 
-    var id = try Id.default(self.allocator, umbrella_lib.install_name);
+    var id = try Id.default(allocator, umbrella_lib.install_name);
     if (umbrella_lib.current_version) |version| {
         try id.parseCurrentVersion(version);
     }
@@ -369,13 +355,13 @@ pub fn parseFromStub(self: *Dylib, lib_stub: LibStub) !void {
     }
     self.id = id;
 
-    const target_string: []const u8 = switch (self.arch.?) {
+    const target_string: []const u8 = switch (arch) {
         .aarch64 => "arm64-macos",
         .x86_64 => "x86_64-macos",
         else => unreachable,
     };
 
-    var umbrella_libs = std.StringHashMap(void).init(self.allocator);
+    var umbrella_libs = std.StringHashMap(void).init(allocator);
     defer umbrella_libs.deinit();
 
     for (lib_stub.inner) |stub, stub_index| {
@@ -395,13 +381,13 @@ pub fn parseFromStub(self: *Dylib, lib_stub: LibStub) !void {
                 if (exp.symbols) |symbols| {
                     for (symbols) |sym_name| {
                         if (self.symbols.contains(sym_name)) continue;
-                        try self.symbols.putNoClobber(self.allocator, try self.allocator.dupe(u8, sym_name), {});
+                        try self.symbols.putNoClobber(allocator, try allocator.dupe(u8, sym_name), {});
                     }
                 }
 
                 if (exp.objc_classes) |classes| {
                     for (classes) |sym_name| {
-                        try self.addObjCClassSymbols(sym_name);
+                        try self.addObjCClassSymbols(allocator, sym_name);
                     }
                 }
             }
@@ -414,13 +400,13 @@ pub fn parseFromStub(self: *Dylib, lib_stub: LibStub) !void {
                 if (reexp.symbols) |symbols| {
                     for (symbols) |sym_name| {
                         if (self.symbols.contains(sym_name)) continue;
-                        try self.symbols.putNoClobber(self.allocator, try self.allocator.dupe(u8, sym_name), {});
+                        try self.symbols.putNoClobber(allocator, try allocator.dupe(u8, sym_name), {});
                     }
                 }
 
                 if (reexp.objc_classes) |classes| {
                     for (classes) |sym_name| {
-                        try self.addObjCClassSymbols(sym_name);
+                        try self.addObjCClassSymbols(allocator, sym_name);
                     }
                 }
             }
@@ -428,7 +414,7 @@ pub fn parseFromStub(self: *Dylib, lib_stub: LibStub) !void {
 
         if (stub.objc_classes) |classes| {
             for (classes) |sym_name| {
-                try self.addObjCClassSymbols(sym_name);
+                try self.addObjCClassSymbols(allocator, sym_name);
             }
         }
     }
@@ -451,15 +437,21 @@ pub fn parseFromStub(self: *Dylib, lib_stub: LibStub) !void {
 
                     log.debug("  | {s}", .{lib});
 
-                    const dep_id = try Id.default(self.allocator, lib);
-                    try self.dependent_libs.append(self.allocator, dep_id);
+                    const dep_id = try Id.default(allocator, lib);
+                    try self.dependent_libs.append(allocator, dep_id);
                 }
             }
         }
     }
 }
 
-pub fn parseDependentLibs(self: *Dylib, out: *std.ArrayList(*Dylib)) !void {
+pub fn parseDependentLibs(
+    self: *Dylib,
+    allocator: *Allocator,
+    arch: Arch,
+    out: *std.ArrayList(*Dylib),
+    syslibroot: ?[]const u8,
+) !void {
     outer: for (self.dependent_libs.items) |id| {
         const has_ext = blk: {
             const basename = fs.path.basename(id.name);
@@ -472,27 +464,27 @@ pub fn parseDependentLibs(self: *Dylib, out: *std.ArrayList(*Dylib)) !void {
         } else id.name;
 
         for (&[_][]const u8{ extension, ".tbd" }) |ext| {
-            const with_ext = try std.fmt.allocPrint(self.allocator, "{s}{s}", .{
+            const with_ext = try std.fmt.allocPrint(allocator, "{s}{s}", .{
                 without_ext,
                 ext,
             });
-            defer self.allocator.free(with_ext);
+            defer allocator.free(with_ext);
 
-            const full_path = if (self.syslibroot) |syslibroot|
-                try fs.path.join(self.allocator, &.{ syslibroot, with_ext })
+            const full_path = if (syslibroot) |root|
+                try fs.path.join(allocator, &.{ root, with_ext })
             else
                 with_ext;
-            defer if (self.syslibroot) |_| self.allocator.free(full_path);
+            defer if (syslibroot) |_| allocator.free(full_path);
 
             log.debug("trying dependency at fully resolved path {s}", .{full_path});
 
             const dylibs = (try createAndParseFromPath(
-                self.allocator,
-                self.arch.?,
+                allocator,
+                arch,
                 full_path,
                 .{
                     .id = id,
-                    .syslibroot = self.syslibroot,
+                    .syslibroot = syslibroot,
                 },
             )) orelse {
                 continue;

From 06396ddd7d632704681bbd6278f18dcc2b6bf20c Mon Sep 17 00:00:00 2001
From: Jakub Konka <kubkon@jakubkonka.com>
Date: Sat, 31 Jul 2021 15:01:37 +0200
Subject: [PATCH 40/96] macho: don't allocate Objects on the heap

instead, ownership is transferred to MachO. This makes Object
management align closer with data-oriented design.
---
 src/link/MachO.zig         | 32 ++++++++++----------
 src/link/MachO/Archive.zig | 10 ++-----
 src/link/MachO/Object.zig  | 60 +++++++++++++++++---------------------
 3 files changed, 46 insertions(+), 56 deletions(-)

diff --git a/src/link/MachO.zig b/src/link/MachO.zig
index aba45b6bd4..e13fc9b91c 100644
--- a/src/link/MachO.zig
+++ b/src/link/MachO.zig
@@ -61,7 +61,7 @@ header_pad: u16 = 0x1000,
 /// The absolute address of the entry point.
 entry_addr: ?u64 = null,
 
-objects: std.ArrayListUnmanaged(*Object) = .{},
+objects: std.ArrayListUnmanaged(Object) = .{},
 archives: std.ArrayListUnmanaged(*Archive) = .{},
 dylibs: std.ArrayListUnmanaged(*Dylib) = .{},
 
@@ -990,13 +990,19 @@ fn parseInputFiles(self: *MachO, files: []const []const u8, syslibroot: ?[]const
     const arch = self.base.options.target.cpu.arch;
     for (files) |file_name| {
         const full_path = full_path: {
-            var buffer: [std.fs.MAX_PATH_BYTES]u8 = undefined;
+            var buffer: [fs.MAX_PATH_BYTES]u8 = undefined;
             const path = try std.fs.realpath(file_name, &buffer);
             break :full_path try self.base.allocator.dupe(u8, path);
         };
+        const file = try fs.cwd().openFile(full_path, .{});
 
-        if (try Object.createAndParseFromPath(self.base.allocator, arch, full_path)) |object| {
-            try self.objects.append(self.base.allocator, object);
+        if (try Object.isObject(file)) {
+            const object = try self.objects.addOne(self.base.allocator);
+            object.* = .{
+                .name = full_path,
+                .file = file,
+            };
+            try object.parse(self.base.allocator, arch);
             continue;
         }
 
@@ -1993,7 +1999,7 @@ fn writeStubHelperCommon(self: *MachO) !void {
 }
 
 fn resolveSymbolsInObject(self: *MachO, object_id: u16) !void {
-    const object = self.objects.items[object_id];
+    const object = &self.objects.items[object_id];
 
     log.debug("resolving symbols in '{s}'", .{object.name});
 
@@ -2228,13 +2234,10 @@ fn resolveSymbols(self: *MachO) !void {
             };
             assert(offsets.items.len > 0);
 
-            const object = try archive.parseObject(
-                self.base.allocator,
-                self.base.options.target.cpu.arch,
-                offsets.items[0],
-            );
             const object_id = @intCast(u16, self.objects.items.len);
-            try self.objects.append(self.base.allocator, object);
+            const object = try self.objects.addOne(self.base.allocator);
+            object.* = try archive.extractObject(self.base.allocator, offsets.items[0]);
+            try object.parse(self.base.allocator, self.base.options.target.cpu.arch);
             try self.resolveSymbolsInObject(object_id);
 
             continue :loop;
@@ -2460,8 +2463,8 @@ fn resolveSymbols(self: *MachO) !void {
 }
 
 fn parseTextBlocks(self: *MachO) !void {
-    for (self.objects.items) |object| {
-        try object.parseTextBlocks(self.base.allocator, self);
+    for (self.objects.items) |*object, object_id| {
+        try object.parseTextBlocks(self.base.allocator, @intCast(u16, object_id), self);
     }
 }
 
@@ -3337,9 +3340,8 @@ pub fn deinit(self: *MachO) void {
     self.locals_free_list.deinit(self.base.allocator);
     self.symbol_resolver.deinit(self.base.allocator);
 
-    for (self.objects.items) |object| {
+    for (self.objects.items) |*object| {
         object.deinit(self.base.allocator);
-        self.base.allocator.destroy(object);
     }
     self.objects.deinit(self.base.allocator);
 
diff --git a/src/link/MachO/Archive.zig b/src/link/MachO/Archive.zig
index 228e8f74b9..23d5d259ef 100644
--- a/src/link/MachO/Archive.zig
+++ b/src/link/MachO/Archive.zig
@@ -223,8 +223,7 @@ fn parseTableOfContents(self: *Archive, allocator: *Allocator, reader: anytype)
     }
 }
 
-/// Caller owns the Object instance.
-pub fn parseObject(self: Archive, allocator: *Allocator, arch: Arch, offset: u32) !*Object {
+pub fn extractObject(self: Archive, allocator: *Allocator, offset: u32) !Object {
     var reader = self.file.reader();
     try reader.context.seekTo(offset + self.library_offset);
 
@@ -246,16 +245,13 @@ pub fn parseObject(self: Archive, allocator: *Allocator, arch: Arch, offset: u32
         break :name try std.fmt.allocPrint(allocator, "{s}({s})", .{ path, object_name });
     };
 
-    var object = try allocator.create(Object);
-    errdefer allocator.destroy(object);
-
-    object.* = .{
+    var object = Object{
         .file = try fs.cwd().openFile(self.name, .{}),
         .name = name,
         .file_offset = @intCast(u32, try reader.context.getPos()),
         .mtime = try self.header.?.date(),
     };
-    try object.parse(allocator, arch);
+
     try reader.context.seekTo(0);
 
     return object;
diff --git a/src/link/MachO/Object.zig b/src/link/MachO/Object.zig
index 1250f015ed..6a1bf8fd57 100644
--- a/src/link/MachO/Object.zig
+++ b/src/link/MachO/Object.zig
@@ -127,36 +127,6 @@ const DebugInfo = struct {
     }
 };
 
-pub fn createAndParseFromPath(allocator: *Allocator, arch: Arch, path: []const u8) !?*Object {
-    const file = fs.cwd().openFile(path, .{}) catch |err| switch (err) {
-        error.FileNotFound => return null,
-        else => |e| return e,
-    };
-    errdefer file.close();
-
-    const object = try allocator.create(Object);
-    errdefer allocator.destroy(object);
-
-    const name = try allocator.dupe(u8, path);
-    errdefer allocator.free(name);
-
-    object.* = .{
-        .name = name,
-        .file = file,
-    };
-
-    object.parse(allocator, arch) catch |err| switch (err) {
-        error.EndOfStream, error.NotObject => {
-            object.deinit(allocator);
-            allocator.destroy(object);
-            return null;
-        },
-        else => |e| return e,
-    };
-
-    return object;
-}
-
 pub fn deinit(self: *Object, allocator: *Allocator) void {
     for (self.load_commands.items) |*lc| {
         lc.deinit(allocator);
@@ -184,6 +154,22 @@ pub fn deinit(self: *Object, allocator: *Allocator) void {
     }
 }
 
+pub fn isObject(file: fs.File) !bool {
+    const reader = file.reader();
+    const is_object = blk: {
+        if (reader.readStruct(macho.mach_header_64)) |header| {
+            break :blk header.filetype == macho.MH_OBJECT;
+        } else |err| {
+            switch (err) {
+                error.EndOfStream => break :blk false,
+                else => |e| return e,
+            }
+        }
+    };
+    try file.seekTo(0);
+    return is_object;
+}
+
 pub fn parse(self: *Object, allocator: *Allocator, arch: Arch) !void {
     var reader = self.file.reader();
     if (self.file_offset) |offset| {
@@ -481,7 +467,12 @@ const TextBlockParser = struct {
     }
 };
 
-pub fn parseTextBlocks(self: *Object, allocator: *Allocator, macho_file: *MachO) !void {
+pub fn parseTextBlocks(
+    self: *Object,
+    allocator: *Allocator,
+    object_id: u16,
+    macho_file: *MachO,
+) !void {
     const seg = self.load_commands.items[self.segment_cmd_index.?].Segment;
 
     log.debug("analysing {s}", .{self.name});
@@ -668,13 +659,14 @@ pub fn parseTextBlocks(self: *Object, allocator: *Allocator, macho_file: *MachO)
                     if (is_ext) {
                         if (macho_file.symbol_resolver.get(sym.n_strx)) |resolv| {
                             assert(resolv.where == .global);
-                            const global_object = macho_file.objects.items[resolv.file];
-                            if (global_object != self) {
+                            if (resolv.file != object_id) {
                                 log.debug("deduping definition of {s} in {s}", .{
                                     macho_file.getString(sym.n_strx),
                                     self.name,
                                 });
-                                log.debug("  already defined in {s}", .{global_object.name});
+                                log.debug("  already defined in {s}", .{
+                                    macho_file.objects.items[resolv.file].name,
+                                });
                                 continue;
                             }
                         }

From f023cdad7ca676977d9b5abd3d38677779aab211 Mon Sep 17 00:00:00 2001
From: Jakub Konka <kubkon@jakubkonka.com>
Date: Sat, 31 Jul 2021 15:33:39 +0200
Subject: [PATCH 41/96] macho: don't allocate Archives on the heap

instead, transfer ownership directly to MachO struct.
---
 src/link/MachO.zig         | 28 +++++++++++----
 src/link/MachO/Archive.zig | 72 +++++++++++++-------------------------
 src/link/MachO/Object.zig  | 27 ++++++--------
 3 files changed, 56 insertions(+), 71 deletions(-)

diff --git a/src/link/MachO.zig b/src/link/MachO.zig
index e13fc9b91c..544073f3e1 100644
--- a/src/link/MachO.zig
+++ b/src/link/MachO.zig
@@ -62,7 +62,7 @@ header_pad: u16 = 0x1000,
 entry_addr: ?u64 = null,
 
 objects: std.ArrayListUnmanaged(Object) = .{},
-archives: std.ArrayListUnmanaged(*Archive) = .{},
+archives: std.ArrayListUnmanaged(Archive) = .{},
 dylibs: std.ArrayListUnmanaged(*Dylib) = .{},
 
 next_dylib_ordinal: u16 = 1,
@@ -1006,8 +1006,13 @@ fn parseInputFiles(self: *MachO, files: []const []const u8, syslibroot: ?[]const
             continue;
         }
 
-        if (try Archive.createAndParseFromPath(self.base.allocator, arch, full_path)) |archive| {
-            try self.archives.append(self.base.allocator, archive);
+        if (try Archive.isArchive(file, arch)) {
+            const archive = try self.archives.addOne(self.base.allocator);
+            archive.* = .{
+                .name = full_path,
+                .file = file,
+            };
+            try archive.parse(self.base.allocator, arch);
             continue;
         }
 
@@ -1019,6 +1024,8 @@ fn parseInputFiles(self: *MachO, files: []const []const u8, syslibroot: ?[]const
             continue;
         }
 
+        self.base.allocator.free(full_path);
+        file.close();
         log.warn("unknown filetype for positional input file: '{s}'", .{file_name});
     }
 }
@@ -1026,6 +1033,8 @@ fn parseInputFiles(self: *MachO, files: []const []const u8, syslibroot: ?[]const
 fn parseLibs(self: *MachO, libs: []const []const u8, syslibroot: ?[]const u8) !void {
     const arch = self.base.options.target.cpu.arch;
     for (libs) |lib| {
+        const file = try fs.cwd().openFile(lib, .{});
+
         if (try Dylib.createAndParseFromPath(self.base.allocator, arch, lib, .{
             .syslibroot = syslibroot,
         })) |dylibs| {
@@ -1034,11 +1043,17 @@ fn parseLibs(self: *MachO, libs: []const []const u8, syslibroot: ?[]const u8) !v
             continue;
         }
 
-        if (try Archive.createAndParseFromPath(self.base.allocator, arch, lib)) |archive| {
-            try self.archives.append(self.base.allocator, archive);
+        if (try Archive.isArchive(file, arch)) {
+            const archive = try self.archives.addOne(self.base.allocator);
+            archive.* = .{
+                .name = try self.base.allocator.dupe(u8, lib),
+                .file = file,
+            };
+            try archive.parse(self.base.allocator, arch);
             continue;
         }
 
+        file.close();
         log.warn("unknown filetype for a library: '{s}'", .{lib});
     }
 }
@@ -3345,9 +3360,8 @@ pub fn deinit(self: *MachO) void {
     }
     self.objects.deinit(self.base.allocator);
 
-    for (self.archives.items) |archive| {
+    for (self.archives.items) |*archive| {
         archive.deinit(self.base.allocator);
-        self.base.allocator.destroy(archive);
     }
     self.archives.deinit(self.base.allocator);
 
diff --git a/src/link/MachO/Archive.zig b/src/link/MachO/Archive.zig
index 23d5d259ef..0ac34d90fc 100644
--- a/src/link/MachO/Archive.zig
+++ b/src/link/MachO/Archive.zig
@@ -93,36 +93,6 @@ const ar_hdr = extern struct {
     }
 };
 
-pub fn createAndParseFromPath(allocator: *Allocator, arch: Arch, path: []const u8) !?*Archive {
-    const file = fs.cwd().openFile(path, .{}) catch |err| switch (err) {
-        error.FileNotFound => return null,
-        else => |e| return e,
-    };
-    errdefer file.close();
-
-    const archive = try allocator.create(Archive);
-    errdefer allocator.destroy(archive);
-
-    const name = try allocator.dupe(u8, path);
-    errdefer allocator.free(name);
-
-    archive.* = .{
-        .name = name,
-        .file = file,
-    };
-
-    archive.parse(allocator, arch) catch |err| switch (err) {
-        error.EndOfStream, error.NotArchive => {
-            archive.deinit(allocator);
-            allocator.destroy(archive);
-            return null;
-        },
-        else => |e| return e,
-    };
-
-    return archive;
-}
-
 pub fn deinit(self: *Archive, allocator: *Allocator) void {
     for (self.toc.keys()) |*key| {
         allocator.free(key.*);
@@ -134,32 +104,40 @@ pub fn deinit(self: *Archive, allocator: *Allocator) void {
     allocator.free(self.name);
 }
 
+pub fn isArchive(file: fs.File, arch: Arch) !bool {
+    const Internal = struct {
+        fn isArchive(reader: anytype, a: Arch) !bool {
+            const offset = try fat.getLibraryOffset(reader, a);
+            try reader.context.seekTo(offset);
+            const magic = try reader.readBytesNoEof(SARMAG);
+            if (!mem.eql(u8, &magic, ARMAG)) return false;
+            const header = try reader.readStruct(ar_hdr);
+            return mem.eql(u8, &header.ar_fmag, ARFMAG);
+        }
+    };
+    const is_archive = if (Internal.isArchive(file.reader(), arch)) |res|
+        res
+    else |err| switch (err) {
+        error.EndOfStream => false,
+        error.MismatchedCpuArchitecture => true, // TODO maybe this check should be done differently?
+        else => |e| return e,
+    };
+    try file.seekTo(0);
+    return is_archive;
+}
+
 pub fn parse(self: *Archive, allocator: *Allocator, arch: Arch) !void {
     self.library_offset = try fat.getLibraryOffset(self.file.reader(), arch);
-
     try self.file.seekTo(self.library_offset);
-
-    var reader = self.file.reader();
+    const reader = self.file.reader();
     const magic = try reader.readBytesNoEof(SARMAG);
-
-    if (!mem.eql(u8, &magic, ARMAG)) {
-        log.debug("invalid magic: expected '{s}', found '{s}'", .{ ARMAG, magic });
-        return error.NotArchive;
-    }
-
     self.header = try reader.readStruct(ar_hdr);
-
-    if (!mem.eql(u8, &self.header.?.ar_fmag, ARFMAG)) {
-        log.debug("invalid header delimiter: expected '{s}', found '{s}'", .{ ARFMAG, self.header.?.ar_fmag });
-        return error.NotArchive;
-    }
-
     var embedded_name = try parseName(allocator, self.header.?, reader);
-    log.debug("parsing archive '{s}' at '{s}'", .{ embedded_name, self.name });
     defer allocator.free(embedded_name);
 
-    try self.parseTableOfContents(allocator, reader);
+    log.debug("parsing archive '{s}' at '{s}'", .{ embedded_name, self.name });
 
+    try self.parseTableOfContents(allocator, reader);
     try reader.context.seekTo(0);
 }
 
diff --git a/src/link/MachO/Object.zig b/src/link/MachO/Object.zig
index 6a1bf8fd57..ff397ed7b0 100644
--- a/src/link/MachO/Object.zig
+++ b/src/link/MachO/Object.zig
@@ -155,17 +155,18 @@ pub fn deinit(self: *Object, allocator: *Allocator) void {
 }
 
 pub fn isObject(file: fs.File) !bool {
-    const reader = file.reader();
-    const is_object = blk: {
-        if (reader.readStruct(macho.mach_header_64)) |header| {
-            break :blk header.filetype == macho.MH_OBJECT;
-        } else |err| {
-            switch (err) {
-                error.EndOfStream => break :blk false,
-                else => |e| return e,
-            }
+    const Internal = struct {
+        fn isObject(reader: anytype) !bool {
+            const header = try reader.readStruct(macho.mach_header_64);
+            return header.filetype == macho.MH_OBJECT;
         }
     };
+    const is_object = if (Internal.isObject(file.reader())) |res|
+        res
+    else |err| switch (err) {
+        error.EndOfStream => false,
+        else => |e| return e,
+    };
     try file.seekTo(0);
     return is_object;
 }
@@ -175,14 +176,7 @@ pub fn parse(self: *Object, allocator: *Allocator, arch: Arch) !void {
     if (self.file_offset) |offset| {
         try reader.context.seekTo(offset);
     }
-
     const header = try reader.readStruct(macho.mach_header_64);
-
-    if (header.filetype != macho.MH_OBJECT) {
-        log.debug("invalid filetype: expected 0x{x}, found 0x{x}", .{ macho.MH_OBJECT, header.filetype });
-        return error.NotObject;
-    }
-
     const this_arch: Arch = switch (header.cputype) {
         macho.CPU_TYPE_ARM64 => .aarch64,
         macho.CPU_TYPE_X86_64 => .x86_64,
@@ -195,7 +189,6 @@ pub fn parse(self: *Object, allocator: *Allocator, arch: Arch) !void {
         log.err("mismatched cpu architecture: expected {s}, found {s}", .{ arch, this_arch });
         return error.MismatchedCpuArchitecture;
     }
-
     self.header = header;
 
     try self.readLoadCommands(allocator, reader);

From 0b15ba8334bc03b59a975e579aac01a6b3fc2109 Mon Sep 17 00:00:00 2001
From: Jakub Konka <kubkon@jakubkonka.com>
Date: Sat, 31 Jul 2021 16:01:02 +0200
Subject: [PATCH 42/96] macho: don't allocate Dylib on the heap

instead, immediately transfer ownership to MachO struct. Also, revert
back to try-ok-fail parsing approach of objects, archives, and dylibs.
It seems easier to try and fail than check if the file *is* of a
certain type given that a dylib may be a stub and parsing yaml
twice in a row seems very wasteful.

Hint for the future: if we optimise yaml/TAPI parsing, this approach
may be rethought!
---
 src/link/MachO.zig         | 47 ++++++++---------------------
 src/link/MachO/Archive.zig | 62 +++++++++++++++++++++++---------------
 src/link/MachO/Dylib.zig   | 14 +++------
 src/link/MachO/Object.zig  | 47 ++++++++++++++++++++---------
 4 files changed, 89 insertions(+), 81 deletions(-)

diff --git a/src/link/MachO.zig b/src/link/MachO.zig
index 544073f3e1..3eb34cf415 100644
--- a/src/link/MachO.zig
+++ b/src/link/MachO.zig
@@ -63,7 +63,7 @@ entry_addr: ?u64 = null,
 
 objects: std.ArrayListUnmanaged(Object) = .{},
 archives: std.ArrayListUnmanaged(Archive) = .{},
-dylibs: std.ArrayListUnmanaged(*Dylib) = .{},
+dylibs: std.ArrayListUnmanaged(Dylib) = .{},
 
 next_dylib_ordinal: u16 = 1,
 
@@ -994,25 +994,15 @@ fn parseInputFiles(self: *MachO, files: []const []const u8, syslibroot: ?[]const
             const path = try std.fs.realpath(file_name, &buffer);
             break :full_path try self.base.allocator.dupe(u8, path);
         };
-        const file = try fs.cwd().openFile(full_path, .{});
+        defer self.base.allocator.free(full_path);
 
-        if (try Object.isObject(file)) {
-            const object = try self.objects.addOne(self.base.allocator);
-            object.* = .{
-                .name = full_path,
-                .file = file,
-            };
-            try object.parse(self.base.allocator, arch);
+        if (try Object.createAndParseFromPath(self.base.allocator, arch, full_path)) |object| {
+            try self.objects.append(self.base.allocator, object);
             continue;
         }
 
-        if (try Archive.isArchive(file, arch)) {
-            const archive = try self.archives.addOne(self.base.allocator);
-            archive.* = .{
-                .name = full_path,
-                .file = file,
-            };
-            try archive.parse(self.base.allocator, arch);
+        if (try Archive.createAndParseFromPath(self.base.allocator, arch, full_path)) |archive| {
+            try self.archives.append(self.base.allocator, archive);
             continue;
         }
 
@@ -1024,8 +1014,6 @@ fn parseInputFiles(self: *MachO, files: []const []const u8, syslibroot: ?[]const
             continue;
         }
 
-        self.base.allocator.free(full_path);
-        file.close();
         log.warn("unknown filetype for positional input file: '{s}'", .{file_name});
     }
 }
@@ -1033,8 +1021,6 @@ fn parseInputFiles(self: *MachO, files: []const []const u8, syslibroot: ?[]const
 fn parseLibs(self: *MachO, libs: []const []const u8, syslibroot: ?[]const u8) !void {
     const arch = self.base.options.target.cpu.arch;
     for (libs) |lib| {
-        const file = try fs.cwd().openFile(lib, .{});
-
         if (try Dylib.createAndParseFromPath(self.base.allocator, arch, lib, .{
             .syslibroot = syslibroot,
         })) |dylibs| {
@@ -1043,17 +1029,11 @@ fn parseLibs(self: *MachO, libs: []const []const u8, syslibroot: ?[]const u8) !v
             continue;
         }
 
-        if (try Archive.isArchive(file, arch)) {
-            const archive = try self.archives.addOne(self.base.allocator);
-            archive.* = .{
-                .name = try self.base.allocator.dupe(u8, lib),
-                .file = file,
-            };
-            try archive.parse(self.base.allocator, arch);
+        if (try Archive.createAndParseFromPath(self.base.allocator, arch, lib)) |archive| {
+            try self.archives.append(self.base.allocator, archive);
             continue;
         }
 
-        file.close();
         log.warn("unknown filetype for a library: '{s}'", .{lib});
     }
 }
@@ -2351,17 +2331,17 @@ fn resolveSymbols(self: *MachO) !void {
         });
     }
 
-    var referenced = std.AutoHashMap(*Dylib, void).init(self.base.allocator);
+    var referenced = std.AutoHashMap(u16, void).init(self.base.allocator);
     defer referenced.deinit();
 
     loop: for (self.undefs.items) |sym| {
         if (symbolIsNull(sym)) continue;
 
         const sym_name = self.getString(sym.n_strx);
-        for (self.dylibs.items) |dylib| {
+        for (self.dylibs.items) |*dylib, id| {
             if (!dylib.symbols.contains(sym_name)) continue;
 
-            if (!referenced.contains(dylib)) {
+            if (!referenced.contains(@intCast(u16, id))) {
                 // Add LC_LOAD_DYLIB load command for each referenced dylib/stub.
                 dylib.ordinal = self.next_dylib_ordinal;
                 const dylib_id = dylib.id orelse unreachable;
@@ -2375,7 +2355,7 @@ fn resolveSymbols(self: *MachO) !void {
                 errdefer dylib_cmd.deinit(self.base.allocator);
                 try self.load_commands.append(self.base.allocator, .{ .Dylib = dylib_cmd });
                 self.next_dylib_ordinal += 1;
-                try referenced.putNoClobber(dylib, {});
+                try referenced.putNoClobber(@intCast(u16, id), {});
             }
 
             const resolv = self.symbol_resolver.getPtr(sym.n_strx) orelse unreachable;
@@ -3365,9 +3345,8 @@ pub fn deinit(self: *MachO) void {
     }
     self.archives.deinit(self.base.allocator);
 
-    for (self.dylibs.items) |dylib| {
+    for (self.dylibs.items) |*dylib| {
         dylib.deinit(self.base.allocator);
-        self.base.allocator.destroy(dylib);
     }
     self.dylibs.deinit(self.base.allocator);
 
diff --git a/src/link/MachO/Archive.zig b/src/link/MachO/Archive.zig
index 0ac34d90fc..f02ad0cfa9 100644
--- a/src/link/MachO/Archive.zig
+++ b/src/link/MachO/Archive.zig
@@ -104,38 +104,52 @@ pub fn deinit(self: *Archive, allocator: *Allocator) void {
     allocator.free(self.name);
 }
 
-pub fn isArchive(file: fs.File, arch: Arch) !bool {
-    const Internal = struct {
-        fn isArchive(reader: anytype, a: Arch) !bool {
-            const offset = try fat.getLibraryOffset(reader, a);
-            try reader.context.seekTo(offset);
-            const magic = try reader.readBytesNoEof(SARMAG);
-            if (!mem.eql(u8, &magic, ARMAG)) return false;
-            const header = try reader.readStruct(ar_hdr);
-            return mem.eql(u8, &header.ar_fmag, ARFMAG);
-        }
-    };
-    const is_archive = if (Internal.isArchive(file.reader(), arch)) |res|
-        res
-    else |err| switch (err) {
-        error.EndOfStream => false,
-        error.MismatchedCpuArchitecture => true, // TODO maybe this check should be done differently?
+pub fn createAndParseFromPath(allocator: *Allocator, arch: Arch, path: []const u8) !?Archive {
+    const file = fs.cwd().openFile(path, .{}) catch |err| switch (err) {
+        error.FileNotFound => return null,
         else => |e| return e,
     };
-    try file.seekTo(0);
-    return is_archive;
+    errdefer file.close();
+
+    const name = try allocator.dupe(u8, path);
+    errdefer allocator.free(name);
+
+    var archive = Archive{
+        .name = name,
+        .file = file,
+    };
+
+    archive.parse(allocator, arch) catch |err| switch (err) {
+        error.EndOfStream, error.NotArchive => {
+            archive.deinit(allocator);
+            return null;
+        },
+        else => |e| return e,
+    };
+
+    return archive;
 }
 
 pub fn parse(self: *Archive, allocator: *Allocator, arch: Arch) !void {
-    self.library_offset = try fat.getLibraryOffset(self.file.reader(), arch);
-    try self.file.seekTo(self.library_offset);
     const reader = self.file.reader();
-    const magic = try reader.readBytesNoEof(SARMAG);
-    self.header = try reader.readStruct(ar_hdr);
-    var embedded_name = try parseName(allocator, self.header.?, reader);
-    defer allocator.free(embedded_name);
+    self.library_offset = try fat.getLibraryOffset(reader, arch);
+    try self.file.seekTo(self.library_offset);
 
+    const magic = try reader.readBytesNoEof(SARMAG);
+    if (!mem.eql(u8, &magic, ARMAG)) {
+        log.debug("invalid magic: expected '{s}', found '{s}'", .{ ARMAG, magic });
+        return error.NotArchive;
+    }
+
+    self.header = try reader.readStruct(ar_hdr);
+    if (!mem.eql(u8, &self.header.?.ar_fmag, ARFMAG)) {
+        log.debug("invalid header delimiter: expected '{s}', found '{s}'", .{ ARFMAG, self.header.?.ar_fmag });
+        return error.NotArchive;
+    }
+
+    var embedded_name = try parseName(allocator, self.header.?, reader);
     log.debug("parsing archive '{s}' at '{s}'", .{ embedded_name, self.name });
+    defer allocator.free(embedded_name);
 
     try self.parseTableOfContents(allocator, reader);
     try reader.context.seekTo(0);
diff --git a/src/link/MachO/Dylib.zig b/src/link/MachO/Dylib.zig
index de0d697db3..7b2f94ba67 100644
--- a/src/link/MachO/Dylib.zig
+++ b/src/link/MachO/Dylib.zig
@@ -148,20 +148,17 @@ pub fn createAndParseFromPath(
     arch: Arch,
     path: []const u8,
     opts: CreateOpts,
-) Error!?[]*Dylib {
+) Error!?[]Dylib {
     const file = fs.cwd().openFile(path, .{}) catch |err| switch (err) {
         error.FileNotFound => return null,
         else => |e| return e,
     };
     errdefer file.close();
 
-    const dylib = try allocator.create(Dylib);
-    errdefer allocator.destroy(dylib);
-
     const name = try allocator.dupe(u8, path);
     errdefer allocator.free(name);
 
-    dylib.* = .{
+    var dylib = Dylib{
         .name = name,
         .file = file,
     };
@@ -172,7 +169,6 @@ pub fn createAndParseFromPath(
 
             var lib_stub = LibStub.loadFromFile(allocator, file) catch {
                 dylib.deinit(allocator);
-                allocator.destroy(dylib);
                 return null;
             };
             defer lib_stub.deinit();
@@ -191,12 +187,11 @@ pub fn createAndParseFromPath(
 
             // TODO maybe this should be an error and facilitate auto-cleanup?
             dylib.deinit(allocator);
-            allocator.destroy(dylib);
             return null;
         }
     }
 
-    var dylibs = std.ArrayList(*Dylib).init(allocator);
+    var dylibs = std.ArrayList(Dylib).init(allocator);
     defer dylibs.deinit();
 
     try dylibs.append(dylib);
@@ -449,7 +444,7 @@ pub fn parseDependentLibs(
     self: *Dylib,
     allocator: *Allocator,
     arch: Arch,
-    out: *std.ArrayList(*Dylib),
+    out: *std.ArrayList(Dylib),
     syslibroot: ?[]const u8,
 ) !void {
     outer: for (self.dependent_libs.items) |id| {
@@ -489,6 +484,7 @@ pub fn parseDependentLibs(
             )) orelse {
                 continue;
             };
+            defer allocator.free(dylibs);
 
             try out.appendSlice(dylibs);
 
diff --git a/src/link/MachO/Object.zig b/src/link/MachO/Object.zig
index ff397ed7b0..04071a1cdb 100644
--- a/src/link/MachO/Object.zig
+++ b/src/link/MachO/Object.zig
@@ -154,29 +154,47 @@ pub fn deinit(self: *Object, allocator: *Allocator) void {
     }
 }
 
-pub fn isObject(file: fs.File) !bool {
-    const Internal = struct {
-        fn isObject(reader: anytype) !bool {
-            const header = try reader.readStruct(macho.mach_header_64);
-            return header.filetype == macho.MH_OBJECT;
-        }
-    };
-    const is_object = if (Internal.isObject(file.reader())) |res|
-        res
-    else |err| switch (err) {
-        error.EndOfStream => false,
+pub fn createAndParseFromPath(allocator: *Allocator, arch: Arch, path: []const u8) !?Object {
+    const file = fs.cwd().openFile(path, .{}) catch |err| switch (err) {
+        error.FileNotFound => return null,
         else => |e| return e,
     };
-    try file.seekTo(0);
-    return is_object;
+    errdefer file.close();
+
+    const name = try allocator.dupe(u8, path);
+    errdefer allocator.free(name);
+
+    var object = Object{
+        .name = name,
+        .file = file,
+    };
+
+    object.parse(allocator, arch) catch |err| switch (err) {
+        error.EndOfStream, error.NotObject => {
+            object.deinit(allocator);
+            return null;
+        },
+        else => |e| return e,
+    };
+
+    return object;
 }
 
 pub fn parse(self: *Object, allocator: *Allocator, arch: Arch) !void {
-    var reader = self.file.reader();
+    const reader = self.file.reader();
     if (self.file_offset) |offset| {
         try reader.context.seekTo(offset);
     }
+
     const header = try reader.readStruct(macho.mach_header_64);
+    if (header.filetype != macho.MH_OBJECT) {
+        log.debug("invalid filetype: expected 0x{x}, found 0x{x}", .{
+            macho.MH_OBJECT,
+            header.filetype,
+        });
+        return error.NotObject;
+    }
+
     const this_arch: Arch = switch (header.cputype) {
         macho.CPU_TYPE_ARM64 => .aarch64,
         macho.CPU_TYPE_X86_64 => .x86_64,
@@ -189,6 +207,7 @@ pub fn parse(self: *Object, allocator: *Allocator, arch: Arch) !void {
         log.err("mismatched cpu architecture: expected {s}, found {s}", .{ arch, this_arch });
         return error.MismatchedCpuArchitecture;
     }
+
     self.header = header;
 
     try self.readLoadCommands(allocator, reader);

From 2e30bf23aa4515682038bc69ffc0b7d06b734be9 Mon Sep 17 00:00:00 2001
From: Jakub Konka <kubkon@jakubkonka.com>
Date: Sat, 31 Jul 2021 16:06:50 +0200
Subject: [PATCH 43/96] macho: cleanup extracting objects from archives

---
 src/link/MachO.zig         | 7 +++++--
 src/link/MachO/Archive.zig | 5 +++--
 2 files changed, 8 insertions(+), 4 deletions(-)

diff --git a/src/link/MachO.zig b/src/link/MachO.zig
index 3eb34cf415..d4a30040fc 100644
--- a/src/link/MachO.zig
+++ b/src/link/MachO.zig
@@ -2231,8 +2231,11 @@ fn resolveSymbols(self: *MachO) !void {
 
             const object_id = @intCast(u16, self.objects.items.len);
             const object = try self.objects.addOne(self.base.allocator);
-            object.* = try archive.extractObject(self.base.allocator, offsets.items[0]);
-            try object.parse(self.base.allocator, self.base.options.target.cpu.arch);
+            object.* = try archive.parseObject(
+                self.base.allocator,
+                self.base.options.target.cpu.arch,
+                offsets.items[0],
+            );
             try self.resolveSymbolsInObject(object_id);
 
             continue :loop;
diff --git a/src/link/MachO/Archive.zig b/src/link/MachO/Archive.zig
index f02ad0cfa9..6959dbac89 100644
--- a/src/link/MachO/Archive.zig
+++ b/src/link/MachO/Archive.zig
@@ -215,8 +215,8 @@ fn parseTableOfContents(self: *Archive, allocator: *Allocator, reader: anytype)
     }
 }
 
-pub fn extractObject(self: Archive, allocator: *Allocator, offset: u32) !Object {
-    var reader = self.file.reader();
+pub fn parseObject(self: Archive, allocator: *Allocator, arch: Arch, offset: u32) !Object {
+    const reader = self.file.reader();
     try reader.context.seekTo(offset + self.library_offset);
 
     const object_header = try reader.readStruct(ar_hdr);
@@ -244,6 +244,7 @@ pub fn extractObject(self: Archive, allocator: *Allocator, offset: u32) !Object
         .mtime = try self.header.?.date(),
     };
 
+    try object.parse(allocator, arch);
     try reader.context.seekTo(0);
 
     return object;

From d19fdf09ae1686ae5f7eb5f2386dd6de1f441db5 Mon Sep 17 00:00:00 2001
From: Jakub Konka <kubkon@jakubkonka.com>
Date: Sat, 31 Jul 2021 21:31:06 +0200
Subject: [PATCH 44/96] macho: make CodeSignature accept allocator as param

instead storing it within the struct.
---
 src/link/MachO.zig               |  7 +++++--
 src/link/MachO/CodeSignature.zig | 33 +++++++++++---------------------
 2 files changed, 16 insertions(+), 24 deletions(-)

diff --git a/src/link/MachO.zig b/src/link/MachO.zig
index d4a30040fc..fab655dc21 100644
--- a/src/link/MachO.zig
+++ b/src/link/MachO.zig
@@ -5239,14 +5239,17 @@ fn writeCodeSignature(self: *MachO) !void {
     const text_segment = self.load_commands.items[self.text_segment_cmd_index.?].Segment;
     const code_sig_cmd = self.load_commands.items[self.code_signature_cmd_index.?].LinkeditData;
 
-    var code_sig = CodeSignature.init(self.base.allocator, self.page_size);
-    defer code_sig.deinit();
+    var code_sig: CodeSignature = .{};
+    defer code_sig.deinit(self.base.allocator);
+
     try code_sig.calcAdhocSignature(
+        self.base.allocator,
         self.base.file.?,
         self.base.options.emit.?.sub_path,
         text_segment.inner,
         code_sig_cmd,
         self.base.options.output_mode,
+        self.page_size,
     );
 
     var buffer = try self.base.allocator.alloc(u8, code_sig.size());
diff --git a/src/link/MachO/CodeSignature.zig b/src/link/MachO/CodeSignature.zig
index d0dd47be92..293de32def 100644
--- a/src/link/MachO/CodeSignature.zig
+++ b/src/link/MachO/CodeSignature.zig
@@ -46,8 +46,6 @@ const CodeDirectory = struct {
     }
 };
 
-allocator: *Allocator,
-
 /// Code signature blob header.
 inner: macho.SuperBlob = .{
     .magic = macho.CSMAGIC_EMBEDDED_SIGNATURE,
@@ -58,24 +56,15 @@ inner: macho.SuperBlob = .{
 /// CodeDirectory header which holds the hash of the binary.
 cdir: ?CodeDirectory = null,
 
-/// Page size is dependent on the target cpu architecture.
-/// For x86_64 that's 4KB, whereas for aarch64, that's 16KB.
-page_size: u16,
-
-pub fn init(allocator: *Allocator, page_size: u16) CodeSignature {
-    return .{
-        .allocator = allocator,
-        .page_size = page_size,
-    };
-}
-
 pub fn calcAdhocSignature(
     self: *CodeSignature,
+    allocator: *Allocator,
     file: fs.File,
     id: []const u8,
     text_segment: macho.segment_command_64,
     code_sig_cmd: macho.linkedit_data_command,
     output_mode: std.builtin.OutputMode,
+    page_size: u16,
 ) !void {
     const execSegBase: u64 = text_segment.fileoff;
     const execSegLimit: u64 = text_segment.filesize;
@@ -95,7 +84,7 @@ pub fn calcAdhocSignature(
             .hashSize = hash_size,
             .hashType = macho.CS_HASHTYPE_SHA256,
             .platform = 0,
-            .pageSize = @truncate(u8, std.math.log2(self.page_size)),
+            .pageSize = @truncate(u8, std.math.log2(page_size)),
             .spare2 = 0,
             .scatterOffset = 0,
             .teamOffset = 0,
@@ -107,13 +96,13 @@ pub fn calcAdhocSignature(
         },
     };
 
-    const total_pages = mem.alignForward(file_size, self.page_size) / self.page_size;
+    const total_pages = mem.alignForward(file_size, page_size) / page_size;
 
     var hash: [hash_size]u8 = undefined;
-    var buffer = try self.allocator.alloc(u8, self.page_size);
-    defer self.allocator.free(buffer);
+    var buffer = try allocator.alloc(u8, page_size);
+    defer allocator.free(buffer);
 
-    try cdir.data.ensureCapacity(self.allocator, total_pages * hash_size + id.len + 1);
+    try cdir.data.ensureCapacity(allocator, total_pages * hash_size + id.len + 1);
 
     // 1. Save the identifier and update offsets
     cdir.inner.identOffset = cdir.inner.length;
@@ -126,8 +115,8 @@ pub fn calcAdhocSignature(
     cdir.inner.hashOffset = cdir.inner.identOffset + @intCast(u32, id.len) + 1;
     var i: usize = 0;
     while (i < total_pages) : (i += 1) {
-        const fstart = i * self.page_size;
-        const fsize = if (fstart + self.page_size > file_size) file_size - fstart else self.page_size;
+        const fstart = i * page_size;
+        const fsize = if (fstart + page_size > file_size) file_size - fstart else page_size;
         const len = try file.preadAll(buffer, fstart);
         assert(fsize <= len);
 
@@ -156,9 +145,9 @@ pub fn write(self: CodeSignature, writer: anytype) !void {
     try self.cdir.?.write(writer);
 }
 
-pub fn deinit(self: *CodeSignature) void {
+pub fn deinit(self: *CodeSignature, allocator: *Allocator) void {
     if (self.cdir) |*cdir| {
-        cdir.data.deinit(self.allocator);
+        cdir.data.deinit(allocator);
     }
 }
 

From 58bc713c171e74b3c4f8283636561e6521edbeef Mon Sep 17 00:00:00 2001
From: Jakub Konka <kubkon@jakubkonka.com>
Date: Sat, 31 Jul 2021 21:37:46 +0200
Subject: [PATCH 45/96] macho: make Trie accept allocator as a param

instead of storing it as a member of Trie struct.
---
 src/link/MachO.zig      | 16 ++++++++--------
 src/link/MachO/Trie.zig | 30 ++++++++++++------------------
 2 files changed, 20 insertions(+), 26 deletions(-)

diff --git a/src/link/MachO.zig b/src/link/MachO.zig
index fab655dc21..9f9a0d5157 100644
--- a/src/link/MachO.zig
+++ b/src/link/MachO.zig
@@ -3126,8 +3126,8 @@ fn writeLazyBindInfoTableZld(self: *MachO) !void {
 }
 
 fn writeExportInfoZld(self: *MachO) !void {
-    var trie = Trie.init(self.base.allocator);
-    defer trie.deinit();
+    var trie: Trie = .{};
+    defer trie.deinit(self.base.allocator);
 
     const text_segment = self.load_commands.items[self.text_segment_cmd_index.?].Segment;
     const base_address = text_segment.inner.vmaddr;
@@ -3139,14 +3139,14 @@ fn writeExportInfoZld(self: *MachO) !void {
         const sym_name = self.getString(sym.n_strx);
         log.debug("  | putting '{s}' defined at 0x{x}", .{ sym_name, sym.n_value });
 
-        try trie.put(.{
+        try trie.put(self.base.allocator, .{
             .name = sym_name,
             .vmaddr_offset = sym.n_value - base_address,
             .export_flags = macho.EXPORT_SYMBOL_FLAGS_KIND_REGULAR,
         });
     }
 
-    try trie.finalize();
+    try trie.finalize(self.base.allocator);
 
     var buffer = try self.base.allocator.alloc(u8, @intCast(usize, trie.size));
     defer self.base.allocator.free(buffer);
@@ -5269,8 +5269,8 @@ fn writeExportInfo(self: *MachO) !void {
     const tracy = trace(@src());
     defer tracy.end();
 
-    var trie = Trie.init(self.base.allocator);
-    defer trie.deinit();
+    var trie: Trie = .{};
+    defer trie.deinit(self.base.allocator);
 
     const text_segment = self.load_commands.items[self.text_segment_cmd_index.?].Segment;
     const base_address = text_segment.inner.vmaddr;
@@ -5282,14 +5282,14 @@ fn writeExportInfo(self: *MachO) !void {
         const sym_name = self.getString(sym.n_strx);
         log.debug("  | putting '{s}' defined at 0x{x}", .{ sym_name, sym.n_value });
 
-        try trie.put(.{
+        try trie.put(self.base.allocator, .{
             .name = sym_name,
             .vmaddr_offset = sym.n_value - base_address,
             .export_flags = macho.EXPORT_SYMBOL_FLAGS_KIND_REGULAR,
         });
     }
+    try trie.finalize(self.base.allocator);
 
-    try trie.finalize();
     var buffer = try self.base.allocator.alloc(u8, @intCast(usize, trie.size));
     defer self.base.allocator.free(buffer);
     var stream = std.io.fixedBufferStream(buffer);
diff --git a/src/link/MachO/Trie.zig b/src/link/MachO/Trie.zig
index 8aa2262bff..6f66f73a32 100644
--- a/src/link/MachO/Trie.zig
+++ b/src/link/MachO/Trie.zig
@@ -273,8 +273,6 @@ pub const Node = struct {
 /// The root node of the trie.
 root: ?*Node = null,
 
-allocator: *Allocator,
-
 /// If you want to access nodes ordered in DFS fashion,
 /// you should call `finalize` first since the nodes
 /// in this container are not guaranteed to not be stale
@@ -294,10 +292,6 @@ node_count: usize = 0,
 
 trie_dirty: bool = true,
 
-pub fn init(allocator: *Allocator) Trie {
-    return .{ .allocator = allocator };
-}
-
 /// Export symbol that is to be placed in the trie.
 pub const ExportSymbol = struct {
     /// Name of the symbol.
@@ -314,9 +308,9 @@ pub const ExportSymbol = struct {
 /// Insert a symbol into the trie, updating the prefixes in the process.
 /// This operation may change the layout of the trie by splicing edges in
 /// certain circumstances.
-pub fn put(self: *Trie, symbol: ExportSymbol) !void {
-    try self.createRoot();
-    const node = try self.root.?.put(self.allocator, symbol.name);
+pub fn put(self: *Trie, allocator: *Allocator, symbol: ExportSymbol) !void {
+    try self.createRoot(allocator);
+    const node = try self.root.?.put(allocator, symbol.name);
     node.terminal_info = .{
         .vmaddr_offset = symbol.vmaddr_offset,
         .export_flags = symbol.export_flags,
@@ -328,13 +322,13 @@ pub fn put(self: *Trie, symbol: ExportSymbol) !void {
 /// This step performs multiple passes through the trie ensuring
 /// there are no gaps after every `Node` is ULEB128 encoded.
 /// Call this method before trying to `write` the trie to a byte stream.
-pub fn finalize(self: *Trie) !void {
+pub fn finalize(self: *Trie, allocator: *Allocator) !void {
     if (!self.trie_dirty) return;
 
     self.ordered_nodes.shrinkRetainingCapacity(0);
-    try self.ordered_nodes.ensureCapacity(self.allocator, self.node_count);
+    try self.ordered_nodes.ensureCapacity(allocator, self.node_count);
 
-    var fifo = std.fifo.LinearFifo(*Node, .Dynamic).init(self.allocator);
+    var fifo = std.fifo.LinearFifo(*Node, .Dynamic).init(allocator);
     defer fifo.deinit();
 
     try fifo.writeItem(self.root.?);
@@ -383,17 +377,17 @@ pub fn write(self: Trie, writer: anytype) !u64 {
     return counting_writer.bytes_written;
 }
 
-pub fn deinit(self: *Trie) void {
+pub fn deinit(self: *Trie, allocator: *Allocator) void {
     if (self.root) |root| {
-        root.deinit(self.allocator);
-        self.allocator.destroy(root);
+        root.deinit(allocator);
+        allocator.destroy(root);
     }
-    self.ordered_nodes.deinit(self.allocator);
+    self.ordered_nodes.deinit(allocator);
 }
 
-fn createRoot(self: *Trie) !void {
+fn createRoot(self: *Trie, allocator: *Allocator) !void {
     if (self.root == null) {
-        const root = try self.allocator.create(Node);
+        const root = try allocator.create(Node);
         root.* = .{ .base = self };
         self.root = root;
         self.node_count += 1;

From 0ce56f93052184e5c0f627f6af1ff4d34bb3110a Mon Sep 17 00:00:00 2001
From: Jakub Konka <kubkon@jakubkonka.com>
Date: Sat, 31 Jul 2021 22:01:26 +0200
Subject: [PATCH 46/96] macho: fix Trie and CodeSignature unit tests

after the cleanup.
---
 src/link/MachO/CodeSignature.zig |  4 +--
 src/link/MachO/Trie.zig          | 50 ++++++++++++++++----------------
 2 files changed, 27 insertions(+), 27 deletions(-)

diff --git a/src/link/MachO/CodeSignature.zig b/src/link/MachO/CodeSignature.zig
index 293de32def..6dd7e556b5 100644
--- a/src/link/MachO/CodeSignature.zig
+++ b/src/link/MachO/CodeSignature.zig
@@ -163,8 +163,8 @@ fn writeBlobIndex(tt: u32, offset: u32, writer: anytype) !void {
 }
 
 test "CodeSignature header" {
-    var code_sig = CodeSignature.init(testing.allocator, 0x1000);
-    defer code_sig.deinit();
+    var code_sig: CodeSignature = .{};
+    defer code_sig.deinit(testing.allocator);
 
     var buffer: [@sizeOf(macho.SuperBlob)]u8 = undefined;
     var stream = std.io.fixedBufferStream(&buffer);
diff --git a/src/link/MachO/Trie.zig b/src/link/MachO/Trie.zig
index 6f66f73a32..ab3a97eb33 100644
--- a/src/link/MachO/Trie.zig
+++ b/src/link/MachO/Trie.zig
@@ -361,9 +361,9 @@ const ReadError = error{
 };
 
 /// Parse the trie from a byte stream.
-pub fn read(self: *Trie, reader: anytype) ReadError!usize {
-    try self.createRoot();
-    return self.root.?.read(self.allocator, reader);
+pub fn read(self: *Trie, allocator: *Allocator, reader: anytype) ReadError!usize {
+    try self.createRoot(allocator);
+    return self.root.?.read(allocator, reader);
 }
 
 /// Write the trie to a byte stream.
@@ -396,13 +396,13 @@ fn createRoot(self: *Trie, allocator: *Allocator) !void {
 
 test "Trie node count" {
     var gpa = testing.allocator;
-    var trie = Trie.init(gpa);
-    defer trie.deinit();
+    var trie: Trie = .{};
+    defer trie.deinit(gpa);
 
     try testing.expectEqual(trie.node_count, 0);
     try testing.expect(trie.root == null);
 
-    try trie.put(.{
+    try trie.put(gpa, .{
         .name = "_main",
         .vmaddr_offset = 0,
         .export_flags = 0,
@@ -410,14 +410,14 @@ test "Trie node count" {
     try testing.expectEqual(trie.node_count, 2);
 
     // Inserting the same node shouldn't update the trie.
-    try trie.put(.{
+    try trie.put(gpa, .{
         .name = "_main",
         .vmaddr_offset = 0,
         .export_flags = 0,
     });
     try testing.expectEqual(trie.node_count, 2);
 
-    try trie.put(.{
+    try trie.put(gpa, .{
         .name = "__mh_execute_header",
         .vmaddr_offset = 0x1000,
         .export_flags = 0,
@@ -425,13 +425,13 @@ test "Trie node count" {
     try testing.expectEqual(trie.node_count, 4);
 
     // Inserting the same node shouldn't update the trie.
-    try trie.put(.{
+    try trie.put(gpa, .{
         .name = "__mh_execute_header",
         .vmaddr_offset = 0x1000,
         .export_flags = 0,
     });
     try testing.expectEqual(trie.node_count, 4);
-    try trie.put(.{
+    try trie.put(gpa, .{
         .name = "_main",
         .vmaddr_offset = 0,
         .export_flags = 0,
@@ -441,11 +441,11 @@ test "Trie node count" {
 
 test "Trie basic" {
     var gpa = testing.allocator;
-    var trie = Trie.init(gpa);
-    defer trie.deinit();
+    var trie: Trie = .{};
+    defer trie.deinit(gpa);
 
     // root --- _st ---> node
-    try trie.put(.{
+    try trie.put(gpa, .{
         .name = "_st",
         .vmaddr_offset = 0,
         .export_flags = 0,
@@ -455,7 +455,7 @@ test "Trie basic" {
 
     {
         // root --- _st ---> node --- art ---> node
-        try trie.put(.{
+        try trie.put(gpa, .{
             .name = "_start",
             .vmaddr_offset = 0,
             .export_flags = 0,
@@ -471,7 +471,7 @@ test "Trie basic" {
         // root --- _ ---> node --- st ---> node --- art ---> node
         //                  |
         //                  |   --- main ---> node
-        try trie.put(.{
+        try trie.put(gpa, .{
             .name = "_main",
             .vmaddr_offset = 0,
             .export_flags = 0,
@@ -491,22 +491,22 @@ test "Trie basic" {
 
 test "write Trie to a byte stream" {
     var gpa = testing.allocator;
-    var trie = Trie.init(gpa);
-    defer trie.deinit();
+    var trie: Trie = .{};
+    defer trie.deinit(gpa);
 
-    try trie.put(.{
+    try trie.put(gpa, .{
         .name = "__mh_execute_header",
         .vmaddr_offset = 0,
         .export_flags = 0,
     });
-    try trie.put(.{
+    try trie.put(gpa, .{
         .name = "_main",
         .vmaddr_offset = 0x1000,
         .export_flags = 0,
     });
 
-    try trie.finalize();
-    try trie.finalize(); // Finalizing mulitple times is a nop subsequently unless we add new nodes.
+    try trie.finalize(gpa);
+    try trie.finalize(gpa); // Finalizing mulitple times is a nop subsequently unless we add new nodes.
 
     const exp_buffer = [_]u8{
         0x0, 0x1, // node root
@@ -551,13 +551,13 @@ test "parse Trie from byte stream" {
     };
 
     var in_stream = std.io.fixedBufferStream(&in_buffer);
-    var trie = Trie.init(gpa);
-    defer trie.deinit();
-    const nread = try trie.read(in_stream.reader());
+    var trie: Trie = .{};
+    defer trie.deinit(gpa);
+    const nread = try trie.read(gpa, in_stream.reader());
 
     try testing.expect(nread == in_buffer.len);
 
-    try trie.finalize();
+    try trie.finalize(gpa);
 
     var out_buffer = try gpa.alloc(u8, trie.size);
     defer gpa.free(out_buffer);

From 0d09c6aed8811ded3e6dcb62fa9539d3795cf97b Mon Sep 17 00:00:00 2001
From: joachimschmidt557 <joachim.schmidt557@outlook.com>
Date: Sat, 31 Jul 2021 12:52:35 +0200
Subject: [PATCH 47/96] stage2 ARM: fix stack alignment

Acording to the AAPCS32, the stack alignment at public interfaces
should be 8, not 4.
---
 src/codegen.zig | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/codegen.zig b/src/codegen.zig
index 77672e82b0..8c56ab4431 100644
--- a/src/codegen.zig
+++ b/src/codegen.zig
@@ -4916,7 +4916,7 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
                             }
 
                             result.stack_byte_count = nsaa;
-                            result.stack_align = 4;
+                            result.stack_align = 8;
                         },
                         else => return self.fail("TODO implement function parameters for {} on arm", .{cc}),
                     }

From 5589edf45ce20b5b6d893b1a5488007981322550 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C5=BDiga=20=C5=BDeljko?= <ziga.zeljko@gmail.com>
Date: Sat, 31 Jul 2021 10:58:42 +0200
Subject: [PATCH 48/96] fix help for ast-check command

---
 src/main.zig | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/main.zig b/src/main.zig
index 5b0c9edc8f..8c1964fc43 100644
--- a/src/main.zig
+++ b/src/main.zig
@@ -3886,6 +3886,8 @@ const usage_ast_check =
     \\  -h, --help            Print this help and exit
     \\  --color [auto|off|on] Enable or disable colored error messages
     \\  -t                    (debug option) Output ZIR in text form to stdout
+    \\
+    \\
 ;
 
 pub fn cmdAstCheck(

From 5667ab7dcd2e367f3e1ac337eabadd64d9d850ad Mon Sep 17 00:00:00 2001
From: Luuk de Gram <luuk@degram.dev>
Date: Fri, 30 Jul 2021 20:35:30 +0200
Subject: [PATCH 49/96] wasm: Implement wrapping operands, add opcodes to
 wasm.zig

- Some opcodes have the incorrect value set in std.
- Some opcodes were missing and have now been added to std.
- Adding wrapping operands for add,sub and mul.
- Implement intCast which either extends or shortens the type.
---
 lib/std/wasm.zig     | 10 ++++++++--
 src/codegen/wasm.zig | 29 ++++++++++++++++++++++++++++-
 2 files changed, 36 insertions(+), 3 deletions(-)

diff --git a/lib/std/wasm.zig b/lib/std/wasm.zig
index 8922b3c83e..aebbb3b163 100644
--- a/lib/std/wasm.zig
+++ b/lib/std/wasm.zig
@@ -162,8 +162,14 @@ pub const Opcode = enum(u8) {
     i32_wrap_i64 = 0xA7,
     i32_trunc_f32_s = 0xA8,
     i32_trunc_f32_u = 0xA9,
-    i32_trunc_f64_s = 0xB0,
-    i32_trunc_f64_u = 0xB1,
+    i32_trunc_f64_s = 0xAA,
+    i32_trunc_f64_u = 0xAB,
+    i64_extend_i32_s = 0xAC,
+    i64_extend_i32_u = 0xAD,
+    i64_trunc_f32_s = 0xAE,
+    i64_trunc_f32_u = 0xAF,
+    i64_trunc_f64_s = 0xB0,
+    i64_trunc_f64_u = 0xB1,
     f32_convert_i32_s = 0xB2,
     f32_convert_i32_u = 0xB3,
     f32_convert_i64_s = 0xB4,
diff --git a/src/codegen/wasm.zig b/src/codegen/wasm.zig
index 2f1632e0fc..1a23a8fa35 100644
--- a/src/codegen/wasm.zig
+++ b/src/codegen/wasm.zig
@@ -591,7 +591,7 @@ pub const Context = struct {
             .ErrorSet,
             => wasm.Valtype.i32,
             .Struct, .ErrorUnion => unreachable, // Multi typed, must be handled individually.
-            else => self.fail("TODO - Wasm valtype for type '{s}'", .{ty.zigTypeTag()}),
+            else => |tag| self.fail("TODO - Wasm valtype for type '{s}'", .{tag}),
         };
     }
 
@@ -800,8 +800,11 @@ pub const Context = struct {
         const air_tags = self.air.instructions.items(.tag);
         return switch (air_tags[inst]) {
             .add => self.airBinOp(inst, .add),
+            .addwrap => self.airBinOp(inst, .add),
             .sub => self.airBinOp(inst, .sub),
+            .subwrap => self.airBinOp(inst, .sub),
             .mul => self.airBinOp(inst, .mul),
+            .mulwrap => self.airBinOp(inst, .mul),
             .div => self.airBinOp(inst, .div),
             .bit_and => self.airBinOp(inst, .@"and"),
             .bit_or => self.airBinOp(inst, .@"or"),
@@ -826,6 +829,7 @@ pub const Context = struct {
             .cond_br => self.airCondBr(inst),
             .constant => unreachable,
             .dbg_stmt => WValue.none,
+            .intcast => self.airIntcast(inst),
             .is_err => self.airIsErr(inst, .i32_ne),
             .is_non_err => self.airIsErr(inst, .i32_eq),
             .load => self.airLoad(inst),
@@ -1494,4 +1498,27 @@ pub const Context = struct {
         const ty_op = self.air.instructions.items(.data)[inst].ty_op;
         return self.resolveInst(ty_op.operand);
     }
+
+    fn airIntcast(self: *Context, inst: Air.Inst.Index) InnerError!WValue {
+        const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+        const ty = self.air.getRefType(ty_op.ty);
+        const operand = self.resolveInst(ty_op.operand);
+        const ref_ty = self.air.typeOf(ty_op.operand);
+        const ref_info = ref_ty.intInfo(self.target);
+        const op_bits = ref_info.bits;
+        const wanted_bits = ty.intInfo(self.target).bits;
+
+        try self.emitWValue(operand);
+        if (op_bits > 32 and wanted_bits <= 32) {
+            try self.code.append(wasm.opcode(.i32_wrap_i64));
+        } else if (op_bits <= 32 and wanted_bits > 32) {
+            try self.code.append(wasm.opcode(switch (ref_info.signedness) {
+                .signed => .i64_extend_i32_s,
+                .unsigned => .i64_extend_i32_u,
+            }));
+        }
+
+        // other cases are no-op
+        return .none;
+    }
 };

From e58976542b096df6cbb2088b6c7a690d7b95c50a Mon Sep 17 00:00:00 2001
From: Luuk de Gram <luuk@degram.dev>
Date: Fri, 30 Jul 2021 21:05:30 +0200
Subject: [PATCH 50/96] wasm: Test cases for wrap+intcast instructions

---
 test/stage2/wasm.zig | 32 ++++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)

diff --git a/test/stage2/wasm.zig b/test/stage2/wasm.zig
index f746be99d2..b0099c392c 100644
--- a/test/stage2/wasm.zig
+++ b/test/stage2/wasm.zig
@@ -113,6 +113,13 @@ pub fn addCases(ctx: *TestContext) !void {
             \\}
         , "25\n");
 
+        case.addCompareOutput(
+            \\pub export fn _start() i32 {
+            \\    var i: i32 = 2147483647;
+            \\    return i +% 1;
+            \\}
+        , "-2147483648\n");
+
         case.addCompareOutput(
             \\pub export fn _start() u32 {
             \\    var i: u32 = 5;
@@ -133,6 +140,13 @@ pub fn addCases(ctx: *TestContext) !void {
             \\}
         , "15\n");
 
+        case.addCompareOutput(
+            \\pub export fn _start() i32 {
+            \\    var i: i32 = -2147483648;
+            \\    return i -% 1;
+            \\}
+        , "2147483647\n");
+
         case.addCompareOutput(
             \\pub export fn _start() u32 {
             \\    var i: u32 = 5;
@@ -157,6 +171,13 @@ pub fn addCases(ctx: *TestContext) !void {
             \\}
         , "350\n");
 
+        case.addCompareOutput(
+            \\pub export fn _start() i32 {
+            \\    var i: i32 = 2147483647;
+            \\    return i *% 2;
+            \\}
+        , "-2\n");
+
         case.addCompareOutput(
             \\pub export fn _start() u32 {
             \\    var i: u32 = 352;
@@ -612,4 +633,15 @@ pub fn addCases(ctx: *TestContext) !void {
             \\}
         , "42\n");
     }
+
+    {
+        var case = ctx.exe("wasm integer widening", wasi);
+
+        case.addCompareOutput(
+            \\pub export fn _start() u64 {
+            \\    var x: u32 = 5;
+            \\    return x;
+            \\}
+        , "5\n");
+    }
 }

From 61de59e121ebd5ad2a8af871ddb1d785c3694481 Mon Sep 17 00:00:00 2001
From: Luuk de Gram <luuk@degram.dev>
Date: Sat, 31 Jul 2021 16:01:37 +0200
Subject: [PATCH 51/96] wasm: Implement optionals

This uses the same approach as error unions,
meaning it's a `WValue` with its tag set to `multi_value`.
The initial index of the multi_value will contain the null-tag, used to check if the value
is null or not. The other values will be the payload.

To support the `.?` shorthand syntax, we save the result from checking the null-tag
into a new local, which can then be loaded later in the block to either hit `unreachable` or
set the actual payload value.

Currently, it seems `.?` and `orelse unreachable` results in different AIR structure.
TODO: Is this expected?
---
 src/codegen/wasm.zig | 106 ++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 104 insertions(+), 2 deletions(-)

diff --git a/src/codegen/wasm.zig b/src/codegen/wasm.zig
index 1a23a8fa35..5178c43c00 100644
--- a/src/codegen/wasm.zig
+++ b/src/codegen/wasm.zig
@@ -590,7 +590,7 @@ pub const Context = struct {
             .Pointer,
             .ErrorSet,
             => wasm.Valtype.i32,
-            .Struct, .ErrorUnion => unreachable, // Multi typed, must be handled individually.
+            .Struct, .ErrorUnion, .Optional => unreachable, // Multi typed, must be handled individually.
             else => |tag| self.fail("TODO - Wasm valtype for type '{s}'", .{tag}),
         };
     }
@@ -663,6 +663,23 @@ pub const Context = struct {
                     .count = 2,
                 } };
             },
+            .Optional => {
+                var opt_buf: Type.Payload.ElemType = undefined;
+                const child_type = ty.optionalChild(&opt_buf);
+                if (ty.isPtrLikeOptional()) {
+                    return self.fail("TODO: wasm optional pointer", .{});
+                }
+
+                try self.locals.ensureCapacity(self.gpa, self.locals.items.len + 2);
+                self.locals.appendAssumeCapacity(wasm.valtype(.i32)); // optional 'tag' for null-checking is always i32
+                self.locals.appendAssumeCapacity(try self.genValtype(child_type));
+                self.local_index += 2;
+
+                return WValue{ .multi_value = .{
+                    .index = initial_index,
+                    .count = 2,
+                } };
+            },
             else => {
                 const valtype = try self.genValtype(ty);
                 try self.locals.append(self.gpa, valtype);
@@ -830,8 +847,15 @@ pub const Context = struct {
             .constant => unreachable,
             .dbg_stmt => WValue.none,
             .intcast => self.airIntcast(inst),
+
             .is_err => self.airIsErr(inst, .i32_ne),
             .is_non_err => self.airIsErr(inst, .i32_eq),
+
+            .is_null => self.airIsNull(inst, .i32_ne),
+            .is_non_null => self.airIsNull(inst, .i32_eq),
+            .is_null_ptr => self.airIsNull(inst, .i32_ne),
+            .is_non_null_ptr => self.airIsNull(inst, .i32_eq),
+
             .load => self.airLoad(inst),
             .loop => self.airLoop(inst),
             .not => self.airNot(inst),
@@ -840,8 +864,13 @@ pub const Context = struct {
             .struct_field_ptr => self.airStructFieldPtr(inst),
             .switch_br => self.airSwitchBr(inst),
             .unreach => self.airUnreachable(inst),
+            .wrap_optional => self.airWrapOptional(inst),
+
             .unwrap_errunion_payload => self.airUnwrapErrUnionPayload(inst),
             .wrap_errunion_payload => self.airWrapErrUnionPayload(inst),
+
+            .optional_payload => self.airOptionalPayload(inst),
+            .optional_payload_ptr => self.airOptionalPayload(inst),
             else => |tag| self.fail("TODO: Implement wasm inst: {s}", .{@tagName(tag)}),
         };
     }
@@ -926,6 +955,22 @@ pub const Context = struct {
                         try leb.writeULEB128(writer, multi_value.index + i - 1);
                     }
                 },
+                .local => {
+                    // This can occur when we wrap a single value into a multi-value,
+                    // such as wrapping a non-optional value into an optional.
+                    // This means we must zero the null-tag, and set the payload.
+                    assert(multi_value.count == 2);
+                    // set null-tag
+                    try writer.writeByte(wasm.opcode(.i32_const));
+                    try leb.writeULEB128(writer, @as(u32, 0));
+                    try writer.writeByte(wasm.opcode(.local_set));
+                    try leb.writeULEB128(writer, multi_value.index);
+
+                    // set payload
+                    try self.emitWValue(rhs);
+                    try writer.writeByte(wasm.opcode(.local_set));
+                    try leb.writeULEB128(writer, multi_value.index + 1);
+                },
                 else => unreachable,
             },
             .local => |local| {
@@ -1088,6 +1133,31 @@ pub const Context = struct {
                     try self.emitConstant(data, payload_type);
                 }
             },
+            .Optional => {
+                var buf: Type.Payload.ElemType = undefined;
+                const payload_type = ty.optionalChild(&buf);
+                if (ty.isPtrLikeOptional()) {
+                    return self.fail("Wasm TODO: emitConstant for optional pointer", .{});
+                }
+
+                // When constant has value 'null', set is_null local to '1'
+                // and payload to '0'
+                if (val.tag() == .null_value) {
+                    try writer.writeByte(wasm.opcode(.i32_const));
+                    try leb.writeILEB128(writer, @as(i32, 1));
+
+                    const opcode: wasm.Opcode = buildOpcode(.{
+                        .op = .@"const",
+                        .valtype1 = try self.typeToValtype(payload_type),
+                    });
+                    try writer.writeByte(wasm.opcode(opcode));
+                    try leb.writeULEB128(writer, @as(u32, 0));
+                } else {
+                    try writer.writeByte(wasm.opcode(.i32_const));
+                    try leb.writeILEB128(writer, @as(i32, 0));
+                    try self.emitConstant(val, payload_type);
+                }
+            },
             else => |zig_type| return self.fail("Wasm TODO: emitConstant for zigTypeTag {s}", .{zig_type}),
         }
     }
@@ -1188,7 +1258,6 @@ pub const Context = struct {
         const then_body = self.air.extra[extra.end..][0..extra.data.then_body_len];
         const else_body = self.air.extra[extra.end + then_body.len ..][0..extra.data.else_body_len];
         const writer = self.code.writer();
-
         // TODO: Handle death instructions for then and else body
 
         // insert blocks at the position of `offset` so
@@ -1521,4 +1590,37 @@ pub const Context = struct {
         // other cases are no-op
         return .none;
     }
+
+    fn airIsNull(self: *Context, inst: Air.Inst.Index, opcode: wasm.Opcode) InnerError!WValue {
+        const un_op = self.air.instructions.items(.data)[inst].un_op;
+        const operand = self.resolveInst(un_op);
+        // const offset = self.code.items.len;
+        const writer = self.code.writer();
+
+        // load the null value which is positioned at multi_value's index
+        try self.emitWValue(.{ .local = operand.multi_value.index });
+        // Compare the null value with '0'
+        try writer.writeByte(wasm.opcode(.i32_const));
+        try leb.writeILEB128(writer, @as(i32, 0));
+
+        try writer.writeByte(@enumToInt(opcode));
+
+        // we save the result in a new local
+        const local = try self.allocLocal(Type.initTag(.i32));
+        try writer.writeByte(wasm.opcode(.local_set));
+        try leb.writeULEB128(writer, local.local);
+
+        return local;
+    }
+
+    fn airOptionalPayload(self: *Context, inst: Air.Inst.Index) InnerError!WValue {
+        const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+        const operand = self.resolveInst(ty_op.operand);
+        return WValue{ .local = operand.multi_value.index + 1 };
+    }
+
+    fn airWrapOptional(self: *Context, inst: Air.Inst.Index) InnerError!WValue {
+        const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+        return self.resolveInst(ty_op.operand);
+    }
 };

From a861b7d160737acb60913d2ff7ed316f19af9066 Mon Sep 17 00:00:00 2001
From: Luuk de Gram <luuk@degram.dev>
Date: Sat, 31 Jul 2021 16:39:48 +0200
Subject: [PATCH 52/96] wasm: Test cases for optionals

---
 test/stage2/wasm.zig | 54 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 54 insertions(+)

diff --git a/test/stage2/wasm.zig b/test/stage2/wasm.zig
index b0099c392c..a9f7984893 100644
--- a/test/stage2/wasm.zig
+++ b/test/stage2/wasm.zig
@@ -644,4 +644,58 @@ pub fn addCases(ctx: *TestContext) !void {
             \\}
         , "5\n");
     }
+
+    {
+        var case = ctx.exe("wasm optionals", wasi);
+
+        case.addCompareOutput(
+            \\pub export fn _start() u32 {
+            \\    var x: ?u32 = 5;
+            \\    var y: u32 = 0;
+            \\    if (x) |val| {
+            \\        y = val;
+            \\    }
+            \\    return y;
+            \\}
+        , "5\n");
+
+        case.addCompareOutput(
+            \\pub export fn _start() u32 {
+            \\    var x: ?u32 = null;
+            \\    var y: u32 = 0;
+            \\    if (x) |val| {
+            \\        y = val;
+            \\    }
+            \\    return y;
+            \\}
+        , "0\n");
+
+        case.addCompareOutput(
+            \\pub export fn _start() u32 {
+            \\    var x: ?u32 = 5;
+            \\    return x.?;
+            \\}
+        , "5\n");
+
+        case.addCompareOutput(
+            \\pub export fn _start() u32 {
+            \\    var x: u32 = 5;
+            \\    var y: ?u32 = x;
+            \\    return y.?;
+            \\}
+        , "5\n");
+
+        case.addCompareOutput(
+            \\pub export fn _start() u32 {
+            \\    var val: ?u32 = 5;
+            \\    while (val) |*v| {
+            \\        v.* -= 1;
+            \\        if (v.* == 2) {
+            \\            val = null;
+            \\        }
+            \\    }
+            \\    return 0;
+            \\}
+        , "0\n");
+    }
 }

From 32069d23301f624a7cdd4f1763c2de24f7a234ab Mon Sep 17 00:00:00 2001
From: Meghan <hello@nektro.net>
Date: Sun, 1 Aug 2021 02:42:05 -0700
Subject: [PATCH 53/96] langref- fix use after block error code

---
 doc/langref.html.in | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/doc/langref.html.in b/doc/langref.html.in
index 4efa7d0e3c..ce07d6494a 100644
--- a/doc/langref.html.in
+++ b/doc/langref.html.in
@@ -3422,10 +3422,11 @@ test "call foo" {
       <p>
       Blocks are used to limit the scope of variable declarations:
       </p>
-      {#code_begin|test_err|unused local variable#}
+      {#code_begin|test_err|use of undeclared identifier 'x'#}
 test "access variable after block scope" {
     {
         var x: i32 = 1;
+        _ = x;
     }
     x += 1;
 }

From 7e52a096dbace546cae89ab691741ecca45f28ce Mon Sep 17 00:00:00 2001
From: Meghan <hello@nektro.net>
Date: Sun, 1 Aug 2021 02:42:48 -0700
Subject: [PATCH 54/96] langref- fix packed struct error code

---
 doc/langref.html.in | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/doc/langref.html.in b/doc/langref.html.in
index ce07d6494a..386fe9f41a 100644
--- a/doc/langref.html.in
+++ b/doc/langref.html.in
@@ -2846,7 +2846,7 @@ test "pointer to non-bit-aligned field" {
       Zig should correctly understand the alignment of fields. However there is
       <a href="https://github.com/ziglang/zig/issues/1994">a bug</a>:
       </p>
-      {#code_begin|test_err#}
+      {#code_begin|test_err|expected type '*u32', found '*align(1) u32'#}
 const S = packed struct {
     a: u32,
     b: u32,
@@ -2855,6 +2855,7 @@ test "overaligned pointer to packed struct" {
     var foo: S align(4) = undefined;
     const ptr: *align(4) S = &foo;
     const ptr_to_b: *u32 = &ptr.b;
+    _ = ptr_to_b;
 }
       {#code_end#}
       <p>When this bug is fixed, the above test in the documentation will unexpectedly pass, which will

From d794f4cd2a1e62334ba6b413864bc33bae6d41ef Mon Sep 17 00:00:00 2001
From: Jakub Konka <kubkon@jakubkonka.com>
Date: Sun, 1 Aug 2021 18:05:07 +0200
Subject: [PATCH 55/96] macho: add runaway section id when sorting sections

---
 src/link/MachO.zig | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/link/MachO.zig b/src/link/MachO.zig
index 9f9a0d5157..61b2ff888c 100644
--- a/src/link/MachO.zig
+++ b/src/link/MachO.zig
@@ -1471,6 +1471,7 @@ fn sortSections(self: *MachO) !void {
             &self.cstring_section_index,
             &self.ustring_section_index,
             &self.text_const_section_index,
+            &self.objc_methlist_section_index,
             &self.objc_methname_section_index,
             &self.objc_methtype_section_index,
             &self.objc_classname_section_index,

From 6e139d124be92cfddef01adaa166ce09691cd5cc Mon Sep 17 00:00:00 2001
From: Luuk de Gram <luuk@degram.dev>
Date: Sun, 1 Aug 2021 11:05:15 +0200
Subject: [PATCH 56/96] wasm: Resolve feedback (wrapping arbitrary int sizes)

- This ensures we honor the user's integer size when performing wrapping operations.
- Also, instead of using ensureCapacity, we now use ensureUnusedCapacity.
---
 src/codegen/wasm.zig | 68 ++++++++++++++++++++++++++++++++++++++++----
 test/stage2/wasm.zig | 42 +++++++++++++++++++++++++++
 2 files changed, 104 insertions(+), 6 deletions(-)

diff --git a/src/codegen/wasm.zig b/src/codegen/wasm.zig
index 5178c43c00..e21645d1ee 100644
--- a/src/codegen/wasm.zig
+++ b/src/codegen/wasm.zig
@@ -634,7 +634,7 @@ pub const Context = struct {
                 // for each struct field, generate a local
                 const struct_data: *Module.Struct = ty.castTag(.@"struct").?.data;
                 const fields_len = @intCast(u32, struct_data.fields.count());
-                try self.locals.ensureCapacity(self.gpa, self.locals.items.len + fields_len);
+                try self.locals.ensureUnusedCapacity(self.gpa, fields_len);
                 for (struct_data.fields.values()) |*value| {
                     const val_type = try self.genValtype(value.ty);
                     self.locals.appendAssumeCapacity(val_type);
@@ -653,7 +653,7 @@ pub const Context = struct {
                 // The first local is also used to find the index of the error and payload.
                 //
                 // TODO: Add support where the payload is a type that contains multiple locals such as a struct.
-                try self.locals.ensureCapacity(self.gpa, self.locals.items.len + 2);
+                try self.locals.ensureUnusedCapacity(self.gpa, 2);
                 self.locals.appendAssumeCapacity(wasm.valtype(.i32)); // error values are always i32
                 self.locals.appendAssumeCapacity(val_type);
                 self.local_index += 2;
@@ -670,7 +670,7 @@ pub const Context = struct {
                     return self.fail("TODO: wasm optional pointer", .{});
                 }
 
-                try self.locals.ensureCapacity(self.gpa, self.locals.items.len + 2);
+                try self.locals.ensureUnusedCapacity(self.gpa, 2);
                 self.locals.appendAssumeCapacity(wasm.valtype(.i32)); // optional 'tag' for null-checking is always i32
                 self.locals.appendAssumeCapacity(try self.genValtype(child_type));
                 self.local_index += 2;
@@ -817,11 +817,11 @@ pub const Context = struct {
         const air_tags = self.air.instructions.items(.tag);
         return switch (air_tags[inst]) {
             .add => self.airBinOp(inst, .add),
-            .addwrap => self.airBinOp(inst, .add),
+            .addwrap => self.airWrapBinOp(inst, .add),
             .sub => self.airBinOp(inst, .sub),
-            .subwrap => self.airBinOp(inst, .sub),
+            .subwrap => self.airWrapBinOp(inst, .sub),
             .mul => self.airBinOp(inst, .mul),
-            .mulwrap => self.airBinOp(inst, .mul),
+            .mulwrap => self.airWrapBinOp(inst, .mul),
             .div => self.airBinOp(inst, .div),
             .bit_and => self.airBinOp(inst, .@"and"),
             .bit_or => self.airBinOp(inst, .@"or"),
@@ -1021,6 +1021,62 @@ pub const Context = struct {
         return WValue{ .code_offset = offset };
     }
 
+    fn airWrapBinOp(self: *Context, inst: Air.Inst.Index, op: Op) InnerError!WValue {
+        const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+        const lhs = self.resolveInst(bin_op.lhs);
+        const rhs = self.resolveInst(bin_op.rhs);
+
+        // it's possible for both lhs and/or rhs to return an offset as well,
+        // in which case we return the first offset occurance we find.
+        const offset = blk: {
+            if (lhs == .code_offset) break :blk lhs.code_offset;
+            if (rhs == .code_offset) break :blk rhs.code_offset;
+            break :blk self.code.items.len;
+        };
+
+        try self.emitWValue(lhs);
+        try self.emitWValue(rhs);
+
+        const bin_ty = self.air.typeOf(bin_op.lhs);
+        const opcode: wasm.Opcode = buildOpcode(.{
+            .op = op,
+            .valtype1 = try self.typeToValtype(bin_ty),
+            .signedness = if (bin_ty.isSignedInt()) .signed else .unsigned,
+        });
+        try self.code.append(wasm.opcode(opcode));
+
+        const int_info = bin_ty.intInfo(self.target);
+        const bitsize = int_info.bits;
+        const is_signed = int_info.signedness == .signed;
+        // if target type bitsize is x < 32 and 32 > x < 64, we perform
+        // result & ((1<<N)-1) where N = bitsize or bitsize -1 incase of signed.
+        if (bitsize != 32 and bitsize < 64) {
+            // first check if we can use a single instruction,
+            // wasm provides those if the integers are signed and 8/16-bit.
+            // For arbitrary integer sizes, we use the algorithm mentioned above.
+            if (is_signed and bitsize == 8) {
+                try self.code.append(wasm.opcode(.i32_extend8_s));
+            } else if (is_signed and bitsize == 16) {
+                try self.code.append(wasm.opcode(.i32_extend16_s));
+            } else {
+                const result = (@as(u64, 1) << @intCast(u6, bitsize - @boolToInt(is_signed))) - 1;
+                if (bitsize < 32) {
+                    try self.code.append(wasm.opcode(.i32_const));
+                    try leb.writeILEB128(self.code.writer(), @bitCast(i32, @intCast(u32, result)));
+                    try self.code.append(wasm.opcode(.i32_and));
+                } else {
+                    try self.code.append(wasm.opcode(.i64_const));
+                    try leb.writeILEB128(self.code.writer(), @bitCast(i64, result));
+                    try self.code.append(wasm.opcode(.i64_and));
+                }
+            }
+        } else if (int_info.bits > 64) {
+            return self.fail("TODO wasm: Integer wrapping for bitsizes larger than 64", .{});
+        }
+
+        return WValue{ .code_offset = offset };
+    }
+
     fn emitConstant(self: *Context, val: Value, ty: Type) InnerError!void {
         const writer = self.code.writer();
         switch (ty.zigTypeTag()) {
diff --git a/test/stage2/wasm.zig b/test/stage2/wasm.zig
index a9f7984893..ab400f0a53 100644
--- a/test/stage2/wasm.zig
+++ b/test/stage2/wasm.zig
@@ -120,6 +120,20 @@ pub fn addCases(ctx: *TestContext) !void {
             \\}
         , "-2147483648\n");
 
+        case.addCompareOutput(
+            \\pub export fn _start() i32 {
+            \\    var i: i4 = 7;
+            \\    return i +% 1;
+            \\}
+        , "0\n");
+
+        case.addCompareOutput(
+            \\pub export fn _start() u32 {
+            \\    var i: u8 = 255;
+            \\    return i +% 1;
+            \\}
+        , "0\n");
+
         case.addCompareOutput(
             \\pub export fn _start() u32 {
             \\    var i: u32 = 5;
@@ -147,6 +161,20 @@ pub fn addCases(ctx: *TestContext) !void {
             \\}
         , "2147483647\n");
 
+        case.addCompareOutput(
+            \\pub export fn _start() i32 {
+            \\    var i: i7 = -64;
+            \\    return i -% 1;
+            \\}
+        , "63\n");
+
+        case.addCompareOutput(
+            \\pub export fn _start() u32 {
+            \\    var i: u4 = 0;
+            \\    return i -% 1;
+            \\}
+        , "15\n");
+
         case.addCompareOutput(
             \\pub export fn _start() u32 {
             \\    var i: u32 = 5;
@@ -178,6 +206,20 @@ pub fn addCases(ctx: *TestContext) !void {
             \\}
         , "-2\n");
 
+        case.addCompareOutput(
+            \\pub export fn _start() u32 {
+            \\    var i: u3 = 3;
+            \\    return i *% 3;
+            \\}
+        , "1\n");
+
+        case.addCompareOutput(
+            \\pub export fn _start() i32 {
+            \\    var i: i4 = 3;
+            \\    return i *% 3;
+            \\}
+        , "1\n");
+
         case.addCompareOutput(
             \\pub export fn _start() u32 {
             \\    var i: u32 = 352;

From 6ae0825e7f87fc9b73a4b968964196b0e164f062 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Sun, 1 Aug 2021 12:27:22 -0700
Subject: [PATCH 57/96] Sema: implement comptime variables

Sema now properly handles alloc_inferred and alloc_inferred_mut ZIR
instructions inside a comptime execution context. In this case it
creates Decl objects and points to them with the new `decl_ref_mut`
Value Tag. `storePtr` is updated to mutate such Decl types and values.
In this case it destroys the old arena and makes a new one, preventing
memory growth during comptime code execution.

Additionally:

 * Fix `storePtr` to emit a compile error for a pointer comptime-known
   to be undefined.
 * Fix `storePtr` to emit runtime instructions for all the cases that a
   pointer is comptime-known but does not support comptime
   dereferencing, such as `@intToPtr` on a hard-coded address, or an
   extern function.
 * Fix `ret_coerce` not coercing inside inline function call context.
---
 src/Sema.zig            | 225 +++++++++++++++++++++++++---------------
 src/value.zig           |  45 +++++---
 test/behavior.zig       |   1 +
 test/behavior/basic.zig |   9 ++
 test/behavior/bool.zig  |  44 ++++++++
 test/behavior/misc.zig  |  64 ------------
 6 files changed, 226 insertions(+), 162 deletions(-)
 create mode 100644 test/behavior/basic.zig

diff --git a/src/Sema.zig b/src/Sema.zig
index 4fa59c4744..5ad590be6a 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -154,9 +154,6 @@ pub fn analyzeBody(
     // We use a while(true) loop here to avoid a redundant way of breaking out of
     // the loop. The only way to break out of the loop is with a `noreturn`
     // instruction.
-    // TODO: As an optimization, make sure the codegen for these switch prongs
-    // directly jump to the next one, rather than detouring through the loop
-    // continue expression. Related: https://github.com/ziglang/zig/issues/8220
     var i: usize = 0;
     while (true) {
         const inst = body[i];
@@ -391,7 +388,7 @@ pub fn analyzeBody(
             .condbr         => return sema.zirCondbr(block, inst),
             .@"break"       => return sema.zirBreak(block, inst),
             .compile_error  => return sema.zirCompileError(block, inst),
-            .ret_coerce     => return sema.zirRetCoerce(block, inst, true),
+            .ret_coerce     => return sema.zirRetCoerce(block, inst),
             .ret_node       => return sema.zirRetNode(block, inst),
             .ret_err_value  => return sema.zirRetErrValue(block, inst),
             .@"unreachable" => return sema.zirUnreachable(block, inst),
@@ -1396,14 +1393,19 @@ fn zirAllocComptime(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) Comp
     const var_type = try sema.resolveType(block, ty_src, inst_data.operand);
     const ptr_type = try Module.simplePtrType(sema.arena, var_type, true, .One);
 
-    const val_payload = try sema.arena.create(Value.Payload.ComptimeAlloc);
-    val_payload.* = .{
-        .data = .{
-            .runtime_index = block.runtime_index,
-            .val = undefined, // astgen guarantees there will be a store before the first load
-        },
-    };
-    return sema.addConstant(ptr_type, Value.initPayload(&val_payload.base));
+    var anon_decl = try block.startAnonDecl();
+    defer anon_decl.deinit();
+    const decl = try anon_decl.finish(
+        try var_type.copy(anon_decl.arena()),
+        // AstGen guarantees there will be a store before the first load, so we put a value
+        // here indicating there is no valid value.
+        Value.initTag(.unreachable_value),
+    );
+    try sema.mod.declareDeclDependency(sema.owner_decl, decl);
+    return sema.addConstant(ptr_type, try Value.Tag.decl_ref_mut.create(sema.arena, .{
+        .runtime_index = block.runtime_index,
+        .decl = decl,
+    }));
 }
 
 fn zirAllocInferredComptime(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
@@ -1450,16 +1452,23 @@ fn zirAllocInferred(
 
     const src_node = sema.code.instructions.items(.data)[inst].node;
     const src: LazySrcLoc = .{ .node_offset = src_node };
+    sema.src = src;
 
-    const val_payload = try sema.arena.create(Value.Payload.InferredAlloc);
-    val_payload.* = .{
-        .data = .{},
-    };
-    // `Module.constInst` does not add the instruction to the block because it is
+    if (block.is_comptime) {
+        return sema.addConstant(
+            inferred_alloc_ty,
+            try Value.Tag.inferred_alloc_comptime.create(sema.arena, undefined),
+        );
+    }
+
+    // `Sema.addConstant` does not add the instruction to the block because it is
     // not needed in the case of constant values. However here, we plan to "downgrade"
     // to a normal instruction when we hit `resolve_inferred_alloc`. So we append
     // to the block even though it is currently a `.constant`.
-    const result = try sema.addConstant(inferred_alloc_ty, Value.initPayload(&val_payload.base));
+    const result = try sema.addConstant(
+        inferred_alloc_ty,
+        try Value.Tag.inferred_alloc.create(sema.arena, .{}),
+    );
     try sema.requireFunctionBlock(block, src);
     try block.instructions.append(sema.gpa, Air.refToIndex(result).?);
     return result;
@@ -1475,25 +1484,47 @@ fn zirResolveInferredAlloc(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Inde
     const ptr_inst = Air.refToIndex(ptr).?;
     assert(sema.air_instructions.items(.tag)[ptr_inst] == .constant);
     const air_datas = sema.air_instructions.items(.data);
-    const ptr_val = sema.air_values.items[air_datas[ptr_inst].ty_pl.payload];
-    const inferred_alloc = ptr_val.castTag(.inferred_alloc).?;
-    const peer_inst_list = inferred_alloc.data.stored_inst_list.items;
-    const final_elem_ty = try sema.resolvePeerTypes(block, ty_src, peer_inst_list);
+    const value_index = air_datas[ptr_inst].ty_pl.payload;
+    const ptr_val = sema.air_values.items[value_index];
     const var_is_mut = switch (sema.typeOf(ptr).tag()) {
         .inferred_alloc_const => false,
         .inferred_alloc_mut => true,
         else => unreachable,
     };
-    if (var_is_mut) {
-        try sema.validateVarType(block, ty_src, final_elem_ty);
-    }
-    const final_ptr_ty = try Module.simplePtrType(sema.arena, final_elem_ty, true, .One);
 
-    // Change it to a normal alloc.
-    sema.air_instructions.set(ptr_inst, .{
-        .tag = .alloc,
-        .data = .{ .ty = final_ptr_ty },
-    });
+    if (ptr_val.castTag(.inferred_alloc_comptime)) |iac| {
+        const decl = iac.data;
+        try sema.mod.declareDeclDependency(sema.owner_decl, decl);
+
+        const final_elem_ty = try decl.ty.copy(sema.arena);
+        const final_ptr_ty = try Module.simplePtrType(sema.arena, final_elem_ty, true, .One);
+        air_datas[ptr_inst].ty_pl.ty = try sema.addType(final_ptr_ty);
+
+        if (var_is_mut) {
+            sema.air_values.items[value_index] = try Value.Tag.decl_ref_mut.create(sema.arena, .{
+                .decl = decl,
+                .runtime_index = block.runtime_index,
+            });
+        } else {
+            sema.air_values.items[value_index] = try Value.Tag.decl_ref.create(sema.arena, decl);
+        }
+        return;
+    }
+
+    if (ptr_val.castTag(.inferred_alloc)) |inferred_alloc| {
+        const peer_inst_list = inferred_alloc.data.stored_inst_list.items;
+        const final_elem_ty = try sema.resolvePeerTypes(block, ty_src, peer_inst_list);
+        if (var_is_mut) {
+            try sema.validateVarType(block, ty_src, final_elem_ty);
+        }
+        // Change it to a normal alloc.
+        const final_ptr_ty = try Module.simplePtrType(sema.arena, final_elem_ty, true, .One);
+        sema.air_instructions.set(ptr_inst, .{
+            .tag = .alloc,
+            .data = .{ .ty = final_ptr_ty },
+        });
+        return;
+    }
 }
 
 fn zirValidateStructInitPtr(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) CompileError!void {
@@ -1654,23 +1685,45 @@ fn zirStoreToInferredPtr(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index)
     const tracy = trace(@src());
     defer tracy.end();
 
-    const src: LazySrcLoc = .unneeded;
+    const src: LazySrcLoc = sema.src;
     const bin_inst = sema.code.instructions.items(.data)[inst].bin;
     const ptr = sema.resolveInst(bin_inst.lhs);
-    const value = sema.resolveInst(bin_inst.rhs);
+    const operand = sema.resolveInst(bin_inst.rhs);
+    const operand_ty = sema.typeOf(operand);
     const ptr_inst = Air.refToIndex(ptr).?;
     assert(sema.air_instructions.items(.tag)[ptr_inst] == .constant);
     const air_datas = sema.air_instructions.items(.data);
     const ptr_val = sema.air_values.items[air_datas[ptr_inst].ty_pl.payload];
-    const inferred_alloc = ptr_val.castTag(.inferred_alloc).?;
-    // Add the stored instruction to the set we will use to resolve peer types
-    // for the inferred allocation.
-    try inferred_alloc.data.stored_inst_list.append(sema.arena, value);
-    // Create a runtime bitcast instruction with exactly the type the pointer wants.
-    const ptr_ty = try Module.simplePtrType(sema.arena, sema.typeOf(value), true, .One);
-    try sema.requireRuntimeBlock(block, src);
-    const bitcasted_ptr = try block.addTyOp(.bitcast, ptr_ty, ptr);
-    return sema.storePtr(block, src, bitcasted_ptr, value);
+
+    if (ptr_val.castTag(.inferred_alloc_comptime)) |iac| {
+        // There will be only one store_to_inferred_ptr because we are running at comptime.
+        // The alloc will turn into a Decl.
+        if (try sema.resolveMaybeUndefValAllowVariables(block, src, operand)) |operand_val| {
+            if (operand_val.tag() == .variable) {
+                return sema.failWithNeededComptime(block, src);
+            }
+            var anon_decl = try block.startAnonDecl();
+            defer anon_decl.deinit();
+            iac.data = try anon_decl.finish(
+                try operand_ty.copy(anon_decl.arena()),
+                try operand_val.copy(anon_decl.arena()),
+            );
+            return;
+        } else {
+            return sema.failWithNeededComptime(block, src);
+        }
+    }
+
+    if (ptr_val.castTag(.inferred_alloc)) |inferred_alloc| {
+        // Add the stored instruction to the set we will use to resolve peer types
+        // for the inferred allocation.
+        try inferred_alloc.data.stored_inst_list.append(sema.arena, operand);
+        // Create a runtime bitcast instruction with exactly the type the pointer wants.
+        const ptr_ty = try Module.simplePtrType(sema.arena, operand_ty, true, .One);
+        const bitcasted_ptr = try block.addTyOp(.bitcast, ptr_ty, ptr);
+        return sema.storePtr(block, src, bitcasted_ptr, operand);
+    }
+    unreachable;
 }
 
 fn zirSetEvalBranchQuota(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) CompileError!void {
@@ -5643,7 +5696,6 @@ fn zirRetCoerce(
     sema: *Sema,
     block: *Scope.Block,
     inst: Zir.Inst.Index,
-    need_coercion: bool,
 ) CompileError!Zir.Inst.Index {
     const tracy = trace(@src());
     defer tracy.end();
@@ -5652,7 +5704,7 @@ fn zirRetCoerce(
     const operand = sema.resolveInst(inst_data.operand);
     const src = inst_data.src();
 
-    return sema.analyzeRet(block, operand, src, need_coercion);
+    return sema.analyzeRet(block, operand, src, true);
 }
 
 fn zirRetNode(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) CompileError!Zir.Inst.Index {
@@ -5673,23 +5725,20 @@ fn analyzeRet(
     src: LazySrcLoc,
     need_coercion: bool,
 ) CompileError!Zir.Inst.Index {
+    const casted_operand = if (!need_coercion) operand else op: {
+        const func = sema.func.?;
+        const fn_ty = func.owner_decl.ty;
+        const fn_ret_ty = fn_ty.fnReturnType();
+        break :op try sema.coerce(block, fn_ret_ty, operand, src);
+    };
     if (block.inlining) |inlining| {
         // We are inlining a function call; rewrite the `ret` as a `break`.
-        try inlining.merges.results.append(sema.gpa, operand);
-        _ = try block.addBr(inlining.merges.block_inst, operand);
+        try inlining.merges.results.append(sema.gpa, casted_operand);
+        _ = try block.addBr(inlining.merges.block_inst, casted_operand);
         return always_noreturn;
     }
 
-    if (need_coercion) {
-        if (sema.func) |func| {
-            const fn_ty = func.owner_decl.ty;
-            const fn_ret_ty = fn_ty.fnReturnType();
-            const casted_operand = try sema.coerce(block, fn_ret_ty, operand, src);
-            _ = try block.addUnOp(.ret, casted_operand);
-            return always_noreturn;
-        }
-    }
-    _ = try block.addUnOp(.ret, operand);
+    _ = try block.addUnOp(.ret, casted_operand);
     return always_noreturn;
 }
 
@@ -7603,37 +7652,45 @@ fn storePtr(
     if ((try sema.typeHasOnePossibleValue(block, src, elem_ty)) != null)
         return;
 
-    if (try sema.resolveMaybeUndefVal(block, src, ptr)) |ptr_val| blk: {
-        const const_val = (try sema.resolveMaybeUndefVal(block, src, value)) orelse
-            return sema.mod.fail(&block.base, src, "cannot store runtime value in compile time variable", .{});
+    if (try sema.resolveDefinedValue(block, src, ptr)) |ptr_val| {
+        if (ptr_val.castTag(.decl_ref_mut)) |decl_ref_mut| {
+            const const_val = (try sema.resolveMaybeUndefVal(block, src, value)) orelse
+                return sema.mod.fail(&block.base, src, "cannot store runtime value in compile time variable", .{});
 
-        if (ptr_val.tag() == .int_u64)
-            break :blk; // propogate it down to runtime
-
-        const comptime_alloc = ptr_val.castTag(.comptime_alloc).?;
-        if (comptime_alloc.data.runtime_index < block.runtime_index) {
-            if (block.runtime_cond) |cond_src| {
-                const msg = msg: {
-                    const msg = try sema.mod.errMsg(&block.base, src, "store to comptime variable depends on runtime condition", .{});
-                    errdefer msg.destroy(sema.gpa);
-                    try sema.mod.errNote(&block.base, cond_src, msg, "runtime condition here", .{});
-                    break :msg msg;
-                };
-                return sema.mod.failWithOwnedErrorMsg(&block.base, msg);
+            if (decl_ref_mut.data.runtime_index < block.runtime_index) {
+                if (block.runtime_cond) |cond_src| {
+                    const msg = msg: {
+                        const msg = try sema.mod.errMsg(&block.base, src, "store to comptime variable depends on runtime condition", .{});
+                        errdefer msg.destroy(sema.gpa);
+                        try sema.mod.errNote(&block.base, cond_src, msg, "runtime condition here", .{});
+                        break :msg msg;
+                    };
+                    return sema.mod.failWithOwnedErrorMsg(&block.base, msg);
+                }
+                if (block.runtime_loop) |loop_src| {
+                    const msg = msg: {
+                        const msg = try sema.mod.errMsg(&block.base, src, "cannot store to comptime variable in non-inline loop", .{});
+                        errdefer msg.destroy(sema.gpa);
+                        try sema.mod.errNote(&block.base, loop_src, msg, "non-inline loop here", .{});
+                        break :msg msg;
+                    };
+                    return sema.mod.failWithOwnedErrorMsg(&block.base, msg);
+                }
+                unreachable;
             }
-            if (block.runtime_loop) |loop_src| {
-                const msg = msg: {
-                    const msg = try sema.mod.errMsg(&block.base, src, "cannot store to comptime variable in non-inline loop", .{});
-                    errdefer msg.destroy(sema.gpa);
-                    try sema.mod.errNote(&block.base, loop_src, msg, "non-inline loop here", .{});
-                    break :msg msg;
-                };
-                return sema.mod.failWithOwnedErrorMsg(&block.base, msg);
-            }
-            unreachable;
+            var new_arena = std.heap.ArenaAllocator.init(sema.gpa);
+            errdefer new_arena.deinit();
+            const new_ty = try elem_ty.copy(&new_arena.allocator);
+            const new_val = try const_val.copy(&new_arena.allocator);
+            const decl = decl_ref_mut.data.decl;
+            var old_arena = decl.value_arena.?.promote(sema.gpa);
+            decl.value_arena = null;
+            try decl.finalizeNewArena(&new_arena);
+            decl.ty = new_ty;
+            decl.val = new_val;
+            old_arena.deinit();
+            return;
         }
-        comptime_alloc.data.val = const_val;
-        return;
     }
     // TODO handle if the element type requires comptime
 
diff --git a/src/value.zig b/src/value.zig
index 93d6625e7c..a0a7c0650c 100644
--- a/src/value.zig
+++ b/src/value.zig
@@ -100,11 +100,13 @@ pub const Value = extern union {
         function,
         extern_fn,
         variable,
-        /// Represents a comptime variables storage.
-        comptime_alloc,
-        /// Represents a pointer to a decl, not the value of the decl.
+        /// Represents a pointer to a Decl.
         /// When machine codegen backend sees this, it must set the Decl's `alive` field to true.
         decl_ref,
+        /// Pointer to a Decl, but allows comptime code to mutate the Decl's Value.
+        /// This Tag will never be seen by machine codegen backends. It is changed into a
+        /// `decl_ref` when a comptime variable goes out of scope.
+        decl_ref_mut,
         elem_ptr,
         field_ptr,
         /// A slice of u8 whose memory is managed externally.
@@ -134,6 +136,9 @@ pub const Value = extern union {
         /// This is a special value that tracks a set of types that have been stored
         /// to an inferred allocation. It does not support any of the normal value queries.
         inferred_alloc,
+        /// Used to coordinate alloc_inferred, store_to_inferred_ptr, and resolve_inferred_alloc
+        /// instructions for comptime code.
+        inferred_alloc_comptime,
 
         pub const last_no_payload_tag = Tag.empty_array;
         pub const no_payload_count = @enumToInt(last_no_payload_tag) + 1;
@@ -213,6 +218,7 @@ pub const Value = extern union {
 
                 .extern_fn,
                 .decl_ref,
+                .inferred_alloc_comptime,
                 => Payload.Decl,
 
                 .repeated,
@@ -235,7 +241,7 @@ pub const Value = extern union {
                 .int_i64 => Payload.I64,
                 .function => Payload.Function,
                 .variable => Payload.Variable,
-                .comptime_alloc => Payload.ComptimeAlloc,
+                .decl_ref_mut => Payload.DeclRefMut,
                 .elem_ptr => Payload.ElemPtr,
                 .field_ptr => Payload.FieldPtr,
                 .float_16 => Payload.Float_16,
@@ -408,8 +414,8 @@ pub const Value = extern union {
             .function => return self.copyPayloadShallow(allocator, Payload.Function),
             .extern_fn => return self.copyPayloadShallow(allocator, Payload.Decl),
             .variable => return self.copyPayloadShallow(allocator, Payload.Variable),
-            .comptime_alloc => return self.copyPayloadShallow(allocator, Payload.ComptimeAlloc),
             .decl_ref => return self.copyPayloadShallow(allocator, Payload.Decl),
+            .decl_ref_mut => return self.copyPayloadShallow(allocator, Payload.DeclRefMut),
             .elem_ptr => {
                 const payload = self.castTag(.elem_ptr).?;
                 const new_payload = try allocator.create(Payload.ElemPtr);
@@ -485,6 +491,7 @@ pub const Value = extern union {
             .@"union" => @panic("TODO can't copy union value without knowing the type"),
 
             .inferred_alloc => unreachable,
+            .inferred_alloc_comptime => unreachable,
         }
     }
 
@@ -592,10 +599,9 @@ pub const Value = extern union {
             .function => return out_stream.print("(function '{s}')", .{val.castTag(.function).?.data.owner_decl.name}),
             .extern_fn => return out_stream.writeAll("(extern function)"),
             .variable => return out_stream.writeAll("(variable)"),
-            .comptime_alloc => {
-                const ref_val = val.castTag(.comptime_alloc).?.data.val;
-                try out_stream.writeAll("&");
-                val = ref_val;
+            .decl_ref_mut => {
+                const decl = val.castTag(.decl_ref_mut).?.data.decl;
+                return out_stream.print("(decl_ref_mut '{s}')", .{decl.name});
             },
             .decl_ref => return out_stream.writeAll("(decl ref)"),
             .elem_ptr => {
@@ -626,6 +632,7 @@ pub const Value = extern union {
             // TODO to print this it should be error{ Set, Items }!T(val), but we need the type for that
             .error_union => return out_stream.print("error_union_val({})", .{val.castTag(.error_union).?.data}),
             .inferred_alloc => return out_stream.writeAll("(inferred allocation value)"),
+            .inferred_alloc_comptime => return out_stream.writeAll("(inferred comptime allocation value)"),
             .eu_payload_ptr => {
                 try out_stream.writeAll("(eu_payload_ptr)");
                 val = val.castTag(.eu_payload_ptr).?.data;
@@ -741,8 +748,8 @@ pub const Value = extern union {
             .function,
             .extern_fn,
             .variable,
-            .comptime_alloc,
             .decl_ref,
+            .decl_ref_mut,
             .elem_ptr,
             .field_ptr,
             .bytes,
@@ -761,6 +768,7 @@ pub const Value = extern union {
             .@"struct",
             .@"union",
             .inferred_alloc,
+            .inferred_alloc_comptime,
             .abi_align_default,
             .eu_payload_ptr,
             => unreachable,
@@ -1234,7 +1242,13 @@ pub const Value = extern union {
         allocator: *Allocator,
     ) error{ AnalysisFail, OutOfMemory }!?Value {
         const sub_val: Value = switch (self.tag()) {
-            .comptime_alloc => self.castTag(.comptime_alloc).?.data.val,
+            .decl_ref_mut => val: {
+                // The decl whose value we are obtaining here may be overwritten with
+                // a different value, which would invalidate this memory. So we must
+                // copy here.
+                const val = try self.castTag(.decl_ref_mut).?.data.decl.value();
+                break :val try val.copy(allocator);
+            },
             .decl_ref => try self.castTag(.decl_ref).?.data.value(),
             .elem_ptr => blk: {
                 const elem_ptr = self.castTag(.elem_ptr).?.data;
@@ -1351,6 +1365,7 @@ pub const Value = extern union {
             .undef => unreachable,
             .unreachable_value => unreachable,
             .inferred_alloc => unreachable,
+            .inferred_alloc_comptime => unreachable,
             .null_value => true,
 
             else => false,
@@ -1371,6 +1386,7 @@ pub const Value = extern union {
             .undef => unreachable,
             .unreachable_value => unreachable,
             .inferred_alloc => unreachable,
+            .inferred_alloc_comptime => unreachable,
 
             else => null,
         };
@@ -1380,6 +1396,7 @@ pub const Value = extern union {
         return switch (self.tag()) {
             .undef => unreachable,
             .inferred_alloc => unreachable,
+            .inferred_alloc_comptime => unreachable,
 
             .float_16,
             .float_32,
@@ -1443,12 +1460,12 @@ pub const Value = extern union {
             data: Value,
         };
 
-        pub const ComptimeAlloc = struct {
-            pub const base_tag = Tag.comptime_alloc;
+        pub const DeclRefMut = struct {
+            pub const base_tag = Tag.decl_ref_mut;
 
             base: Payload = Payload{ .tag = base_tag },
             data: struct {
-                val: Value,
+                decl: *Module.Decl,
                 runtime_index: u32,
             },
         };
diff --git a/test/behavior.zig b/test/behavior.zig
index a286b1a6e2..4cc4d7fb8b 100644
--- a/test/behavior.zig
+++ b/test/behavior.zig
@@ -3,6 +3,7 @@ const builtin = @import("builtin");
 test {
     // Tests that pass for both.
     _ = @import("behavior/bool.zig");
+    _ = @import("behavior/basic.zig");
 
     if (!builtin.zig_is_stage2) {
         // Tests that only pass for stage1.
diff --git a/test/behavior/basic.zig b/test/behavior/basic.zig
new file mode 100644
index 0000000000..8f0f20cdf5
--- /dev/null
+++ b/test/behavior/basic.zig
@@ -0,0 +1,9 @@
+// normal comment
+
+/// this is a documentation comment
+/// doc comment line 2
+fn emptyFunctionWithComments() void {}
+
+test "empty function with comments" {
+    emptyFunctionWithComments();
+}
diff --git a/test/behavior/bool.zig b/test/behavior/bool.zig
index dfa02a6bfd..447f9e02e6 100644
--- a/test/behavior/bool.zig
+++ b/test/behavior/bool.zig
@@ -33,3 +33,47 @@ test "compile time bool not" {
     try expect(not_global_f);
     try expect(!not_global_t);
 }
+
+test "short circuit" {
+    try testShortCircuit(false, true);
+    comptime try testShortCircuit(false, true);
+}
+
+fn testShortCircuit(f: bool, t: bool) !void {
+    var hit_1 = f;
+    var hit_2 = f;
+    var hit_3 = f;
+    var hit_4 = f;
+
+    if (t or x: {
+        try expect(f);
+        break :x f;
+    }) {
+        hit_1 = t;
+    }
+    if (f or x: {
+        hit_2 = t;
+        break :x f;
+    }) {
+        try expect(f);
+    }
+
+    if (t and x: {
+        hit_3 = t;
+        break :x f;
+    }) {
+        try expect(f);
+    }
+    if (f and x: {
+        try expect(f);
+        break :x f;
+    }) {
+        try expect(f);
+    } else {
+        hit_4 = t;
+    }
+    try expect(hit_1);
+    try expect(hit_2);
+    try expect(hit_3);
+    try expect(hit_4);
+}
diff --git a/test/behavior/misc.zig b/test/behavior/misc.zig
index fdd3f3477b..ba38d6327c 100644
--- a/test/behavior/misc.zig
+++ b/test/behavior/misc.zig
@@ -5,70 +5,6 @@ const expectEqualStrings = std.testing.expectEqualStrings;
 const mem = std.mem;
 const builtin = @import("builtin");
 
-// normal comment
-
-/// this is a documentation comment
-/// doc comment line 2
-fn emptyFunctionWithComments() void {}
-
-test "empty function with comments" {
-    emptyFunctionWithComments();
-}
-
-comptime {
-    @export(disabledExternFn, .{ .name = "disabledExternFn", .linkage = .Internal });
-}
-
-fn disabledExternFn() callconv(.C) void {}
-
-test "call disabled extern fn" {
-    disabledExternFn();
-}
-
-test "short circuit" {
-    try testShortCircuit(false, true);
-    comptime try testShortCircuit(false, true);
-}
-
-fn testShortCircuit(f: bool, t: bool) !void {
-    var hit_1 = f;
-    var hit_2 = f;
-    var hit_3 = f;
-    var hit_4 = f;
-
-    if (t or x: {
-        try expect(f);
-        break :x f;
-    }) {
-        hit_1 = t;
-    }
-    if (f or x: {
-        hit_2 = t;
-        break :x f;
-    }) {
-        try expect(f);
-    }
-
-    if (t and x: {
-        hit_3 = t;
-        break :x f;
-    }) {
-        try expect(f);
-    }
-    if (f and x: {
-        try expect(f);
-        break :x f;
-    }) {
-        try expect(f);
-    } else {
-        hit_4 = t;
-    }
-    try expect(hit_1);
-    try expect(hit_2);
-    try expect(hit_3);
-    try expect(hit_4);
-}
-
 test "truncate" {
     try expect(testTruncate(0x10fd) == 0xfd);
 }

From 0ce54a141628b27ceab074dac4c19827a2188165 Mon Sep 17 00:00:00 2001
From: Jakub Konka <kubkon@jakubkonka.com>
Date: Sun, 1 Aug 2021 22:48:39 +0200
Subject: [PATCH 58/96] add standalone Objective-C enabled on macOS only

---
 test/standalone.zig            |  4 ++++
 test/standalone/objc/Foo.h     |  7 +++++++
 test/standalone/objc/Foo.m     | 11 +++++++++++
 test/standalone/objc/build.zig | 22 ++++++++++++++++++++++
 test/standalone/objc/test.m    | 12 ++++++++++++
 5 files changed, 56 insertions(+)
 create mode 100644 test/standalone/objc/Foo.h
 create mode 100644 test/standalone/objc/Foo.m
 create mode 100644 test/standalone/objc/build.zig
 create mode 100644 test/standalone/objc/test.m

diff --git a/test/standalone.zig b/test/standalone.zig
index a483097f4a..52fba31828 100644
--- a/test/standalone.zig
+++ b/test/standalone.zig
@@ -37,6 +37,10 @@ pub fn addCases(cases: *tests.StandaloneContext) void {
     if (std.Target.current.os.tag == .linux) {
         cases.addBuildFile("test/standalone/pie/build.zig", .{});
     }
+    // Try to build and run an Objective-C executable.
+    if (std.Target.current.os.tag == .macos) {
+        cases.addBuildFile("test/standalone/objc/build.zig", .{ .build_modes = true });
+    }
 
     // Ensure the development tools are buildable.
     cases.add("tools/gen_spirv_spec.zig");
diff --git a/test/standalone/objc/Foo.h b/test/standalone/objc/Foo.h
new file mode 100644
index 0000000000..05cb7df39b
--- /dev/null
+++ b/test/standalone/objc/Foo.h
@@ -0,0 +1,7 @@
+#import <Foundation/Foundation.h>
+
+@interface Foo : NSObject
+
+- (NSString *)name;
+
+@end
diff --git a/test/standalone/objc/Foo.m b/test/standalone/objc/Foo.m
new file mode 100644
index 0000000000..6fc9b1edf0
--- /dev/null
+++ b/test/standalone/objc/Foo.m
@@ -0,0 +1,11 @@
+#import "Foo.h"
+
+@implementation Foo
+
+- (NSString *)name
+{
+      NSString *str = [[NSString alloc] initWithFormat:@"Zig"];
+      return str;
+}
+
+@end
diff --git a/test/standalone/objc/build.zig b/test/standalone/objc/build.zig
new file mode 100644
index 0000000000..30becd398c
--- /dev/null
+++ b/test/standalone/objc/build.zig
@@ -0,0 +1,22 @@
+const std = @import("std");
+const Builder = std.build.Builder;
+
+pub fn build(b: *Builder) void {
+    const mode = b.standardReleaseOptions();
+    const target = b.standardTargetOptions(.{});
+
+    const test_step = b.step("test", "Test the program");
+
+    const exe = b.addExecutable("test", null);
+    b.default_step.dependOn(&exe.step);
+    exe.addIncludeDir(".");
+    exe.addCSourceFile("Foo.m", &[0][]const u8{});
+    exe.addCSourceFile("test.m", &[0][]const u8{});
+    exe.setBuildMode(mode);
+    exe.setTarget(target);
+    exe.linkLibC();
+    exe.linkFramework("Foundation");
+
+    const run_cmd = exe.run();
+    test_step.dependOn(&run_cmd.step);
+}
diff --git a/test/standalone/objc/test.m b/test/standalone/objc/test.m
new file mode 100644
index 0000000000..3c81316788
--- /dev/null
+++ b/test/standalone/objc/test.m
@@ -0,0 +1,12 @@
+#import "Foo.h"
+#import <assert.h>
+
+int main(int argc, char *argv[])
+{
+  @autoreleasepool {
+      Foo *foo = [[Foo alloc] init];
+      NSString *result = [foo name];
+      assert([result isEqualToString:@"Zig"]);
+      return 0;
+  }
+}

From ddf14323ea9b2c75ac5ed286525d27730a192b53 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Sun, 1 Aug 2021 16:13:58 -0700
Subject: [PATCH 59/96] stage2: implement `@truncate`

---
 src/Air.zig                   |  11 +-
 src/Liveness.zig              |   1 +
 src/Module.zig                | 238 ----------------------------------
 src/Sema.zig                  | 104 ++++++++++-----
 src/codegen.zig               |  14 ++
 src/codegen/c.zig             |  15 ++-
 src/codegen/llvm.zig          |  11 ++
 src/codegen/llvm/bindings.zig |   8 ++
 src/print_air.zig             |   1 +
 src/value.zig                 | 238 ++++++++++++++++++++++++++++++++++
 test/behavior/basic.zig       |  11 ++
 test/behavior/misc.zig        |   7 -
 12 files changed, 380 insertions(+), 279 deletions(-)

diff --git a/src/Air.zig b/src/Air.zig
index d202c079bc..d923bf0b02 100644
--- a/src/Air.zig
+++ b/src/Air.zig
@@ -206,10 +206,16 @@ pub const Inst = struct {
         /// Convert from one float type to another.
         /// Uses the `ty_op` field.
         floatcast,
-        /// TODO audit uses of this. We should have explicit instructions for integer
-        /// widening and truncating.
+        /// Returns an integer with a different type than the operand. The new type may have
+        /// fewer, the same, or more bits than the operand type. However, the instruction
+        /// guarantees that the same integer value fits in both types.
+        /// See `trunc` for integer truncation.
         /// Uses the `ty_op` field.
         intcast,
+        /// Truncate higher bits from an integer, resulting in an integer with the same
+        /// sign but an equal or smaller number of bits.
+        /// Uses the `ty_op` field.
+        trunc,
         /// ?T => T. If the value is null, undefined behavior.
         /// Uses the `ty_op` field.
         optional_payload,
@@ -452,6 +458,7 @@ pub fn typeOfIndex(air: Air, inst: Air.Inst.Index) Type {
         .load,
         .floatcast,
         .intcast,
+        .trunc,
         .optional_payload,
         .optional_payload_ptr,
         .wrap_optional,
diff --git a/src/Liveness.zig b/src/Liveness.zig
index 7ba062fa31..4e22febc5a 100644
--- a/src/Liveness.zig
+++ b/src/Liveness.zig
@@ -264,6 +264,7 @@ fn analyzeInst(
         .load,
         .floatcast,
         .intcast,
+        .trunc,
         .optional_payload,
         .optional_payload_ptr,
         .wrap_optional,
diff --git a/src/Module.zig b/src/Module.zig
index d87f20621c..84b721369d 100644
--- a/src/Module.zig
+++ b/src/Module.zig
@@ -4033,244 +4033,6 @@ pub fn failWithOwnedErrorMsg(mod: *Module, scope: *Scope, err_msg: *ErrorMsg) Co
     return error.AnalysisFail;
 }
 
-pub fn intAdd(allocator: *Allocator, lhs: Value, rhs: Value) !Value {
-    // TODO is this a performance issue? maybe we should try the operation without
-    // resorting to BigInt first.
-    var lhs_space: Value.BigIntSpace = undefined;
-    var rhs_space: Value.BigIntSpace = undefined;
-    const lhs_bigint = lhs.toBigInt(&lhs_space);
-    const rhs_bigint = rhs.toBigInt(&rhs_space);
-    const limbs = try allocator.alloc(
-        std.math.big.Limb,
-        std.math.max(lhs_bigint.limbs.len, rhs_bigint.limbs.len) + 1,
-    );
-    var result_bigint = BigIntMutable{ .limbs = limbs, .positive = undefined, .len = undefined };
-    result_bigint.add(lhs_bigint, rhs_bigint);
-    const result_limbs = result_bigint.limbs[0..result_bigint.len];
-
-    if (result_bigint.positive) {
-        return Value.Tag.int_big_positive.create(allocator, result_limbs);
-    } else {
-        return Value.Tag.int_big_negative.create(allocator, result_limbs);
-    }
-}
-
-pub fn intSub(allocator: *Allocator, lhs: Value, rhs: Value) !Value {
-    // TODO is this a performance issue? maybe we should try the operation without
-    // resorting to BigInt first.
-    var lhs_space: Value.BigIntSpace = undefined;
-    var rhs_space: Value.BigIntSpace = undefined;
-    const lhs_bigint = lhs.toBigInt(&lhs_space);
-    const rhs_bigint = rhs.toBigInt(&rhs_space);
-    const limbs = try allocator.alloc(
-        std.math.big.Limb,
-        std.math.max(lhs_bigint.limbs.len, rhs_bigint.limbs.len) + 1,
-    );
-    var result_bigint = BigIntMutable{ .limbs = limbs, .positive = undefined, .len = undefined };
-    result_bigint.sub(lhs_bigint, rhs_bigint);
-    const result_limbs = result_bigint.limbs[0..result_bigint.len];
-
-    if (result_bigint.positive) {
-        return Value.Tag.int_big_positive.create(allocator, result_limbs);
-    } else {
-        return Value.Tag.int_big_negative.create(allocator, result_limbs);
-    }
-}
-
-pub fn intDiv(allocator: *Allocator, lhs: Value, rhs: Value) !Value {
-    // TODO is this a performance issue? maybe we should try the operation without
-    // resorting to BigInt first.
-    var lhs_space: Value.BigIntSpace = undefined;
-    var rhs_space: Value.BigIntSpace = undefined;
-    const lhs_bigint = lhs.toBigInt(&lhs_space);
-    const rhs_bigint = rhs.toBigInt(&rhs_space);
-    const limbs_q = try allocator.alloc(
-        std.math.big.Limb,
-        lhs_bigint.limbs.len + rhs_bigint.limbs.len + 1,
-    );
-    const limbs_r = try allocator.alloc(
-        std.math.big.Limb,
-        lhs_bigint.limbs.len,
-    );
-    const limbs_buffer = try allocator.alloc(
-        std.math.big.Limb,
-        std.math.big.int.calcDivLimbsBufferLen(lhs_bigint.limbs.len, rhs_bigint.limbs.len),
-    );
-    var result_q = BigIntMutable{ .limbs = limbs_q, .positive = undefined, .len = undefined };
-    var result_r = BigIntMutable{ .limbs = limbs_r, .positive = undefined, .len = undefined };
-    result_q.divTrunc(&result_r, lhs_bigint, rhs_bigint, limbs_buffer, null);
-    const result_limbs = result_q.limbs[0..result_q.len];
-
-    if (result_q.positive) {
-        return Value.Tag.int_big_positive.create(allocator, result_limbs);
-    } else {
-        return Value.Tag.int_big_negative.create(allocator, result_limbs);
-    }
-}
-
-pub fn intMul(allocator: *Allocator, lhs: Value, rhs: Value) !Value {
-    // TODO is this a performance issue? maybe we should try the operation without
-    // resorting to BigInt first.
-    var lhs_space: Value.BigIntSpace = undefined;
-    var rhs_space: Value.BigIntSpace = undefined;
-    const lhs_bigint = lhs.toBigInt(&lhs_space);
-    const rhs_bigint = rhs.toBigInt(&rhs_space);
-    const limbs = try allocator.alloc(
-        std.math.big.Limb,
-        lhs_bigint.limbs.len + rhs_bigint.limbs.len + 1,
-    );
-    var result_bigint = BigIntMutable{ .limbs = limbs, .positive = undefined, .len = undefined };
-    var limbs_buffer = try allocator.alloc(
-        std.math.big.Limb,
-        std.math.big.int.calcMulLimbsBufferLen(lhs_bigint.limbs.len, rhs_bigint.limbs.len, 1),
-    );
-    defer allocator.free(limbs_buffer);
-    result_bigint.mul(lhs_bigint, rhs_bigint, limbs_buffer, allocator);
-    const result_limbs = result_bigint.limbs[0..result_bigint.len];
-
-    if (result_bigint.positive) {
-        return Value.Tag.int_big_positive.create(allocator, result_limbs);
-    } else {
-        return Value.Tag.int_big_negative.create(allocator, result_limbs);
-    }
-}
-
-pub fn floatAdd(
-    arena: *Allocator,
-    float_type: Type,
-    src: LazySrcLoc,
-    lhs: Value,
-    rhs: Value,
-) !Value {
-    _ = src;
-    switch (float_type.tag()) {
-        .f16 => {
-            @panic("TODO add __trunctfhf2 to compiler-rt");
-            //const lhs_val = lhs.toFloat(f16);
-            //const rhs_val = rhs.toFloat(f16);
-            //return Value.Tag.float_16.create(arena, lhs_val + rhs_val);
-        },
-        .f32 => {
-            const lhs_val = lhs.toFloat(f32);
-            const rhs_val = rhs.toFloat(f32);
-            return Value.Tag.float_32.create(arena, lhs_val + rhs_val);
-        },
-        .f64 => {
-            const lhs_val = lhs.toFloat(f64);
-            const rhs_val = rhs.toFloat(f64);
-            return Value.Tag.float_64.create(arena, lhs_val + rhs_val);
-        },
-        .f128, .comptime_float, .c_longdouble => {
-            const lhs_val = lhs.toFloat(f128);
-            const rhs_val = rhs.toFloat(f128);
-            return Value.Tag.float_128.create(arena, lhs_val + rhs_val);
-        },
-        else => unreachable,
-    }
-}
-
-pub fn floatSub(
-    arena: *Allocator,
-    float_type: Type,
-    src: LazySrcLoc,
-    lhs: Value,
-    rhs: Value,
-) !Value {
-    _ = src;
-    switch (float_type.tag()) {
-        .f16 => {
-            @panic("TODO add __trunctfhf2 to compiler-rt");
-            //const lhs_val = lhs.toFloat(f16);
-            //const rhs_val = rhs.toFloat(f16);
-            //return Value.Tag.float_16.create(arena, lhs_val - rhs_val);
-        },
-        .f32 => {
-            const lhs_val = lhs.toFloat(f32);
-            const rhs_val = rhs.toFloat(f32);
-            return Value.Tag.float_32.create(arena, lhs_val - rhs_val);
-        },
-        .f64 => {
-            const lhs_val = lhs.toFloat(f64);
-            const rhs_val = rhs.toFloat(f64);
-            return Value.Tag.float_64.create(arena, lhs_val - rhs_val);
-        },
-        .f128, .comptime_float, .c_longdouble => {
-            const lhs_val = lhs.toFloat(f128);
-            const rhs_val = rhs.toFloat(f128);
-            return Value.Tag.float_128.create(arena, lhs_val - rhs_val);
-        },
-        else => unreachable,
-    }
-}
-
-pub fn floatDiv(
-    arena: *Allocator,
-    float_type: Type,
-    src: LazySrcLoc,
-    lhs: Value,
-    rhs: Value,
-) !Value {
-    _ = src;
-    switch (float_type.tag()) {
-        .f16 => {
-            @panic("TODO add __trunctfhf2 to compiler-rt");
-            //const lhs_val = lhs.toFloat(f16);
-            //const rhs_val = rhs.toFloat(f16);
-            //return Value.Tag.float_16.create(arena, lhs_val / rhs_val);
-        },
-        .f32 => {
-            const lhs_val = lhs.toFloat(f32);
-            const rhs_val = rhs.toFloat(f32);
-            return Value.Tag.float_32.create(arena, lhs_val / rhs_val);
-        },
-        .f64 => {
-            const lhs_val = lhs.toFloat(f64);
-            const rhs_val = rhs.toFloat(f64);
-            return Value.Tag.float_64.create(arena, lhs_val / rhs_val);
-        },
-        .f128, .comptime_float, .c_longdouble => {
-            const lhs_val = lhs.toFloat(f128);
-            const rhs_val = rhs.toFloat(f128);
-            return Value.Tag.float_128.create(arena, lhs_val / rhs_val);
-        },
-        else => unreachable,
-    }
-}
-
-pub fn floatMul(
-    arena: *Allocator,
-    float_type: Type,
-    src: LazySrcLoc,
-    lhs: Value,
-    rhs: Value,
-) !Value {
-    _ = src;
-    switch (float_type.tag()) {
-        .f16 => {
-            @panic("TODO add __trunctfhf2 to compiler-rt");
-            //const lhs_val = lhs.toFloat(f16);
-            //const rhs_val = rhs.toFloat(f16);
-            //return Value.Tag.float_16.create(arena, lhs_val * rhs_val);
-        },
-        .f32 => {
-            const lhs_val = lhs.toFloat(f32);
-            const rhs_val = rhs.toFloat(f32);
-            return Value.Tag.float_32.create(arena, lhs_val * rhs_val);
-        },
-        .f64 => {
-            const lhs_val = lhs.toFloat(f64);
-            const rhs_val = rhs.toFloat(f64);
-            return Value.Tag.float_64.create(arena, lhs_val * rhs_val);
-        },
-        .f128, .comptime_float, .c_longdouble => {
-            const lhs_val = lhs.toFloat(f128);
-            const rhs_val = rhs.toFloat(f128);
-            return Value.Tag.float_128.create(arena, lhs_val * rhs_val);
-        },
-        else => unreachable,
-    }
-}
-
 pub fn simplePtrType(
     arena: *Allocator,
     elem_ty: Type,
diff --git a/src/Sema.zig b/src/Sema.zig
index 5ad590be6a..6b281f8569 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -3479,27 +3479,8 @@ fn zirIntCast(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) CompileErr
     const dest_type = try sema.resolveType(block, dest_ty_src, extra.lhs);
     const operand = sema.resolveInst(extra.rhs);
 
-    const dest_is_comptime_int = switch (dest_type.zigTypeTag()) {
-        .ComptimeInt => true,
-        .Int => false,
-        else => return sema.mod.fail(
-            &block.base,
-            dest_ty_src,
-            "expected integer type, found '{}'",
-            .{dest_type},
-        ),
-    };
-
-    const operand_ty = sema.typeOf(operand);
-    switch (operand_ty.zigTypeTag()) {
-        .ComptimeInt, .Int => {},
-        else => return sema.mod.fail(
-            &block.base,
-            operand_src,
-            "expected integer type, found '{}'",
-            .{operand_ty},
-        ),
-    }
+    const dest_is_comptime_int = try sema.requireIntegerType(block, dest_ty_src, dest_type);
+    _ = try sema.requireIntegerType(block, operand_src, sema.typeOf(operand));
 
     if (try sema.isComptimeKnown(block, operand_src, operand)) {
         return sema.coerce(block, dest_type, operand, operand_src);
@@ -4951,30 +4932,30 @@ fn analyzeArithmetic(
             const value = switch (zir_tag) {
                 .add => blk: {
                     const val = if (is_int)
-                        try Module.intAdd(sema.arena, lhs_val, rhs_val)
+                        try lhs_val.intAdd(rhs_val, sema.arena)
                     else
-                        try Module.floatAdd(sema.arena, scalar_type, src, lhs_val, rhs_val);
+                        try lhs_val.floatAdd(rhs_val, scalar_type, sema.arena);
                     break :blk val;
                 },
                 .sub => blk: {
                     const val = if (is_int)
-                        try Module.intSub(sema.arena, lhs_val, rhs_val)
+                        try lhs_val.intSub(rhs_val, sema.arena)
                     else
-                        try Module.floatSub(sema.arena, scalar_type, src, lhs_val, rhs_val);
+                        try lhs_val.floatSub(rhs_val, scalar_type, sema.arena);
                     break :blk val;
                 },
                 .div => blk: {
                     const val = if (is_int)
-                        try Module.intDiv(sema.arena, lhs_val, rhs_val)
+                        try lhs_val.intDiv(rhs_val, sema.arena)
                     else
-                        try Module.floatDiv(sema.arena, scalar_type, src, lhs_val, rhs_val);
+                        try lhs_val.floatDiv(rhs_val, scalar_type, sema.arena);
                     break :blk val;
                 },
                 .mul => blk: {
                     const val = if (is_int)
-                        try Module.intMul(sema.arena, lhs_val, rhs_val)
+                        try lhs_val.intMul(rhs_val, sema.arena)
                     else
-                        try Module.floatMul(sema.arena, scalar_type, src, lhs_val, rhs_val);
+                        try lhs_val.floatMul(rhs_val, scalar_type, sema.arena);
                     break :blk val;
                 },
                 else => return sema.mod.fail(&block.base, src, "TODO Implement arithmetic operand '{s}'", .{@tagName(zir_tag)}),
@@ -6173,7 +6154,62 @@ fn zirPtrCast(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) CompileErr
 fn zirTruncate(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
     const inst_data = sema.code.instructions.items(.data)[inst].pl_node;
     const src = inst_data.src();
-    return sema.mod.fail(&block.base, src, "TODO: Sema.zirTruncate", .{});
+    const dest_ty_src: LazySrcLoc = .{ .node_offset_builtin_call_arg0 = inst_data.src_node };
+    const operand_src: LazySrcLoc = .{ .node_offset_builtin_call_arg1 = inst_data.src_node };
+    const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data;
+    const dest_ty = try sema.resolveType(block, dest_ty_src, extra.lhs);
+    const operand = sema.resolveInst(extra.rhs);
+    const operand_ty = sema.typeOf(operand);
+    const mod = sema.mod;
+    const dest_is_comptime_int = try sema.requireIntegerType(block, dest_ty_src, dest_ty);
+    const src_is_comptime_int = try sema.requireIntegerType(block, operand_src, operand_ty);
+
+    if (dest_is_comptime_int) {
+        return sema.coerce(block, dest_ty, operand, operand_src);
+    }
+
+    const target = mod.getTarget();
+    const src_info = operand_ty.intInfo(target);
+    const dest_info = dest_ty.intInfo(target);
+
+    if (src_info.bits == 0 or dest_info.bits == 0) {
+        return sema.addConstant(dest_ty, Value.initTag(.zero));
+    }
+
+    if (!src_is_comptime_int) {
+        if (src_info.signedness != dest_info.signedness) {
+            return mod.fail(&block.base, operand_src, "expected {s} integer type, found '{}'", .{
+                @tagName(dest_info.signedness), operand_ty,
+            });
+        }
+        if (src_info.bits > 0 and src_info.bits < dest_info.bits) {
+            const msg = msg: {
+                const msg = try mod.errMsg(
+                    &block.base,
+                    src,
+                    "destination type '{}' has more bits than source type '{}'",
+                    .{ dest_ty, operand_ty },
+                );
+                errdefer msg.destroy(mod.gpa);
+                try mod.errNote(&block.base, dest_ty_src, msg, "destination type has {d} bits", .{
+                    dest_info.bits,
+                });
+                try mod.errNote(&block.base, operand_src, msg, "source type has {d} bits", .{
+                    src_info.bits,
+                });
+                break :msg msg;
+            };
+            return mod.failWithOwnedErrorMsg(&block.base, msg);
+        }
+    }
+
+    if (try sema.resolveMaybeUndefVal(block, operand_src, operand)) |val| {
+        if (val.isUndef()) return sema.addConstUndef(dest_ty);
+        return sema.addConstant(dest_ty, try val.intTrunc(sema.arena, dest_info.bits));
+    }
+
+    try sema.requireRuntimeBlock(block, src);
+    return block.addTyOp(.trunc, dest_ty, operand);
 }
 
 fn zirAlignCast(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
@@ -6594,6 +6630,14 @@ fn requireRuntimeBlock(sema: *Sema, block: *Scope.Block, src: LazySrcLoc) !void
     try sema.requireFunctionBlock(block, src);
 }
 
+fn requireIntegerType(sema: *Sema, block: *Scope.Block, src: LazySrcLoc, ty: Type) !bool {
+    switch (ty.zigTypeTag()) {
+        .ComptimeInt => return true,
+        .Int => return false,
+        else => return sema.mod.fail(&block.base, src, "expected integer type, found '{}'", .{ty}),
+    }
+}
+
 fn validateVarType(sema: *Sema, block: *Scope.Block, src: LazySrcLoc, ty: Type) !void {
     if (!ty.isValidVarType(false)) {
         return sema.mod.fail(&block.base, src, "variable of type '{}' must be const or comptime", .{ty});
diff --git a/src/codegen.zig b/src/codegen.zig
index 8c56ab4431..3864479d2d 100644
--- a/src/codegen.zig
+++ b/src/codegen.zig
@@ -835,6 +835,7 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
                     .dbg_stmt        => try self.airDbgStmt(inst),
                     .floatcast       => try self.airFloatCast(inst),
                     .intcast         => try self.airIntCast(inst),
+                    .trunc           => try self.airTrunc(inst),
                     .bool_to_int     => try self.airBoolToInt(inst),
                     .is_non_null     => try self.airIsNonNull(inst),
                     .is_non_null_ptr => try self.airIsNonNullPtr(inst),
@@ -1109,6 +1110,19 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
             return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
         }
 
+        fn airTrunc(self: *Self, inst: Air.Inst.Index) !void {
+            const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+            if (self.liveness.isUnused(inst))
+                return self.finishAir(inst, .dead, .{ ty_op.operand, .none, .none });
+
+            const operand = try self.resolveInst(ty_op.operand);
+            _ = operand;
+            const result: MCValue = switch (arch) {
+                else => return self.fail("TODO implement trunc for {}", .{self.target.cpu.arch}),
+            };
+            return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
+        }
+
         fn airBoolToInt(self: *Self, inst: Air.Inst.Index) !void {
             const un_op = self.air.instructions.items(.data)[inst].un_op;
             const operand = try self.resolveInst(un_op);
diff --git a/src/codegen/c.zig b/src/codegen/c.zig
index 826b73317c..22420aca45 100644
--- a/src/codegen/c.zig
+++ b/src/codegen/c.zig
@@ -900,6 +900,7 @@ fn genBody(o: *Object, body: []const Air.Inst.Index) error{ AnalysisFail, OutOfM
             .call             => try airCall(o, inst),
             .dbg_stmt         => try airDbgStmt(o, inst),
             .intcast          => try airIntCast(o, inst),
+            .trunc            => try airTrunc(o, inst),
             .bool_to_int      => try airBoolToInt(o, inst),
             .load             => try airLoad(o, inst),
             .ret              => try airRet(o, inst),
@@ -1038,7 +1039,7 @@ fn airIntCast(o: *Object, inst: Air.Inst.Index) !CValue {
         return CValue.none;
 
     const ty_op = o.air.instructions.items(.data)[inst].ty_op;
-    const from = try o.resolveInst(ty_op.operand);
+    const operand = try o.resolveInst(ty_op.operand);
 
     const writer = o.writer();
     const inst_ty = o.air.typeOfIndex(inst);
@@ -1046,11 +1047,21 @@ fn airIntCast(o: *Object, inst: Air.Inst.Index) !CValue {
     try writer.writeAll(" = (");
     try o.dg.renderType(writer, inst_ty);
     try writer.writeAll(")");
-    try o.writeCValue(writer, from);
+    try o.writeCValue(writer, operand);
     try writer.writeAll(";\n");
     return local;
 }
 
+fn airTrunc(o: *Object, inst: Air.Inst.Index) !CValue {
+    if (o.liveness.isUnused(inst))
+        return CValue.none;
+
+    const ty_op = o.air.instructions.items(.data)[inst].ty_op;
+    const operand = try o.resolveInst(ty_op.operand);
+    _ = operand;
+    return o.dg.fail("TODO: C backend: airTrunc", .{});
+}
+
 fn airBoolToInt(o: *Object, inst: Air.Inst.Index) !CValue {
     if (o.liveness.isUnused(inst))
         return CValue.none;
diff --git a/src/codegen/llvm.zig b/src/codegen/llvm.zig
index 961ed7ee99..8b3edcfe23 100644
--- a/src/codegen/llvm.zig
+++ b/src/codegen/llvm.zig
@@ -960,6 +960,7 @@ pub const FuncGen = struct {
                 .call       => try self.airCall(inst),
                 .cond_br    => try self.airCondBr(inst),
                 .intcast    => try self.airIntCast(inst),
+                .trunc      => try self.airTrunc(inst),
                 .floatcast  => try self.airFloatCast(inst),
                 .ptrtoint   => try self.airPtrToInt(inst),
                 .load       => try self.airLoad(inst),
@@ -1615,6 +1616,16 @@ pub const FuncGen = struct {
         return self.builder.buildIntCast2(operand, try self.dg.llvmType(inst_ty), llvm.Bool.fromBool(signed), "");
     }
 
+    fn airTrunc(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+        if (self.liveness.isUnused(inst))
+            return null;
+
+        const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+        const operand = try self.resolveInst(ty_op.operand);
+        const dest_llvm_ty = try self.dg.llvmType(self.air.typeOfIndex(inst));
+        return self.builder.buildTrunc(operand, dest_llvm_ty, "");
+    }
+
     fn airFloatCast(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
         if (self.liveness.isUnused(inst))
             return null;
diff --git a/src/codegen/llvm/bindings.zig b/src/codegen/llvm/bindings.zig
index 0977d6128d..4af3cadd84 100644
--- a/src/codegen/llvm/bindings.zig
+++ b/src/codegen/llvm/bindings.zig
@@ -423,6 +423,14 @@ pub const Builder = opaque {
         Idx: c_uint,
         Name: [*:0]const u8,
     ) *const Value;
+
+    pub const buildTrunc = LLVMBuildTrunc;
+    extern fn LLVMBuildTrunc(
+        *const Builder,
+        Val: *const Value,
+        DestTy: *const Type,
+        Name: [*:0]const u8,
+    ) *const Value;
 };
 
 pub const IntPredicate = enum(c_int) {
diff --git a/src/print_air.zig b/src/print_air.zig
index 5d77c303bb..00317b26e8 100644
--- a/src/print_air.zig
+++ b/src/print_air.zig
@@ -151,6 +151,7 @@ const Writer = struct {
             .load,
             .floatcast,
             .intcast,
+            .trunc,
             .optional_payload,
             .optional_payload_ptr,
             .wrap_optional,
diff --git a/src/value.zig b/src/value.zig
index a0a7c0650c..134b51e494 100644
--- a/src/value.zig
+++ b/src/value.zig
@@ -1407,6 +1407,244 @@ pub const Value = extern union {
         };
     }
 
+    pub fn intAdd(lhs: Value, rhs: Value, allocator: *Allocator) !Value {
+        // TODO is this a performance issue? maybe we should try the operation without
+        // resorting to BigInt first.
+        var lhs_space: Value.BigIntSpace = undefined;
+        var rhs_space: Value.BigIntSpace = undefined;
+        const lhs_bigint = lhs.toBigInt(&lhs_space);
+        const rhs_bigint = rhs.toBigInt(&rhs_space);
+        const limbs = try allocator.alloc(
+            std.math.big.Limb,
+            std.math.max(lhs_bigint.limbs.len, rhs_bigint.limbs.len) + 1,
+        );
+        var result_bigint = BigIntMutable{ .limbs = limbs, .positive = undefined, .len = undefined };
+        result_bigint.add(lhs_bigint, rhs_bigint);
+        const result_limbs = result_bigint.limbs[0..result_bigint.len];
+
+        if (result_bigint.positive) {
+            return Value.Tag.int_big_positive.create(allocator, result_limbs);
+        } else {
+            return Value.Tag.int_big_negative.create(allocator, result_limbs);
+        }
+    }
+
+    pub fn intSub(lhs: Value, rhs: Value, allocator: *Allocator) !Value {
+        // TODO is this a performance issue? maybe we should try the operation without
+        // resorting to BigInt first.
+        var lhs_space: Value.BigIntSpace = undefined;
+        var rhs_space: Value.BigIntSpace = undefined;
+        const lhs_bigint = lhs.toBigInt(&lhs_space);
+        const rhs_bigint = rhs.toBigInt(&rhs_space);
+        const limbs = try allocator.alloc(
+            std.math.big.Limb,
+            std.math.max(lhs_bigint.limbs.len, rhs_bigint.limbs.len) + 1,
+        );
+        var result_bigint = BigIntMutable{ .limbs = limbs, .positive = undefined, .len = undefined };
+        result_bigint.sub(lhs_bigint, rhs_bigint);
+        const result_limbs = result_bigint.limbs[0..result_bigint.len];
+
+        if (result_bigint.positive) {
+            return Value.Tag.int_big_positive.create(allocator, result_limbs);
+        } else {
+            return Value.Tag.int_big_negative.create(allocator, result_limbs);
+        }
+    }
+
+    pub fn intDiv(lhs: Value, rhs: Value, allocator: *Allocator) !Value {
+        // TODO is this a performance issue? maybe we should try the operation without
+        // resorting to BigInt first.
+        var lhs_space: Value.BigIntSpace = undefined;
+        var rhs_space: Value.BigIntSpace = undefined;
+        const lhs_bigint = lhs.toBigInt(&lhs_space);
+        const rhs_bigint = rhs.toBigInt(&rhs_space);
+        const limbs_q = try allocator.alloc(
+            std.math.big.Limb,
+            lhs_bigint.limbs.len + rhs_bigint.limbs.len + 1,
+        );
+        const limbs_r = try allocator.alloc(
+            std.math.big.Limb,
+            lhs_bigint.limbs.len,
+        );
+        const limbs_buffer = try allocator.alloc(
+            std.math.big.Limb,
+            std.math.big.int.calcDivLimbsBufferLen(lhs_bigint.limbs.len, rhs_bigint.limbs.len),
+        );
+        var result_q = BigIntMutable{ .limbs = limbs_q, .positive = undefined, .len = undefined };
+        var result_r = BigIntMutable{ .limbs = limbs_r, .positive = undefined, .len = undefined };
+        result_q.divTrunc(&result_r, lhs_bigint, rhs_bigint, limbs_buffer, null);
+        const result_limbs = result_q.limbs[0..result_q.len];
+
+        if (result_q.positive) {
+            return Value.Tag.int_big_positive.create(allocator, result_limbs);
+        } else {
+            return Value.Tag.int_big_negative.create(allocator, result_limbs);
+        }
+    }
+
+    pub fn intMul(lhs: Value, rhs: Value, allocator: *Allocator) !Value {
+        // TODO is this a performance issue? maybe we should try the operation without
+        // resorting to BigInt first.
+        var lhs_space: Value.BigIntSpace = undefined;
+        var rhs_space: Value.BigIntSpace = undefined;
+        const lhs_bigint = lhs.toBigInt(&lhs_space);
+        const rhs_bigint = rhs.toBigInt(&rhs_space);
+        const limbs = try allocator.alloc(
+            std.math.big.Limb,
+            lhs_bigint.limbs.len + rhs_bigint.limbs.len + 1,
+        );
+        var result_bigint = BigIntMutable{ .limbs = limbs, .positive = undefined, .len = undefined };
+        var limbs_buffer = try allocator.alloc(
+            std.math.big.Limb,
+            std.math.big.int.calcMulLimbsBufferLen(lhs_bigint.limbs.len, rhs_bigint.limbs.len, 1),
+        );
+        defer allocator.free(limbs_buffer);
+        result_bigint.mul(lhs_bigint, rhs_bigint, limbs_buffer, allocator);
+        const result_limbs = result_bigint.limbs[0..result_bigint.len];
+
+        if (result_bigint.positive) {
+            return Value.Tag.int_big_positive.create(allocator, result_limbs);
+        } else {
+            return Value.Tag.int_big_negative.create(allocator, result_limbs);
+        }
+    }
+
+    pub fn intTrunc(val: Value, arena: *Allocator, bits: u16) !Value {
+        const x = val.toUnsignedInt(); // TODO: implement comptime truncate on big ints
+        if (bits == 64) return val;
+        const mask = (@as(u64, 1) << @intCast(u6, bits)) - 1;
+        const truncated = x & mask;
+        return Tag.int_u64.create(arena, truncated);
+    }
+
+    pub fn floatAdd(
+        lhs: Value,
+        rhs: Value,
+        float_type: Type,
+        arena: *Allocator,
+    ) !Value {
+        switch (float_type.tag()) {
+            .f16 => {
+                @panic("TODO add __trunctfhf2 to compiler-rt");
+                //const lhs_val = lhs.toFloat(f16);
+                //const rhs_val = rhs.toFloat(f16);
+                //return Value.Tag.float_16.create(arena, lhs_val + rhs_val);
+            },
+            .f32 => {
+                const lhs_val = lhs.toFloat(f32);
+                const rhs_val = rhs.toFloat(f32);
+                return Value.Tag.float_32.create(arena, lhs_val + rhs_val);
+            },
+            .f64 => {
+                const lhs_val = lhs.toFloat(f64);
+                const rhs_val = rhs.toFloat(f64);
+                return Value.Tag.float_64.create(arena, lhs_val + rhs_val);
+            },
+            .f128, .comptime_float, .c_longdouble => {
+                const lhs_val = lhs.toFloat(f128);
+                const rhs_val = rhs.toFloat(f128);
+                return Value.Tag.float_128.create(arena, lhs_val + rhs_val);
+            },
+            else => unreachable,
+        }
+    }
+
+    pub fn floatSub(
+        lhs: Value,
+        rhs: Value,
+        float_type: Type,
+        arena: *Allocator,
+    ) !Value {
+        switch (float_type.tag()) {
+            .f16 => {
+                @panic("TODO add __trunctfhf2 to compiler-rt");
+                //const lhs_val = lhs.toFloat(f16);
+                //const rhs_val = rhs.toFloat(f16);
+                //return Value.Tag.float_16.create(arena, lhs_val - rhs_val);
+            },
+            .f32 => {
+                const lhs_val = lhs.toFloat(f32);
+                const rhs_val = rhs.toFloat(f32);
+                return Value.Tag.float_32.create(arena, lhs_val - rhs_val);
+            },
+            .f64 => {
+                const lhs_val = lhs.toFloat(f64);
+                const rhs_val = rhs.toFloat(f64);
+                return Value.Tag.float_64.create(arena, lhs_val - rhs_val);
+            },
+            .f128, .comptime_float, .c_longdouble => {
+                const lhs_val = lhs.toFloat(f128);
+                const rhs_val = rhs.toFloat(f128);
+                return Value.Tag.float_128.create(arena, lhs_val - rhs_val);
+            },
+            else => unreachable,
+        }
+    }
+
+    pub fn floatDiv(
+        lhs: Value,
+        rhs: Value,
+        float_type: Type,
+        arena: *Allocator,
+    ) !Value {
+        switch (float_type.tag()) {
+            .f16 => {
+                @panic("TODO add __trunctfhf2 to compiler-rt");
+                //const lhs_val = lhs.toFloat(f16);
+                //const rhs_val = rhs.toFloat(f16);
+                //return Value.Tag.float_16.create(arena, lhs_val / rhs_val);
+            },
+            .f32 => {
+                const lhs_val = lhs.toFloat(f32);
+                const rhs_val = rhs.toFloat(f32);
+                return Value.Tag.float_32.create(arena, lhs_val / rhs_val);
+            },
+            .f64 => {
+                const lhs_val = lhs.toFloat(f64);
+                const rhs_val = rhs.toFloat(f64);
+                return Value.Tag.float_64.create(arena, lhs_val / rhs_val);
+            },
+            .f128, .comptime_float, .c_longdouble => {
+                const lhs_val = lhs.toFloat(f128);
+                const rhs_val = rhs.toFloat(f128);
+                return Value.Tag.float_128.create(arena, lhs_val / rhs_val);
+            },
+            else => unreachable,
+        }
+    }
+
+    pub fn floatMul(
+        lhs: Value,
+        rhs: Value,
+        float_type: Type,
+        arena: *Allocator,
+    ) !Value {
+        switch (float_type.tag()) {
+            .f16 => {
+                @panic("TODO add __trunctfhf2 to compiler-rt");
+                //const lhs_val = lhs.toFloat(f16);
+                //const rhs_val = rhs.toFloat(f16);
+                //return Value.Tag.float_16.create(arena, lhs_val * rhs_val);
+            },
+            .f32 => {
+                const lhs_val = lhs.toFloat(f32);
+                const rhs_val = rhs.toFloat(f32);
+                return Value.Tag.float_32.create(arena, lhs_val * rhs_val);
+            },
+            .f64 => {
+                const lhs_val = lhs.toFloat(f64);
+                const rhs_val = rhs.toFloat(f64);
+                return Value.Tag.float_64.create(arena, lhs_val * rhs_val);
+            },
+            .f128, .comptime_float, .c_longdouble => {
+                const lhs_val = lhs.toFloat(f128);
+                const rhs_val = rhs.toFloat(f128);
+                return Value.Tag.float_128.create(arena, lhs_val * rhs_val);
+            },
+            else => unreachable,
+        }
+    }
+
     /// This type is not copyable since it may contain pointers to its inner data.
     pub const Payload = struct {
         tag: Tag,
diff --git a/test/behavior/basic.zig b/test/behavior/basic.zig
index 8f0f20cdf5..87de1c9fe5 100644
--- a/test/behavior/basic.zig
+++ b/test/behavior/basic.zig
@@ -1,3 +1,6 @@
+const std = @import("std");
+const expect = std.testing.expect;
+
 // normal comment
 
 /// this is a documentation comment
@@ -7,3 +10,11 @@ fn emptyFunctionWithComments() void {}
 test "empty function with comments" {
     emptyFunctionWithComments();
 }
+
+test "truncate" {
+    try expect(testTruncate(0x10fd) == 0xfd);
+    comptime try expect(testTruncate(0x10fd) == 0xfd);
+}
+fn testTruncate(x: u32) u8 {
+    return @truncate(u8, x);
+}
diff --git a/test/behavior/misc.zig b/test/behavior/misc.zig
index ba38d6327c..700e043313 100644
--- a/test/behavior/misc.zig
+++ b/test/behavior/misc.zig
@@ -5,13 +5,6 @@ const expectEqualStrings = std.testing.expectEqualStrings;
 const mem = std.mem;
 const builtin = @import("builtin");
 
-test "truncate" {
-    try expect(testTruncate(0x10fd) == 0xfd);
-}
-fn testTruncate(x: u32) u8 {
-    return @truncate(u8, x);
-}
-
 fn first4KeysOfHomeRow() []const u8 {
     return "aoeu";
 }

From dae4c18aa7999a866b6b145ed3c88cb6c06852be Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Sun, 1 Aug 2021 22:04:18 -0700
Subject: [PATCH 60/96] stage2: ZIR encodes comptime parameters

`func_extended` ZIR instructions now have a one of the unused flags used
as a `has_comptime_bits` boolean. When set, it means 1 or more
parameters are `comptime`. In this case, there is a u32 per every 32
parameters (usually just 1 u32) with each bit indicating whether the
corresponding parameter is `comptime`.

Sema uses this information to correctly mark generic functions as
generic. There is now a TODO compile error in place in case a generic
function call happens. A future commit will do the generic function call
implementation.
---
 src/AstGen.zig | 66 +++++++++++++++++++++++++++++++++++++++++++++++++-
 src/Sema.zig   | 29 +++++++++++++++++++++-
 src/Zir.zig    | 28 ++++++++++++++++++---
 src/type.zig   | 15 ++++++++++++
 4 files changed, 132 insertions(+), 6 deletions(-)

diff --git a/src/AstGen.zig b/src/AstGen.zig
index b5e5d60b2c..20480ab33b 100644
--- a/src/AstGen.zig
+++ b/src/AstGen.zig
@@ -1064,11 +1064,28 @@ fn fnProtoExpr(
     const param_types = try gpa.alloc(Zir.Inst.Ref, param_count);
     defer gpa.free(param_types);
 
+    const bits_per_param = 1;
+    const params_per_u32 = 32 / bits_per_param;
+    // We only need this if there are greater than params_per_u32 fields.
+    var bit_bag = ArrayListUnmanaged(u32){};
+    defer bit_bag.deinit(gpa);
+    var cur_bit_bag: u32 = 0;
     var is_var_args = false;
     {
         var param_type_i: usize = 0;
         var it = fn_proto.iterate(tree.*);
         while (it.next()) |param| : (param_type_i += 1) {
+            if (param_type_i % params_per_u32 == 0 and param_type_i != 0) {
+                try bit_bag.append(gpa, cur_bit_bag);
+                cur_bit_bag = 0;
+            }
+            const is_comptime = if (param.comptime_noalias) |token|
+                token_tags[token] == .keyword_comptime
+            else
+                false;
+            cur_bit_bag = (cur_bit_bag >> bits_per_param) |
+                (@as(u32, @boolToInt(is_comptime)) << 31);
+
             if (param.anytype_ellipsis3) |token| {
                 switch (token_tags[token]) {
                     .keyword_anytype => {
@@ -1088,6 +1105,11 @@ fn fnProtoExpr(
                 try expr(gz, scope, .{ .ty = .type_type }, param_type_node);
         }
         assert(param_type_i == param_count);
+
+        const empty_slot_count = params_per_u32 - (param_type_i % params_per_u32);
+        if (empty_slot_count < params_per_u32) {
+            cur_bit_bag >>= @intCast(u5, empty_slot_count * bits_per_param);
+        }
     }
 
     const align_inst: Zir.Inst.Ref = if (fn_proto.ast.align_expr == 0) .none else inst: {
@@ -1131,6 +1153,8 @@ fn fnProtoExpr(
         .is_inferred_error = false,
         .is_test = false,
         .is_extern = false,
+        .cur_bit_bag = cur_bit_bag,
+        .bit_bag = bit_bag.items,
     });
     return rvalue(gz, rl, result, fn_proto.ast.proto_node);
 }
@@ -2916,11 +2940,28 @@ fn fnDecl(
     const param_types = try gpa.alloc(Zir.Inst.Ref, param_count);
     defer gpa.free(param_types);
 
+    const bits_per_param = 1;
+    const params_per_u32 = 32 / bits_per_param;
+    // We only need this if there are greater than params_per_u32 fields.
+    var bit_bag = ArrayListUnmanaged(u32){};
+    defer bit_bag.deinit(gpa);
+    var cur_bit_bag: u32 = 0;
     var is_var_args = false;
     {
         var param_type_i: usize = 0;
         var it = fn_proto.iterate(tree.*);
         while (it.next()) |param| : (param_type_i += 1) {
+            if (param_type_i % params_per_u32 == 0 and param_type_i != 0) {
+                try bit_bag.append(gpa, cur_bit_bag);
+                cur_bit_bag = 0;
+            }
+            const is_comptime = if (param.comptime_noalias) |token|
+                token_tags[token] == .keyword_comptime
+            else
+                false;
+            cur_bit_bag = (cur_bit_bag >> bits_per_param) |
+                (@as(u32, @boolToInt(is_comptime)) << 31);
+
             if (param.anytype_ellipsis3) |token| {
                 switch (token_tags[token]) {
                     .keyword_anytype => {
@@ -2940,6 +2981,11 @@ fn fnDecl(
                 try expr(&decl_gz, &decl_gz.base, .{ .ty = .type_type }, param_type_node);
         }
         assert(param_type_i == param_count);
+
+        const empty_slot_count = params_per_u32 - (param_type_i % params_per_u32);
+        if (empty_slot_count < params_per_u32) {
+            cur_bit_bag >>= @intCast(u5, empty_slot_count * bits_per_param);
+        }
     }
 
     const lib_name: u32 = if (fn_proto.lib_name) |lib_name_token| blk: {
@@ -3001,6 +3047,8 @@ fn fnDecl(
             .is_inferred_error = false,
             .is_test = false,
             .is_extern = true,
+            .cur_bit_bag = cur_bit_bag,
+            .bit_bag = bit_bag.items,
         });
     } else func: {
         if (is_var_args) {
@@ -3094,6 +3142,8 @@ fn fnDecl(
             .is_inferred_error = is_inferred_error,
             .is_test = false,
             .is_extern = false,
+            .cur_bit_bag = cur_bit_bag,
+            .bit_bag = bit_bag.items,
         });
     };
 
@@ -3439,6 +3489,8 @@ fn testDecl(
         .is_inferred_error = true,
         .is_test = true,
         .is_extern = false,
+        .cur_bit_bag = 0,
+        .bit_bag = &.{},
     });
 
     _ = try decl_block.addBreak(.break_inline, block_inst, func_inst);
@@ -9135,6 +9187,8 @@ const GenZir = struct {
         is_inferred_error: bool,
         is_test: bool,
         is_extern: bool,
+        cur_bit_bag: u32,
+        bit_bag: []const u32,
     }) !Zir.Inst.Ref {
         assert(args.src_node != 0);
         assert(args.ret_ty != .none);
@@ -9172,13 +9226,18 @@ const GenZir = struct {
             src_locs = &src_locs_buffer;
         }
 
+        const any_are_comptime = args.cur_bit_bag != 0 or for (args.bit_bag) |x| {
+            if (x != 0) break true;
+        } else false;
+
         if (args.cc != .none or args.lib_name != 0 or
             args.is_var_args or args.is_test or args.align_inst != .none or
-            args.is_extern)
+            args.is_extern or any_are_comptime)
         {
             try astgen.extra.ensureUnusedCapacity(
                 gpa,
                 @typeInfo(Zir.Inst.ExtendedFunc).Struct.fields.len +
+                    @boolToInt(any_are_comptime) + args.bit_bag.len +
                     args.param_types.len + args.body.len + src_locs.len +
                     @boolToInt(args.lib_name != 0) +
                     @boolToInt(args.align_inst != .none) +
@@ -9199,6 +9258,10 @@ const GenZir = struct {
             if (args.align_inst != .none) {
                 astgen.extra.appendAssumeCapacity(@enumToInt(args.align_inst));
             }
+            if (any_are_comptime) {
+                astgen.extra.appendSliceAssumeCapacity(args.bit_bag); // Likely empty.
+                astgen.extra.appendAssumeCapacity(args.cur_bit_bag);
+            }
             astgen.appendRefsAssumeCapacity(args.param_types);
             astgen.extra.appendSliceAssumeCapacity(args.body);
             astgen.extra.appendSliceAssumeCapacity(src_locs);
@@ -9216,6 +9279,7 @@ const GenZir = struct {
                         .has_align = args.align_inst != .none,
                         .is_test = args.is_test,
                         .is_extern = args.is_extern,
+                        .has_comptime_bits = any_are_comptime,
                     }),
                     .operand = payload_index,
                 } },
diff --git a/src/Sema.zig b/src/Sema.zig
index 6b281f8569..753ef8fb9c 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -104,6 +104,9 @@ pub fn analyzeFnBody(
             extra_index += @boolToInt(small.has_lib_name);
             extra_index += @boolToInt(small.has_cc);
             extra_index += @boolToInt(small.has_align);
+            if (small.has_comptime_bits) {
+                extra_index += (extra.data.param_types_len + 31) / 32;
+            }
             extra_index += extra.data.param_types_len;
             const body = sema.code.extra[extra_index..][0..extra.data.body_len];
             break :blk body;
@@ -2533,6 +2536,9 @@ fn analyzeCall(
 
         break :res result;
     } else res: {
+        if (func_ty.fnIsGeneric()) {
+            return sema.mod.fail(&block.base, func_src, "TODO implement generic fn call", .{});
+        }
         try sema.requireRuntimeBlock(block, call_src);
         try sema.air_extra.ensureUnusedCapacity(gpa, @typeInfo(Air.Call).Struct.fields.len +
             args.len);
@@ -3208,6 +3214,7 @@ fn zirFunc(
         false,
         src_locs,
         null,
+        &.{},
     );
 }
 
@@ -3225,6 +3232,7 @@ fn funcCommon(
     is_extern: bool,
     src_locs: Zir.Inst.Func.SrcLocs,
     opt_lib_name: ?[]const u8,
+    comptime_bits: []const u32,
 ) CompileError!Air.Inst.Ref {
     const src: LazySrcLoc = .{ .node_offset = src_node_offset };
     const ret_ty_src: LazySrcLoc = .{ .node_offset_fn_type_ret_ty = src_node_offset };
@@ -3257,13 +3265,23 @@ fn funcCommon(
             }
         }
 
+        var any_are_comptime = false;
         const param_types = try sema.arena.alloc(Type, zir_param_types.len);
         for (zir_param_types) |param_type, i| {
             // TODO make a compile error from `resolveType` report the source location
             // of the specific parameter. Will need to take a similar strategy as
             // `resolveSwitchItemVal` to avoid resolving the source location unless
             // we actually need to report an error.
-            param_types[i] = try sema.resolveType(block, src, param_type);
+            const param_src = src;
+            param_types[i] = try sema.resolveType(block, param_src, param_type);
+
+            any_are_comptime = any_are_comptime or blk: {
+                if (comptime_bits.len == 0)
+                    break :blk false;
+                const bag = comptime_bits[i / 32];
+                const is_comptime = @truncate(u1, bag >> @intCast(u5, i % 32)) != 0;
+                break :blk is_comptime;
+            };
         }
 
         if (align_val.tag() != .null_value) {
@@ -3286,6 +3304,7 @@ fn funcCommon(
             .return_type = return_type,
             .cc = cc,
             .is_var_args = var_args,
+            .is_generic = any_are_comptime,
         });
     };
 
@@ -6526,6 +6545,13 @@ fn zirFuncExtended(
         break :blk align_tv.val;
     } else Value.initTag(.null_value);
 
+    const comptime_bits: []const u32 = if (!small.has_comptime_bits) &.{} else blk: {
+        const amt = (extra.data.param_types_len + 31) / 32;
+        const bit_bags = sema.code.extra[extra_index..][0..amt];
+        extra_index += amt;
+        break :blk bit_bags;
+    };
+
     const param_types = sema.code.refSlice(extra_index, extra.data.param_types_len);
     extra_index += param_types.len;
 
@@ -6554,6 +6580,7 @@ fn zirFuncExtended(
         is_extern,
         src_locs,
         lib_name,
+        comptime_bits,
     );
 }
 
diff --git a/src/Zir.zig b/src/Zir.zig
index a8320b65d4..109ae3b186 100644
--- a/src/Zir.zig
+++ b/src/Zir.zig
@@ -2226,9 +2226,13 @@ pub const Inst = struct {
     /// 0. lib_name: u32, // null terminated string index, if has_lib_name is set
     /// 1. cc: Ref, // if has_cc is set
     /// 2. align: Ref, // if has_align is set
-    /// 3. param_type: Ref // for each param_types_len
-    /// 4. body: Index // for each body_len
-    /// 5. src_locs: Func.SrcLocs // if body_len != 0
+    /// 3. comptime_bits: u32 // for every 32 parameters, if has_comptime_bits is set
+    ///    - sets of 1 bit:
+    ///      0bX: whether corresponding parameter is comptime
+    /// 4. param_type: Ref // for each param_types_len
+    ///    - `none` indicates that the param type is `anytype`.
+    /// 5. body: Index // for each body_len
+    /// 6. src_locs: Func.SrcLocs // if body_len != 0
     pub const ExtendedFunc = struct {
         src_node: i32,
         return_type: Ref,
@@ -2243,7 +2247,8 @@ pub const Inst = struct {
             has_align: bool,
             is_test: bool,
             is_extern: bool,
-            _: u9 = undefined,
+            has_comptime_bits: bool,
+            _: u8 = undefined,
         };
     };
 
@@ -4291,6 +4296,7 @@ const Writer = struct {
             body,
             src,
             src_locs,
+            &.{},
         );
     }
 
@@ -4317,6 +4323,13 @@ const Writer = struct {
             break :blk align_inst;
         };
 
+        const comptime_bits: []const u32 = if (!small.has_comptime_bits) &.{} else blk: {
+            const amt = (extra.data.param_types_len + 31) / 32;
+            const bit_bags = self.code.extra[extra_index..][0..amt];
+            extra_index += amt;
+            break :blk bit_bags;
+        };
+
         const param_types = self.code.refSlice(extra_index, extra.data.param_types_len);
         extra_index += param_types.len;
 
@@ -4339,6 +4352,7 @@ const Writer = struct {
             body,
             src,
             src_locs,
+            comptime_bits,
         );
     }
 
@@ -4422,10 +4436,16 @@ const Writer = struct {
         body: []const Inst.Index,
         src: LazySrcLoc,
         src_locs: Zir.Inst.Func.SrcLocs,
+        comptime_bits: []const u32,
     ) !void {
         try stream.writeAll("[");
         for (param_types) |param_type, i| {
             if (i != 0) try stream.writeAll(", ");
+            if (comptime_bits.len != 0) {
+                const bag = comptime_bits[i / 32];
+                const is_comptime = @truncate(u1, bag >> @intCast(u5, i % 32)) != 0;
+                try self.writeFlag(stream, "comptime ", is_comptime);
+            }
             try self.writeInstRef(stream, param_type);
         }
         try stream.writeAll("], ");
diff --git a/src/type.zig b/src/type.zig
index 82c28ef398..a8c3d77bbb 100644
--- a/src/type.zig
+++ b/src/type.zig
@@ -764,6 +764,7 @@ pub const Type = extern union {
                     .param_types = param_types,
                     .cc = payload.cc,
                     .is_var_args = payload.is_var_args,
+                    .is_generic = payload.is_generic,
                 });
             },
             .pointer => {
@@ -2407,6 +2408,19 @@ pub const Type = extern union {
         };
     }
 
+    /// Asserts the type is a function.
+    pub fn fnIsGeneric(self: Type) bool {
+        return switch (self.tag()) {
+            .fn_noreturn_no_args => false,
+            .fn_void_no_args => false,
+            .fn_naked_noreturn_no_args => false,
+            .fn_ccc_void_no_args => false,
+            .function => self.castTag(.function).?.data.is_generic,
+
+            else => unreachable,
+        };
+    }
+
     pub fn isNumeric(self: Type) bool {
         return switch (self.tag()) {
             .f16,
@@ -3214,6 +3228,7 @@ pub const Type = extern union {
                 return_type: Type,
                 cc: std.builtin.CallingConvention,
                 is_var_args: bool,
+                is_generic: bool,
             },
         };
 

From b465037a65dd6a31c5865086ec4392a1d3a372bc Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Sun, 1 Aug 2021 23:27:38 -0700
Subject: [PATCH 61/96] move some behavior tests to the "passing for stage2"
 section

---
 test/behavior/basic.zig    | 65 +++++++++++++++++++++++++++
 test/behavior/misc.zig     | 92 --------------------------------------
 test/behavior/widening.zig | 11 +++++
 3 files changed, 76 insertions(+), 92 deletions(-)

diff --git a/test/behavior/basic.zig b/test/behavior/basic.zig
index 87de1c9fe5..c5c2972ffc 100644
--- a/test/behavior/basic.zig
+++ b/test/behavior/basic.zig
@@ -18,3 +18,68 @@ test "truncate" {
 fn testTruncate(x: u32) u8 {
     return @truncate(u8, x);
 }
+
+const g1: i32 = 1233 + 1;
+var g2: i32 = 0;
+
+test "global variables" {
+    try expect(g2 == 0);
+    g2 = g1;
+    try expect(g2 == 1234);
+}
+
+test "comptime keyword on expressions" {
+    const x: i32 = comptime x: {
+        break :x 1 + 2 + 3;
+    };
+    try expect(x == comptime 6);
+}
+
+test "type equality" {
+    try expect(*const u8 != *u8);
+}
+
+test "pointer dereferencing" {
+    var x = @as(i32, 3);
+    const y = &x;
+
+    y.* += 1;
+
+    try expect(x == 4);
+    try expect(y.* == 4);
+}
+
+test "const expression eval handling of variables" {
+    var x = true;
+    while (x) {
+        x = false;
+    }
+}
+
+test "character literals" {
+    try expect('\'' == single_quote);
+}
+const single_quote = '\'';
+
+test "non const ptr to aliased type" {
+    const int = i32;
+    try expect(?*int == ?*i32);
+}
+
+test "cold function" {
+    thisIsAColdFn();
+    comptime thisIsAColdFn();
+}
+
+fn thisIsAColdFn() void {
+    @setCold(true);
+}
+
+test "unicode escape in character literal" {
+    var a: u24 = '\u{01f4a9}';
+    try expect(a == 128169);
+}
+
+test "unicode character in character literal" {
+    try expect('💩' == 128169);
+}
diff --git a/test/behavior/misc.zig b/test/behavior/misc.zig
index 700e043313..ddb90773d8 100644
--- a/test/behavior/misc.zig
+++ b/test/behavior/misc.zig
@@ -13,15 +13,6 @@ test "return string from function" {
     try expect(mem.eql(u8, first4KeysOfHomeRow(), "aoeu"));
 }
 
-const g1: i32 = 1233 + 1;
-var g2: i32 = 0;
-
-test "global variables" {
-    try expect(g2 == 0);
-    g2 = g1;
-    try expect(g2 == 1234);
-}
-
 test "memcpy and memset intrinsics" {
     var foo: [20]u8 = undefined;
     var bar: [20]u8 = undefined;
@@ -32,13 +23,6 @@ test "memcpy and memset intrinsics" {
     if (bar[11] != 'A') unreachable;
 }
 
-test "builtin static eval" {
-    const x: i32 = comptime x: {
-        break :x 1 + 2 + 3;
-    };
-    try expect(x == comptime 6);
-}
-
 test "slicing" {
     var array: [20]i32 = undefined;
 
@@ -148,10 +132,6 @@ test "multiline C string" {
     try expect(std.cstr.cmp(s1, s2) == 0);
 }
 
-test "type equality" {
-    try expect(*const u8 != *u8);
-}
-
 const global_a: i32 = 1234;
 const global_b: *const i32 = &global_a;
 const global_c: *const f32 = @ptrCast(*const f32, global_b);
@@ -187,17 +167,6 @@ fn testCastUndefined(x: []const u8) void {
     _ = x;
 }
 
-test "cast small unsigned to larger signed" {
-    try expect(castSmallUnsignedToLargerSigned1(200) == @as(i16, 200));
-    try expect(castSmallUnsignedToLargerSigned2(9999) == @as(i64, 9999));
-}
-fn castSmallUnsignedToLargerSigned1(x: u8) i16 {
-    return x;
-}
-fn castSmallUnsignedToLargerSigned2(x: u16) i64 {
-    return x;
-}
-
 test "implicit cast after unreachable" {
     try expect(outer() == 1234);
 }
@@ -208,16 +177,6 @@ fn outer() i64 {
     return inner();
 }
 
-test "pointer dereferencing" {
-    var x = @as(i32, 3);
-    const y = &x;
-
-    y.* += 1;
-
-    try expect(x == 4);
-    try expect(y.* == 4);
-}
-
 test "call result of if else expression" {
     try expect(mem.eql(u8, f2(true), "a"));
     try expect(mem.eql(u8, f2(false), "b"));
@@ -232,13 +191,6 @@ fn fB() []const u8 {
     return "b";
 }
 
-test "const expression eval handling of variables" {
-    var x = true;
-    while (x) {
-        x = false;
-    }
-}
-
 test "constant enum initialization with differing sizes" {
     try test3_1(test3_foo);
     try test3_2(test3_bar);
@@ -277,11 +229,6 @@ fn test3_2(f: Test3Foo) !void {
     }
 }
 
-test "character literals" {
-    try expect('\'' == single_quote);
-}
-const single_quote = '\'';
-
 test "take address of parameter" {
     try testTakeAddressOfParameter(12.34);
 }
@@ -330,11 +277,6 @@ fn testPointerToVoidReturnType2() *const void {
     return &test_pointer_to_void_return_type_x;
 }
 
-test "non const ptr to aliased type" {
-    const int = i32;
-    try expect(?*int == ?*i32);
-}
-
 test "array 2D const double ptr" {
     const rect_2d_vertexes = [_][1]f32{
         [_]f32{1.0},
@@ -349,22 +291,6 @@ fn testArray2DConstDoublePtr(ptr: *const f32) !void {
     try expect(ptr2[1] == 2.0);
 }
 
-const AStruct = struct {
-    x: i32,
-};
-const AnEnum = enum {
-    One,
-    Two,
-};
-const AUnionEnum = union(enum) {
-    One: i32,
-    Two: void,
-};
-const AUnion = union {
-    One: void,
-    Two: void,
-};
-
 test "double implicit cast in same expression" {
     var x = @as(i32, @as(u16, nine()));
     try expect(x == 9);
@@ -440,15 +366,6 @@ test "function closes over local const" {
     try expect(x == 1);
 }
 
-test "cold function" {
-    thisIsAColdFn();
-    comptime thisIsAColdFn();
-}
-
-fn thisIsAColdFn() void {
-    @setCold(true);
-}
-
 const PackedStruct = packed struct {
     a: u8,
     b: u8,
@@ -562,15 +479,6 @@ test "thread local variable" {
     try expect(S.t == 1235);
 }
 
-test "unicode escape in character literal" {
-    var a: u24 = '\u{01f4a9}';
-    try expect(a == 128169);
-}
-
-test "unicode character in character literal" {
-    try expect('💩' == 128169);
-}
-
 test "result location zero sized array inside struct field implicit cast to slice" {
     const E = struct {
         entries: []u32,
diff --git a/test/behavior/widening.zig b/test/behavior/widening.zig
index dfa70ac4b2..19abf767b8 100644
--- a/test/behavior/widening.zig
+++ b/test/behavior/widening.zig
@@ -37,3 +37,14 @@ test "float widening f16 to f128" {
     var y: f128 = x;
     try expect(x == y);
 }
+
+test "cast small unsigned to larger signed" {
+    try expect(castSmallUnsignedToLargerSigned1(200) == @as(i16, 200));
+    try expect(castSmallUnsignedToLargerSigned2(9999) == @as(i64, 9999));
+}
+fn castSmallUnsignedToLargerSigned1(x: u8) i16 {
+    return x;
+}
+fn castSmallUnsignedToLargerSigned2(x: u16) i64 {
+    return x;
+}

From 934df5bd448e7e27f2142d0d9ceec534f391c7f5 Mon Sep 17 00:00:00 2001
From: N00byEdge <hannesbredberg@gmail.com>
Date: Fri, 30 Jul 2021 19:04:18 +0200
Subject: [PATCH 62/96] Make linux syscalls accessible with non-Linux target OS

---
 lib/std/os/linux/arm-eabi.zig  | 1 +
 lib/std/os/linux/arm64.zig     | 1 +
 lib/std/os/linux/i386.zig      | 1 +
 lib/std/os/linux/mips.zig      | 1 +
 lib/std/os/linux/powerpc.zig   | 1 +
 lib/std/os/linux/powerpc64.zig | 1 +
 lib/std/os/linux/riscv64.zig   | 1 +
 lib/std/os/linux/sparc64.zig   | 1 +
 lib/std/os/linux/thumb.zig     | 1 +
 lib/std/os/linux/x86_64.zig    | 1 +
 10 files changed, 10 insertions(+)

diff --git a/lib/std/os/linux/arm-eabi.zig b/lib/std/os/linux/arm-eabi.zig
index bac7048615..0fe74c9665 100644
--- a/lib/std/os/linux/arm-eabi.zig
+++ b/lib/std/os/linux/arm-eabi.zig
@@ -4,6 +4,7 @@
 // The MIT license requires this copyright notice to be included in all copies
 // and substantial portions of the software.
 usingnamespace @import("../bits.zig");
+usingnamespace @import("../bits/linux.zig");
 
 pub fn syscall0(number: SYS) usize {
     return asm volatile ("svc #0"
diff --git a/lib/std/os/linux/arm64.zig b/lib/std/os/linux/arm64.zig
index dd5c3ef3af..0e1af98493 100644
--- a/lib/std/os/linux/arm64.zig
+++ b/lib/std/os/linux/arm64.zig
@@ -4,6 +4,7 @@
 // The MIT license requires this copyright notice to be included in all copies
 // and substantial portions of the software.
 usingnamespace @import("../bits.zig");
+usingnamespace @import("../bits/linux.zig");
 
 pub fn syscall0(number: SYS) usize {
     return asm volatile ("svc #0"
diff --git a/lib/std/os/linux/i386.zig b/lib/std/os/linux/i386.zig
index c1ac6938fb..df58336eb0 100644
--- a/lib/std/os/linux/i386.zig
+++ b/lib/std/os/linux/i386.zig
@@ -4,6 +4,7 @@
 // The MIT license requires this copyright notice to be included in all copies
 // and substantial portions of the software.
 usingnamespace @import("../bits.zig");
+usingnamespace @import("../bits/linux.zig");
 
 pub fn syscall0(number: SYS) usize {
     return asm volatile ("int $0x80"
diff --git a/lib/std/os/linux/mips.zig b/lib/std/os/linux/mips.zig
index a04a592f3b..2ac029cae8 100644
--- a/lib/std/os/linux/mips.zig
+++ b/lib/std/os/linux/mips.zig
@@ -4,6 +4,7 @@
 // The MIT license requires this copyright notice to be included in all copies
 // and substantial portions of the software.
 usingnamespace @import("../bits.zig");
+usingnamespace @import("../bits/linux.zig");
 
 pub fn syscall0(number: SYS) usize {
     return asm volatile (
diff --git a/lib/std/os/linux/powerpc.zig b/lib/std/os/linux/powerpc.zig
index 567ad2bc1f..341eb3f920 100644
--- a/lib/std/os/linux/powerpc.zig
+++ b/lib/std/os/linux/powerpc.zig
@@ -5,6 +5,7 @@
 // and substantial portions of the software.
 
 usingnamespace @import("../bits.zig");
+usingnamespace @import("../bits/linux.zig");
 
 pub fn syscall0(number: SYS) usize {
     return asm volatile (
diff --git a/lib/std/os/linux/powerpc64.zig b/lib/std/os/linux/powerpc64.zig
index 567ad2bc1f..341eb3f920 100644
--- a/lib/std/os/linux/powerpc64.zig
+++ b/lib/std/os/linux/powerpc64.zig
@@ -5,6 +5,7 @@
 // and substantial portions of the software.
 
 usingnamespace @import("../bits.zig");
+usingnamespace @import("../bits/linux.zig");
 
 pub fn syscall0(number: SYS) usize {
     return asm volatile (
diff --git a/lib/std/os/linux/riscv64.zig b/lib/std/os/linux/riscv64.zig
index d58e080407..cab2ecfbaf 100644
--- a/lib/std/os/linux/riscv64.zig
+++ b/lib/std/os/linux/riscv64.zig
@@ -4,6 +4,7 @@
 // The MIT license requires this copyright notice to be included in all copies
 // and substantial portions of the software.
 usingnamespace @import("../bits.zig");
+usingnamespace @import("../bits/linux.zig");
 
 pub fn syscall0(number: SYS) usize {
     return asm volatile ("ecall"
diff --git a/lib/std/os/linux/sparc64.zig b/lib/std/os/linux/sparc64.zig
index 902940071e..cbe5ee3b70 100644
--- a/lib/std/os/linux/sparc64.zig
+++ b/lib/std/os/linux/sparc64.zig
@@ -1,4 +1,5 @@
 usingnamespace @import("../bits.zig");
+usingnamespace @import("../bits/linux.zig");
 
 pub fn syscall_pipe(fd: *[2]i32) usize {
     return asm volatile (
diff --git a/lib/std/os/linux/thumb.zig b/lib/std/os/linux/thumb.zig
index 5db9d2cbf4..955c3420d4 100644
--- a/lib/std/os/linux/thumb.zig
+++ b/lib/std/os/linux/thumb.zig
@@ -4,6 +4,7 @@
 // The MIT license requires this copyright notice to be included in all copies
 // and substantial portions of the software.
 usingnamespace @import("../bits.zig");
+usingnamespace @import("../bits/linux.zig");
 
 // The syscall interface is identical to the ARM one but we're facing an extra
 // challenge: r7, the register where the syscall number is stored, may be
diff --git a/lib/std/os/linux/x86_64.zig b/lib/std/os/linux/x86_64.zig
index b9b3ff47eb..da4206a521 100644
--- a/lib/std/os/linux/x86_64.zig
+++ b/lib/std/os/linux/x86_64.zig
@@ -4,6 +4,7 @@
 // The MIT license requires this copyright notice to be included in all copies
 // and substantial portions of the software.
 usingnamespace @import("../bits.zig");
+usingnamespace @import("../bits/linux.zig");
 
 pub fn syscall0(number: SYS) usize {
     return asm volatile ("syscall"

From 871f6343f4d36c5c048f3307e2a38d184e248826 Mon Sep 17 00:00:00 2001
From: N00byEdge <hannesbredberg@gmail.com>
Date: Fri, 30 Jul 2021 19:27:41 +0200
Subject: [PATCH 63/96] Move iovec and log levels to bits/posix.zig

This lets only the OSes that uses them to import them, and removes
dependencies on bits.zig for the os/<os>/<arch>.zig files
---
 lib/std/os/bits.zig            | 29 -----------------------------
 lib/std/os/bits/darwin.zig     |  2 ++
 lib/std/os/bits/dragonfly.zig  |  2 ++
 lib/std/os/bits/freebsd.zig    |  2 ++
 lib/std/os/bits/haiku.zig      |  2 ++
 lib/std/os/bits/linux.zig      |  2 +-
 lib/std/os/bits/netbsd.zig     |  2 ++
 lib/std/os/bits/openbsd.zig    |  2 ++
 lib/std/os/bits/posix.zig      | 34 ++++++++++++++++++++++++++++++++++
 lib/std/os/bits/wasi.zig       |  4 ++++
 lib/std/os/bits/windows.zig    |  5 +++++
 lib/std/os/linux/arm-eabi.zig  |  1 -
 lib/std/os/linux/arm64.zig     |  1 -
 lib/std/os/linux/i386.zig      |  1 -
 lib/std/os/linux/mips.zig      |  1 -
 lib/std/os/linux/powerpc.zig   |  1 -
 lib/std/os/linux/powerpc64.zig |  1 -
 lib/std/os/linux/riscv64.zig   |  1 -
 lib/std/os/linux/sparc64.zig   |  1 -
 lib/std/os/linux/thumb.zig     |  1 -
 lib/std/os/linux/x86_64.zig    |  1 -
 21 files changed, 56 insertions(+), 40 deletions(-)
 create mode 100644 lib/std/os/bits/posix.zig

diff --git a/lib/std/os/bits.zig b/lib/std/os/bits.zig
index 5d1de28bad..5c39609182 100644
--- a/lib/std/os/bits.zig
+++ b/lib/std/os/bits.zig
@@ -25,32 +25,3 @@ pub usingnamespace switch (std.Target.current.os.tag) {
 };
 
 pub usingnamespace if (@hasDecl(root, "os") and @hasDecl(root.os, "bits")) root.os.bits else struct {};
-
-pub const iovec = extern struct {
-    iov_base: [*]u8,
-    iov_len: usize,
-};
-
-pub const iovec_const = extern struct {
-    iov_base: [*]const u8,
-    iov_len: usize,
-};
-
-// syslog
-
-/// system is unusable
-pub const LOG_EMERG = 0;
-/// action must be taken immediately
-pub const LOG_ALERT = 1;
-/// critical conditions
-pub const LOG_CRIT = 2;
-/// error conditions
-pub const LOG_ERR = 3;
-/// warning conditions
-pub const LOG_WARNING = 4;
-/// normal but significant condition
-pub const LOG_NOTICE = 5;
-/// informational
-pub const LOG_INFO = 6;
-/// debug-level messages
-pub const LOG_DEBUG = 7;
diff --git a/lib/std/os/bits/darwin.zig b/lib/std/os/bits/darwin.zig
index be77722c05..91705c0d2e 100644
--- a/lib/std/os/bits/darwin.zig
+++ b/lib/std/os/bits/darwin.zig
@@ -7,6 +7,8 @@ const std = @import("../../std.zig");
 const assert = std.debug.assert;
 const maxInt = std.math.maxInt;
 
+pub usingnamespace @import("posix.zig");
+
 // See: https://opensource.apple.com/source/xnu/xnu-6153.141.1/bsd/sys/_types.h.auto.html
 // TODO: audit mode_t/pid_t, should likely be u16/i32
 pub const fd_t = c_int;
diff --git a/lib/std/os/bits/dragonfly.zig b/lib/std/os/bits/dragonfly.zig
index 9f6d3088ba..573721749c 100644
--- a/lib/std/os/bits/dragonfly.zig
+++ b/lib/std/os/bits/dragonfly.zig
@@ -6,6 +6,8 @@
 const std = @import("../../std.zig");
 const maxInt = std.math.maxInt;
 
+pub usingnamespace @import("posix.zig");
+
 pub fn S_ISCHR(m: u32) bool {
     return m & S_IFMT == S_IFCHR;
 }
diff --git a/lib/std/os/bits/freebsd.zig b/lib/std/os/bits/freebsd.zig
index 6d227a168a..1805941993 100644
--- a/lib/std/os/bits/freebsd.zig
+++ b/lib/std/os/bits/freebsd.zig
@@ -7,6 +7,8 @@ const std = @import("../../std.zig");
 const builtin = @import("builtin");
 const maxInt = std.math.maxInt;
 
+pub usingnamespace @import("posix.zig");
+
 pub const blksize_t = i32;
 pub const blkcnt_t = i64;
 pub const clockid_t = i32;
diff --git a/lib/std/os/bits/haiku.zig b/lib/std/os/bits/haiku.zig
index cb31166608..b3ea4aa0e2 100644
--- a/lib/std/os/bits/haiku.zig
+++ b/lib/std/os/bits/haiku.zig
@@ -6,6 +6,8 @@
 const std = @import("../../std.zig");
 const maxInt = std.math.maxInt;
 
+pub usingnamespace @import("posix.zig");
+
 pub const fd_t = c_int;
 pub const pid_t = c_int;
 pub const uid_t = u32;
diff --git a/lib/std/os/bits/linux.zig b/lib/std/os/bits/linux.zig
index 81bdfa6608..28683d47a9 100644
--- a/lib/std/os/bits/linux.zig
+++ b/lib/std/os/bits/linux.zig
@@ -6,7 +6,7 @@
 const std = @import("../../std.zig");
 const maxInt = std.math.maxInt;
 const arch = @import("builtin").target.cpu.arch;
-usingnamespace @import("../bits.zig");
+pub usingnamespace @import("posix.zig");
 
 pub usingnamespace switch (arch) {
     .mips, .mipsel => @import("linux/errno-mips.zig"),
diff --git a/lib/std/os/bits/netbsd.zig b/lib/std/os/bits/netbsd.zig
index d0240709e3..f3ece93493 100644
--- a/lib/std/os/bits/netbsd.zig
+++ b/lib/std/os/bits/netbsd.zig
@@ -7,6 +7,8 @@ const std = @import("../../std.zig");
 const builtin = std.builtin;
 const maxInt = std.math.maxInt;
 
+pub usingnamespace @import("posix.zig");
+
 pub const blkcnt_t = i64;
 pub const blksize_t = i32;
 pub const clock_t = u32;
diff --git a/lib/std/os/bits/openbsd.zig b/lib/std/os/bits/openbsd.zig
index 3b9f8ccd4a..233ebcbd68 100644
--- a/lib/std/os/bits/openbsd.zig
+++ b/lib/std/os/bits/openbsd.zig
@@ -7,6 +7,8 @@ const std = @import("../../std.zig");
 const builtin = std.builtin;
 const maxInt = std.math.maxInt;
 
+pub usingnamespace @import("posix.zig");
+
 pub const blkcnt_t = i64;
 pub const blksize_t = i32;
 pub const clock_t = i64;
diff --git a/lib/std/os/bits/posix.zig b/lib/std/os/bits/posix.zig
new file mode 100644
index 0000000000..0f015cd573
--- /dev/null
+++ b/lib/std/os/bits/posix.zig
@@ -0,0 +1,34 @@
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2015-2021 Zig Contributors
+// This file is part of [zig](https://ziglang.org/), which is MIT licensed.
+// The MIT license requires this copyright notice to be included in all copies
+// and substantial portions of the software.
+
+pub const iovec = extern struct {
+    iov_base: [*]u8,
+    iov_len: usize,
+};
+
+pub const iovec_const = extern struct {
+    iov_base: [*]const u8,
+    iov_len: usize,
+};
+
+// syslog
+
+/// system is unusable
+pub const LOG_EMERG = 0;
+/// action must be taken immediately
+pub const LOG_ALERT = 1;
+/// critical conditions
+pub const LOG_CRIT = 2;
+/// error conditions
+pub const LOG_ERR = 3;
+/// warning conditions
+pub const LOG_WARNING = 4;
+/// normal but significant condition
+pub const LOG_NOTICE = 5;
+/// informational
+pub const LOG_INFO = 6;
+/// debug-level messages
+pub const LOG_DEBUG = 7;
diff --git a/lib/std/os/bits/wasi.zig b/lib/std/os/bits/wasi.zig
index 8b2f5c3351..5cb1334037 100644
--- a/lib/std/os/bits/wasi.zig
+++ b/lib/std/os/bits/wasi.zig
@@ -4,6 +4,10 @@
 // The MIT license requires this copyright notice to be included in all copies
 // and substantial portions of the software.
 // Convenience types and consts used by std.os module
+const posix = @import("posix.zig");
+pub const iovec = posix.iovec;
+pub const iovec_const = posix.iovec_const;
+
 pub const STDIN_FILENO = 0;
 pub const STDOUT_FILENO = 1;
 pub const STDERR_FILENO = 2;
diff --git a/lib/std/os/bits/windows.zig b/lib/std/os/bits/windows.zig
index c5b101296b..05c50ffe47 100644
--- a/lib/std/os/bits/windows.zig
+++ b/lib/std/os/bits/windows.zig
@@ -8,6 +8,11 @@
 usingnamespace @import("../windows/bits.zig");
 const ws2_32 = @import("../windows/ws2_32.zig");
 
+// TODO: Stop using os.iovec in std.fs et al on Windows in the future
+const posix = @import("posix.zig");
+pub const iovec = posix.iovec;
+pub const iovec_const = posix.iovec_const;
+
 pub const fd_t = HANDLE;
 pub const ino_t = LARGE_INTEGER;
 pub const pid_t = HANDLE;
diff --git a/lib/std/os/linux/arm-eabi.zig b/lib/std/os/linux/arm-eabi.zig
index 0fe74c9665..469b7299d1 100644
--- a/lib/std/os/linux/arm-eabi.zig
+++ b/lib/std/os/linux/arm-eabi.zig
@@ -3,7 +3,6 @@
 // This file is part of [zig](https://ziglang.org/), which is MIT licensed.
 // The MIT license requires this copyright notice to be included in all copies
 // and substantial portions of the software.
-usingnamespace @import("../bits.zig");
 usingnamespace @import("../bits/linux.zig");
 
 pub fn syscall0(number: SYS) usize {
diff --git a/lib/std/os/linux/arm64.zig b/lib/std/os/linux/arm64.zig
index 0e1af98493..4c8306c048 100644
--- a/lib/std/os/linux/arm64.zig
+++ b/lib/std/os/linux/arm64.zig
@@ -3,7 +3,6 @@
 // This file is part of [zig](https://ziglang.org/), which is MIT licensed.
 // The MIT license requires this copyright notice to be included in all copies
 // and substantial portions of the software.
-usingnamespace @import("../bits.zig");
 usingnamespace @import("../bits/linux.zig");
 
 pub fn syscall0(number: SYS) usize {
diff --git a/lib/std/os/linux/i386.zig b/lib/std/os/linux/i386.zig
index df58336eb0..2ec34bac40 100644
--- a/lib/std/os/linux/i386.zig
+++ b/lib/std/os/linux/i386.zig
@@ -3,7 +3,6 @@
 // This file is part of [zig](https://ziglang.org/), which is MIT licensed.
 // The MIT license requires this copyright notice to be included in all copies
 // and substantial portions of the software.
-usingnamespace @import("../bits.zig");
 usingnamespace @import("../bits/linux.zig");
 
 pub fn syscall0(number: SYS) usize {
diff --git a/lib/std/os/linux/mips.zig b/lib/std/os/linux/mips.zig
index 2ac029cae8..85157f04f8 100644
--- a/lib/std/os/linux/mips.zig
+++ b/lib/std/os/linux/mips.zig
@@ -3,7 +3,6 @@
 // This file is part of [zig](https://ziglang.org/), which is MIT licensed.
 // The MIT license requires this copyright notice to be included in all copies
 // and substantial portions of the software.
-usingnamespace @import("../bits.zig");
 usingnamespace @import("../bits/linux.zig");
 
 pub fn syscall0(number: SYS) usize {
diff --git a/lib/std/os/linux/powerpc.zig b/lib/std/os/linux/powerpc.zig
index 341eb3f920..611eee1c5f 100644
--- a/lib/std/os/linux/powerpc.zig
+++ b/lib/std/os/linux/powerpc.zig
@@ -4,7 +4,6 @@
 // The MIT license requires this copyright notice to be included in all copies
 // and substantial portions of the software.
 
-usingnamespace @import("../bits.zig");
 usingnamespace @import("../bits/linux.zig");
 
 pub fn syscall0(number: SYS) usize {
diff --git a/lib/std/os/linux/powerpc64.zig b/lib/std/os/linux/powerpc64.zig
index 341eb3f920..611eee1c5f 100644
--- a/lib/std/os/linux/powerpc64.zig
+++ b/lib/std/os/linux/powerpc64.zig
@@ -4,7 +4,6 @@
 // The MIT license requires this copyright notice to be included in all copies
 // and substantial portions of the software.
 
-usingnamespace @import("../bits.zig");
 usingnamespace @import("../bits/linux.zig");
 
 pub fn syscall0(number: SYS) usize {
diff --git a/lib/std/os/linux/riscv64.zig b/lib/std/os/linux/riscv64.zig
index cab2ecfbaf..3e2b15b599 100644
--- a/lib/std/os/linux/riscv64.zig
+++ b/lib/std/os/linux/riscv64.zig
@@ -3,7 +3,6 @@
 // This file is part of [zig](https://ziglang.org/), which is MIT licensed.
 // The MIT license requires this copyright notice to be included in all copies
 // and substantial portions of the software.
-usingnamespace @import("../bits.zig");
 usingnamespace @import("../bits/linux.zig");
 
 pub fn syscall0(number: SYS) usize {
diff --git a/lib/std/os/linux/sparc64.zig b/lib/std/os/linux/sparc64.zig
index cbe5ee3b70..f347a0e88e 100644
--- a/lib/std/os/linux/sparc64.zig
+++ b/lib/std/os/linux/sparc64.zig
@@ -1,4 +1,3 @@
-usingnamespace @import("../bits.zig");
 usingnamespace @import("../bits/linux.zig");
 
 pub fn syscall_pipe(fd: *[2]i32) usize {
diff --git a/lib/std/os/linux/thumb.zig b/lib/std/os/linux/thumb.zig
index 955c3420d4..85f8bfc52b 100644
--- a/lib/std/os/linux/thumb.zig
+++ b/lib/std/os/linux/thumb.zig
@@ -3,7 +3,6 @@
 // This file is part of [zig](https://ziglang.org/), which is MIT licensed.
 // The MIT license requires this copyright notice to be included in all copies
 // and substantial portions of the software.
-usingnamespace @import("../bits.zig");
 usingnamespace @import("../bits/linux.zig");
 
 // The syscall interface is identical to the ARM one but we're facing an extra
diff --git a/lib/std/os/linux/x86_64.zig b/lib/std/os/linux/x86_64.zig
index da4206a521..5aa32c56c3 100644
--- a/lib/std/os/linux/x86_64.zig
+++ b/lib/std/os/linux/x86_64.zig
@@ -3,7 +3,6 @@
 // This file is part of [zig](https://ziglang.org/), which is MIT licensed.
 // The MIT license requires this copyright notice to be included in all copies
 // and substantial portions of the software.
-usingnamespace @import("../bits.zig");
 usingnamespace @import("../bits/linux.zig");
 
 pub fn syscall0(number: SYS) usize {

From 68e26a2ceea85a149cb23286504cbdcec1ae814e Mon Sep 17 00:00:00 2001
From: Jakub Konka <kubkon@jakubkonka.com>
Date: Mon, 2 Aug 2021 11:10:07 +0200
Subject: [PATCH 64/96] std: check for overflow in writeCurrentStackTrace

On arm64 macOS, the address of the last frame is 0x0 rather than
a positive value like 0x1 on x86_64 macOS, therefore, we overflow
an integer trying to subtract 1 when printing the stack trace. This
patch fixes it by first checking for this condition before trying
to subtract 1.

Note that we do not need to signal the `SignalIterator` about this
as it will correctly detect this condition on the subsequent iteration
and return `null`, thus terminating the loop.
---
 lib/std/debug.zig | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/lib/std/debug.zig b/lib/std/debug.zig
index f74d0b3f91..c3ef9dec4c 100644
--- a/lib/std/debug.zig
+++ b/lib/std/debug.zig
@@ -438,7 +438,12 @@ pub fn writeCurrentStackTrace(
     }
     var it = StackIterator.init(start_addr, null);
     while (it.next()) |return_address| {
-        try printSourceAtAddress(debug_info, out_stream, return_address - 1, tty_config);
+        // On arm64 macOS, the address of the last frame is 0x0 rather than 0x1 as on x86_64 macOS,
+        // therefore, we do a check for `return_address == 0` before subtracting 1 from it to avoid
+        // an overflow. We do not need to signal `StackIterator` as it will correctly detect this
+        // condition on the subsequent iteration and return `null` thus terminating the loop.
+        const address = if (return_address == 0) return_address else return_address - 1;
+        try printSourceAtAddress(debug_info, out_stream, address, tty_config);
     }
 }
 

From 159cd528b164f77177e71309dee9fa79d2d5f4f4 Mon Sep 17 00:00:00 2001
From: Jakub Konka <kubkon@jakubkonka.com>
Date: Mon, 2 Aug 2021 10:04:54 +0200
Subject: [PATCH 65/96] Add -Denable-macos-sdk explicit flag to build.zig

This way, we can explicitly signal if a test requires the presence
of macOS SDK to build. For instance, when testing our in-house
MachO linker for correctly linking Objective-C, we require the
presence of the SDK on the host system, and we can enforce this
with `-Denable-macos-sdk` flag to `zig build test-standalone`.
---
 build.zig                      |  3 ++-
 ci/azure/macos_script          |  2 +-
 test/standalone.zig            |  4 +---
 test/standalone/objc/build.zig | 18 ++++++++++++++++--
 test/tests.zig                 | 19 +++++++++++++++++--
 5 files changed, 37 insertions(+), 9 deletions(-)

diff --git a/build.zig b/build.zig
index 40e1b36e71..f60cd573a4 100644
--- a/build.zig
+++ b/build.zig
@@ -61,6 +61,7 @@ pub fn build(b: *Builder) !void {
     const omit_stage2 = b.option(bool, "omit-stage2", "Do not include stage2 behind a feature flag inside stage1") orelse false;
     const static_llvm = b.option(bool, "static-llvm", "Disable integration with system-installed LLVM, Clang, LLD, and libc++") orelse false;
     const enable_llvm = b.option(bool, "enable-llvm", "Build self-hosted compiler with LLVM backend enabled") orelse (is_stage1 or static_llvm);
+    const enable_macos_sdk = b.option(bool, "enable-macos-sdk", "Run tests requiring presence of macOS SDK and frameworks") orelse false;
     const config_h_path_option = b.option([]const u8, "config_h", "Path to the generated config.h");
 
     if (!skip_install_lib_files) {
@@ -340,7 +341,7 @@ pub fn build(b: *Builder) !void {
     ));
 
     toolchain_step.dependOn(tests.addCompareOutputTests(b, test_filter, modes));
-    toolchain_step.dependOn(tests.addStandaloneTests(b, test_filter, modes, skip_non_native, target));
+    toolchain_step.dependOn(tests.addStandaloneTests(b, test_filter, modes, skip_non_native, enable_macos_sdk, target));
     toolchain_step.dependOn(tests.addStackTraceTests(b, test_filter, modes));
     toolchain_step.dependOn(tests.addCliTests(b, test_filter, modes));
     toolchain_step.dependOn(tests.addAssembleAndLinkTests(b, test_filter, modes));
diff --git a/ci/azure/macos_script b/ci/azure/macos_script
index 01ac3f5838..d56ba63b6b 100755
--- a/ci/azure/macos_script
+++ b/ci/azure/macos_script
@@ -57,7 +57,7 @@ make $JOBS install
 # TODO figure out why this causes a segmentation fault
 # release/bin/zig test ../test/behavior.zig -fno-stage1 -fLLVM -I ../test
 
-release/bin/zig build test-toolchain
+release/bin/zig build test-toolchain -Denable-macos-sdk
 release/bin/zig build test-std
 release/bin/zig build docs
 
diff --git a/test/standalone.zig b/test/standalone.zig
index 52fba31828..9a32701ddd 100644
--- a/test/standalone.zig
+++ b/test/standalone.zig
@@ -38,9 +38,7 @@ pub fn addCases(cases: *tests.StandaloneContext) void {
         cases.addBuildFile("test/standalone/pie/build.zig", .{});
     }
     // Try to build and run an Objective-C executable.
-    if (std.Target.current.os.tag == .macos) {
-        cases.addBuildFile("test/standalone/objc/build.zig", .{ .build_modes = true });
-    }
+    cases.addBuildFile("test/standalone/objc/build.zig", .{ .build_modes = true, .requires_macos_sdk = true });
 
     // Ensure the development tools are buildable.
     cases.add("tools/gen_spirv_spec.zig");
diff --git a/test/standalone/objc/build.zig b/test/standalone/objc/build.zig
index 30becd398c..7fdec514e7 100644
--- a/test/standalone/objc/build.zig
+++ b/test/standalone/objc/build.zig
@@ -1,5 +1,15 @@
 const std = @import("std");
 const Builder = std.build.Builder;
+const CrossTarget = std.zig.CrossTarget;
+
+fn isRunnableTarget(t: CrossTarget) bool {
+    // TODO I think we might be able to run this on Linux via Darling.
+    // Add a check for that here, and return true if Darling is available.
+    if (t.isNative() and t.getOsTag() == .macos)
+        return true
+    else
+        return false;
+}
 
 pub fn build(b: *Builder) void {
     const mode = b.standardReleaseOptions();
@@ -15,8 +25,12 @@ pub fn build(b: *Builder) void {
     exe.setBuildMode(mode);
     exe.setTarget(target);
     exe.linkLibC();
+    // TODO when we figure out how to ship framework stubs for cross-compilation,
+    // populate paths to the sysroot here.
     exe.linkFramework("Foundation");
 
-    const run_cmd = exe.run();
-    test_step.dependOn(&run_cmd.step);
+    if (isRunnableTarget(target)) {
+        const run_cmd = exe.run();
+        test_step.dependOn(&run_cmd.step);
+    }
 }
diff --git a/test/tests.zig b/test/tests.zig
index 0b736792b9..fc83137bc4 100644
--- a/test/tests.zig
+++ b/test/tests.zig
@@ -383,7 +383,14 @@ pub fn addRuntimeSafetyTests(b: *build.Builder, test_filter: ?[]const u8, modes:
     return cases.step;
 }
 
-pub fn addStandaloneTests(b: *build.Builder, test_filter: ?[]const u8, modes: []const Mode, skip_non_native: bool, target: std.zig.CrossTarget) *build.Step {
+pub fn addStandaloneTests(
+    b: *build.Builder,
+    test_filter: ?[]const u8,
+    modes: []const Mode,
+    skip_non_native: bool,
+    enable_macos_sdk: bool,
+    target: std.zig.CrossTarget,
+) *build.Step {
     const cases = b.allocator.create(StandaloneContext) catch unreachable;
     cases.* = StandaloneContext{
         .b = b,
@@ -392,6 +399,7 @@ pub fn addStandaloneTests(b: *build.Builder, test_filter: ?[]const u8, modes: []
         .test_filter = test_filter,
         .modes = modes,
         .skip_non_native = skip_non_native,
+        .enable_macos_sdk = enable_macos_sdk,
         .target = target,
     };
 
@@ -831,6 +839,7 @@ pub const StandaloneContext = struct {
     test_filter: ?[]const u8,
     modes: []const Mode,
     skip_non_native: bool,
+    enable_macos_sdk: bool,
     target: std.zig.CrossTarget,
 
     pub fn addC(self: *StandaloneContext, root_src: []const u8) void {
@@ -841,9 +850,15 @@ pub const StandaloneContext = struct {
         self.addAllArgs(root_src, false);
     }
 
-    pub fn addBuildFile(self: *StandaloneContext, build_file: []const u8, features: struct { build_modes: bool = false, cross_targets: bool = false }) void {
+    pub fn addBuildFile(self: *StandaloneContext, build_file: []const u8, features: struct {
+        build_modes: bool = false,
+        cross_targets: bool = false,
+        requires_macos_sdk: bool = false,
+    }) void {
         const b = self.b;
 
+        if (features.requires_macos_sdk and !self.enable_macos_sdk) return;
+
         const annotated_case_name = b.fmt("build {s}", .{build_file});
         if (self.test_filter) |filter| {
             if (mem.indexOf(u8, annotated_case_name, filter) == null) return;

From f3b328ee8cb9c8340afaec510055d41aa4895583 Mon Sep 17 00:00:00 2001
From: Jakub Konka <kubkon@jakubkonka.com>
Date: Mon, 2 Aug 2021 17:40:39 +0200
Subject: [PATCH 66/96] macho: refactor tracking of referenced dylibs

Now, index in the global referenced array hashmap is equivalent to
the dylib's ordinal in the final linked image.
---
 src/link/MachO.zig       | 72 +++++++++++++++++++++-------------------
 src/link/MachO/Dylib.zig |  2 --
 2 files changed, 38 insertions(+), 36 deletions(-)

diff --git a/src/link/MachO.zig b/src/link/MachO.zig
index 61b2ff888c..bfc0ab8ff6 100644
--- a/src/link/MachO.zig
+++ b/src/link/MachO.zig
@@ -63,9 +63,9 @@ entry_addr: ?u64 = null,
 
 objects: std.ArrayListUnmanaged(Object) = .{},
 archives: std.ArrayListUnmanaged(Archive) = .{},
-dylibs: std.ArrayListUnmanaged(Dylib) = .{},
 
-next_dylib_ordinal: u16 = 1,
+dylibs: std.ArrayListUnmanaged(Dylib) = .{},
+referenced_dylibs: std.AutoArrayHashMapUnmanaged(u16, void) = .{},
 
 load_commands: std.ArrayListUnmanaged(LoadCommand) = .{},
 
@@ -929,6 +929,17 @@ fn linkWithZld(self: *MachO, comp: *Compilation) !void {
             else => unreachable,
         };
 
+        // TODO mimicking insertion of null symbol from incremental linker.
+        // This will need to moved.
+        try self.locals.append(self.base.allocator, .{
+            .n_strx = 0,
+            .n_type = macho.N_UNDF,
+            .n_sect = 0,
+            .n_desc = 0,
+            .n_value = 0,
+        });
+        try self.strtab.append(self.base.allocator, 0);
+
         // Initialize section ordinals with null ordinal pointing at
         // PAGEZERO segment.
         try self.section_ordinals.append(self.base.allocator, .{
@@ -958,7 +969,8 @@ fn linkWithZld(self: *MachO, comp: *Compilation) !void {
         }
 
         try self.sortSections();
-        try self.addRpaths(rpaths.items);
+        try self.addRpathLCs(rpaths.items);
+        try self.addLoadDylibLCs();
         try self.addDataInCodeLC();
         try self.addCodeSignatureLC();
         try self.allocateTextSegment();
@@ -2196,17 +2208,6 @@ fn resolveSymbolsInObject(self: *MachO, object_id: u16) !void {
 }
 
 fn resolveSymbols(self: *MachO) !void {
-    // TODO mimicking insertion of null symbol from incremental linker.
-    // This will need to moved.
-    try self.locals.append(self.base.allocator, .{
-        .n_strx = 0,
-        .n_type = macho.N_UNDF,
-        .n_sect = 0,
-        .n_desc = 0,
-        .n_value = 0,
-    });
-    try self.strtab.append(self.base.allocator, 0);
-
     // First pass, resolve symbols in provided objects.
     for (self.objects.items) |_, object_id| {
         try self.resolveSymbolsInObject(@intCast(u16, object_id));
@@ -2335,9 +2336,6 @@ fn resolveSymbols(self: *MachO) !void {
         });
     }
 
-    var referenced = std.AutoHashMap(u16, void).init(self.base.allocator);
-    defer referenced.deinit();
-
     loop: for (self.undefs.items) |sym| {
         if (symbolIsNull(sym)) continue;
 
@@ -2345,23 +2343,12 @@ fn resolveSymbols(self: *MachO) !void {
         for (self.dylibs.items) |*dylib, id| {
             if (!dylib.symbols.contains(sym_name)) continue;
 
-            if (!referenced.contains(@intCast(u16, id))) {
-                // Add LC_LOAD_DYLIB load command for each referenced dylib/stub.
-                dylib.ordinal = self.next_dylib_ordinal;
-                const dylib_id = dylib.id orelse unreachable;
-                var dylib_cmd = try commands.createLoadDylibCommand(
-                    self.base.allocator,
-                    dylib_id.name,
-                    dylib_id.timestamp,
-                    dylib_id.current_version,
-                    dylib_id.compatibility_version,
-                );
-                errdefer dylib_cmd.deinit(self.base.allocator);
-                try self.load_commands.append(self.base.allocator, .{ .Dylib = dylib_cmd });
-                self.next_dylib_ordinal += 1;
-                try referenced.putNoClobber(@intCast(u16, id), {});
+            const dylib_id = @intCast(u16, id);
+            if (!self.referenced_dylibs.contains(dylib_id)) {
+                try self.referenced_dylibs.putNoClobber(self.base.allocator, dylib_id, {});
             }
 
+            const ordinal = self.referenced_dylibs.getIndex(dylib_id) orelse unreachable;
             const resolv = self.symbol_resolver.getPtr(sym.n_strx) orelse unreachable;
             const undef = &self.undefs.items[resolv.where_index];
             const import_sym_index = @intCast(u32, self.imports.items.len);
@@ -2369,7 +2356,7 @@ fn resolveSymbols(self: *MachO) !void {
                 .n_strx = undef.n_strx,
                 .n_type = macho.N_UNDF | macho.N_EXT,
                 .n_sect = 0,
-                .n_desc = packDylibOrdinal(dylib.ordinal.?),
+                .n_desc = packDylibOrdinal(@intCast(u16, ordinal + 1)),
                 .n_value = 0,
             });
             resolv.* = .{
@@ -2804,7 +2791,7 @@ fn addCodeSignatureLC(self: *MachO) !void {
     }
 }
 
-fn addRpaths(self: *MachO, rpaths: []const []const u8) !void {
+fn addRpathLCs(self: *MachO, rpaths: []const []const u8) !void {
     for (rpaths) |rpath| {
         const cmdsize = @intCast(u32, mem.alignForwardGeneric(
             u64,
@@ -2823,6 +2810,22 @@ fn addRpaths(self: *MachO, rpaths: []const []const u8) !void {
     }
 }
 
+fn addLoadDylibLCs(self: *MachO) !void {
+    for (self.referenced_dylibs.keys()) |id| {
+        const dylib = self.dylibs.items[id];
+        const dylib_id = dylib.id orelse unreachable;
+        var dylib_cmd = try commands.createLoadDylibCommand(
+            self.base.allocator,
+            dylib_id.name,
+            dylib_id.timestamp,
+            dylib_id.current_version,
+            dylib_id.compatibility_version,
+        );
+        errdefer dylib_cmd.deinit(self.base.allocator);
+        try self.load_commands.append(self.base.allocator, .{ .Dylib = dylib_cmd });
+    }
+}
+
 fn flushZld(self: *MachO) !void {
     self.load_commands_dirty = true;
     try self.writeTextBlocks();
@@ -3353,6 +3356,7 @@ pub fn deinit(self: *MachO) void {
         dylib.deinit(self.base.allocator);
     }
     self.dylibs.deinit(self.base.allocator);
+    self.referenced_dylibs.deinit(self.base.allocator);
 
     for (self.load_commands.items) |*lc| {
         lc.deinit(self.base.allocator);
diff --git a/src/link/MachO/Dylib.zig b/src/link/MachO/Dylib.zig
index 7b2f94ba67..1d2833c764 100644
--- a/src/link/MachO/Dylib.zig
+++ b/src/link/MachO/Dylib.zig
@@ -22,8 +22,6 @@ name: []const u8,
 
 header: ?macho.mach_header_64 = null,
 
-ordinal: ?u16 = null,
-
 // The actual dylib contents we care about linking with will be embedded at
 // an offset within a file if we are linking against a fat lib
 library_offset: u64 = 0,

From bf25650974933cdb8c1314a85e0838257f6f4471 Mon Sep 17 00:00:00 2001
From: Jakub Konka <kubkon@jakubkonka.com>
Date: Mon, 2 Aug 2021 18:15:27 +0200
Subject: [PATCH 67/96] macho: refactor management of section ordinals

Instead of storing a two-way relation (seg,sect) <=> ordinal
we get the latter with `getIndex((seg, sect))`.
---
 src/link/MachO.zig           | 55 ++++++++++++------------------------
 src/link/MachO/Object.zig    | 10 +++----
 src/link/MachO/TextBlock.zig |  6 ++--
 3 files changed, 26 insertions(+), 45 deletions(-)

diff --git a/src/link/MachO.zig b/src/link/MachO.zig
index bfc0ab8ff6..d3412cec3d 100644
--- a/src/link/MachO.zig
+++ b/src/link/MachO.zig
@@ -168,8 +168,7 @@ strtab_needs_relocation: bool = false,
 has_dices: bool = false,
 has_stabs: bool = false,
 
-section_ordinals: std.ArrayListUnmanaged(MatchingSection) = .{},
-section_to_ordinal: std.AutoHashMapUnmanaged(MatchingSection, u8) = .{},
+section_ordinals: std.AutoArrayHashMapUnmanaged(MatchingSection, void) = .{},
 
 pending_updates: std.ArrayListUnmanaged(struct {
     kind: enum {
@@ -940,13 +939,6 @@ fn linkWithZld(self: *MachO, comp: *Compilation) !void {
         });
         try self.strtab.append(self.base.allocator, 0);
 
-        // Initialize section ordinals with null ordinal pointing at
-        // PAGEZERO segment.
-        try self.section_ordinals.append(self.base.allocator, .{
-            .seg = 0,
-            .sect = 0,
-        });
-
         try self.populateMetadata();
         try self.parseInputFiles(positionals.items, self.base.options.sysroot);
         try self.parseLibs(libs.items, self.base.options.sysroot);
@@ -1454,7 +1446,7 @@ pub fn getMatchingSection(self: *MachO, sect: macho.section_64) !?MatchingSectio
     };
 
     if (res) |match| {
-        try self.createSectionOrdinal(match);
+        _ = try self.section_ordinals.getOrPut(self.base.allocator, match);
     }
 
     return res;
@@ -1586,32 +1578,29 @@ fn sortSections(self: *MachO) !void {
     {
         // Create new section ordinals.
         self.section_ordinals.clearRetainingCapacity();
-        self.section_to_ordinal.clearRetainingCapacity();
-        // First ordinal is always null
-        self.section_ordinals.appendAssumeCapacity(.{
-            .seg = 0,
-            .sect = 0,
-        });
         const text_seg = self.load_commands.items[self.text_segment_cmd_index.?].Segment;
         for (text_seg.sections.items) |_, sect_id| {
-            try self.createSectionOrdinal(.{
+            const res = self.section_ordinals.getOrPutAssumeCapacity(.{
                 .seg = self.text_segment_cmd_index.?,
                 .sect = @intCast(u16, sect_id),
             });
+            assert(!res.found_existing);
         }
         const data_const_seg = self.load_commands.items[self.data_const_segment_cmd_index.?].Segment;
         for (data_const_seg.sections.items) |_, sect_id| {
-            try self.createSectionOrdinal(.{
+            const res = self.section_ordinals.getOrPutAssumeCapacity(.{
                 .seg = self.data_const_segment_cmd_index.?,
                 .sect = @intCast(u16, sect_id),
             });
+            assert(!res.found_existing);
         }
         const data_seg = self.load_commands.items[self.data_segment_cmd_index.?].Segment;
         for (data_seg.sections.items) |_, sect_id| {
-            try self.createSectionOrdinal(.{
+            const res = self.section_ordinals.getOrPutAssumeCapacity(.{
                 .seg = self.data_segment_cmd_index.?,
                 .sect = @intCast(u16, sect_id),
             });
+            assert(!res.found_existing);
         }
     }
 }
@@ -1740,7 +1729,7 @@ fn allocateTextBlocks(self: *MachO) !void {
         const sect = seg.sections.items[match.sect];
 
         var base_addr: u64 = sect.addr;
-        const n_sect = self.section_to_ordinal.get(match) orelse unreachable;
+        const n_sect = @intCast(u8, self.section_ordinals.getIndex(match).? + 1);
 
         log.debug("  within section {s},{s}", .{ commands.segmentName(sect), commands.sectionName(sect) });
         log.debug("    {}", .{sect});
@@ -2262,7 +2251,7 @@ fn resolveSymbols(self: *MachO) !void {
                 .sect = self.common_section_index.?,
             };
         };
-        try self.createSectionOrdinal(match);
+        _ = try self.section_ordinals.getOrPut(self.base.allocator, match);
 
         const size = sym.n_value;
         const code = try self.base.allocator.alloc(u8, size);
@@ -2275,7 +2264,7 @@ fn resolveSymbols(self: *MachO) !void {
         var nlist = macho.nlist_64{
             .n_strx = sym.n_strx,
             .n_type = macho.N_SECT,
-            .n_sect = self.section_to_ordinal.get(match) orelse unreachable,
+            .n_sect = @intCast(u8, self.section_ordinals.getIndex(match).? + 1),
             .n_desc = 0,
             .n_value = 0,
         };
@@ -2391,7 +2380,7 @@ fn resolveSymbols(self: *MachO) !void {
         var nlist = macho.nlist_64{
             .n_strx = undef.n_strx,
             .n_type = macho.N_SECT,
-            .n_sect = self.section_to_ordinal.get(match) orelse unreachable,
+            .n_sect = @intCast(u8, self.section_ordinals.getIndex(match).? + 1),
             .n_desc = 0,
             .n_value = 0,
         };
@@ -2487,7 +2476,7 @@ fn populateMetadata(self: *MachO) !void {
             .@"align" = alignment,
             .flags = macho.S_REGULAR | macho.S_ATTR_PURE_INSTRUCTIONS | macho.S_ATTR_SOME_INSTRUCTIONS,
         });
-        try self.createSectionOrdinal(.{
+        _ = try self.section_ordinals.getOrPut(self.base.allocator, .{
             .seg = self.text_segment_cmd_index.?,
             .sect = self.text_section_index.?,
         });
@@ -2511,7 +2500,7 @@ fn populateMetadata(self: *MachO) !void {
             .flags = macho.S_SYMBOL_STUBS | macho.S_ATTR_PURE_INSTRUCTIONS | macho.S_ATTR_SOME_INSTRUCTIONS,
             .reserved2 = stub_size,
         });
-        try self.createSectionOrdinal(.{
+        _ = try self.section_ordinals.getOrPut(self.base.allocator, .{
             .seg = self.text_segment_cmd_index.?,
             .sect = self.stubs_section_index.?,
         });
@@ -2535,7 +2524,7 @@ fn populateMetadata(self: *MachO) !void {
             .@"align" = alignment,
             .flags = macho.S_REGULAR | macho.S_ATTR_PURE_INSTRUCTIONS | macho.S_ATTR_SOME_INSTRUCTIONS,
         });
-        try self.createSectionOrdinal(.{
+        _ = try self.section_ordinals.getOrPut(self.base.allocator, .{
             .seg = self.text_segment_cmd_index.?,
             .sect = self.stub_helper_section_index.?,
         });
@@ -2558,7 +2547,7 @@ fn populateMetadata(self: *MachO) !void {
             .@"align" = 3, // 2^3 = @sizeOf(u64)
             .flags = macho.S_NON_LAZY_SYMBOL_POINTERS,
         });
-        try self.createSectionOrdinal(.{
+        _ = try self.section_ordinals.getOrPut(self.base.allocator, .{
             .seg = self.data_const_segment_cmd_index.?,
             .sect = self.got_section_index.?,
         });
@@ -2581,7 +2570,7 @@ fn populateMetadata(self: *MachO) !void {
             .@"align" = 3, // 2^3 = @sizeOf(u64)
             .flags = macho.S_LAZY_SYMBOL_POINTERS,
         });
-        try self.createSectionOrdinal(.{
+        _ = try self.section_ordinals.getOrPut(self.base.allocator, .{
             .seg = self.data_segment_cmd_index.?,
             .sect = self.la_symbol_ptr_section_index.?,
         });
@@ -2593,7 +2582,7 @@ fn populateMetadata(self: *MachO) !void {
         try data_seg.addSection(self.base.allocator, "__data", .{
             .@"align" = 3, // 2^3 = @sizeOf(u64)
         });
-        try self.createSectionOrdinal(.{
+        _ = try self.section_ordinals.getOrPut(self.base.allocator, .{
             .seg = self.data_segment_cmd_index.?,
             .sect = self.data_section_index.?,
         });
@@ -3324,7 +3313,6 @@ pub fn deinit(self: *MachO) void {
     }
 
     self.section_ordinals.deinit(self.base.allocator);
-    self.section_to_ordinal.deinit(self.base.allocator);
     self.pending_updates.deinit(self.base.allocator);
     self.got_entries.deinit(self.base.allocator);
     self.got_entries_map.deinit(self.base.allocator);
@@ -5882,13 +5870,6 @@ pub fn findFirst(comptime T: type, haystack: []T, start: usize, predicate: anyty
     return i;
 }
 
-fn createSectionOrdinal(self: *MachO, match: MatchingSection) !void {
-    if (self.section_to_ordinal.contains(match)) return;
-    const ordinal = @intCast(u8, self.section_ordinals.items.len);
-    try self.section_ordinals.append(self.base.allocator, match);
-    try self.section_to_ordinal.putNoClobber(self.base.allocator, match, ordinal);
-}
-
 fn printSymtabAndTextBlock(self: *MachO) void {
     log.debug("locals", .{});
     for (self.locals.items) |sym, id| {
diff --git a/src/link/MachO/Object.zig b/src/link/MachO/Object.zig
index 04071a1cdb..2e6a20ad4b 100644
--- a/src/link/MachO/Object.zig
+++ b/src/link/MachO/Object.zig
@@ -402,7 +402,7 @@ const TextBlockParser = struct {
 
         const senior_nlist = aliases.pop();
         const senior_sym = &context.macho_file.locals.items[senior_nlist.index];
-        senior_sym.n_sect = context.macho_file.section_to_ordinal.get(context.match) orelse unreachable;
+        senior_sym.n_sect = @intCast(u8, context.macho_file.section_ordinals.getIndex(context.match).? + 1);
 
         const start_addr = senior_nlist.nlist.n_value - self.section.addr;
         const end_addr = if (next_nlist) |n| n.nlist.n_value - self.section.addr else self.section.size;
@@ -446,7 +446,7 @@ const TextBlockParser = struct {
         for (aliases.items) |alias| {
             block.aliases.appendAssumeCapacity(alias.index);
             const sym = &context.macho_file.locals.items[alias.index];
-            sym.n_sect = context.macho_file.section_to_ordinal.get(context.match) orelse unreachable;
+            sym.n_sect = @intCast(u8, context.macho_file.section_ordinals.getIndex(context.match).? + 1);
         }
 
         try block.parseRelocs(self.relocs, .{
@@ -588,7 +588,7 @@ pub fn parseTextBlocks(
                         try macho_file.locals.append(allocator, .{
                             .n_strx = try macho_file.makeString(sym_name),
                             .n_type = macho.N_SECT,
-                            .n_sect = macho_file.section_to_ordinal.get(match) orelse unreachable,
+                            .n_sect = @intCast(u8, macho_file.section_ordinals.getIndex(match).? + 1),
                             .n_desc = 0,
                             .n_value = sect.addr,
                         });
@@ -733,7 +733,7 @@ pub fn parseTextBlocks(
                 try macho_file.locals.append(allocator, .{
                     .n_strx = try macho_file.makeString(sym_name),
                     .n_type = macho.N_SECT,
-                    .n_sect = macho_file.section_to_ordinal.get(match) orelse unreachable,
+                    .n_sect = @intCast(u8, macho_file.section_ordinals.getIndex(match).? + 1),
                     .n_desc = 0,
                     .n_value = sect.addr,
                 });
@@ -781,7 +781,7 @@ pub fn parseTextBlocks(
                 const nlist = nlist_with_index.nlist;
                 const local_sym_index = self.symbol_mapping.get(nlist_with_index.index) orelse unreachable;
                 const local = &macho_file.locals.items[local_sym_index];
-                local.n_sect = macho_file.section_to_ordinal.get(match) orelse unreachable;
+                local.n_sect = @intCast(u8, macho_file.section_ordinals.getIndex(match).? + 1);
 
                 const stab: ?TextBlock.Stab = if (self.debug_info) |di| blk: {
                     // TODO there has to be a better to handle this.
diff --git a/src/link/MachO/TextBlock.zig b/src/link/MachO/TextBlock.zig
index ef10d3fe09..55dc2db471 100644
--- a/src/link/MachO/TextBlock.zig
+++ b/src/link/MachO/TextBlock.zig
@@ -637,7 +637,7 @@ fn initRelocFromObject(rel: macho.relocation_info, context: RelocContext) !Reloc
             try context.macho_file.locals.append(context.allocator, .{
                 .n_strx = try context.macho_file.makeString(sym_name),
                 .n_type = macho.N_SECT,
-                .n_sect = context.macho_file.section_to_ordinal.get(match) orelse unreachable,
+                .n_sect = @intCast(u8, context.macho_file.section_ordinals.getIndex(match).? + 1),
                 .n_desc = 0,
                 .n_value = sect.addr,
             });
@@ -844,7 +844,7 @@ pub fn parseRelocs(self: *TextBlock, relocs: []macho.relocation_info, context: R
                 },
                 .local => {
                     const source_sym = context.macho_file.locals.items[self.local_sym_index];
-                    const match = context.macho_file.section_ordinals.items[source_sym.n_sect];
+                    const match = context.macho_file.section_ordinals.keys()[source_sym.n_sect - 1];
                     const seg = context.macho_file.load_commands.items[match.seg].Segment;
                     const sect = seg.sections.items[match.sect];
                     const sect_type = commands.sectionType(sect);
@@ -1108,7 +1108,7 @@ pub fn resolveRelocs(self: *TextBlock, macho_file: *MachO) !void {
                     const sym = macho_file.locals.items[rel.where_index];
                     const is_tlv = is_tlv: {
                         const source_sym = macho_file.locals.items[self.local_sym_index];
-                        const match = macho_file.section_ordinals.items[source_sym.n_sect];
+                        const match = macho_file.section_ordinals.keys()[source_sym.n_sect - 1];
                         const seg = macho_file.load_commands.items[match.seg].Segment;
                         const sect = seg.sections.items[match.sect];
                         break :is_tlv commands.sectionType(sect) == macho.S_THREAD_LOCAL_VARIABLES;

From 41d7787b69a437e21351d103353fc2eefafb5d17 Mon Sep 17 00:00:00 2001
From: Jakub Konka <kubkon@jakubkonka.com>
Date: Mon, 2 Aug 2021 19:48:23 +0200
Subject: [PATCH 68/96] macho: remove obsolete pack/unpack dylib ordinal fns

Remove some unused debugging machinery such as full printing of the
symtab after symbol resolution. It was there only for the time of
rewriting the linker.
---
 src/link/MachO.zig | 94 +++++-----------------------------------------
 1 file changed, 9 insertions(+), 85 deletions(-)

diff --git a/src/link/MachO.zig b/src/link/MachO.zig
index d3412cec3d..36d5bc6a87 100644
--- a/src/link/MachO.zig
+++ b/src/link/MachO.zig
@@ -970,7 +970,6 @@ fn linkWithZld(self: *MachO, comp: *Compilation) !void {
         try self.allocateDataSegment();
         self.allocateLinkeditSegment();
         try self.allocateTextBlocks();
-        self.printSymtabAndTextBlock();
         try self.flushZld();
     }
 
@@ -2345,7 +2344,7 @@ fn resolveSymbols(self: *MachO) !void {
                 .n_strx = undef.n_strx,
                 .n_type = macho.N_UNDF | macho.N_EXT,
                 .n_sect = 0,
-                .n_desc = packDylibOrdinal(@intCast(u16, ordinal + 1)),
+                .n_desc = @intCast(u16, ordinal + 1) * macho.N_SYMBOL_RESOLVER,
                 .n_value = 0,
             });
             resolv.* = .{
@@ -3021,7 +3020,7 @@ fn writeBindInfoTableZld(self: *MachO) !void {
             try pointers.append(.{
                 .offset = base_offset + i * @sizeOf(u64),
                 .segment_id = segment_id,
-                .dylib_ordinal = unpackDylibOrdinal(sym.n_desc),
+                .dylib_ordinal = @divExact(sym.n_desc, macho.N_SYMBOL_RESOLVER),
                 .name = self.getString(sym.n_strx),
             });
         }
@@ -3046,7 +3045,7 @@ fn writeBindInfoTableZld(self: *MachO) !void {
                     try pointers.append(.{
                         .offset = binding.offset + base_offset,
                         .segment_id = match.seg,
-                        .dylib_ordinal = unpackDylibOrdinal(bind_sym.n_desc),
+                        .dylib_ordinal = @divExact(bind_sym.n_desc, macho.N_SYMBOL_RESOLVER),
                         .name = self.getString(bind_sym.n_strx),
                     });
                 }
@@ -3093,7 +3092,7 @@ fn writeLazyBindInfoTableZld(self: *MachO) !void {
             pointers.appendAssumeCapacity(.{
                 .offset = base_offset + i * @sizeOf(u64),
                 .segment_id = segment_id,
-                .dylib_ordinal = unpackDylibOrdinal(sym.n_desc),
+                .dylib_ordinal = @divExact(sym.n_desc, macho.N_SYMBOL_RESOLVER),
                 .name = self.getString(sym.n_strx),
             });
         }
@@ -4395,7 +4394,7 @@ pub fn populateMissingMetadata(self: *MachO) !void {
             .n_strx = n_strx,
             .n_type = macho.N_UNDF | macho.N_EXT,
             .n_sect = 0,
-            .n_desc = packDylibOrdinal(1),
+            .n_desc = @intCast(u8, 1) * macho.N_SYMBOL_RESOLVER,
             .n_value = 0,
         });
         try self.symbol_resolver.putNoClobber(self.base.allocator, n_strx, .{
@@ -4541,7 +4540,7 @@ pub fn addExternFn(self: *MachO, name: []const u8) !u32 {
         .n_strx = n_strx,
         .n_type = macho.N_UNDF | macho.N_EXT,
         .n_sect = 0,
-        .n_desc = packDylibOrdinal(1),
+        .n_desc = @intCast(u8, 1) * macho.N_SYMBOL_RESOLVER,
         .n_value = 0,
     });
     try self.symbol_resolver.putNoClobber(self.base.allocator, n_strx, .{
@@ -5423,7 +5422,7 @@ fn writeBindInfoTable(self: *MachO) !void {
             try pointers.append(.{
                 .offset = base_offset + i * @sizeOf(u64),
                 .segment_id = segment_id,
-                .dylib_ordinal = unpackDylibOrdinal(sym.n_desc),
+                .dylib_ordinal = @divExact(sym.n_desc, macho.N_SYMBOL_RESOLVER),
                 .name = self.getString(sym.n_strx),
             });
         }
@@ -5448,7 +5447,7 @@ fn writeBindInfoTable(self: *MachO) !void {
                     try pointers.append(.{
                         .offset = binding.offset + base_offset,
                         .segment_id = match.seg,
-                        .dylib_ordinal = unpackDylibOrdinal(bind_sym.n_desc),
+                        .dylib_ordinal = @divExact(bind_sym.n_desc, macho.N_SYMBOL_RESOLVER),
                         .name = self.getString(bind_sym.n_strx),
                     });
                 }
@@ -5507,7 +5506,7 @@ fn writeLazyBindInfoTable(self: *MachO) !void {
             pointers.appendAssumeCapacity(.{
                 .offset = base_offset + i * @sizeOf(u64),
                 .segment_id = segment_id,
-                .dylib_ordinal = unpackDylibOrdinal(sym.n_desc),
+                .dylib_ordinal = @divExact(sym.n_desc, macho.N_SYMBOL_RESOLVER),
                 .name = self.getString(sym.n_strx),
             });
         }
@@ -5849,14 +5848,6 @@ pub fn symbolIsTemp(sym: macho.nlist_64, sym_name: []const u8) bool {
     return mem.startsWith(u8, sym_name, "l") or mem.startsWith(u8, sym_name, "L");
 }
 
-fn packDylibOrdinal(ordinal: u16) u16 {
-    return ordinal * macho.N_SYMBOL_RESOLVER;
-}
-
-fn unpackDylibOrdinal(pack: u16) u16 {
-    return @divExact(pack, macho.N_SYMBOL_RESOLVER);
-}
-
 pub fn findFirst(comptime T: type, haystack: []T, start: usize, predicate: anytype) usize {
     if (!@hasDecl(@TypeOf(predicate), "predicate"))
         @compileError("Predicate is required to define fn predicate(@This(), T) bool");
@@ -5869,70 +5860,3 @@ pub fn findFirst(comptime T: type, haystack: []T, start: usize, predicate: anyty
     }
     return i;
 }
-
-fn printSymtabAndTextBlock(self: *MachO) void {
-    log.debug("locals", .{});
-    for (self.locals.items) |sym, id| {
-        log.debug("  {d}: {s}, {}", .{ id, self.getString(sym.n_strx), sym });
-    }
-
-    log.debug("globals", .{});
-    for (self.globals.items) |sym, id| {
-        log.debug("  {d}: {s}, {}", .{ id, self.getString(sym.n_strx), sym });
-    }
-
-    log.debug("tentatives", .{});
-    for (self.tentatives.items) |sym, id| {
-        log.debug("  {d}: {s}, {}", .{ id, self.getString(sym.n_strx), sym });
-    }
-
-    log.debug("undefines", .{});
-    for (self.undefs.items) |sym, id| {
-        log.debug("  {d}: {s}, {}", .{ id, self.getString(sym.n_strx), sym });
-    }
-
-    log.debug("imports", .{});
-    for (self.imports.items) |sym, id| {
-        log.debug("  {d}: {s}, {}", .{ id, self.getString(sym.n_strx), sym });
-    }
-
-    {
-        log.debug("symbol resolver", .{});
-        var it = self.symbol_resolver.keyIterator();
-        while (it.next()) |key_ptr| {
-            const sym_name = self.getString(key_ptr.*);
-            log.debug("  {s} => {}", .{ sym_name, self.symbol_resolver.get(key_ptr.*).? });
-        }
-    }
-
-    log.debug("mappings", .{});
-    for (self.objects.items) |object| {
-        log.debug("  in object {s}", .{object.name});
-        for (object.symtab.items) |sym, sym_id| {
-            if (object.symbol_mapping.get(@intCast(u32, sym_id))) |local_id| {
-                log.debug("    | {d} => {d}", .{ sym_id, local_id });
-            } else {
-                log.debug("    | {d} no local mapping for {s}", .{ sym_id, object.getString(sym.n_strx) });
-            }
-        }
-    }
-
-    {
-        var it = self.blocks.iterator();
-        while (it.next()) |entry| {
-            const seg = self.load_commands.items[entry.key_ptr.seg].Segment;
-            const sect = seg.sections.items[entry.key_ptr.sect];
-
-            var block: *TextBlock = entry.value_ptr.*;
-
-            log.debug("\n\n{s},{s} contents:", .{ commands.segmentName(sect), commands.sectionName(sect) });
-            log.debug("{}", .{sect});
-            log.debug("{}", .{block});
-
-            while (block.prev) |prev| {
-                block = prev;
-                log.debug("{}", .{block});
-            }
-        }
-    }
-}

From 1472dc3ddb6fd7932ff530e7a2fd3f0185c7353f Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Mon, 2 Aug 2021 20:35:55 -0700
Subject: [PATCH 69/96] stage2: update ZIR for generic functions

ZIR encoding for functions is changed in preparation for generic
function support. As an example:

```zig
const std = @import("std");
const expect = std.testing.expect;

test "example" {
    var x: usize = 0;
    x += checkSize(i32, 1);
    x += checkSize(bool, true);
    try expect(x == 5);
}

fn checkSize(comptime T: type, x: T) usize {
    _ = x;
    return @sizeOf(T);
}
```

Previous ZIR for the `checkSize` function:

```zir
  [165] checkSize line(10) hash(0226f62e189fd0b1c5fca02cf4617562): %55 = block_inline({
    %56 = decl_val("T") token_offset:11:35
    %57 = as_node(@Ref.type_type, %56) node_offset:11:35
    %69 = extended(func([comptime @Ref.type_type, %57], @Ref.usize_type, {
      %58 = arg("T") token_offset:11:23
      %59 = as_node(@Ref.type_type, %58) node_offset:11:35
      %60 = arg("x") token_offset:11:32
      %61 = dbg_stmt(11, 4)
```

ZIR for the `checkSize` function after this commit:

```zir
  [157] checkSize line(10) hash(0226f62e189fd0b1c5fca02cf4617562): %55 = block_inline({
    %56 = param_comptime("T", @Ref.type_type) token_offset:11:23
    %57 = as_node(@Ref.type_type, %56) node_offset:11:35
    %58 = param("x", %57) token_offset:11:32
    %67 = func(@Ref.usize_type, {
      %59 = dbg_stmt(11, 4)
```

Noted differences:
 * Previously the type expression was redundantly repeated.
 * Previously the parameter names were redundantly stored in the ZIR
   extra array.
 * Instead of `arg` ZIR instructions as the first instructions within a
   function body, they are now outside the function body, in the same
   block as the `func` instruction. There are variants:
   - param
   - param_comptime
   - param_anytype
   - param_anytype_comptime
 * The param instructions additionally encode the type.
 * Because of the param instructions, the `func` instruction no longer
   encodes the list of parameter types or the comptime bits.

It's implied that Sema will collect the parameters so that when a `func`
instruction is encountered, they will be implicitly used to construct
the function's type. This is so that we can satisfy all 3 ways of
performing semantic analysis on a function:

 1. runtime: Sema will insert AIR arg instructions for each parameter,
    and insert into the Sema inst_map ZIR param => AIR arg.

 2. comptime/inline: Sema will insert into the inst_map ZIR param =>
    callsite arguments.

 3. generic: Sema will map *only the comptime* ZIR param instructions to
    the AIR instructions for the comptime arguments at the callsite, and
    then re-run Sema for the function's Decl. This will produce a new
    function which is the monomorphized function.

Additionally:

 * AstGen: Update usage of deprecated `ensureCapacity` to
   `ensureUnusedCapacity` or `ensureTotalCapacity`.
 * Introduce `Type.fnInfo` for getting a bunch of data about a function
   type at once, and use it in `analyzeCall`.

This commit starts a branch to implement generic functions in stage2.
Test regressions have not been addressed yet.
---
 BRANCH_TODO    |   9 ++
 src/AstGen.zig | 424 +++++++++++++++++++++----------------------------
 src/Module.zig |   2 +-
 src/Sema.zig   | 193 ++++++++++++++--------
 src/Zir.zig    | 121 +++++++-------
 src/type.zig   |  60 +++++--
 6 files changed, 431 insertions(+), 378 deletions(-)
 create mode 100644 BRANCH_TODO

diff --git a/BRANCH_TODO b/BRANCH_TODO
new file mode 100644
index 0000000000..bc0a67f799
--- /dev/null
+++ b/BRANCH_TODO
@@ -0,0 +1,9 @@
+* update arg instructions:
+  - runtime function call inserts AIR arg instructions and Sema map items for them
+  - comptime/inline function call inserts Sema map items for the args
+  - generic instantiation inserts Sema map items for the comptime args only, re-runs the
+    Decl ZIR to get the new Fn.
+* generic function call where it makes a new function
+* memoize the instantiation in a table
+* anytype with next parameter expression using it
+* comptime anytype
diff --git a/src/AstGen.zig b/src/AstGen.zig
index 20480ab33b..0b78c839a0 100644
--- a/src/AstGen.zig
+++ b/src/AstGen.zig
@@ -42,7 +42,7 @@ const InnerError = error{ OutOfMemory, AnalysisFail };
 
 fn addExtra(astgen: *AstGen, extra: anytype) Allocator.Error!u32 {
     const fields = std.meta.fields(@TypeOf(extra));
-    try astgen.extra.ensureCapacity(astgen.gpa, astgen.extra.items.len + fields.len);
+    try astgen.extra.ensureUnusedCapacity(astgen.gpa, fields.len);
     return addExtraAssumeCapacity(astgen, extra);
 }
 
@@ -259,6 +259,7 @@ pub const ResultLoc = union(enum) {
 
 pub const align_rl: ResultLoc = .{ .ty = .u16_type };
 pub const bool_rl: ResultLoc = .{ .ty = .bool_type };
+pub const type_rl: ResultLoc = .{ .ty = .type_type };
 
 fn typeExpr(gz: *GenZir, scope: *Scope, type_node: ast.Node.Index) InnerError!Zir.Inst.Ref {
     const prev_force_comptime = gz.force_comptime;
@@ -1036,7 +1037,6 @@ fn fnProtoExpr(
     fn_proto: ast.full.FnProto,
 ) InnerError!Zir.Inst.Ref {
     const astgen = gz.astgen;
-    const gpa = astgen.gpa;
     const tree = astgen.tree;
     const token_tags = tree.tokens.items(.tag);
 
@@ -1046,71 +1046,53 @@ fn fnProtoExpr(
     };
     assert(!is_extern);
 
-    // The AST params array does not contain anytype and ... parameters.
-    // We must iterate to count how many param types to allocate.
-    const param_count = blk: {
-        var count: usize = 0;
-        var it = fn_proto.iterate(tree.*);
-        while (it.next()) |param| {
-            if (param.anytype_ellipsis3) |token| switch (token_tags[token]) {
-                .ellipsis3 => break,
-                .keyword_anytype => {},
-                else => unreachable,
-            };
-            count += 1;
-        }
-        break :blk count;
-    };
-    const param_types = try gpa.alloc(Zir.Inst.Ref, param_count);
-    defer gpa.free(param_types);
-
-    const bits_per_param = 1;
-    const params_per_u32 = 32 / bits_per_param;
-    // We only need this if there are greater than params_per_u32 fields.
-    var bit_bag = ArrayListUnmanaged(u32){};
-    defer bit_bag.deinit(gpa);
-    var cur_bit_bag: u32 = 0;
-    var is_var_args = false;
-    {
+    const is_var_args = is_var_args: {
         var param_type_i: usize = 0;
         var it = fn_proto.iterate(tree.*);
         while (it.next()) |param| : (param_type_i += 1) {
-            if (param_type_i % params_per_u32 == 0 and param_type_i != 0) {
-                try bit_bag.append(gpa, cur_bit_bag);
-                cur_bit_bag = 0;
-            }
             const is_comptime = if (param.comptime_noalias) |token|
                 token_tags[token] == .keyword_comptime
             else
                 false;
-            cur_bit_bag = (cur_bit_bag >> bits_per_param) |
-                (@as(u32, @boolToInt(is_comptime)) << 31);
 
-            if (param.anytype_ellipsis3) |token| {
+            const is_anytype = if (param.anytype_ellipsis3) |token| blk: {
                 switch (token_tags[token]) {
-                    .keyword_anytype => {
-                        param_types[param_type_i] = .none;
-                        continue;
-                    },
-                    .ellipsis3 => {
-                        is_var_args = true;
-                        break;
-                    },
+                    .keyword_anytype => break :blk true,
+                    .ellipsis3 => break :is_var_args true,
                     else => unreachable,
                 }
-            }
-            const param_type_node = param.type_expr;
-            assert(param_type_node != 0);
-            param_types[param_type_i] =
-                try expr(gz, scope, .{ .ty = .type_type }, param_type_node);
-        }
-        assert(param_type_i == param_count);
+            } else false;
 
-        const empty_slot_count = params_per_u32 - (param_type_i % params_per_u32);
-        if (empty_slot_count < params_per_u32) {
-            cur_bit_bag >>= @intCast(u5, empty_slot_count * bits_per_param);
+            const param_name: u32 = if (param.name_token) |name_token| blk: {
+                if (mem.eql(u8, "_", tree.tokenSlice(name_token)))
+                    break :blk 0;
+
+                break :blk try astgen.identAsString(name_token);
+            } else 0;
+
+            if (is_anytype) {
+                const name_token = param.name_token orelse param.anytype_ellipsis3.?;
+
+                const tag: Zir.Inst.Tag = if (is_comptime)
+                    .param_anytype_comptime
+                else
+                    .param_anytype;
+                _ = try gz.addStrTok(tag, param_name, name_token);
+            } else {
+                const param_type_node = param.type_expr;
+                assert(param_type_node != 0);
+                const param_type = try expr(gz, scope, type_rl, param_type_node);
+                const main_tokens = tree.nodes.items(.main_token);
+                const name_token = param.name_token orelse main_tokens[param_type_node];
+                const tag: Zir.Inst.Tag = if (is_comptime) .param_comptime else .param;
+                _ = try gz.addPlTok(tag, name_token, Zir.Inst.Param{
+                    .name = param_name,
+                    .ty = param_type,
+                });
+            }
         }
-    }
+        break :is_var_args false;
+    };
 
     const align_inst: Zir.Inst.Ref = if (fn_proto.ast.align_expr == 0) .none else inst: {
         break :inst try expr(gz, scope, align_rl, fn_proto.ast.align_expr);
@@ -1144,7 +1126,6 @@ fn fnProtoExpr(
     const result = try gz.addFunc(.{
         .src_node = fn_proto.ast.proto_node,
         .ret_ty = return_type_inst,
-        .param_types = param_types,
         .body = &[0]Zir.Inst.Index{},
         .cc = cc,
         .align_inst = align_inst,
@@ -1153,8 +1134,6 @@ fn fnProtoExpr(
         .is_inferred_error = false,
         .is_test = false,
         .is_extern = false,
-        .cur_bit_bag = cur_bit_bag,
-        .bit_bag = bit_bag.items,
     });
     return rvalue(gz, rl, result, fn_proto.ast.proto_node);
 }
@@ -1447,8 +1426,8 @@ fn structInitExprRlNone(
     const init_inst = try gz.addPlNode(tag, node, Zir.Inst.StructInitAnon{
         .fields_len = @intCast(u32, fields_list.len),
     });
-    try astgen.extra.ensureCapacity(gpa, astgen.extra.items.len +
-        fields_list.len * @typeInfo(Zir.Inst.StructInitAnon.Item).Struct.fields.len);
+    try astgen.extra.ensureUnusedCapacity(gpa, fields_list.len *
+        @typeInfo(Zir.Inst.StructInitAnon.Item).Struct.fields.len);
     for (fields_list) |field| {
         _ = gz.astgen.addExtraAssumeCapacity(field);
     }
@@ -1520,8 +1499,8 @@ fn structInitExprRlTy(
     const init_inst = try gz.addPlNode(tag, node, Zir.Inst.StructInit{
         .fields_len = @intCast(u32, fields_list.len),
     });
-    try astgen.extra.ensureCapacity(gpa, astgen.extra.items.len +
-        fields_list.len * @typeInfo(Zir.Inst.StructInit.Item).Struct.fields.len);
+    try astgen.extra.ensureUnusedCapacity(gpa, fields_list.len *
+        @typeInfo(Zir.Inst.StructInit.Item).Struct.fields.len);
     for (fields_list) |field| {
         _ = gz.astgen.addExtraAssumeCapacity(field);
     }
@@ -1918,7 +1897,10 @@ fn unusedResultExpr(gz: *GenZir, scope: *Scope, statement: ast.Node.Index) Inner
             // ZIR instructions that might be a type other than `noreturn` or `void`.
             .add,
             .addwrap,
-            .arg,
+            .param,
+            .param_comptime,
+            .param_anytype,
+            .param_anytype_comptime,
             .alloc,
             .alloc_mut,
             .alloc_comptime,
@@ -2488,7 +2470,7 @@ fn varDecl(
             // Move the init_scope instructions into the parent scope, swapping
             // store_to_block_ptr for store_to_inferred_ptr.
             const expected_len = parent_zir.items.len + init_scope.instructions.items.len;
-            try parent_zir.ensureCapacity(gpa, expected_len);
+            try parent_zir.ensureTotalCapacity(gpa, expected_len);
             for (init_scope.instructions.items) |src_inst| {
                 if (zir_tags[src_inst] == .store_to_block_ptr) {
                     if (zir_datas[src_inst].bin.lhs == init_scope.rl_ptr) {
@@ -2750,10 +2732,10 @@ fn ptrType(
     }
 
     const gpa = gz.astgen.gpa;
-    try gz.instructions.ensureCapacity(gpa, gz.instructions.items.len + 1);
-    try gz.astgen.instructions.ensureCapacity(gpa, gz.astgen.instructions.len + 1);
-    try gz.astgen.extra.ensureCapacity(gpa, gz.astgen.extra.items.len +
-        @typeInfo(Zir.Inst.PtrType).Struct.fields.len + trailing_count);
+    try gz.instructions.ensureUnusedCapacity(gpa, 1);
+    try gz.astgen.instructions.ensureUnusedCapacity(gpa, 1);
+    try gz.astgen.extra.ensureUnusedCapacity(gpa, @typeInfo(Zir.Inst.PtrType).Struct.fields.len +
+        trailing_count);
 
     const payload_index = gz.astgen.addExtraAssumeCapacity(Zir.Inst.PtrType{ .elem_type = elem_type });
     if (sentinel_ref != .none) {
@@ -2899,6 +2881,16 @@ fn fnDecl(
     };
     defer decl_gz.instructions.deinit(gpa);
 
+    var fn_gz: GenZir = .{
+        .force_comptime = false,
+        .in_defer = false,
+        .decl_node_index = fn_proto.ast.proto_node,
+        .decl_line = decl_gz.decl_line,
+        .parent = &decl_gz.base,
+        .astgen = astgen,
+    };
+    defer fn_gz.instructions.deinit(gpa);
+
     // TODO: support noinline
     const is_pub = fn_proto.visib_token != null;
     const is_export = blk: {
@@ -2922,71 +2914,76 @@ fn fnDecl(
 
     try wip_decls.next(gpa, is_pub, is_export, align_inst != .none, section_inst != .none);
 
-    // The AST params array does not contain anytype and ... parameters.
-    // We must iterate to count how many param types to allocate.
-    const param_count = blk: {
-        var count: usize = 0;
-        var it = fn_proto.iterate(tree.*);
-        while (it.next()) |param| {
-            if (param.anytype_ellipsis3) |token| switch (token_tags[token]) {
-                .ellipsis3 => break,
-                .keyword_anytype => {},
-                else => unreachable,
-            };
-            count += 1;
-        }
-        break :blk count;
-    };
-    const param_types = try gpa.alloc(Zir.Inst.Ref, param_count);
-    defer gpa.free(param_types);
-
-    const bits_per_param = 1;
-    const params_per_u32 = 32 / bits_per_param;
-    // We only need this if there are greater than params_per_u32 fields.
-    var bit_bag = ArrayListUnmanaged(u32){};
-    defer bit_bag.deinit(gpa);
-    var cur_bit_bag: u32 = 0;
-    var is_var_args = false;
-    {
+    var params_scope = &fn_gz.base;
+    const is_var_args = is_var_args: {
         var param_type_i: usize = 0;
         var it = fn_proto.iterate(tree.*);
         while (it.next()) |param| : (param_type_i += 1) {
-            if (param_type_i % params_per_u32 == 0 and param_type_i != 0) {
-                try bit_bag.append(gpa, cur_bit_bag);
-                cur_bit_bag = 0;
-            }
             const is_comptime = if (param.comptime_noalias) |token|
                 token_tags[token] == .keyword_comptime
             else
                 false;
-            cur_bit_bag = (cur_bit_bag >> bits_per_param) |
-                (@as(u32, @boolToInt(is_comptime)) << 31);
 
-            if (param.anytype_ellipsis3) |token| {
+            const is_anytype = if (param.anytype_ellipsis3) |token| blk: {
                 switch (token_tags[token]) {
-                    .keyword_anytype => {
-                        param_types[param_type_i] = .none;
-                        continue;
-                    },
-                    .ellipsis3 => {
-                        is_var_args = true;
-                        break;
-                    },
+                    .keyword_anytype => break :blk true,
+                    .ellipsis3 => break :is_var_args true,
                     else => unreachable,
                 }
-            }
-            const param_type_node = param.type_expr;
-            assert(param_type_node != 0);
-            param_types[param_type_i] =
-                try expr(&decl_gz, &decl_gz.base, .{ .ty = .type_type }, param_type_node);
-        }
-        assert(param_type_i == param_count);
+            } else false;
 
-        const empty_slot_count = params_per_u32 - (param_type_i % params_per_u32);
-        if (empty_slot_count < params_per_u32) {
-            cur_bit_bag >>= @intCast(u5, empty_slot_count * bits_per_param);
+            const param_name: u32 = if (param.name_token) |name_token| blk: {
+                if (mem.eql(u8, "_", tree.tokenSlice(name_token)))
+                    break :blk 0;
+
+                const param_name = try astgen.identAsString(name_token);
+                if (!is_extern) {
+                    try astgen.detectLocalShadowing(params_scope, param_name, name_token);
+                }
+                break :blk param_name;
+            } else if (!is_extern) {
+                if (param.anytype_ellipsis3) |tok| {
+                    return astgen.failTok(tok, "missing parameter name", .{});
+                } else {
+                    return astgen.failNode(param.type_expr, "missing parameter name", .{});
+                }
+            } else 0;
+
+            const param_inst = if (is_anytype) param: {
+                const name_token = param.name_token orelse param.anytype_ellipsis3.?;
+                const tag: Zir.Inst.Tag = if (is_comptime)
+                    .param_anytype_comptime
+                else
+                    .param_anytype;
+                break :param try decl_gz.addStrTok(tag, param_name, name_token);
+            } else param: {
+                const param_type_node = param.type_expr;
+                assert(param_type_node != 0);
+                const param_type = try expr(&decl_gz, params_scope, type_rl, param_type_node);
+                const main_tokens = tree.nodes.items(.main_token);
+                const name_token = param.name_token orelse main_tokens[param_type_node];
+                const tag: Zir.Inst.Tag = if (is_comptime) .param_comptime else .param;
+                break :param try decl_gz.addPlTok(tag, name_token, Zir.Inst.Param{
+                    .name = param_name,
+                    .ty = param_type,
+                });
+            };
+
+            if (param_name == 0) continue;
+
+            const sub_scope = try astgen.arena.create(Scope.LocalVal);
+            sub_scope.* = .{
+                .parent = params_scope,
+                .gen_zir = &decl_gz,
+                .name = param_name,
+                .inst = param_inst,
+                .token_src = param.name_token.?,
+                .id_cat = .@"function parameter",
+            };
+            params_scope = &sub_scope.base;
         }
-    }
+        break :is_var_args false;
+    };
 
     const lib_name: u32 = if (fn_proto.lib_name) |lib_name_token| blk: {
         const lib_name_str = try astgen.strLitAsString(lib_name_token);
@@ -2998,7 +2995,7 @@ fn fnDecl(
 
     const return_type_inst = try AstGen.expr(
         &decl_gz,
-        &decl_gz.base,
+        params_scope,
         .{ .ty = .type_type },
         fn_proto.ast.return_type,
     );
@@ -3014,7 +3011,7 @@ fn fnDecl(
             }
             break :blk try AstGen.expr(
                 &decl_gz,
-                &decl_gz.base,
+                params_scope,
                 .{ .ty = .calling_convention_type },
                 fn_proto.ast.callconv_expr,
             );
@@ -3038,7 +3035,6 @@ fn fnDecl(
         break :func try decl_gz.addFunc(.{
             .src_node = decl_node,
             .ret_ty = return_type_inst,
-            .param_types = param_types,
             .body = &[0]Zir.Inst.Index{},
             .cc = cc,
             .align_inst = .none, // passed in the per-decl data
@@ -3047,75 +3043,18 @@ fn fnDecl(
             .is_inferred_error = false,
             .is_test = false,
             .is_extern = true,
-            .cur_bit_bag = cur_bit_bag,
-            .bit_bag = bit_bag.items,
         });
     } else func: {
         if (is_var_args) {
             return astgen.failTok(fn_proto.ast.fn_token, "non-extern function is variadic", .{});
         }
 
-        var fn_gz: GenZir = .{
-            .force_comptime = false,
-            .in_defer = false,
-            .decl_node_index = fn_proto.ast.proto_node,
-            .decl_line = decl_gz.decl_line,
-            .parent = &decl_gz.base,
-            .astgen = astgen,
-        };
-        defer fn_gz.instructions.deinit(gpa);
-
         const prev_fn_block = astgen.fn_block;
         astgen.fn_block = &fn_gz;
         defer astgen.fn_block = prev_fn_block;
 
-        // Iterate over the parameters. We put the param names as the first N
-        // items inside `extra` so that debug info later can refer to the parameter names
-        // even while the respective source code is unloaded.
-        try astgen.extra.ensureUnusedCapacity(gpa, param_count);
-
-        {
-            var params_scope = &fn_gz.base;
-            var i: usize = 0;
-            var it = fn_proto.iterate(tree.*);
-            while (it.next()) |param| : (i += 1) {
-                const name_token = param.name_token orelse {
-                    if (param.anytype_ellipsis3) |tok| {
-                        return astgen.failTok(tok, "missing parameter name", .{});
-                    } else {
-                        return astgen.failNode(param.type_expr, "missing parameter name", .{});
-                    }
-                };
-                if (param.type_expr != 0)
-                    _ = try typeExpr(&fn_gz, params_scope, param.type_expr);
-                if (mem.eql(u8, "_", tree.tokenSlice(name_token)))
-                    continue;
-                const param_name = try astgen.identAsString(name_token);
-                // Create an arg instruction. This is needed to emit a semantic analysis
-                // error for shadowing decls.
-                try astgen.detectLocalShadowing(params_scope, param_name, name_token);
-                const arg_inst = try fn_gz.addStrTok(.arg, param_name, name_token);
-                const sub_scope = try astgen.arena.create(Scope.LocalVal);
-                sub_scope.* = .{
-                    .parent = params_scope,
-                    .gen_zir = &fn_gz,
-                    .name = param_name,
-                    .inst = arg_inst,
-                    .token_src = name_token,
-                    .id_cat = .@"function parameter",
-                };
-                params_scope = &sub_scope.base;
-
-                // Additionally put the param name into `string_bytes` and reference it with
-                // `extra` so that we have access to the data in codegen, for debug info.
-                const str_index = try astgen.identAsString(name_token);
-                try astgen.extra.append(astgen.gpa, str_index);
-            }
-            _ = try typeExpr(&fn_gz, params_scope, fn_proto.ast.return_type);
-
-            _ = try expr(&fn_gz, params_scope, .none, body_node);
-            try checkUsed(gz, &fn_gz.base, params_scope);
-        }
+        _ = try expr(&fn_gz, params_scope, .none, body_node);
+        try checkUsed(gz, &fn_gz.base, params_scope);
 
         const need_implicit_ret = blk: {
             if (fn_gz.instructions.items.len == 0)
@@ -3133,7 +3072,6 @@ fn fnDecl(
         break :func try decl_gz.addFunc(.{
             .src_node = decl_node,
             .ret_ty = return_type_inst,
-            .param_types = param_types,
             .body = fn_gz.instructions.items,
             .cc = cc,
             .align_inst = .none, // passed in the per-decl data
@@ -3142,8 +3080,6 @@ fn fnDecl(
             .is_inferred_error = is_inferred_error,
             .is_test = false,
             .is_extern = false,
-            .cur_bit_bag = cur_bit_bag,
-            .bit_bag = bit_bag.items,
         });
     };
 
@@ -3480,7 +3416,6 @@ fn testDecl(
     const func_inst = try decl_block.addFunc(.{
         .src_node = node,
         .ret_ty = .void_type,
-        .param_types = &[0]Zir.Inst.Ref{},
         .body = fn_block.instructions.items,
         .cc = .none,
         .align_inst = .none,
@@ -3489,8 +3424,6 @@ fn testDecl(
         .is_inferred_error = true,
         .is_test = true,
         .is_extern = false,
-        .cur_bit_bag = 0,
-        .bit_bag = &.{},
     });
 
     _ = try decl_block.addBreak(.break_inline, block_inst, func_inst);
@@ -4238,7 +4171,7 @@ fn containerDecl(
             var fields_data = ArrayListUnmanaged(u32){};
             defer fields_data.deinit(gpa);
 
-            try fields_data.ensureCapacity(gpa, counts.total_fields + counts.values);
+            try fields_data.ensureTotalCapacity(gpa, counts.total_fields + counts.values);
 
             // We only need this if there are greater than 32 fields.
             var bit_bag = ArrayListUnmanaged(u32){};
@@ -5184,8 +5117,7 @@ fn setCondBrPayload(
 ) !void {
     const astgen = then_scope.astgen;
 
-    try astgen.extra.ensureCapacity(astgen.gpa, astgen.extra.items.len +
-        @typeInfo(Zir.Inst.CondBr).Struct.fields.len +
+    try astgen.extra.ensureUnusedCapacity(astgen.gpa, @typeInfo(Zir.Inst.CondBr).Struct.fields.len +
         then_scope.instructions.items.len + else_scope.instructions.items.len);
 
     const zir_datas = astgen.instructions.items(.data);
@@ -5839,10 +5771,9 @@ fn switchExpr(
             _ = try case_scope.addBreak(.@"break", switch_block, case_result);
         }
         // Documentation for this: `Zir.Inst.SwitchBlock` and `Zir.Inst.SwitchBlockMulti`.
-        try scalar_cases_payload.ensureCapacity(gpa, scalar_cases_payload.items.len +
+        try scalar_cases_payload.ensureUnusedCapacity(gpa, case_scope.instructions.items.len +
             3 + // operand, scalar_cases_len, else body len
-            @boolToInt(multi_cases_len != 0) +
-            case_scope.instructions.items.len);
+            @boolToInt(multi_cases_len != 0));
         scalar_cases_payload.appendAssumeCapacity(@enumToInt(operand));
         scalar_cases_payload.appendAssumeCapacity(scalar_cases_len);
         if (multi_cases_len != 0) {
@@ -5852,9 +5783,11 @@ fn switchExpr(
         scalar_cases_payload.appendSliceAssumeCapacity(case_scope.instructions.items);
     } else {
         // Documentation for this: `Zir.Inst.SwitchBlock` and `Zir.Inst.SwitchBlockMulti`.
-        try scalar_cases_payload.ensureCapacity(gpa, scalar_cases_payload.items.len +
-            2 + // operand, scalar_cases_len
-            @boolToInt(multi_cases_len != 0));
+        try scalar_cases_payload.ensureUnusedCapacity(
+            gpa,
+            @as(usize, 2) + // operand, scalar_cases_len
+                @boolToInt(multi_cases_len != 0),
+        );
         scalar_cases_payload.appendAssumeCapacity(@enumToInt(operand));
         scalar_cases_payload.appendAssumeCapacity(scalar_cases_len);
         if (multi_cases_len != 0) {
@@ -5975,8 +5908,8 @@ fn switchExpr(
                 block_scope.break_count += 1;
                 _ = try case_scope.addBreak(.@"break", switch_block, case_result);
             }
-            try scalar_cases_payload.ensureCapacity(gpa, scalar_cases_payload.items.len +
-                2 + case_scope.instructions.items.len);
+            try scalar_cases_payload.ensureUnusedCapacity(gpa, 2 +
+                case_scope.instructions.items.len);
             scalar_cases_payload.appendAssumeCapacity(@enumToInt(item_inst));
             scalar_cases_payload.appendAssumeCapacity(@intCast(u32, case_scope.instructions.items.len));
             scalar_cases_payload.appendSliceAssumeCapacity(case_scope.instructions.items);
@@ -6012,8 +5945,8 @@ fn switchExpr(
     const payload_index = astgen.extra.items.len;
     const zir_datas = astgen.instructions.items(.data);
     zir_datas[switch_block].pl_node.payload_index = @intCast(u32, payload_index);
-    try astgen.extra.ensureCapacity(gpa, astgen.extra.items.len +
-        scalar_cases_payload.items.len + multi_cases_payload.items.len);
+    try astgen.extra.ensureUnusedCapacity(gpa, scalar_cases_payload.items.len +
+        multi_cases_payload.items.len);
     const strat = rl.strategy(&block_scope);
     switch (strat.tag) {
         .break_operand => {
@@ -8659,7 +8592,7 @@ fn failNodeNotes(
     }
     const notes_index: u32 = if (notes.len != 0) blk: {
         const notes_start = astgen.extra.items.len;
-        try astgen.extra.ensureCapacity(astgen.gpa, notes_start + 1 + notes.len);
+        try astgen.extra.ensureTotalCapacity(astgen.gpa, notes_start + 1 + notes.len);
         astgen.extra.appendAssumeCapacity(@intCast(u32, notes.len));
         astgen.extra.appendSliceAssumeCapacity(notes);
         break :blk @intCast(u32, notes_start);
@@ -8700,7 +8633,7 @@ fn failTokNotes(
     }
     const notes_index: u32 = if (notes.len != 0) blk: {
         const notes_start = astgen.extra.items.len;
-        try astgen.extra.ensureCapacity(astgen.gpa, notes_start + 1 + notes.len);
+        try astgen.extra.ensureTotalCapacity(astgen.gpa, notes_start + 1 + notes.len);
         astgen.extra.appendAssumeCapacity(@intCast(u32, notes.len));
         astgen.extra.appendSliceAssumeCapacity(notes);
         break :blk @intCast(u32, notes_start);
@@ -8864,7 +8797,7 @@ fn strLitNodeAsString(astgen: *AstGen, node: ast.Node.Index) !IndexSlice {
     while (tok_i <= end) : (tok_i += 1) {
         const slice = tree.tokenSlice(tok_i);
         const line_bytes = slice[2 .. slice.len - 1];
-        try string_bytes.ensureCapacity(gpa, string_bytes.items.len + line_bytes.len + 1);
+        try string_bytes.ensureUnusedCapacity(gpa, line_bytes.len + 1);
         string_bytes.appendAssumeCapacity('\n');
         string_bytes.appendSliceAssumeCapacity(line_bytes);
     }
@@ -9131,8 +9064,8 @@ const GenZir = struct {
 
     fn setBoolBrBody(gz: GenZir, inst: Zir.Inst.Index) !void {
         const gpa = gz.astgen.gpa;
-        try gz.astgen.extra.ensureCapacity(gpa, gz.astgen.extra.items.len +
-            @typeInfo(Zir.Inst.Block).Struct.fields.len + gz.instructions.items.len);
+        try gz.astgen.extra.ensureUnusedCapacity(gpa, @typeInfo(Zir.Inst.Block).Struct.fields.len +
+            gz.instructions.items.len);
         const zir_datas = gz.astgen.instructions.items(.data);
         zir_datas[inst].bool_br.payload_index = gz.astgen.addExtraAssumeCapacity(
             Zir.Inst.Block{ .body_len = @intCast(u32, gz.instructions.items.len) },
@@ -9142,8 +9075,8 @@ const GenZir = struct {
 
     fn setBlockBody(gz: GenZir, inst: Zir.Inst.Index) !void {
         const gpa = gz.astgen.gpa;
-        try gz.astgen.extra.ensureCapacity(gpa, gz.astgen.extra.items.len +
-            @typeInfo(Zir.Inst.Block).Struct.fields.len + gz.instructions.items.len);
+        try gz.astgen.extra.ensureUnusedCapacity(gpa, @typeInfo(Zir.Inst.Block).Struct.fields.len +
+            gz.instructions.items.len);
         const zir_datas = gz.astgen.instructions.items(.data);
         zir_datas[inst].pl_node.payload_index = gz.astgen.addExtraAssumeCapacity(
             Zir.Inst.Block{ .body_len = @intCast(u32, gz.instructions.items.len) },
@@ -9155,8 +9088,8 @@ const GenZir = struct {
     /// `store_to_block_ptr` instructions with lhs set to .none.
     fn setBlockBodyEliding(gz: GenZir, inst: Zir.Inst.Index) !void {
         const gpa = gz.astgen.gpa;
-        try gz.astgen.extra.ensureCapacity(gpa, gz.astgen.extra.items.len +
-            @typeInfo(Zir.Inst.Block).Struct.fields.len + gz.instructions.items.len);
+        try gz.astgen.extra.ensureUnusedCapacity(gpa, @typeInfo(Zir.Inst.Block).Struct.fields.len +
+            gz.instructions.items.len);
         const zir_datas = gz.astgen.instructions.items(.data);
         const zir_tags = gz.astgen.instructions.items(.tag);
         const block_pl_index = gz.astgen.addExtraAssumeCapacity(Zir.Inst.Block{
@@ -9177,7 +9110,6 @@ const GenZir = struct {
 
     fn addFunc(gz: *GenZir, args: struct {
         src_node: ast.Node.Index,
-        param_types: []const Zir.Inst.Ref,
         body: []const Zir.Inst.Index,
         ret_ty: Zir.Inst.Ref,
         cc: Zir.Inst.Ref,
@@ -9187,8 +9119,6 @@ const GenZir = struct {
         is_inferred_error: bool,
         is_test: bool,
         is_extern: bool,
-        cur_bit_bag: u32,
-        bit_bag: []const u32,
     }) !Zir.Inst.Ref {
         assert(args.src_node != 0);
         assert(args.ret_ty != .none);
@@ -9226,19 +9156,14 @@ const GenZir = struct {
             src_locs = &src_locs_buffer;
         }
 
-        const any_are_comptime = args.cur_bit_bag != 0 or for (args.bit_bag) |x| {
-            if (x != 0) break true;
-        } else false;
-
         if (args.cc != .none or args.lib_name != 0 or
             args.is_var_args or args.is_test or args.align_inst != .none or
-            args.is_extern or any_are_comptime)
+            args.is_extern)
         {
             try astgen.extra.ensureUnusedCapacity(
                 gpa,
                 @typeInfo(Zir.Inst.ExtendedFunc).Struct.fields.len +
-                    @boolToInt(any_are_comptime) + args.bit_bag.len +
-                    args.param_types.len + args.body.len + src_locs.len +
+                    args.body.len + src_locs.len +
                     @boolToInt(args.lib_name != 0) +
                     @boolToInt(args.align_inst != .none) +
                     @boolToInt(args.cc != .none),
@@ -9246,7 +9171,6 @@ const GenZir = struct {
             const payload_index = astgen.addExtraAssumeCapacity(Zir.Inst.ExtendedFunc{
                 .src_node = gz.nodeIndexToRelative(args.src_node),
                 .return_type = args.ret_ty,
-                .param_types_len = @intCast(u32, args.param_types.len),
                 .body_len = @intCast(u32, args.body.len),
             });
             if (args.lib_name != 0) {
@@ -9258,11 +9182,6 @@ const GenZir = struct {
             if (args.align_inst != .none) {
                 astgen.extra.appendAssumeCapacity(@enumToInt(args.align_inst));
             }
-            if (any_are_comptime) {
-                astgen.extra.appendSliceAssumeCapacity(args.bit_bag); // Likely empty.
-                astgen.extra.appendAssumeCapacity(args.cur_bit_bag);
-            }
-            astgen.appendRefsAssumeCapacity(args.param_types);
             astgen.extra.appendSliceAssumeCapacity(args.body);
             astgen.extra.appendSliceAssumeCapacity(src_locs);
 
@@ -9279,7 +9198,6 @@ const GenZir = struct {
                         .has_align = args.align_inst != .none,
                         .is_test = args.is_test,
                         .is_extern = args.is_extern,
-                        .has_comptime_bits = any_are_comptime,
                     }),
                     .operand = payload_index,
                 } },
@@ -9290,15 +9208,13 @@ const GenZir = struct {
             try gz.astgen.extra.ensureUnusedCapacity(
                 gpa,
                 @typeInfo(Zir.Inst.Func).Struct.fields.len +
-                    args.param_types.len + args.body.len + src_locs.len,
+                    args.body.len + src_locs.len,
             );
 
             const payload_index = gz.astgen.addExtraAssumeCapacity(Zir.Inst.Func{
                 .return_type = args.ret_ty,
-                .param_types_len = @intCast(u32, args.param_types.len),
                 .body_len = @intCast(u32, args.body.len),
             });
-            gz.astgen.appendRefsAssumeCapacity(args.param_types);
             gz.astgen.extra.appendSliceAssumeCapacity(args.body);
             gz.astgen.extra.appendSliceAssumeCapacity(src_locs);
 
@@ -9380,10 +9296,10 @@ const GenZir = struct {
         assert(callee != .none);
         assert(src_node != 0);
         const gpa = gz.astgen.gpa;
-        try gz.instructions.ensureCapacity(gpa, gz.instructions.items.len + 1);
-        try gz.astgen.instructions.ensureCapacity(gpa, gz.astgen.instructions.len + 1);
-        try gz.astgen.extra.ensureCapacity(gpa, gz.astgen.extra.items.len +
-            @typeInfo(Zir.Inst.Call).Struct.fields.len + args.len);
+        try gz.instructions.ensureUnusedCapacity(gpa, 1);
+        try gz.astgen.instructions.ensureUnusedCapacity(gpa, 1);
+        try gz.astgen.extra.ensureUnusedCapacity(gpa, @typeInfo(Zir.Inst.Call).Struct.fields.len +
+            args.len);
 
         const payload_index = gz.astgen.addExtraAssumeCapacity(Zir.Inst.Call{
             .callee = callee,
@@ -9412,8 +9328,8 @@ const GenZir = struct {
     ) !Zir.Inst.Index {
         assert(lhs != .none);
         const gpa = gz.astgen.gpa;
-        try gz.instructions.ensureCapacity(gpa, gz.instructions.items.len + 1);
-        try gz.astgen.instructions.ensureCapacity(gpa, gz.astgen.instructions.len + 1);
+        try gz.instructions.ensureUnusedCapacity(gpa, 1);
+        try gz.astgen.instructions.ensureUnusedCapacity(gpa, 1);
 
         const new_index = @intCast(Zir.Inst.Index, gz.astgen.instructions.len);
         gz.astgen.instructions.appendAssumeCapacity(.{
@@ -9486,8 +9402,8 @@ const GenZir = struct {
         extra: anytype,
     ) !Zir.Inst.Ref {
         const gpa = gz.astgen.gpa;
-        try gz.instructions.ensureCapacity(gpa, gz.instructions.items.len + 1);
-        try gz.astgen.instructions.ensureCapacity(gpa, gz.astgen.instructions.len + 1);
+        try gz.instructions.ensureUnusedCapacity(gpa, 1);
+        try gz.astgen.instructions.ensureUnusedCapacity(gpa, 1);
 
         const payload_index = try gz.astgen.addExtra(extra);
         const new_index = @intCast(Zir.Inst.Index, gz.astgen.instructions.len);
@@ -9502,6 +9418,30 @@ const GenZir = struct {
         return indexToRef(new_index);
     }
 
+    fn addPlTok(
+        gz: *GenZir,
+        tag: Zir.Inst.Tag,
+        /// Absolute token index. This function does the conversion to Decl offset.
+        abs_tok_index: ast.TokenIndex,
+        extra: anytype,
+    ) !Zir.Inst.Ref {
+        const gpa = gz.astgen.gpa;
+        try gz.instructions.ensureUnusedCapacity(gpa, 1);
+        try gz.astgen.instructions.ensureUnusedCapacity(gpa, 1);
+
+        const payload_index = try gz.astgen.addExtra(extra);
+        const new_index = @intCast(Zir.Inst.Index, gz.astgen.instructions.len);
+        gz.astgen.instructions.appendAssumeCapacity(.{
+            .tag = tag,
+            .data = .{ .pl_tok = .{
+                .src_tok = gz.tokenIndexToRelative(abs_tok_index),
+                .payload_index = payload_index,
+            } },
+        });
+        gz.instructions.appendAssumeCapacity(new_index);
+        return indexToRef(new_index);
+    }
+
     fn addExtendedPayload(
         gz: *GenZir,
         opcode: Zir.Inst.Extended,
@@ -9509,8 +9449,8 @@ const GenZir = struct {
     ) !Zir.Inst.Ref {
         const gpa = gz.astgen.gpa;
 
-        try gz.instructions.ensureCapacity(gpa, gz.instructions.items.len + 1);
-        try gz.astgen.instructions.ensureCapacity(gpa, gz.astgen.instructions.len + 1);
+        try gz.instructions.ensureUnusedCapacity(gpa, 1);
+        try gz.astgen.instructions.ensureUnusedCapacity(gpa, 1);
 
         const payload_index = try gz.astgen.addExtra(extra);
         const new_index = @intCast(Zir.Inst.Index, gz.astgen.instructions.len);
@@ -9566,8 +9506,8 @@ const GenZir = struct {
         elem_type: Zir.Inst.Ref,
     ) !Zir.Inst.Ref {
         const gpa = gz.astgen.gpa;
-        try gz.instructions.ensureCapacity(gpa, gz.instructions.items.len + 1);
-        try gz.astgen.instructions.ensureCapacity(gpa, gz.astgen.instructions.len + 1);
+        try gz.instructions.ensureUnusedCapacity(gpa, 1);
+        try gz.astgen.instructions.ensureUnusedCapacity(gpa, 1);
 
         const payload_index = try gz.astgen.addExtra(Zir.Inst.ArrayTypeSentinel{
             .sentinel = sentinel,
@@ -9822,7 +9762,7 @@ const GenZir = struct {
     /// Leaves the `payload_index` field undefined.
     fn addCondBr(gz: *GenZir, tag: Zir.Inst.Tag, node: ast.Node.Index) !Zir.Inst.Index {
         const gpa = gz.astgen.gpa;
-        try gz.instructions.ensureCapacity(gpa, gz.instructions.items.len + 1);
+        try gz.instructions.ensureUnusedCapacity(gpa, 1);
         const new_index = @intCast(Zir.Inst.Index, gz.astgen.instructions.len);
         try gz.astgen.instructions.append(gpa, .{
             .tag = tag,
diff --git a/src/Module.zig b/src/Module.zig
index 84b721369d..fa8b4ca768 100644
--- a/src/Module.zig
+++ b/src/Module.zig
@@ -3714,7 +3714,7 @@ fn markOutdatedDecl(mod: *Module, decl: *Decl) !void {
     decl.analysis = .outdated;
 }
 
-fn allocateNewDecl(mod: *Module, namespace: *Scope.Namespace, src_node: ast.Node.Index) !*Decl {
+pub fn allocateNewDecl(mod: *Module, namespace: *Scope.Namespace, src_node: ast.Node.Index) !*Decl {
     // If we have emit-h then we must allocate a bigger structure to store the emit-h state.
     const new_decl: *Decl = if (mod.emit_h != null) blk: {
         const parent_struct = try mod.gpa.create(DeclPlusEmitH);
diff --git a/src/Sema.zig b/src/Sema.zig
index 753ef8fb9c..5fd3c149a2 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -44,6 +44,7 @@ branch_count: u32 = 0,
 /// contain a mapped source location.
 src: LazySrcLoc = .{ .token_offset = 0 },
 next_arg_index: usize = 0,
+params: std.ArrayListUnmanaged(Param) = .{},
 decl_val_table: std.AutoHashMapUnmanaged(*Decl, Air.Inst.Ref) = .{},
 
 const std = @import("std");
@@ -68,6 +69,13 @@ const LazySrcLoc = Module.LazySrcLoc;
 const RangeSet = @import("RangeSet.zig");
 const target_util = @import("target.zig");
 
+const Param = struct {
+    name: [:0]const u8,
+    /// `none` means `anytype`.
+    ty: Air.Inst.Ref,
+    is_comptime: bool,
+};
+
 pub const InstMap = std.AutoHashMapUnmanaged(Zir.Inst.Index, Air.Inst.Ref);
 
 pub fn deinit(sema: *Sema) void {
@@ -91,8 +99,7 @@ pub fn analyzeFnBody(
         .func, .func_inferred => blk: {
             const inst_data = datas[fn_body_inst].pl_node;
             const extra = sema.code.extraData(Zir.Inst.Func, inst_data.payload_index);
-            const param_types_len = extra.data.param_types_len;
-            const body = sema.code.extra[extra.end + param_types_len ..][0..extra.data.body_len];
+            const body = sema.code.extra[extra.end..][0..extra.data.body_len];
             break :blk body;
         },
         .extended => blk: {
@@ -104,10 +111,6 @@ pub fn analyzeFnBody(
             extra_index += @boolToInt(small.has_lib_name);
             extra_index += @boolToInt(small.has_cc);
             extra_index += @boolToInt(small.has_align);
-            if (small.has_comptime_bits) {
-                extra_index += (extra.data.param_types_len + 31) / 32;
-            }
-            extra_index += extra.data.param_types_len;
             const body = sema.code.extra[extra_index..][0..extra.data.body_len];
             break :blk body;
         },
@@ -162,7 +165,6 @@ pub fn analyzeBody(
         const inst = body[i];
         const air_inst: Air.Inst.Ref = switch (tags[inst]) {
             // zig fmt: off
-            .arg                          => try sema.zirArg(block, inst),
             .alloc                        => try sema.zirAlloc(block, inst),
             .alloc_inferred               => try sema.zirAllocInferred(block, inst, Type.initTag(.inferred_alloc_const)),
             .alloc_inferred_mut           => try sema.zirAllocInferred(block, inst, Type.initTag(.inferred_alloc_mut)),
@@ -404,6 +406,26 @@ pub fn analyzeBody(
             // continue the loop.
             // We also know that they cannot be referenced later, so we avoid
             // putting them into the map.
+            .param => {
+                try sema.zirParam(inst, false);
+                i += 1;
+                continue;
+            },
+            .param_comptime => {
+                try sema.zirParam(inst, true);
+                i += 1;
+                continue;
+            },
+            .param_anytype => {
+                try sema.zirParamAnytype(inst, false);
+                i += 1;
+                continue;
+            },
+            .param_anytype_comptime => {
+                try sema.zirParamAnytype(inst, true);
+                i += 1;
+                continue;
+            },
             .breakpoint => {
                 try sema.zirBreakpoint(block, inst);
                 i += 1;
@@ -1358,23 +1380,34 @@ fn zirIndexablePtrLen(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) Co
     return sema.analyzeLoad(block, src, result_ptr, result_ptr_src);
 }
 
-fn zirArg(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
+fn zirParam(sema: *Sema, inst: Zir.Inst.Index, is_comptime: bool) CompileError!void {
+    const inst_data = sema.code.instructions.items(.data)[inst].pl_tok;
+    const extra = sema.code.extraData(Zir.Inst.Param, inst_data.payload_index).data;
+    const param_name = sema.code.nullTerminatedString(extra.name);
+
+    // TODO check if param_name shadows a Decl. This only needs to be done if
+    // usingnamespace is implemented.
+
+    const param_ty = sema.resolveInst(extra.ty);
+    try sema.params.append(sema.gpa, .{
+        .name = param_name,
+        .ty = param_ty,
+        .is_comptime = is_comptime,
+    });
+}
+
+fn zirParamAnytype(sema: *Sema, inst: Zir.Inst.Index, is_comptime: bool) CompileError!void {
     const inst_data = sema.code.instructions.items(.data)[inst].str_tok;
-    const arg_name = inst_data.get(sema.code);
-    const arg_index = sema.next_arg_index;
-    sema.next_arg_index += 1;
+    const param_name = inst_data.get(sema.code);
 
-    // TODO check if arg_name shadows a Decl
-    _ = arg_name;
+    // TODO check if param_name shadows a Decl. This only needs to be done if
+    // usingnamespace is implemented.
 
-    if (block.inlining) |_| {
-        return sema.param_inst_list[arg_index];
-    }
-
-    // Set the name of the Air.Arg instruction for use by codegen debug info.
-    const air_arg = sema.param_inst_list[arg_index];
-    sema.air_instructions.items(.data)[Air.refToIndex(air_arg).?].ty_str.str = inst_data.start;
-    return air_arg;
+    try sema.params.append(sema.gpa, .{
+        .name = param_name,
+        .ty = .none,
+        .is_comptime = is_comptime,
+    });
 }
 
 fn zirAllocExtended(
@@ -2395,26 +2428,29 @@ fn analyzeCall(
     ensure_result_used: bool,
     args: []const Air.Inst.Ref,
 ) CompileError!Air.Inst.Ref {
+    const mod = sema.mod;
+
     const func_ty = sema.typeOf(func);
     if (func_ty.zigTypeTag() != .Fn)
-        return sema.mod.fail(&block.base, func_src, "type '{}' not a function", .{func_ty});
+        return mod.fail(&block.base, func_src, "type '{}' not a function", .{func_ty});
 
-    const cc = func_ty.fnCallingConvention();
+    const func_ty_info = func_ty.fnInfo();
+    const cc = func_ty_info.cc;
     if (cc == .Naked) {
         // TODO add error note: declared here
-        return sema.mod.fail(
+        return mod.fail(
             &block.base,
             func_src,
             "unable to call function with naked calling convention",
             .{},
         );
     }
-    const fn_params_len = func_ty.fnParamLen();
-    if (func_ty.fnIsVarArgs()) {
+    const fn_params_len = func_ty_info.param_types.len;
+    if (func_ty_info.is_var_args) {
         assert(cc == .C);
         if (args.len < fn_params_len) {
             // TODO add error note: declared here
-            return sema.mod.fail(
+            return mod.fail(
                 &block.base,
                 func_src,
                 "expected at least {d} argument(s), found {d}",
@@ -2423,7 +2459,7 @@ fn analyzeCall(
         }
     } else if (fn_params_len != args.len) {
         // TODO add error note: declared here
-        return sema.mod.fail(
+        return mod.fail(
             &block.base,
             func_src,
             "expected {d} argument(s), found {d}",
@@ -2442,7 +2478,7 @@ fn analyzeCall(
         .never_inline,
         .no_async,
         .always_tail,
-        => return sema.mod.fail(&block.base, call_src, "TODO implement call with modifier {}", .{
+        => return mod.fail(&block.base, call_src, "TODO implement call with modifier {}", .{
             modifier,
         }),
     }
@@ -2451,12 +2487,12 @@ fn analyzeCall(
 
     const is_comptime_call = block.is_comptime or modifier == .compile_time;
     const is_inline_call = is_comptime_call or modifier == .always_inline or
-        func_ty.fnCallingConvention() == .Inline;
+        func_ty_info.cc == .Inline;
     const result: Air.Inst.Ref = if (is_inline_call) res: {
         const func_val = try sema.resolveConstValue(block, func_src, func);
         const module_fn = switch (func_val.tag()) {
             .function => func_val.castTag(.function).?.data,
-            .extern_fn => return sema.mod.fail(&block.base, call_src, "{s} call of extern function", .{
+            .extern_fn => return mod.fail(&block.base, call_src, "{s} call of extern function", .{
                 @as([]const u8, if (is_comptime_call) "comptime" else "inline"),
             }),
             else => unreachable,
@@ -2535,10 +2571,46 @@ fn analyzeCall(
         const result = try sema.analyzeBlockBody(block, call_src, &child_block, merges);
 
         break :res result;
+    } else if (func_ty_info.is_generic) {
+        const func_val = try sema.resolveConstValue(block, func_src, func);
+        const module_fn = func_val.castTag(.function).?.data;
+        // Check the Module's generic function map with an adapted context, so that we
+        // can match against `args` rather than doing the work below to create a generic Scope
+        // only to junk it if it matches an existing instantiation.
+        // TODO
+
+        // Create a Decl for the new function.
+        const generic_namespace = try sema.arena.create(Module.Scope.Namespace);
+        generic_namespace.* = .{
+            .parent = block.src_decl.namespace,
+            .file_scope = block.src_decl.namespace.file_scope,
+            .ty = func_ty,
+        };
+        const new_decl = try mod.allocateNewDecl(generic_namespace, module_fn.owner_decl.src_node);
+        _ = new_decl;
+
+        // Iterate over the parameters that are comptime, evaluating their type expressions
+        // inside a Scope which contains the previous parameters.
+        //for (args) |arg, arg_i| {
+        //}
+
+        // Create a new Fn with only the runtime-known parameters.
+        // TODO
+
+        // Populate the Decl ty/val with the function and its type.
+        // TODO
+
+        // Queue up a `codegen_func` work item for the new Fn, making sure it will have
+        // `analyzeFnBody` called with the Scope which contains the comptime parameters.
+        // TODO
+
+        // Save it into the Module's generic function map.
+        // TODO
+
+        // Call it the same as a runtime function.
+        // TODO
+        return mod.fail(&block.base, func_src, "TODO implement generic fn call", .{});
     } else res: {
-        if (func_ty.fnIsGeneric()) {
-            return sema.mod.fail(&block.base, func_src, "TODO implement generic fn call", .{});
-        }
         try sema.requireRuntimeBlock(block, call_src);
         try sema.air_extra.ensureUnusedCapacity(gpa, @typeInfo(Air.Call).Struct.fields.len +
             args.len);
@@ -3186,13 +3258,12 @@ fn zirFunc(
 
     const inst_data = sema.code.instructions.items(.data)[inst].pl_node;
     const extra = sema.code.extraData(Zir.Inst.Func, inst_data.payload_index);
-    const param_types = sema.code.refSlice(extra.end, extra.data.param_types_len);
 
     var body_inst: Zir.Inst.Index = 0;
     var src_locs: Zir.Inst.Func.SrcLocs = undefined;
     if (extra.data.body_len != 0) {
         body_inst = inst;
-        const extra_index = extra.end + extra.data.param_types_len + extra.data.body_len;
+        const extra_index = extra.end + extra.data.body_len;
         src_locs = sema.code.extraData(Zir.Inst.Func.SrcLocs, extra_index).data;
     }
 
@@ -3204,7 +3275,6 @@ fn zirFunc(
     return sema.funcCommon(
         block,
         inst_data.src_node,
-        param_types,
         body_inst,
         extra.data.return_type,
         cc,
@@ -3214,7 +3284,6 @@ fn zirFunc(
         false,
         src_locs,
         null,
-        &.{},
     );
 }
 
@@ -3222,7 +3291,6 @@ fn funcCommon(
     sema: *Sema,
     block: *Scope.Block,
     src_node_offset: i32,
-    zir_param_types: []const Zir.Inst.Ref,
     body_inst: Zir.Inst.Index,
     zir_return_type: Zir.Inst.Ref,
     cc: std.builtin.CallingConvention,
@@ -3232,7 +3300,6 @@ fn funcCommon(
     is_extern: bool,
     src_locs: Zir.Inst.Func.SrcLocs,
     opt_lib_name: ?[]const u8,
-    comptime_bits: []const u32,
 ) CompileError!Air.Inst.Ref {
     const src: LazySrcLoc = .{ .node_offset = src_node_offset };
     const ret_ty_src: LazySrcLoc = .{ .node_offset_fn_type_ret_ty = src_node_offset };
@@ -3245,7 +3312,7 @@ fn funcCommon(
 
     const fn_ty: Type = fn_ty: {
         // Hot path for some common function types.
-        if (zir_param_types.len == 0 and !var_args and align_val.tag() == .null_value and
+        if (sema.params.items.len == 0 and !var_args and align_val.tag() == .null_value and
             !inferred_error_set)
         {
             if (bare_return_type.zigTypeTag() == .NoReturn and cc == .Unspecified) {
@@ -3266,22 +3333,21 @@ fn funcCommon(
         }
 
         var any_are_comptime = false;
-        const param_types = try sema.arena.alloc(Type, zir_param_types.len);
-        for (zir_param_types) |param_type, i| {
-            // TODO make a compile error from `resolveType` report the source location
-            // of the specific parameter. Will need to take a similar strategy as
-            // `resolveSwitchItemVal` to avoid resolving the source location unless
-            // we actually need to report an error.
-            const param_src = src;
-            param_types[i] = try sema.resolveType(block, param_src, param_type);
-
-            any_are_comptime = any_are_comptime or blk: {
-                if (comptime_bits.len == 0)
-                    break :blk false;
-                const bag = comptime_bits[i / 32];
-                const is_comptime = @truncate(u1, bag >> @intCast(u5, i % 32)) != 0;
-                break :blk is_comptime;
-            };
+        const param_types = try sema.arena.alloc(Type, sema.params.items.len);
+        const comptime_params = try sema.arena.alloc(bool, sema.params.items.len);
+        for (sema.params.items) |param, i| {
+            if (param.ty == .none) {
+                param_types[i] = Type.initTag(.noreturn); // indicates anytype
+            } else {
+                // TODO make a compile error from `resolveType` report the source location
+                // of the specific parameter. Will need to take a similar strategy as
+                // `resolveSwitchItemVal` to avoid resolving the source location unless
+                // we actually need to report an error.
+                const param_src = src;
+                param_types[i] = try sema.resolveType(block, param_src, param.ty);
+            }
+            comptime_params[i] = param.is_comptime;
+            any_are_comptime = any_are_comptime or param.is_comptime;
         }
 
         if (align_val.tag() != .null_value) {
@@ -3301,6 +3367,7 @@ fn funcCommon(
 
         break :fn_ty try Type.Tag.function.create(sema.arena, .{
             .param_types = param_types,
+            .comptime_params = comptime_params.ptr,
             .return_type = return_type,
             .cc = cc,
             .is_var_args = var_args,
@@ -6545,16 +6612,6 @@ fn zirFuncExtended(
         break :blk align_tv.val;
     } else Value.initTag(.null_value);
 
-    const comptime_bits: []const u32 = if (!small.has_comptime_bits) &.{} else blk: {
-        const amt = (extra.data.param_types_len + 31) / 32;
-        const bit_bags = sema.code.extra[extra_index..][0..amt];
-        extra_index += amt;
-        break :blk bit_bags;
-    };
-
-    const param_types = sema.code.refSlice(extra_index, extra.data.param_types_len);
-    extra_index += param_types.len;
-
     var body_inst: Zir.Inst.Index = 0;
     var src_locs: Zir.Inst.Func.SrcLocs = undefined;
     if (extra.data.body_len != 0) {
@@ -6570,7 +6627,6 @@ fn zirFuncExtended(
     return sema.funcCommon(
         block,
         extra.data.src_node,
-        param_types,
         body_inst,
         extra.data.return_type,
         cc,
@@ -6580,7 +6636,6 @@ fn zirFuncExtended(
         is_extern,
         src_locs,
         lib_name,
-        comptime_bits,
     );
 }
 
diff --git a/src/Zir.zig b/src/Zir.zig
index 109ae3b186..6445d73af5 100644
--- a/src/Zir.zig
+++ b/src/Zir.zig
@@ -173,11 +173,22 @@ pub const Inst = struct {
         /// Twos complement wrapping integer addition.
         /// Uses the `pl_node` union field. Payload is `Bin`.
         addwrap,
-        /// Declares a parameter of the current function. Used for debug info and
-        /// for checking shadowing against declarations in the current namespace.
-        /// Uses the `str_tok` field. Token is the parameter name, string is the
-        /// parameter name.
-        arg,
+        /// Declares a parameter of the current function. Used for:
+        /// * debug info
+        /// * checking shadowing against declarations in the current namespace
+        /// * parameter type expressions referencing other parameters
+        /// These occur in the block outside a function body (the same block as
+        /// contains the func instruction).
+        /// Uses the `pl_tok` field. Token is the parameter name, payload is a `Param`.
+        param,
+        /// Same as `param` except the parameter is marked comptime.
+        param_comptime,
+        /// Same as `param` except the parameter is marked anytype.
+        /// Uses the `str_tok` field. Token is the parameter name. String is the parameter name.
+        param_anytype,
+        /// Same as `param` except the parameter is marked both comptime and anytype.
+        /// Uses the `str_tok` field. Token is the parameter name. String is the parameter name.
+        param_anytype_comptime,
         /// Array concatenation. `a ++ b`
         /// Uses the `pl_node` union field. Payload is `Bin`.
         array_cat,
@@ -971,7 +982,10 @@ pub const Inst = struct {
         /// Function calls do not count.
         pub fn isNoReturn(tag: Tag) bool {
             return switch (tag) {
-                .arg,
+                .param,
+                .param_comptime,
+                .param_anytype,
+                .param_anytype_comptime,
                 .add,
                 .addwrap,
                 .alloc,
@@ -1233,7 +1247,10 @@ pub const Inst = struct {
             break :list std.enums.directEnumArray(Tag, Data.FieldEnum, 0, .{
                 .add = .pl_node,
                 .addwrap = .pl_node,
-                .arg = .str_tok,
+                .param = .pl_tok,
+                .param_comptime = .pl_tok,
+                .param_anytype = .str_tok,
+                .param_anytype_comptime = .str_tok,
                 .array_cat = .pl_node,
                 .array_mul = .pl_node,
                 .array_type = .bin,
@@ -2047,6 +2064,17 @@ pub const Inst = struct {
                 return .{ .node_offset = self.src_node };
             }
         },
+        pl_tok: struct {
+            /// Offset from Decl AST token index.
+            src_tok: ast.TokenIndex,
+            /// index into extra.
+            /// `Tag` determines what lives there.
+            payload_index: u32,
+
+            pub fn src(self: @This()) LazySrcLoc {
+                return .{ .token_offset = self.src_tok };
+            }
+        },
         bin: Bin,
         /// For strings which may contain null bytes.
         str: struct {
@@ -2170,6 +2198,7 @@ pub const Inst = struct {
             un_node,
             un_tok,
             pl_node,
+            pl_tok,
             bin,
             str,
             str_tok,
@@ -2226,17 +2255,11 @@ pub const Inst = struct {
     /// 0. lib_name: u32, // null terminated string index, if has_lib_name is set
     /// 1. cc: Ref, // if has_cc is set
     /// 2. align: Ref, // if has_align is set
-    /// 3. comptime_bits: u32 // for every 32 parameters, if has_comptime_bits is set
-    ///    - sets of 1 bit:
-    ///      0bX: whether corresponding parameter is comptime
-    /// 4. param_type: Ref // for each param_types_len
-    ///    - `none` indicates that the param type is `anytype`.
-    /// 5. body: Index // for each body_len
-    /// 6. src_locs: Func.SrcLocs // if body_len != 0
+    /// 3. body: Index // for each body_len
+    /// 4. src_locs: Func.SrcLocs // if body_len != 0
     pub const ExtendedFunc = struct {
         src_node: i32,
         return_type: Ref,
-        param_types_len: u32,
         body_len: u32,
 
         pub const Small = packed struct {
@@ -2247,8 +2270,7 @@ pub const Inst = struct {
             has_align: bool,
             is_test: bool,
             is_extern: bool,
-            has_comptime_bits: bool,
-            _: u8 = undefined,
+            _: u9 = undefined,
         };
     };
 
@@ -2271,13 +2293,10 @@ pub const Inst = struct {
     };
 
     /// Trailing:
-    /// 0. param_type: Ref // for each param_types_len
-    ///    - `none` indicates that the param type is `anytype`.
-    /// 1. body: Index // for each body_len
-    /// 2. src_locs: SrcLocs // if body_len != 0
+    /// 0. body: Index // for each body_len
+    /// 1. src_locs: SrcLocs // if body_len != 0
     pub const Func = struct {
         return_type: Ref,
-        param_types_len: u32,
         body_len: u32,
 
         pub const SrcLocs = struct {
@@ -2764,6 +2783,12 @@ pub const Inst = struct {
         args: Ref,
     };
 
+    pub const Param = struct {
+        /// Null-terminated string index.
+        name: u32,
+        ty: Ref,
+    };
+
     /// Trailing:
     /// 0. type_inst: Ref,  // if small 0b000X is set
     /// 1. align_inst: Ref, // if small 0b00X0 is set
@@ -3108,11 +3133,14 @@ const Writer = struct {
             .decl_ref,
             .decl_val,
             .import,
-            .arg,
             .ret_err_value,
             .ret_err_value_code,
+            .param_anytype,
+            .param_anytype_comptime,
             => try self.writeStrTok(stream, inst),
 
+            .param, .param_comptime => try self.writeParam(stream, inst),
+
             .func => try self.writeFunc(stream, inst, false),
             .func_inferred => try self.writeFunc(stream, inst, true),
 
@@ -3314,6 +3342,17 @@ const Writer = struct {
         try self.writeSrc(stream, inst_data.src());
     }
 
+    fn writeParam(self: *Writer, stream: anytype, inst: Inst.Index) !void {
+        const inst_data = self.code.instructions.items(.data)[inst].pl_tok;
+        const extra = self.code.extraData(Inst.Param, inst_data.payload_index).data;
+        try stream.print("\"{}\", ", .{
+            std.zig.fmtEscapes(self.code.nullTerminatedString(extra.name)),
+        });
+        try self.writeInstRef(stream, extra.ty);
+        try stream.writeAll(") ");
+        try self.writeSrc(stream, inst_data.src());
+    }
+
     fn writePlNodeBin(self: *Writer, stream: anytype, inst: Inst.Index) !void {
         const inst_data = self.code.instructions.items(.data)[inst].pl_node;
         const extra = self.code.extraData(Inst.Bin, inst_data.payload_index).data;
@@ -4277,16 +4316,14 @@ const Writer = struct {
         const inst_data = self.code.instructions.items(.data)[inst].pl_node;
         const src = inst_data.src();
         const extra = self.code.extraData(Inst.Func, inst_data.payload_index);
-        const param_types = self.code.refSlice(extra.end, extra.data.param_types_len);
-        const body = self.code.extra[extra.end + param_types.len ..][0..extra.data.body_len];
+        const body = self.code.extra[extra.end..][0..extra.data.body_len];
         var src_locs: Zir.Inst.Func.SrcLocs = undefined;
         if (body.len != 0) {
-            const extra_index = extra.end + param_types.len + body.len;
+            const extra_index = extra.end + body.len;
             src_locs = self.code.extraData(Zir.Inst.Func.SrcLocs, extra_index).data;
         }
         return self.writeFuncCommon(
             stream,
-            param_types,
             extra.data.return_type,
             inferred_error_set,
             false,
@@ -4296,7 +4333,6 @@ const Writer = struct {
             body,
             src,
             src_locs,
-            &.{},
         );
     }
 
@@ -4323,16 +4359,6 @@ const Writer = struct {
             break :blk align_inst;
         };
 
-        const comptime_bits: []const u32 = if (!small.has_comptime_bits) &.{} else blk: {
-            const amt = (extra.data.param_types_len + 31) / 32;
-            const bit_bags = self.code.extra[extra_index..][0..amt];
-            extra_index += amt;
-            break :blk bit_bags;
-        };
-
-        const param_types = self.code.refSlice(extra_index, extra.data.param_types_len);
-        extra_index += param_types.len;
-
         const body = self.code.extra[extra_index..][0..extra.data.body_len];
         extra_index += body.len;
 
@@ -4342,7 +4368,6 @@ const Writer = struct {
         }
         return self.writeFuncCommon(
             stream,
-            param_types,
             extra.data.return_type,
             small.is_inferred_error,
             small.is_var_args,
@@ -4352,7 +4377,6 @@ const Writer = struct {
             body,
             src,
             src_locs,
-            comptime_bits,
         );
     }
 
@@ -4426,7 +4450,6 @@ const Writer = struct {
     fn writeFuncCommon(
         self: *Writer,
         stream: anytype,
-        param_types: []const Inst.Ref,
         ret_ty: Inst.Ref,
         inferred_error_set: bool,
         var_args: bool,
@@ -4436,19 +4459,7 @@ const Writer = struct {
         body: []const Inst.Index,
         src: LazySrcLoc,
         src_locs: Zir.Inst.Func.SrcLocs,
-        comptime_bits: []const u32,
     ) !void {
-        try stream.writeAll("[");
-        for (param_types) |param_type, i| {
-            if (i != 0) try stream.writeAll(", ");
-            if (comptime_bits.len != 0) {
-                const bag = comptime_bits[i / 32];
-                const is_comptime = @truncate(u1, bag >> @intCast(u5, i % 32)) != 0;
-                try self.writeFlag(stream, "comptime ", is_comptime);
-            }
-            try self.writeInstRef(stream, param_type);
-        }
-        try stream.writeAll("], ");
         try self.writeInstRef(stream, ret_ty);
         try self.writeOptionalInstRef(stream, ", cc=", cc);
         try self.writeOptionalInstRef(stream, ", align=", align_inst);
@@ -4714,8 +4725,7 @@ fn findDeclsInner(
 
             const inst_data = datas[inst].pl_node;
             const extra = zir.extraData(Inst.Func, inst_data.payload_index);
-            const param_types_len = extra.data.param_types_len;
-            const body = zir.extra[extra.end + param_types_len ..][0..extra.data.body_len];
+            const body = zir.extra[extra.end..][0..extra.data.body_len];
             return zir.findDeclsBody(list, body);
         },
         .extended => {
@@ -4730,7 +4740,6 @@ fn findDeclsInner(
                     extra_index += @boolToInt(small.has_lib_name);
                     extra_index += @boolToInt(small.has_cc);
                     extra_index += @boolToInt(small.has_align);
-                    extra_index += extra.data.param_types_len;
                     const body = zir.extra[extra_index..][0..extra.data.body_len];
                     return zir.findDeclsBody(list, body);
                 },
diff --git a/src/type.zig b/src/type.zig
index a8c3d77bbb..feb16fd47c 100644
--- a/src/type.zig
+++ b/src/type.zig
@@ -759,12 +759,15 @@ pub const Type = extern union {
                 for (payload.param_types) |param_type, i| {
                     param_types[i] = try param_type.copy(allocator);
                 }
+                const other_comptime_params = payload.comptime_params[0..payload.param_types.len];
+                const comptime_params = try allocator.dupe(bool, other_comptime_params);
                 return Tag.function.create(allocator, .{
                     .return_type = try payload.return_type.copy(allocator),
                     .param_types = param_types,
                     .cc = payload.cc,
                     .is_var_args = payload.is_var_args,
                     .is_generic = payload.is_generic,
+                    .comptime_params = comptime_params.ptr,
                 });
             },
             .pointer => {
@@ -2408,14 +2411,41 @@ pub const Type = extern union {
         };
     }
 
-    /// Asserts the type is a function.
-    pub fn fnIsGeneric(self: Type) bool {
-        return switch (self.tag()) {
-            .fn_noreturn_no_args => false,
-            .fn_void_no_args => false,
-            .fn_naked_noreturn_no_args => false,
-            .fn_ccc_void_no_args => false,
-            .function => self.castTag(.function).?.data.is_generic,
+    pub fn fnInfo(ty: Type) Payload.Function.Data {
+        return switch (ty.tag()) {
+            .fn_noreturn_no_args => .{
+                .param_types = &.{},
+                .comptime_params = undefined,
+                .return_type = initTag(.noreturn),
+                .cc = .Unspecified,
+                .is_var_args = false,
+                .is_generic = false,
+            },
+            .fn_void_no_args => .{
+                .param_types = &.{},
+                .comptime_params = undefined,
+                .return_type = initTag(.void),
+                .cc = .Unspecified,
+                .is_var_args = false,
+                .is_generic = false,
+            },
+            .fn_naked_noreturn_no_args => .{
+                .param_types = &.{},
+                .comptime_params = undefined,
+                .return_type = initTag(.noreturn),
+                .cc = .Naked,
+                .is_var_args = false,
+                .is_generic = false,
+            },
+            .fn_ccc_void_no_args => .{
+                .param_types = &.{},
+                .comptime_params = undefined,
+                .return_type = initTag(.void),
+                .cc = .C,
+                .is_var_args = false,
+                .is_generic = false,
+            },
+            .function => ty.castTag(.function).?.data,
 
             else => unreachable,
         };
@@ -3223,13 +3253,23 @@ pub const Type = extern union {
             pub const base_tag = Tag.function;
 
             base: Payload = Payload{ .tag = base_tag },
-            data: struct {
+            data: Data,
+
+            // TODO look into optimizing this memory to take fewer bytes
+            const Data = struct {
                 param_types: []Type,
+                comptime_params: [*]bool,
                 return_type: Type,
                 cc: std.builtin.CallingConvention,
                 is_var_args: bool,
                 is_generic: bool,
-            },
+
+                fn paramIsComptime(self: @This(), i: usize) bool {
+                    if (!self.is_generic) return false;
+                    assert(i < self.param_types.len);
+                    return self.comptime_params[i];
+                }
+            };
         };
 
         pub const ErrorSet = struct {

From bc18e93825f1f3703b97590cc0e963b3faa8cd3e Mon Sep 17 00:00:00 2001
From: Evan Haas <evan@lagerdata.com>
Date: Mon, 2 Aug 2021 08:15:59 -0700
Subject: [PATCH 70/96] translate-c: better codegen for pointer index by int
 literal

#8589 introduced correct handling of signed (possibly negative) array access
of pointers. Since unadorned integer literals in C are signed, this resulted
in inefficient generated code when indexing a pointer by a non-negative
integer literal.
---
 src/clang.zig        |  4 ++--
 src/translate_c.zig  | 20 +++++++++++++++++---
 src/zig_clang.cpp    | 14 ++++++++++++--
 src/zig_clang.h      |  2 +-
 test/translate_c.zig | 11 +++++++++++
 5 files changed, 43 insertions(+), 8 deletions(-)

diff --git a/src/clang.zig b/src/clang.zig
index 0632c5ab67..1254a505f4 100644
--- a/src/clang.zig
+++ b/src/clang.zig
@@ -616,8 +616,8 @@ pub const IntegerLiteral = opaque {
     pub const getBeginLoc = ZigClangIntegerLiteral_getBeginLoc;
     extern fn ZigClangIntegerLiteral_getBeginLoc(*const IntegerLiteral) SourceLocation;
 
-    pub const isZero = ZigClangIntegerLiteral_isZero;
-    extern fn ZigClangIntegerLiteral_isZero(*const IntegerLiteral, *bool, *const ASTContext) bool;
+    pub const getSignum = ZigClangIntegerLiteral_getSignum;
+    extern fn ZigClangIntegerLiteral_getSignum(*const IntegerLiteral, *c_int, *const ASTContext) bool;
 };
 
 /// This is just used as a namespace for a static method on clang's Lexer class; we don't directly
diff --git a/src/translate_c.zig b/src/translate_c.zig
index 8b465fff96..e6d6392a9c 100644
--- a/src/translate_c.zig
+++ b/src/translate_c.zig
@@ -1985,10 +1985,11 @@ fn transBoolExpr(
     used: ResultUsed,
 ) TransError!Node {
     if (@ptrCast(*const clang.Stmt, expr).getStmtClass() == .IntegerLiteralClass) {
-        var is_zero: bool = undefined;
-        if (!(@ptrCast(*const clang.IntegerLiteral, expr).isZero(&is_zero, c.clang_context))) {
+        var signum: c_int = undefined;
+        if (!(@ptrCast(*const clang.IntegerLiteral, expr).getSignum(&signum, c.clang_context))) {
             return fail(c, error.UnsupportedTranslation, expr.getBeginLoc(), "invalid integer literal", .{});
         }
+        const is_zero = signum == 0;
         return Node{ .tag_if_small_enough = @enumToInt(([2]Tag{ .true_literal, .false_literal })[@boolToInt(is_zero)]) };
     }
 
@@ -3360,6 +3361,7 @@ fn transArrayAccess(c: *Context, scope: *Scope, stmt: *const clang.ArraySubscrip
     const subscr_qt = getExprQualType(c, subscr_expr);
     const is_longlong = cIsLongLongInteger(subscr_qt);
     const is_signed = cIsSignedInteger(subscr_qt);
+    const is_nonnegative_int_literal = cIsNonNegativeIntLiteral(c, subscr_expr);
 
     // Unwrap the base statement if it's an array decayed to a bare pointer type
     // so that we index the array itself
@@ -3374,7 +3376,7 @@ fn transArrayAccess(c: *Context, scope: *Scope, stmt: *const clang.ArraySubscrip
 
     // Special case: actual pointer (not decayed array) and signed integer subscript
     // See discussion at https://github.com/ziglang/zig/pull/8589
-    if (is_signed and (base_stmt == unwrapped_base) and !is_vector) return transSignedArrayAccess(c, scope, base_stmt, subscr_expr, result_used);
+    if (is_signed and (base_stmt == unwrapped_base) and !is_vector and !is_nonnegative_int_literal) return transSignedArrayAccess(c, scope, base_stmt, subscr_expr, result_used);
 
     const container_node = try transExpr(c, scope, unwrapped_base, .used);
     const rhs = if (is_longlong or is_signed) blk: {
@@ -4260,6 +4262,18 @@ fn cIntTypeCmp(a: clang.QualType, b: clang.QualType) math.Order {
     return math.order(a_index, b_index);
 }
 
+/// Checks if expr is an integer literal >= 0
+fn cIsNonNegativeIntLiteral(c: *Context, expr: *const clang.Expr) bool {
+    if (@ptrCast(*const clang.Stmt, expr).getStmtClass() == .IntegerLiteralClass) {
+        var signum: c_int = undefined;
+        if (!(@ptrCast(*const clang.IntegerLiteral, expr).getSignum(&signum, c.clang_context))) {
+            return false;
+        }
+        return signum >= 0;
+    }
+    return false;
+}
+
 fn cIsSignedInteger(qt: clang.QualType) bool {
     const c_type = qualTypeCanon(qt);
     if (c_type.getTypeClass() != .Builtin) return false;
diff --git a/src/zig_clang.cpp b/src/zig_clang.cpp
index 4fe1dfc286..6611585f68 100644
--- a/src/zig_clang.cpp
+++ b/src/zig_clang.cpp
@@ -2754,7 +2754,7 @@ struct ZigClangSourceLocation ZigClangIntegerLiteral_getBeginLoc(const struct Zi
     return bitcast(casted->getBeginLoc());
 }
 
-bool ZigClangIntegerLiteral_isZero(const struct ZigClangIntegerLiteral *self, bool *result, const struct ZigClangASTContext *ctx) {
+bool ZigClangIntegerLiteral_getSignum(const struct ZigClangIntegerLiteral *self, int *result, const struct ZigClangASTContext *ctx) {
     auto casted_self = reinterpret_cast<const clang::IntegerLiteral *>(self);
     auto casted_ctx = reinterpret_cast<const clang::ASTContext *>(ctx);
     clang::Expr::EvalResult eval_result;
@@ -2763,7 +2763,17 @@ bool ZigClangIntegerLiteral_isZero(const struct ZigClangIntegerLiteral *self, bo
     }
     const llvm::APSInt result_int = eval_result.Val.getInt();
     const llvm::APSInt zero(result_int.getBitWidth(), result_int.isUnsigned());
-    *result = zero == result_int;
+
+    if (zero == result_int) {
+        *result = 0;
+    } else if (result_int < zero) {
+        *result = -1;
+    } else if (result_int > zero) {
+        *result = 1;
+    } else {
+        return false;
+    }
+
     return true;
 }
 
diff --git a/src/zig_clang.h b/src/zig_clang.h
index dc35df3772..0e7a8b2990 100644
--- a/src/zig_clang.h
+++ b/src/zig_clang.h
@@ -1222,7 +1222,7 @@ ZIG_EXTERN_C struct ZigClangQualType ZigClangCStyleCastExpr_getType(const struct
 
 ZIG_EXTERN_C bool ZigClangIntegerLiteral_EvaluateAsInt(const struct ZigClangIntegerLiteral *, struct ZigClangExprEvalResult *, const struct ZigClangASTContext *);
 ZIG_EXTERN_C struct ZigClangSourceLocation ZigClangIntegerLiteral_getBeginLoc(const struct ZigClangIntegerLiteral *);
-ZIG_EXTERN_C bool ZigClangIntegerLiteral_isZero(const struct ZigClangIntegerLiteral *, bool *, const struct ZigClangASTContext *);
+ZIG_EXTERN_C bool ZigClangIntegerLiteral_getSignum(const struct ZigClangIntegerLiteral *, int *, const struct ZigClangASTContext *);
 
 ZIG_EXTERN_C const struct ZigClangExpr *ZigClangReturnStmt_getRetValue(const struct ZigClangReturnStmt *);
 
diff --git a/test/translate_c.zig b/test/translate_c.zig
index b75d3b5cac..6ddc2107ee 100644
--- a/test/translate_c.zig
+++ b/test/translate_c.zig
@@ -3630,4 +3630,15 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
     , &[_][]const u8{
         \\pub const FOO = @import("std").zig.c_translation.Macros.U_SUFFIX;
     });
+
+    cases.add("Simple array access of pointer with non-negative integer constant",
+        \\void foo(int *p) {
+        \\    p[0];
+        \\    p[1];
+        \\}
+    , &[_][]const u8{
+        \\_ = p[@intCast(c_uint, @as(c_int, 0))];
+        ,
+        \\_ = p[@intCast(c_uint, @as(c_int, 1))];
+    });
 }

From aad4598367b136a06e3569373be7da8febea7f31 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Z=C3=BA=C3=B1iga?= <carlos.zun@gmail.com>
Date: Thu, 22 Jul 2021 18:01:56 -0500
Subject: [PATCH 71/96] ci: remove extra zig directory in windows builds

From $prefix/lib/zig/std/std.zig to $prefix/lib/std/std.zig
---
 ci/azure/windows_upload | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/ci/azure/windows_upload b/ci/azure/windows_upload
index 1f47359dd9..9c5e07e5f9 100755
--- a/ci/azure/windows_upload
+++ b/ci/azure/windows_upload
@@ -11,6 +11,11 @@ if [ "${BUILD_REASON}" != "PullRequest" ]; then
   mv dist/bin/zig.exe dist/
   rmdir dist/bin
 
+  # Remove the unnecessary zig dir in $prefix/lib/zig/std/std.zig
+  mv dist/lib/zig dist/lib2
+  rmdir dist/lib
+  mv dist/lib2 dist/lib
+
   VERSION=$(dist/zig.exe version)
   DIRNAME="zig-windows-x86_64-$VERSION"
   TARBALL="$DIRNAME.zip"

From 609b84611dcde382af5d9fbc2345ede468d31a6f Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Tue, 3 Aug 2021 17:29:59 -0700
Subject: [PATCH 72/96] stage2: rework runtime, comptime, inline function calls

 * ZIR function instructions encode the index of the block that
   contains the function instruction. This allows Zig to later scan the
   block and find the parameter instructions, which is needed for
   semantically analyzing function bodies.

 * Runtime function calls insert AIR arg instructions and then inserts
   Sema inst_map entries mapping the ZIR param instructions to them.

 * comptime/inline function call inserts Sema inst_map entries mapping
   the ZIR param instructions to the AIR callsite arguments.

With this commit we are back to the tests passing.
---
 BRANCH_TODO    |  2 --
 src/AstGen.zig |  7 +++++
 src/Module.zig | 57 +++++++++++++++++++++++++-------------
 src/Sema.zig   | 75 ++++++++++++++------------------------------------
 src/Zir.zig    | 54 ++++++++++++++++++++++++++++++++++--
 5 files changed, 117 insertions(+), 78 deletions(-)

diff --git a/BRANCH_TODO b/BRANCH_TODO
index bc0a67f799..1cdd8362e7 100644
--- a/BRANCH_TODO
+++ b/BRANCH_TODO
@@ -1,6 +1,4 @@
 * update arg instructions:
-  - runtime function call inserts AIR arg instructions and Sema map items for them
-  - comptime/inline function call inserts Sema map items for the args
   - generic instantiation inserts Sema map items for the comptime args only, re-runs the
     Decl ZIR to get the new Fn.
 * generic function call where it makes a new function
diff --git a/src/AstGen.zig b/src/AstGen.zig
index 0b78c839a0..f88b59d211 100644
--- a/src/AstGen.zig
+++ b/src/AstGen.zig
@@ -1125,6 +1125,7 @@ fn fnProtoExpr(
 
     const result = try gz.addFunc(.{
         .src_node = fn_proto.ast.proto_node,
+        .param_block = 0,
         .ret_ty = return_type_inst,
         .body = &[0]Zir.Inst.Index{},
         .cc = cc,
@@ -3035,6 +3036,7 @@ fn fnDecl(
         break :func try decl_gz.addFunc(.{
             .src_node = decl_node,
             .ret_ty = return_type_inst,
+            .param_block = block_inst,
             .body = &[0]Zir.Inst.Index{},
             .cc = cc,
             .align_inst = .none, // passed in the per-decl data
@@ -3071,6 +3073,7 @@ fn fnDecl(
 
         break :func try decl_gz.addFunc(.{
             .src_node = decl_node,
+            .param_block = block_inst,
             .ret_ty = return_type_inst,
             .body = fn_gz.instructions.items,
             .cc = cc,
@@ -3415,6 +3418,7 @@ fn testDecl(
 
     const func_inst = try decl_block.addFunc(.{
         .src_node = node,
+        .param_block = block_inst,
         .ret_ty = .void_type,
         .body = fn_block.instructions.items,
         .cc = .none,
@@ -9111,6 +9115,7 @@ const GenZir = struct {
     fn addFunc(gz: *GenZir, args: struct {
         src_node: ast.Node.Index,
         body: []const Zir.Inst.Index,
+        param_block: Zir.Inst.Index,
         ret_ty: Zir.Inst.Ref,
         cc: Zir.Inst.Ref,
         align_inst: Zir.Inst.Ref,
@@ -9170,6 +9175,7 @@ const GenZir = struct {
             );
             const payload_index = astgen.addExtraAssumeCapacity(Zir.Inst.ExtendedFunc{
                 .src_node = gz.nodeIndexToRelative(args.src_node),
+                .param_block = args.param_block,
                 .return_type = args.ret_ty,
                 .body_len = @intCast(u32, args.body.len),
             });
@@ -9212,6 +9218,7 @@ const GenZir = struct {
             );
 
             const payload_index = gz.astgen.addExtraAssumeCapacity(Zir.Inst.Func{
+                .param_block = args.param_block,
                 .return_type = args.ret_ty,
                 .body_len = @intCast(u32, args.body.len),
             });
diff --git a/src/Module.zig b/src/Module.zig
index fa8b4ca768..6253e2808d 100644
--- a/src/Module.zig
+++ b/src/Module.zig
@@ -2899,7 +2899,6 @@ pub fn semaFile(mod: *Module, file: *Scope.File) SemaError!void {
             .namespace = &struct_obj.namespace,
             .func = null,
             .owner_func = null,
-            .param_inst_list = &.{},
         };
         defer sema.deinit();
         var block_scope: Scope.Block = .{
@@ -2954,7 +2953,6 @@ fn semaDecl(mod: *Module, decl: *Decl) !bool {
         .namespace = decl.namespace,
         .func = null,
         .owner_func = null,
-        .param_inst_list = &.{},
     };
     defer sema.deinit();
 
@@ -3625,8 +3623,6 @@ pub fn analyzeFnBody(mod: *Module, decl: *Decl, func: *Fn) SemaError!Air {
     defer decl.value_arena.?.* = arena.state;
 
     const fn_ty = decl.ty;
-    const param_inst_list = try gpa.alloc(Air.Inst.Ref, fn_ty.fnParamLen());
-    defer gpa.free(param_inst_list);
 
     var sema: Sema = .{
         .mod = mod,
@@ -3637,7 +3633,6 @@ pub fn analyzeFnBody(mod: *Module, decl: *Decl, func: *Fn) SemaError!Air {
         .namespace = decl.namespace,
         .func = func,
         .owner_func = func,
-        .param_inst_list = param_inst_list,
     };
     defer sema.deinit();
 
@@ -3656,29 +3651,55 @@ pub fn analyzeFnBody(mod: *Module, decl: *Decl, func: *Fn) SemaError!Air {
     };
     defer inner_block.instructions.deinit(gpa);
 
-    // AIR requires the arg parameters to be the first N instructions.
-    try inner_block.instructions.ensureTotalCapacity(gpa, param_inst_list.len);
-    for (param_inst_list) |*param_inst, param_index| {
+    const fn_info = sema.code.getFnInfo(func.zir_body_inst);
+    const zir_tags = sema.code.instructions.items(.tag);
+
+    // Here we are performing "runtime semantic analysis" for a function body, which means
+    // we must map the parameter ZIR instructions to `arg` AIR instructions.
+    // AIR requires the `arg` parameters to be the first N instructions.
+    const params_len = @intCast(u32, fn_ty.fnParamLen());
+    try inner_block.instructions.ensureTotalCapacity(gpa, params_len);
+    try sema.air_instructions.ensureUnusedCapacity(gpa, params_len * 2); // * 2 for the `addType`
+    try sema.inst_map.ensureUnusedCapacity(gpa, params_len);
+
+    var param_index: usize = 0;
+    for (fn_info.param_body) |inst| {
+        const name = switch (zir_tags[inst]) {
+            .param, .param_comptime => blk: {
+                const inst_data = sema.code.instructions.items(.data)[inst].pl_tok;
+                const extra = sema.code.extraData(Zir.Inst.Param, inst_data.payload_index).data;
+                break :blk extra.name;
+            },
+
+            .param_anytype, .param_anytype_comptime => blk: {
+                const str_tok = sema.code.instructions.items(.data)[inst].str_tok;
+                break :blk str_tok.start;
+            },
+
+            else => continue,
+        };
         const param_type = fn_ty.fnParamType(param_index);
+        param_index += 1;
         const ty_ref = try sema.addType(param_type);
         const arg_index = @intCast(u32, sema.air_instructions.len);
         inner_block.instructions.appendAssumeCapacity(arg_index);
-        param_inst.* = Air.indexToRef(arg_index);
-        try sema.air_instructions.append(gpa, .{
+        sema.air_instructions.appendAssumeCapacity(.{
             .tag = .arg,
-            .data = .{
-                .ty_str = .{
-                    .ty = ty_ref,
-                    .str = undefined, // Set in the semantic analysis of the arg instruction.
-                },
-            },
+            .data = .{ .ty_str = .{
+                .ty = ty_ref,
+                .str = name,
+            } },
         });
+        sema.inst_map.putAssumeCapacityNoClobber(inst, Air.indexToRef(arg_index));
     }
 
     func.state = .in_progress;
     log.debug("set {s} to in_progress", .{decl.name});
 
-    try sema.analyzeFnBody(&inner_block, func.zir_body_inst);
+    _ = sema.analyzeBody(&inner_block, fn_info.body) catch |err| switch (err) {
+        error.NeededSourceLocation => unreachable,
+        else => |e| return e,
+    };
 
     // Copy the block into place and mark that as the main block.
     try sema.air_extra.ensureUnusedCapacity(gpa, @typeInfo(Air.Block).Struct.fields.len +
@@ -4330,7 +4351,6 @@ pub fn analyzeStructFields(mod: *Module, struct_obj: *Struct) CompileError!void
         .namespace = &struct_obj.namespace,
         .owner_func = null,
         .func = null,
-        .param_inst_list = &.{},
     };
     defer sema.deinit();
 
@@ -4484,7 +4504,6 @@ pub fn analyzeUnionFields(mod: *Module, union_obj: *Union) CompileError!void {
         .namespace = &union_obj.namespace,
         .owner_func = null,
         .func = null,
-        .param_inst_list = &.{},
     };
     defer sema.deinit();
 
diff --git a/src/Sema.zig b/src/Sema.zig
index 5fd3c149a2..923295069d 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -29,13 +29,6 @@ owner_func: ?*Module.Fn,
 /// This starts out the same as `owner_func` and then diverges in the case of
 /// an inline or comptime function call.
 func: ?*Module.Fn,
-/// For now, AIR requires arg instructions to be the first N instructions in the
-/// AIR code. We store references here for the purpose of `resolveInst`.
-/// This can get reworked with AIR memory layout changes, into simply:
-/// > Denormalized data to make `resolveInst` faster. This is 0 if not inside a function,
-/// > otherwise it is the number of parameters of the function.
-/// > param_count: u32
-param_inst_list: []const Air.Inst.Ref,
 branch_quota: u32 = 1000,
 branch_count: u32 = 0,
 /// This field is updated when a new source location becomes active, so that
@@ -85,43 +78,10 @@ pub fn deinit(sema: *Sema) void {
     sema.air_values.deinit(gpa);
     sema.inst_map.deinit(gpa);
     sema.decl_val_table.deinit(gpa);
+    sema.params.deinit(gpa);
     sema.* = undefined;
 }
 
-pub fn analyzeFnBody(
-    sema: *Sema,
-    block: *Scope.Block,
-    fn_body_inst: Zir.Inst.Index,
-) SemaError!void {
-    const tags = sema.code.instructions.items(.tag);
-    const datas = sema.code.instructions.items(.data);
-    const body: []const Zir.Inst.Index = switch (tags[fn_body_inst]) {
-        .func, .func_inferred => blk: {
-            const inst_data = datas[fn_body_inst].pl_node;
-            const extra = sema.code.extraData(Zir.Inst.Func, inst_data.payload_index);
-            const body = sema.code.extra[extra.end..][0..extra.data.body_len];
-            break :blk body;
-        },
-        .extended => blk: {
-            const extended = datas[fn_body_inst].extended;
-            assert(extended.opcode == .func);
-            const extra = sema.code.extraData(Zir.Inst.ExtendedFunc, extended.operand);
-            const small = @bitCast(Zir.Inst.ExtendedFunc.Small, extended.small);
-            var extra_index: usize = extra.end;
-            extra_index += @boolToInt(small.has_lib_name);
-            extra_index += @boolToInt(small.has_cc);
-            extra_index += @boolToInt(small.has_align);
-            const body = sema.code.extra[extra_index..][0..extra.data.body_len];
-            break :blk body;
-        },
-        else => unreachable,
-    };
-    _ = sema.analyzeBody(block, body) catch |err| switch (err) {
-        error.NeededSourceLocation => unreachable,
-        else => |e| return e,
-    };
-}
-
 /// Returns only the result from the body that is specified.
 /// Only appropriate to call when it is determined at comptime that this body
 /// has no peers.
@@ -1066,7 +1026,6 @@ fn zirEnumDecl(
             .namespace = &enum_obj.namespace,
             .owner_func = null,
             .func = null,
-            .param_inst_list = &.{},
             .branch_quota = sema.branch_quota,
             .branch_count = sema.branch_count,
         };
@@ -2538,10 +2497,6 @@ fn analyzeCall(
         sema.func = module_fn;
         defer sema.func = parent_func;
 
-        const parent_param_inst_list = sema.param_inst_list;
-        sema.param_inst_list = args;
-        defer sema.param_inst_list = parent_param_inst_list;
-
         const parent_next_arg_index = sema.next_arg_index;
         sema.next_arg_index = 0;
         defer sema.next_arg_index = parent_next_arg_index;
@@ -2565,12 +2520,23 @@ fn analyzeCall(
         try sema.emitBackwardBranch(&child_block, call_src);
 
         // This will have return instructions analyzed as break instructions to
-        // the block_inst above.
-        try sema.analyzeFnBody(&child_block, module_fn.zir_body_inst);
-
-        const result = try sema.analyzeBlockBody(block, call_src, &child_block, merges);
-
-        break :res result;
+        // the block_inst above. Here we are performing "comptime/inline semantic analysis"
+        // for a function body, which means we must map the parameter ZIR instructions to
+        // the AIR instructions of the callsite.
+        const fn_info = sema.code.getFnInfo(module_fn.zir_body_inst);
+        const zir_tags = sema.code.instructions.items(.tag);
+        var arg_i: usize = 0;
+        try sema.inst_map.ensureUnusedCapacity(gpa, @intCast(u32, args.len));
+        for (fn_info.param_body) |inst| {
+            switch (zir_tags[inst]) {
+                .param, .param_comptime, .param_anytype, .param_anytype_comptime => {},
+                else => continue,
+            }
+            sema.inst_map.putAssumeCapacityNoClobber(inst, args[arg_i]);
+            arg_i += 1;
+        }
+        _ = try sema.analyzeBody(&child_block, fn_info.body);
+        break :res try sema.analyzeBlockBody(block, call_src, &child_block, merges);
     } else if (func_ty_info.is_generic) {
         const func_val = try sema.resolveConstValue(block, func_src, func);
         const module_fn = func_val.castTag(.function).?.data;
@@ -2601,7 +2567,7 @@ fn analyzeCall(
         // TODO
 
         // Queue up a `codegen_func` work item for the new Fn, making sure it will have
-        // `analyzeFnBody` called with the Scope which contains the comptime parameters.
+        // `analyzeBody` called with the ZIR parameters mapped appropriately.
         // TODO
 
         // Save it into the Module's generic function map.
@@ -3344,11 +3310,12 @@ fn funcCommon(
                 // `resolveSwitchItemVal` to avoid resolving the source location unless
                 // we actually need to report an error.
                 const param_src = src;
-                param_types[i] = try sema.resolveType(block, param_src, param.ty);
+                param_types[i] = try sema.analyzeAsType(block, param_src, param.ty);
             }
             comptime_params[i] = param.is_comptime;
             any_are_comptime = any_are_comptime or param.is_comptime;
         }
+        sema.params.clearRetainingCapacity();
 
         if (align_val.tag() != .null_value) {
             return mod.fail(&block.base, src, "TODO implement support for function prototypes to have alignment specified", .{});
diff --git a/src/Zir.zig b/src/Zir.zig
index 6445d73af5..b7f4c28161 100644
--- a/src/Zir.zig
+++ b/src/Zir.zig
@@ -61,7 +61,7 @@ pub const ExtraIndex = enum(u32) {
     _,
 };
 
-pub fn getMainStruct(zir: Zir) Zir.Inst.Index {
+pub fn getMainStruct(zir: Zir) Inst.Index {
     return zir.extra[@enumToInt(ExtraIndex.main_struct)] -
         @intCast(u32, Inst.Ref.typed_value_map.len);
 }
@@ -2260,6 +2260,8 @@ pub const Inst = struct {
     pub const ExtendedFunc = struct {
         src_node: i32,
         return_type: Ref,
+        /// Points to the block that contains the param instructions for this function.
+        param_block: Index,
         body_len: u32,
 
         pub const Small = packed struct {
@@ -2297,6 +2299,8 @@ pub const Inst = struct {
     /// 1. src_locs: SrcLocs // if body_len != 0
     pub const Func = struct {
         return_type: Ref,
+        /// Points to the block that contains the param instructions for this function.
+        param_block: Index,
         body_len: u32,
 
         pub const SrcLocs = struct {
@@ -4894,10 +4898,54 @@ fn findDeclsSwitchMulti(
 
 fn findDeclsBody(
     zir: Zir,
-    list: *std.ArrayList(Zir.Inst.Index),
-    body: []const Zir.Inst.Index,
+    list: *std.ArrayList(Inst.Index),
+    body: []const Inst.Index,
 ) Allocator.Error!void {
     for (body) |member| {
         try zir.findDeclsInner(list, member);
     }
 }
+
+pub fn getFnInfo(zir: Zir, fn_inst: Inst.Index) struct {
+    param_body: []const Inst.Index,
+    body: []const Inst.Index,
+} {
+    const tags = zir.instructions.items(.tag);
+    const datas = zir.instructions.items(.data);
+    const info: struct {
+        param_block: Inst.Index,
+        body: []const Inst.Index,
+    } = switch (tags[fn_inst]) {
+        .func, .func_inferred => blk: {
+            const inst_data = datas[fn_inst].pl_node;
+            const extra = zir.extraData(Inst.Func, inst_data.payload_index);
+            const body = zir.extra[extra.end..][0..extra.data.body_len];
+            break :blk .{
+                .param_block = extra.data.param_block,
+                .body = body,
+            };
+        },
+        .extended => blk: {
+            const extended = datas[fn_inst].extended;
+            assert(extended.opcode == .func);
+            const extra = zir.extraData(Inst.ExtendedFunc, extended.operand);
+            const small = @bitCast(Inst.ExtendedFunc.Small, extended.small);
+            var extra_index: usize = extra.end;
+            extra_index += @boolToInt(small.has_lib_name);
+            extra_index += @boolToInt(small.has_cc);
+            extra_index += @boolToInt(small.has_align);
+            const body = zir.extra[extra_index..][0..extra.data.body_len];
+            break :blk .{
+                .param_block = extra.data.param_block,
+                .body = body,
+            };
+        },
+        else => unreachable,
+    };
+    assert(tags[info.param_block] == .block or tags[info.param_block] == .block_inline);
+    const param_block = zir.extraData(Inst.Block, datas[info.param_block].pl_node.payload_index);
+    return .{
+        .param_body = zir.extra[param_block.end..][0..param_block.data.body_len],
+        .body = info.body,
+    };
+}

From 382d201781eb57d9e950ad07ce814adc5a68b329 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Tue, 3 Aug 2021 22:34:22 -0700
Subject: [PATCH 73/96] stage2: basic generic functions are working

The general strategy is that Sema will pre-map comptime arguments into
the inst_map, and then re-run the block body that contains the `param`
and `func` instructions. This re-runs all the parameter type expressions
except with comptime values populated.

In Sema, param instructions are now handled specially: they detect
whether they are comptime-elided or not. If so, they skip putting a
value in the inst_map, since it is already pre-populated. If not, then
they append to the `fields` field of `Sema` for use with the `func`
instruction.

So when the block body is re-run, a new function is generated with
all the comptime arguments elided, and the new function type has only
runtime parameters in it. TODO: give the generated Decls better names
than "foo__anon_x".

The new function is then added to the work queue to have its body
analyzed and a runtime call AIR instruction to the new function is
emitted.

When the new function gets semantically analyzed, comptime parameters are
pre-mapped to the corresponding `comptime_args` values rather than
mapped to an `arg` AIR instruction. `comptime_args` is a new field that
`Fn` has which is a `TypedValue` for each parameter. This field is non-null
for generic function instantiations only. The values are the comptime
arguments. For non-comptime parameters, a sentinel value is used. This is
because we need to know the information of which parameters are
comptime-known.

Additionally:
 * AstGen: align and section expressions are evaluated in the scope that
   has comptime parameters in it.

There are still some TODO items left; see the BRANCH_TODO file.
---
 BRANCH_TODO    |   7 +-
 src/AstGen.zig |  16 +--
 src/Module.zig |  27 +++-
 src/Sema.zig   | 346 ++++++++++++++++++++++++++++++++++---------------
 src/Zir.zig    |  14 +-
 src/type.zig   |   3 +-
 6 files changed, 287 insertions(+), 126 deletions(-)

diff --git a/BRANCH_TODO b/BRANCH_TODO
index 1cdd8362e7..e8606332d7 100644
--- a/BRANCH_TODO
+++ b/BRANCH_TODO
@@ -1,7 +1,4 @@
-* update arg instructions:
-  - generic instantiation inserts Sema map items for the comptime args only, re-runs the
-    Decl ZIR to get the new Fn.
-* generic function call where it makes a new function
 * memoize the instantiation in a table
-* anytype with next parameter expression using it
+* expressions that depend on comptime stuff need a poison value to use for
+  types when generating the generic function type
 * comptime anytype
diff --git a/src/AstGen.zig b/src/AstGen.zig
index f88b59d211..7534afe961 100644
--- a/src/AstGen.zig
+++ b/src/AstGen.zig
@@ -2906,14 +2906,7 @@ fn fnDecl(
         const maybe_inline_token = fn_proto.extern_export_inline_token orelse break :blk false;
         break :blk token_tags[maybe_inline_token] == .keyword_inline;
     };
-    const align_inst: Zir.Inst.Ref = if (fn_proto.ast.align_expr == 0) .none else inst: {
-        break :inst try expr(&decl_gz, &decl_gz.base, align_rl, fn_proto.ast.align_expr);
-    };
-    const section_inst: Zir.Inst.Ref = if (fn_proto.ast.section_expr == 0) .none else inst: {
-        break :inst try comptimeExpr(&decl_gz, &decl_gz.base, .{ .ty = .const_slice_u8_type }, fn_proto.ast.section_expr);
-    };
-
-    try wip_decls.next(gpa, is_pub, is_export, align_inst != .none, section_inst != .none);
+    try wip_decls.next(gpa, is_pub, is_export, fn_proto.ast.align_expr != 0, fn_proto.ast.section_expr != 0);
 
     var params_scope = &fn_gz.base;
     const is_var_args = is_var_args: {
@@ -2994,6 +2987,13 @@ fn fnDecl(
     const maybe_bang = tree.firstToken(fn_proto.ast.return_type) - 1;
     const is_inferred_error = token_tags[maybe_bang] == .bang;
 
+    const align_inst: Zir.Inst.Ref = if (fn_proto.ast.align_expr == 0) .none else inst: {
+        break :inst try expr(&decl_gz, params_scope, align_rl, fn_proto.ast.align_expr);
+    };
+    const section_inst: Zir.Inst.Ref = if (fn_proto.ast.section_expr == 0) .none else inst: {
+        break :inst try comptimeExpr(&decl_gz, params_scope, .{ .ty = .const_slice_u8_type }, fn_proto.ast.section_expr);
+    };
+
     const return_type_inst = try AstGen.expr(
         &decl_gz,
         params_scope,
diff --git a/src/Module.zig b/src/Module.zig
index 6253e2808d..184ea617b1 100644
--- a/src/Module.zig
+++ b/src/Module.zig
@@ -757,6 +757,10 @@ pub const Union = struct {
 pub const Fn = struct {
     /// The Decl that corresponds to the function itself.
     owner_decl: *Decl,
+    /// If this is not null, this function is a generic function instantiation, and
+    /// there is a `Value` here for each parameter of the function. Non-comptime
+    /// parameters are marked with an `unreachable_value`.
+    comptime_args: ?[*]TypedValue = null,
     /// The ZIR instruction that is a function instruction. Use this to find
     /// the body. We store this rather than the body directly so that when ZIR
     /// is regenerated on update(), we can map this to the new corresponding
@@ -3657,10 +3661,13 @@ pub fn analyzeFnBody(mod: *Module, decl: *Decl, func: *Fn) SemaError!Air {
     // Here we are performing "runtime semantic analysis" for a function body, which means
     // we must map the parameter ZIR instructions to `arg` AIR instructions.
     // AIR requires the `arg` parameters to be the first N instructions.
-    const params_len = @intCast(u32, fn_ty.fnParamLen());
-    try inner_block.instructions.ensureTotalCapacity(gpa, params_len);
-    try sema.air_instructions.ensureUnusedCapacity(gpa, params_len * 2); // * 2 for the `addType`
-    try sema.inst_map.ensureUnusedCapacity(gpa, params_len);
+    // This could be a generic function instantiation, however, in which case we need to
+    // map the comptime parameters to constant values and only emit arg AIR instructions
+    // for the runtime ones.
+    const runtime_params_len = @intCast(u32, fn_ty.fnParamLen());
+    try inner_block.instructions.ensureTotalCapacity(gpa, runtime_params_len);
+    try sema.air_instructions.ensureUnusedCapacity(gpa, fn_info.total_params_len * 2); // * 2 for the `addType`
+    try sema.inst_map.ensureUnusedCapacity(gpa, fn_info.total_params_len);
 
     var param_index: usize = 0;
     for (fn_info.param_body) |inst| {
@@ -3678,8 +3685,17 @@ pub fn analyzeFnBody(mod: *Module, decl: *Decl, func: *Fn) SemaError!Air {
 
             else => continue,
         };
+        if (func.comptime_args) |comptime_args| {
+            const arg_tv = comptime_args[param_index];
+            if (arg_tv.val.tag() != .unreachable_value) {
+                // We have a comptime value for this parameter.
+                const arg = try sema.addConstant(arg_tv.ty, arg_tv.val);
+                sema.inst_map.putAssumeCapacityNoClobber(inst, arg);
+                param_index += 1;
+                continue;
+            }
+        }
         const param_type = fn_ty.fnParamType(param_index);
-        param_index += 1;
         const ty_ref = try sema.addType(param_type);
         const arg_index = @intCast(u32, sema.air_instructions.len);
         inner_block.instructions.appendAssumeCapacity(arg_index);
@@ -3691,6 +3707,7 @@ pub fn analyzeFnBody(mod: *Module, decl: *Decl, func: *Fn) SemaError!Air {
             } },
         });
         sema.inst_map.putAssumeCapacityNoClobber(inst, Air.indexToRef(arg_index));
+        param_index += 1;
     }
 
     func.state = .in_progress;
diff --git a/src/Sema.zig b/src/Sema.zig
index 923295069d..9a7eb6fc40 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -36,9 +36,14 @@ branch_count: u32 = 0,
 /// access to the source location set by the previous instruction which did
 /// contain a mapped source location.
 src: LazySrcLoc = .{ .token_offset = 0 },
-next_arg_index: usize = 0,
-params: std.ArrayListUnmanaged(Param) = .{},
 decl_val_table: std.AutoHashMapUnmanaged(*Decl, Air.Inst.Ref) = .{},
+/// `param` instructions are collected here to be used by the `func` instruction.
+params: std.ArrayListUnmanaged(Param) = .{},
+/// When doing a generic function instantiation, this array collects a `Value` object for
+/// each parameter that is comptime known and thus elided from the generated function.
+/// This memory is allocated by a parent `Sema` and owned by the values arena of the owner_decl.
+comptime_args: []TypedValue = &.{},
+next_arg_index: usize = 0,
 
 const std = @import("std");
 const mem = std.mem;
@@ -64,8 +69,8 @@ const target_util = @import("target.zig");
 
 const Param = struct {
     name: [:0]const u8,
-    /// `none` means `anytype`.
-    ty: Air.Inst.Ref,
+    /// `noreturn` means `anytype`.
+    ty: Type,
     is_comptime: bool,
 };
 
@@ -366,26 +371,6 @@ pub fn analyzeBody(
             // continue the loop.
             // We also know that they cannot be referenced later, so we avoid
             // putting them into the map.
-            .param => {
-                try sema.zirParam(inst, false);
-                i += 1;
-                continue;
-            },
-            .param_comptime => {
-                try sema.zirParam(inst, true);
-                i += 1;
-                continue;
-            },
-            .param_anytype => {
-                try sema.zirParamAnytype(inst, false);
-                i += 1;
-                continue;
-            },
-            .param_anytype_comptime => {
-                try sema.zirParamAnytype(inst, true);
-                i += 1;
-                continue;
-            },
             .breakpoint => {
                 try sema.zirBreakpoint(block, inst);
                 i += 1;
@@ -519,6 +504,88 @@ pub fn analyzeBody(
                     return break_inst;
                 }
             },
+            .param => blk: {
+                const inst_data = sema.code.instructions.items(.data)[inst].pl_tok;
+                const src = inst_data.src();
+                const extra = sema.code.extraData(Zir.Inst.Param, inst_data.payload_index).data;
+                const param_name = sema.code.nullTerminatedString(extra.name);
+
+                if (sema.nextArgIsComptimeElided()) {
+                    i += 1;
+                    continue;
+                }
+
+                // TODO check if param_name shadows a Decl. This only needs to be done if
+                // usingnamespace is implemented.
+
+                const param_ty = try sema.resolveType(block, src, extra.ty);
+                try sema.params.append(sema.gpa, .{
+                    .name = param_name,
+                    .ty = param_ty,
+                    .is_comptime = false,
+                });
+                break :blk try sema.addConstUndef(param_ty);
+            },
+            .param_comptime => blk: {
+                const inst_data = sema.code.instructions.items(.data)[inst].pl_tok;
+                const src = inst_data.src();
+                const extra = sema.code.extraData(Zir.Inst.Param, inst_data.payload_index).data;
+                const param_name = sema.code.nullTerminatedString(extra.name);
+
+                if (sema.nextArgIsComptimeElided()) {
+                    i += 1;
+                    continue;
+                }
+
+                // TODO check if param_name shadows a Decl. This only needs to be done if
+                // usingnamespace is implemented.
+
+                const param_ty = try sema.resolveType(block, src, extra.ty);
+                try sema.params.append(sema.gpa, .{
+                    .name = param_name,
+                    .ty = param_ty,
+                    .is_comptime = true,
+                });
+                break :blk try sema.addConstUndef(param_ty);
+            },
+            .param_anytype => blk: {
+                const inst_data = sema.code.instructions.items(.data)[inst].str_tok;
+                const param_name = inst_data.get(sema.code);
+
+                if (sema.nextArgIsComptimeElided()) {
+                    i += 1;
+                    continue;
+                }
+
+                // TODO check if param_name shadows a Decl. This only needs to be done if
+                // usingnamespace is implemented.
+
+                try sema.params.append(sema.gpa, .{
+                    .name = param_name,
+                    .ty = Type.initTag(.noreturn),
+                    .is_comptime = false,
+                });
+                break :blk try sema.addConstUndef(Type.initTag(.@"undefined"));
+            },
+            .param_anytype_comptime => blk: {
+                const inst_data = sema.code.instructions.items(.data)[inst].str_tok;
+                const param_name = inst_data.get(sema.code);
+
+                if (sema.nextArgIsComptimeElided()) {
+                    i += 1;
+                    continue;
+                }
+
+                // TODO check if param_name shadows a Decl. This only needs to be done if
+                // usingnamespace is implemented.
+
+                try sema.params.append(sema.gpa, .{
+                    .name = param_name,
+                    .ty = Type.initTag(.noreturn),
+                    .is_comptime = true,
+                });
+                break :blk try sema.addConstUndef(Type.initTag(.@"undefined"));
+            },
         };
         if (sema.typeOf(air_inst).isNoReturn())
             return always_noreturn;
@@ -1339,36 +1406,6 @@ fn zirIndexablePtrLen(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) Co
     return sema.analyzeLoad(block, src, result_ptr, result_ptr_src);
 }
 
-fn zirParam(sema: *Sema, inst: Zir.Inst.Index, is_comptime: bool) CompileError!void {
-    const inst_data = sema.code.instructions.items(.data)[inst].pl_tok;
-    const extra = sema.code.extraData(Zir.Inst.Param, inst_data.payload_index).data;
-    const param_name = sema.code.nullTerminatedString(extra.name);
-
-    // TODO check if param_name shadows a Decl. This only needs to be done if
-    // usingnamespace is implemented.
-
-    const param_ty = sema.resolveInst(extra.ty);
-    try sema.params.append(sema.gpa, .{
-        .name = param_name,
-        .ty = param_ty,
-        .is_comptime = is_comptime,
-    });
-}
-
-fn zirParamAnytype(sema: *Sema, inst: Zir.Inst.Index, is_comptime: bool) CompileError!void {
-    const inst_data = sema.code.instructions.items(.data)[inst].str_tok;
-    const param_name = inst_data.get(sema.code);
-
-    // TODO check if param_name shadows a Decl. This only needs to be done if
-    // usingnamespace is implemented.
-
-    try sema.params.append(sema.gpa, .{
-        .name = param_name,
-        .ty = .none,
-        .is_comptime = is_comptime,
-    });
-}
-
 fn zirAllocExtended(
     sema: *Sema,
     block: *Scope.Block,
@@ -2497,10 +2534,6 @@ fn analyzeCall(
         sema.func = module_fn;
         defer sema.func = parent_func;
 
-        const parent_next_arg_index = sema.next_arg_index;
-        sema.next_arg_index = 0;
-        defer sema.next_arg_index = parent_next_arg_index;
-
         var child_block: Scope.Block = .{
             .parent = null,
             .sema = sema,
@@ -2537,7 +2570,7 @@ fn analyzeCall(
         }
         _ = try sema.analyzeBody(&child_block, fn_info.body);
         break :res try sema.analyzeBlockBody(block, call_src, &child_block, merges);
-    } else if (func_ty_info.is_generic) {
+    } else if (func_ty_info.is_generic) res: {
         const func_val = try sema.resolveConstValue(block, func_src, func);
         const module_fn = func_val.castTag(.function).?.data;
         // Check the Module's generic function map with an adapted context, so that we
@@ -2545,37 +2578,142 @@ fn analyzeCall(
         // only to junk it if it matches an existing instantiation.
         // TODO
 
-        // Create a Decl for the new function.
-        const generic_namespace = try sema.arena.create(Module.Scope.Namespace);
-        generic_namespace.* = .{
-            .parent = block.src_decl.namespace,
-            .file_scope = block.src_decl.namespace.file_scope,
-            .ty = func_ty,
+        const fn_info = sema.code.getFnInfo(module_fn.zir_body_inst);
+        const zir_tags = sema.code.instructions.items(.tag);
+        var non_comptime_args_len: u32 = 0;
+        const new_func = new_func: {
+            const namespace = module_fn.owner_decl.namespace;
+            try namespace.anon_decls.ensureUnusedCapacity(gpa, 1);
+
+            // Create a Decl for the new function.
+            const new_decl = try mod.allocateNewDecl(namespace, module_fn.owner_decl.src_node);
+            // TODO better names for generic function instantiations
+            const name_index = mod.getNextAnonNameIndex();
+            new_decl.name = try std.fmt.allocPrintZ(gpa, "{s}__anon_{d}", .{
+                module_fn.owner_decl.name, name_index,
+            });
+            new_decl.src_line = module_fn.owner_decl.src_line;
+            new_decl.is_pub = module_fn.owner_decl.is_pub;
+            new_decl.is_exported = module_fn.owner_decl.is_exported;
+            new_decl.has_align = module_fn.owner_decl.has_align;
+            new_decl.has_linksection = module_fn.owner_decl.has_linksection;
+            new_decl.zir_decl_index = module_fn.owner_decl.zir_decl_index;
+            new_decl.alive = true; // This Decl is called at runtime.
+            new_decl.has_tv = true;
+            new_decl.owns_tv = true;
+            new_decl.analysis = .in_progress;
+            new_decl.generation = mod.generation;
+
+            namespace.anon_decls.putAssumeCapacityNoClobber(new_decl, {});
+
+            var new_decl_arena = std.heap.ArenaAllocator.init(sema.gpa);
+            errdefer new_decl_arena.deinit();
+
+            // Re-run the block that creates the function, with the comptime parameters
+            // pre-populated inside `inst_map`. This causes `param_comptime` and
+            // `param_anytype_comptime` ZIR instructions to be ignored, resulting in a
+            // new, monomorphized function, with the comptime parameters elided.
+            var child_sema: Sema = .{
+                .mod = mod,
+                .gpa = gpa,
+                .arena = sema.arena,
+                .code = sema.code,
+                .owner_decl = new_decl,
+                .namespace = namespace,
+                .func = null,
+                .owner_func = null,
+                .comptime_args = try new_decl_arena.allocator.alloc(TypedValue, args.len),
+            };
+            defer child_sema.deinit();
+
+            var child_block: Scope.Block = .{
+                .parent = null,
+                .sema = &child_sema,
+                .src_decl = new_decl,
+                .instructions = .{},
+                .inlining = null,
+                .is_comptime = true,
+            };
+            defer child_block.instructions.deinit(gpa);
+
+            try child_sema.inst_map.ensureUnusedCapacity(gpa, @intCast(u32, args.len));
+            var arg_i: usize = 0;
+            for (fn_info.param_body) |inst| {
+                const is_comptime = switch (zir_tags[inst]) {
+                    .param_comptime, .param_anytype_comptime => true,
+                    .param, .param_anytype => false, // TODO make true for always comptime types
+                    else => continue,
+                };
+                if (is_comptime) {
+                    // TODO: pass .unneeded to resolveConstValue and then if we get
+                    // error.NeededSourceLocation resolve the arg source location and
+                    // try again.
+                    const arg_src = call_src;
+                    const arg = args[arg_i];
+                    const arg_val = try sema.resolveConstValue(block, arg_src, arg);
+                    child_sema.comptime_args[arg_i] = .{
+                        .ty = try sema.typeOf(arg).copy(&new_decl_arena.allocator),
+                        .val = try arg_val.copy(&new_decl_arena.allocator),
+                    };
+                    const child_arg = try child_sema.addConstant(sema.typeOf(arg), arg_val);
+                    child_sema.inst_map.putAssumeCapacityNoClobber(inst, child_arg);
+                } else {
+                    non_comptime_args_len += 1;
+                    child_sema.comptime_args[arg_i] = .{
+                        .ty = Type.initTag(.noreturn),
+                        .val = Value.initTag(.unreachable_value),
+                    };
+                }
+                arg_i += 1;
+            }
+            const new_func_inst = try child_sema.resolveBody(&child_block, fn_info.param_body);
+            const new_func_val = try child_sema.resolveConstValue(&child_block, .unneeded, new_func_inst);
+            const new_func = new_func_val.castTag(.function).?.data;
+
+            // Populate the Decl ty/val with the function and its type.
+            new_decl.ty = try child_sema.typeOf(new_func_inst).copy(&new_decl_arena.allocator);
+            new_decl.val = try Value.Tag.function.create(&new_decl_arena.allocator, new_func);
+            new_decl.analysis = .complete;
+
+            // Queue up a `codegen_func` work item for the new Fn. The `comptime_args` field
+            // will be populated, ensuring it will have `analyzeBody` called with the ZIR
+            // parameters mapped appropriately.
+            try mod.comp.bin_file.allocateDeclIndexes(new_decl);
+            try mod.comp.work_queue.writeItem(.{ .codegen_func = new_func });
+
+            try new_decl.finalizeNewArena(&new_decl_arena);
+            break :new_func try sema.analyzeDeclVal(block, func_src, new_decl);
         };
-        const new_decl = try mod.allocateNewDecl(generic_namespace, module_fn.owner_decl.src_node);
-        _ = new_decl;
-
-        // Iterate over the parameters that are comptime, evaluating their type expressions
-        // inside a Scope which contains the previous parameters.
-        //for (args) |arg, arg_i| {
-        //}
-
-        // Create a new Fn with only the runtime-known parameters.
-        // TODO
-
-        // Populate the Decl ty/val with the function and its type.
-        // TODO
-
-        // Queue up a `codegen_func` work item for the new Fn, making sure it will have
-        // `analyzeBody` called with the ZIR parameters mapped appropriately.
-        // TODO
 
         // Save it into the Module's generic function map.
         // TODO
 
-        // Call it the same as a runtime function.
-        // TODO
-        return mod.fail(&block.base, func_src, "TODO implement generic fn call", .{});
+        // Make a runtime call to the new function, making sure to omit the comptime args.
+        try sema.requireRuntimeBlock(block, call_src);
+        try sema.air_extra.ensureUnusedCapacity(gpa, @typeInfo(Air.Call).Struct.fields.len +
+            non_comptime_args_len);
+        const func_inst = try block.addInst(.{
+            .tag = .call,
+            .data = .{ .pl_op = .{
+                .operand = new_func,
+                .payload = sema.addExtraAssumeCapacity(Air.Call{
+                    .args_len = non_comptime_args_len,
+                }),
+            } },
+        });
+        var arg_i: usize = 0;
+        for (fn_info.param_body) |inst| {
+            const is_comptime = switch (zir_tags[inst]) {
+                .param_comptime, .param_anytype_comptime => true,
+                .param, .param_anytype => false, // TODO make true for always comptime types
+                else => continue,
+            };
+            if (is_comptime) {
+                sema.air_extra.appendAssumeCapacity(@enumToInt(args[arg_i]));
+            }
+            arg_i += 1;
+        }
+        break :res func_inst;
     } else res: {
         try sema.requireRuntimeBlock(block, call_src);
         try sema.air_extra.ensureUnusedCapacity(gpa, @typeInfo(Air.Call).Struct.fields.len +
@@ -3302,15 +3440,10 @@ fn funcCommon(
         const param_types = try sema.arena.alloc(Type, sema.params.items.len);
         const comptime_params = try sema.arena.alloc(bool, sema.params.items.len);
         for (sema.params.items) |param, i| {
-            if (param.ty == .none) {
+            if (param.ty.tag() == .noreturn) {
                 param_types[i] = Type.initTag(.noreturn); // indicates anytype
             } else {
-                // TODO make a compile error from `resolveType` report the source location
-                // of the specific parameter. Will need to take a similar strategy as
-                // `resolveSwitchItemVal` to avoid resolving the source location unless
-                // we actually need to report an error.
-                const param_src = src;
-                param_types[i] = try sema.analyzeAsType(block, param_src, param.ty);
+                param_types[i] = param.ty;
             }
             comptime_params[i] = param.is_comptime;
             any_are_comptime = any_are_comptime or param.is_comptime;
@@ -3402,6 +3535,7 @@ fn funcCommon(
         .state = anal_state,
         .zir_body_inst = body_inst,
         .owner_decl = sema.owner_decl,
+        .comptime_args = if (sema.comptime_args.len == 0) null else sema.comptime_args.ptr,
         .lbrace_line = src_locs.lbrace_line,
         .rbrace_line = src_locs.rbrace_line,
         .lbrace_column = @truncate(u16, src_locs.columns),
@@ -6819,19 +6953,12 @@ fn safetyPanic(
     const msg_inst = msg_inst: {
         // TODO instead of making a new decl for every panic in the entire compilation,
         // introduce the concept of a reference-counted decl for these
-        var new_decl_arena = std.heap.ArenaAllocator.init(sema.gpa);
-        errdefer new_decl_arena.deinit();
-
-        const decl_ty = try Type.Tag.array_u8.create(&new_decl_arena.allocator, msg.len);
-        const decl_val = try Value.Tag.bytes.create(&new_decl_arena.allocator, msg);
-
-        const new_decl = try sema.mod.createAnonymousDecl(&block.base, .{
-            .ty = decl_ty,
-            .val = decl_val,
-        });
-        errdefer sema.mod.deleteAnonDecl(&block.base, new_decl);
-        try new_decl.finalizeNewArena(&new_decl_arena);
-        break :msg_inst try sema.analyzeDeclRef(new_decl);
+        var anon_decl = try block.startAnonDecl();
+        defer anon_decl.deinit();
+        break :msg_inst try sema.analyzeDeclRef(try anon_decl.finish(
+            try Type.Tag.array_u8.create(anon_decl.arena(), msg.len),
+            try Value.Tag.bytes.create(anon_decl.arena(), msg),
+        ));
     };
 
     const casted_msg_inst = try sema.coerce(block, Type.initTag(.const_slice_u8), msg_inst, src);
@@ -8832,7 +8959,7 @@ fn addConstUndef(sema: *Sema, ty: Type) CompileError!Air.Inst.Ref {
     return sema.addConstant(ty, Value.initTag(.undef));
 }
 
-fn addConstant(sema: *Sema, ty: Type, val: Value) CompileError!Air.Inst.Ref {
+pub fn addConstant(sema: *Sema, ty: Type, val: Value) SemaError!Air.Inst.Ref {
     const gpa = sema.gpa;
     const ty_inst = try sema.addType(ty);
     try sema.air_values.append(gpa, val);
@@ -8888,3 +9015,10 @@ fn isComptimeKnown(
 ) !bool {
     return (try sema.resolveMaybeUndefVal(block, src, inst)) != null;
 }
+
+fn nextArgIsComptimeElided(sema: *Sema) bool {
+    if (sema.comptime_args.len == 0) return false;
+    const result = sema.comptime_args[sema.next_arg_index].val.tag() != .unreachable_value;
+    sema.next_arg_index += 1;
+    return result;
+}
diff --git a/src/Zir.zig b/src/Zir.zig
index b7f4c28161..0b93208564 100644
--- a/src/Zir.zig
+++ b/src/Zir.zig
@@ -4909,6 +4909,7 @@ fn findDeclsBody(
 pub fn getFnInfo(zir: Zir, fn_inst: Inst.Index) struct {
     param_body: []const Inst.Index,
     body: []const Inst.Index,
+    total_params_len: u32,
 } {
     const tags = zir.instructions.items(.tag);
     const datas = zir.instructions.items(.data);
@@ -4944,8 +4945,19 @@ pub fn getFnInfo(zir: Zir, fn_inst: Inst.Index) struct {
     };
     assert(tags[info.param_block] == .block or tags[info.param_block] == .block_inline);
     const param_block = zir.extraData(Inst.Block, datas[info.param_block].pl_node.payload_index);
+    const param_body = zir.extra[param_block.end..][0..param_block.data.body_len];
+    var total_params_len: u32 = 0;
+    for (param_body) |inst| {
+        switch (tags[inst]) {
+            .param, .param_comptime, .param_anytype, .param_anytype_comptime => {
+                total_params_len += 1;
+            },
+            else => continue,
+        }
+    }
     return .{
-        .param_body = zir.extra[param_block.end..][0..param_block.data.body_len],
+        .param_body = param_body,
         .body = info.body,
+        .total_params_len = total_params_len,
     };
 }
diff --git a/src/type.zig b/src/type.zig
index feb16fd47c..237614e372 100644
--- a/src/type.zig
+++ b/src/type.zig
@@ -1182,7 +1182,6 @@ pub const Type = extern union {
             .fn_void_no_args,
             .fn_naked_noreturn_no_args,
             .fn_ccc_void_no_args,
-            .function,
             .single_const_pointer_to_comptime_int,
             .const_slice_u8,
             .array_u8_sentinel_0,
@@ -1207,6 +1206,8 @@ pub const Type = extern union {
             .anyframe_T,
             => true,
 
+            .function => !self.castTag(.function).?.data.is_generic,
+
             .@"struct" => {
                 // TODO introduce lazy value mechanism
                 const struct_obj = self.castTag(.@"struct").?.data;

From ee6f7fee2900ea18bfd056e57952aba606158d7b Mon Sep 17 00:00:00 2001
From: Jakub Konka <kubkon@jakubkonka.com>
Date: Wed, 4 Aug 2021 00:29:39 +0200
Subject: [PATCH 74/96] libstd: add ArrayHashMap.popOrNull function

which internally calls `ArrayHashMap.pop`, however, returns `?KV`
instead and performs the bounds checking automatically.

This function correponds to `ArrayList.popOrNull` and is meant
to fill the gap for situations where we want the quick lookup offered
by the hash map with elegant ability to iterate and pop of the
container with automatic bound checking that plugs in well with
a `while`-loop such as

```zig
var map = std.ArrayHashMap(K, V).init(allocator);
map.deinit();
while (map.popOrNull()) |entry| {
  // ... do something
}
assert(map.count() == 0);
```
---
 lib/std/array_hash_map.zig | 37 +++++++++++++++++++++++++++++++++++++
 1 file changed, 37 insertions(+)

diff --git a/lib/std/array_hash_map.zig b/lib/std/array_hash_map.zig
index 9bcecab47e..4ca603d2e8 100644
--- a/lib/std/array_hash_map.zig
+++ b/lib/std/array_hash_map.zig
@@ -414,6 +414,12 @@ pub fn ArrayHashMap(
         pub fn pop(self: *Self) KV {
             return self.unmanaged.popContext(self.ctx);
         }
+
+        /// Removes the last inserted `Entry` in the hash map and returns it if count is nonzero.
+        /// Otherwise returns null.
+        pub fn popOrNull(self: *Self) ?KV {
+            return self.unmanaged.popOrNullContext(self.ctx);
+        }
     };
 }
 
@@ -1181,6 +1187,17 @@ pub fn ArrayHashMapUnmanaged(
             };
         }
 
+        /// Removes the last inserted `Entry` in the hash map and returns it if count is nonzero.
+        /// Otherwise returns null.
+        pub fn popOrNull(self: *Self) ?KV {
+            if (@sizeOf(ByIndexContext) != 0)
+                @compileError("Cannot infer context " ++ @typeName(Context) ++ ", call popContext instead.");
+            return self.popOrNullContext(undefined);
+        }
+        pub fn popOrNullContext(self: *Self, ctx: Context) ?KV {
+            return if (self.entries.len == 0) null else self.popContext(ctx);
+        }
+
         // ------------------ No pub fns below this point ------------------
 
         fn fetchRemoveByKey(self: *Self, key: anytype, key_ctx: anytype, ctx: ByIndexContext, comptime removal_type: RemovalType) ?KV {
@@ -2094,6 +2111,26 @@ test "pop" {
     }
 }
 
+test "popOrNull" {
+    var map = AutoArrayHashMap(i32, i32).init(std.testing.allocator);
+    defer map.deinit();
+
+    // Insert just enough entries so that the map expands. Afterwards,
+    // pop all entries out of the map.
+
+    var i: i32 = 0;
+    while (i < 9) : (i += 1) {
+        try testing.expect((try map.fetchPut(i, i)) == null);
+    }
+
+    while (map.popOrNull()) |pop| {
+        try testing.expect(pop.key == i - 1 and pop.value == i - 1);
+        i -= 1;
+    }
+
+    try testing.expect(map.count() == 0);
+}
+
 test "reIndex" {
     var map = ArrayHashMap(i32, i32, AutoContext(i32), true).init(std.testing.allocator);
     defer map.deinit();

From bd8baefaaad97d3ec3c47163113e4b5778ef83b4 Mon Sep 17 00:00:00 2001
From: Jakub Konka <kubkon@jakubkonka.com>
Date: Wed, 4 Aug 2021 18:20:06 +0200
Subject: [PATCH 75/96] Update x86_64-macos headers

---
 .../Availability.h                            |    0
 .../CommonCrypto/CommonDigest.h               |    0
 .../TargetConditionals.h                      |    0
 .../_ctermid.h                                |    0
 .../{aarch64-macos-gnu => any-macos-any}/ar.h |    0
 .../bsm/audit.h                               |    0
 .../dispatch/block.h                          |    0
 .../dispatch/dispatch.h                       |    0
 .../dispatch/group.h                          |    0
 .../dispatch/object.h                         |    0
 .../dispatch/queue.h                          |    0
 .../dispatch/semaphore.h                      |    0
 .../dispatch/source.h                         |    0
 .../dispatch/workloop.h                       |    0
 .../libkern/OSByteOrder.h                     |    0
 .../libkern/_OSByteOrder.h                    |    0
 .../libproc.h                                 |    0
 .../mach-o/arch.h                             |    0
 .../mach-o/arm64/reloc.h                      |    0
 .../mach-o/compact_unwind_encoding.h          |    0
 .../mach-o/dyld.h                             |    0
 .../mach-o/fat.h                              |    0
 .../mach-o/loader.h                           |    0
 .../mach-o/nlist.h                            |    0
 .../mach-o/ranlib.h                           |    0
 .../mach-o/reloc.h                            |    0
 .../mach-o/stab.h                             |    0
 .../mach-o/x86_64/reloc.h                     |    0
 .../mach/kern_return.h                        |    0
 .../mach/mach_port.h                          |    0
 .../mach/mach_traps.h                         |    0
 .../mach/mach_types.h                         |    0
 .../mach/machine.h                            |    0
 .../mach/machine/_structs.h                   |    0
 .../mach/machine/boolean.h                    |    0
 .../mach/machine/exception.h                  |    0
 .../mach/machine/kern_return.h                |    0
 .../mach/machine/processor_info.h             |    0
 .../mach/machine/rpc.h                        |    0
 .../mach/machine/thread_state.h               |    0
 .../mach/machine/thread_status.h              |    0
 .../mach/machine/vm_param.h                   |    0
 .../mach/machine/vm_types.h                   |    0
 .../mach/message.h                            |    0
 .../mach/port.h                               |    0
 .../mach/processor_set.h                      |    0
 .../mach/task.h                               |    0
 .../mach/task_info.h                          |    0
 .../mach/task_policy.h                        |    0
 .../mach/task_special_ports.h                 |    0
 .../mach/thread_act.h                         |    0
 .../mach/thread_special_ports.h               |    0
 .../mach/thread_status.h                      |    0
 .../mach/vm_prot.h                            |    0
 .../mach/vm_statistics.h                      |    0
 .../mach/vm_types.h                           |    0
 .../machine/_mcontext.h                       |    0
 .../machine/_param.h                          |    0
 .../machine/_types.h                          |    0
 .../machine/endian.h                          |    0
 .../machine/limits.h                          |    0
 .../machine/param.h                           |    0
 .../machine/signal.h                          |    0
 .../machine/types.h                           |    0
 .../malloc/_malloc.h                          |    0
 .../malloc/malloc.h                           |    0
 .../math.h                                    |    0
 .../net/if.h                                  |    0
 .../net/if_var.h                              |    0
 .../net/route.h                               |    0
 .../netinet/in.h                              |    0
 .../netinet/tcp.h                             |    0
 .../netinet6/in6.h                            |    0
 .../objc/objc-api.h                           |    0
 .../objc/runtime.h                            |    0
 .../os/base.h                                 |    0
 .../os/clock.h                                |    0
 .../os/object.h                               |    0
 .../os/workgroup.h                            |    0
 .../os/workgroup_base.h                       |    0
 .../os/workgroup_interval.h                   |    0
 .../os/workgroup_object.h                     |    0
 .../os/workgroup_parallel.h                   |    0
 .../pthread.h                                 |    0
 .../pthread/sched.h                           |    0
 .../sched.h                                   |    0
 .../signal.h                                  |    0
 .../simd/common.h                             |    0
 .../simd/conversion.h                         |    0
 .../simd/logic.h                              |    0
 .../simd/math.h                               |    0
 .../simd/packed.h                             |    0
 .../simd/quaternion.h                         |    0
 .../spawn.h                                   |    0
 .../stdio.h                                   |    0
 .../stdlib.h                                  |    0
 .../string.h                                  |    0
 .../sys/_pthread/_pthread_attr_t.h            |    0
 .../sys/_pthread/_pthread_cond_t.h            |    0
 .../sys/_pthread/_pthread_condattr_t.h        |    0
 .../sys/_pthread/_pthread_rwlock_t.h          |    0
 .../sys/_pthread/_pthread_rwlockattr_t.h      |    0
 .../sys/_pthread/_pthread_t.h                 |    0
 .../sys/_pthread/_pthread_types.h             |    0
 .../sys/_select.h                             |    0
 .../sys/_symbol_aliasing.h                    |    0
 .../sys/_types/_fd_def.h                      |    0
 .../sys/_types/_int8_t.h                      |    0
 .../sys/_types/_ucontext.h                    |    0
 .../sys/acl.h                                 |    0
 .../sys/attr.h                                |    0
 .../sys/cdefs.h                               |    0
 .../sys/event.h                               |    0
 .../sys/fcntl.h                               |    0
 .../sys/ioccom.h                              |    0
 .../sys/kauth.h                               |    0
 .../sys/kern_control.h                        |    0
 .../sys/mman.h                                |    0
 .../sys/mount.h                               |    0
 .../sys/param.h                               |    0
 .../sys/proc.h                                |    0
 .../sys/proc_info.h                           |    0
 .../sys/random.h                              |    0
 .../sys/resource.h                            |    0
 .../sys/shm.h                                 |    0
 .../sys/socket.h                              |    0
 .../sys/sockio.h                              |    0
 .../sys/spawn.h                               |    0
 .../sys/stat.h                                |    0
 .../sys/sysctl.h                              |    0
 .../sys/syslimits.h                           |    0
 .../sys/ucontext.h                            |    0
 .../sys/uio.h                                 |    0
 .../sys/un.h                                  |    0
 .../ucontext.h                                |    0
 .../xlocale/_inttypes.h                       |    0
 .../xlocale/_wchar.h                          |    0
 .../xpc/availability.h                        |    0
 .../xpc/base.h                                |    0
 .../xpc/connection.h                          |    0
 .../xpc/xpc.h                                 |    0
 .../include/x86_64-macos-gnu/Availability.h   |  605 --
 .../x86_64-macos-gnu/AvailabilityInternal.h   |   17 +-
 .../x86_64-macos-gnu/AvailabilityMacros.h     |   10 +-
 .../x86_64-macos-gnu/AvailabilityVersions.h   |  216 +
 .../x86_64-macos-gnu/TargetConditionals.h     |  502 --
 lib/libc/include/x86_64-macos-gnu/_ctermid.h  |   27 -
 lib/libc/include/x86_64-macos-gnu/bsm/audit.h |  378 --
 .../include/x86_64-macos-gnu/dispatch/block.h |  428 --
 .../x86_64-macos-gnu/dispatch/dispatch.h      |   75 -
 .../include/x86_64-macos-gnu/dispatch/group.h |  279 -
 .../x86_64-macos-gnu/dispatch/object.h        |  606 --
 .../include/x86_64-macos-gnu/dispatch/queue.h | 1674 -----
 .../x86_64-macos-gnu/dispatch/semaphore.h     |  117 -
 .../x86_64-macos-gnu/dispatch/source.h        |  780 ---
 .../x86_64-macos-gnu/dispatch/workloop.h      |  136 -
 .../include/x86_64-macos-gnu/i386/_param.h    |    4 +-
 .../libkern/OSAtomicDeprecated.h              |  113 +-
 .../x86_64-macos-gnu/libkern/OSAtomicQueue.h  |   78 +-
 .../x86_64-macos-gnu/libkern/OSByteOrder.h    |  305 -
 .../x86_64-macos-gnu/libkern/_OSByteOrder.h   |  130 -
 lib/libc/include/x86_64-macos-gnu/libproc.h   |  187 -
 .../include/x86_64-macos-gnu/mach-o/dyld.h    |  263 -
 .../include/x86_64-macos-gnu/mach-o/loader.h  | 1577 -----
 .../x86_64-macos-gnu/mach/exception_types.h   |  204 -
 .../mach/host_special_ports.h                 |  281 -
 .../x86_64-macos-gnu/mach/i386/_structs.h     |   80 +
 .../x86_64-macos-gnu/mach/i386/thread_state.h |    2 +-
 .../mach/i386/thread_status.h                 |   19 +-
 .../x86_64-macos-gnu/mach/i386/vm_param.h     |   53 +-
 .../x86_64-macos-gnu/mach/i386/vm_types.h     |    1 -
 .../x86_64-macos-gnu/mach/kern_return.h       |  330 -
 .../include/x86_64-macos-gnu/mach/mach_init.h |  110 -
 .../include/x86_64-macos-gnu/mach/mach_port.h | 1808 ------
 .../x86_64-macos-gnu/mach/mach_traps.h        |  303 -
 .../x86_64-macos-gnu/mach/mach_types.h        |  254 -
 .../include/x86_64-macos-gnu/mach/machine.h   |  395 --
 .../x86_64-macos-gnu/mach/machine/_structs.h  |   38 -
 .../x86_64-macos-gnu/mach/machine/boolean.h   |   38 -
 .../x86_64-macos-gnu/mach/machine/exception.h |   38 -
 .../mach/machine/kern_return.h                |   38 -
 .../mach/machine/processor_info.h             |   38 -
 .../x86_64-macos-gnu/mach/machine/rpc.h       |   38 -
 .../mach/machine/thread_state.h               |   38 -
 .../mach/machine/thread_status.h              |   38 -
 .../x86_64-macos-gnu/mach/machine/vm_param.h  |   38 -
 .../x86_64-macos-gnu/mach/machine/vm_types.h  |   38 -
 .../mach/memory_object_types.h                |  299 -
 .../include/x86_64-macos-gnu/mach/message.h   |  902 ---
 lib/libc/include/x86_64-macos-gnu/mach/port.h |  422 --
 .../x86_64-macos-gnu/mach/processor_set.h     |  540 --
 lib/libc/include/x86_64-macos-gnu/mach/task.h | 2523 --------
 .../include/x86_64-macos-gnu/mach/task_info.h |  478 --
 .../x86_64-macos-gnu/mach/task_policy.h       |  189 -
 .../mach/task_special_ports.h                 |  132 -
 .../x86_64-macos-gnu/mach/thread_act.h        | 1336 ----
 .../mach/thread_special_ports.h               |   83 -
 .../x86_64-macos-gnu/mach/thread_status.h     |   97 -
 .../include/x86_64-macos-gnu/mach/vm_map.h    | 1440 -----
 .../include/x86_64-macos-gnu/mach/vm_prot.h   |  152 -
 .../x86_64-macos-gnu/mach/vm_statistics.h     |  523 --
 .../include/x86_64-macos-gnu/mach/vm_types.h  |   95 -
 .../x86_64-macos-gnu/mach_debug/ipc_info.h    |  116 -
 .../x86_64-macos-gnu/machine/_mcontext.h      |   32 -
 .../include/x86_64-macos-gnu/machine/_param.h |   32 -
 .../include/x86_64-macos-gnu/machine/_types.h |   37 -
 .../include/x86_64-macos-gnu/machine/endian.h |   40 -
 .../include/x86_64-macos-gnu/machine/limits.h |    9 -
 .../include/x86_64-macos-gnu/machine/param.h  |   40 -
 .../include/x86_64-macos-gnu/machine/signal.h |   37 -
 .../include/x86_64-macos-gnu/machine/types.h  |   40 -
 .../include/x86_64-macos-gnu/malloc/_malloc.h |   56 -
 .../include/x86_64-macos-gnu/malloc/malloc.h  |  314 -
 lib/libc/include/x86_64-macos-gnu/math.h      |  771 ---
 lib/libc/include/x86_64-macos-gnu/net/if.h    |  442 --
 .../include/x86_64-macos-gnu/net/if_var.h     |  242 -
 lib/libc/include/x86_64-macos-gnu/net/route.h |  257 -
 .../include/x86_64-macos-gnu/netinet/in.h     |  671 --
 .../include/x86_64-macos-gnu/netinet/tcp.h    |  283 -
 .../include/x86_64-macos-gnu/netinet6/in6.h   |  667 --
 .../include/x86_64-macos-gnu/objc/objc-api.h  |  280 -
 .../include/x86_64-macos-gnu/objc/runtime.h   | 2169 -------
 lib/libc/include/x86_64-macos-gnu/os/base.h   |  325 -
 lib/libc/include/x86_64-macos-gnu/os/clock.h  |   18 -
 lib/libc/include/x86_64-macos-gnu/os/object.h |  271 -
 .../include/x86_64-macos-gnu/os/workgroup.h   |   37 -
 .../x86_64-macos-gnu/os/workgroup_base.h      |   78 -
 .../x86_64-macos-gnu/os/workgroup_interval.h  |  155 -
 .../x86_64-macos-gnu/os/workgroup_object.h    |  357 --
 .../x86_64-macos-gnu/os/workgroup_parallel.h  |   74 -
 lib/libc/include/x86_64-macos-gnu/pthread.h   |  568 --
 .../include/x86_64-macos-gnu/pthread/sched.h  |   43 -
 .../include/x86_64-macos-gnu/pthread_impl.h   |   66 -
 lib/libc/include/x86_64-macos-gnu/sched.h     |   43 -
 lib/libc/include/x86_64-macos-gnu/signal.h    |  129 -
 .../include/x86_64-macos-gnu/simd/common.h    | 4458 --------------
 .../x86_64-macos-gnu/simd/conversion.h        | 1876 ------
 .../include/x86_64-macos-gnu/simd/logic.h     | 1315 ----
 lib/libc/include/x86_64-macos-gnu/simd/math.h | 5379 -----------------
 .../include/x86_64-macos-gnu/simd/packed.h    | 1031 ----
 .../x86_64-macos-gnu/simd/quaternion.h        | 1192 ----
 lib/libc/include/x86_64-macos-gnu/spawn.h     |  165 -
 lib/libc/include/x86_64-macos-gnu/stdio.h     |  410 --
 lib/libc/include/x86_64-macos-gnu/stdlib.h    |  370 --
 lib/libc/include/x86_64-macos-gnu/string.h    |  193 -
 .../sys/_pthread/_pthread_attr_t.h            |   32 -
 .../sys/_pthread/_pthread_cond_t.h            |   32 -
 .../sys/_pthread/_pthread_condattr_t.h        |   32 -
 .../sys/_pthread/_pthread_rwlock_t.h          |   32 -
 .../sys/_pthread/_pthread_rwlockattr_t.h      |   32 -
 .../sys/_pthread/_pthread_t.h                 |   32 -
 .../sys/_pthread/_pthread_types.h             |  120 -
 .../include/x86_64-macos-gnu/sys/_select.h    |   52 -
 .../x86_64-macos-gnu/sys/_symbol_aliasing.h   |  498 --
 .../x86_64-macos-gnu/sys/_types/_fd_def.h     |  114 -
 .../x86_64-macos-gnu/sys/_types/_int8_t.h     |   31 -
 .../x86_64-macos-gnu/sys/_types/_ucontext.h   |   58 -
 lib/libc/include/x86_64-macos-gnu/sys/acl.h   |  211 -
 lib/libc/include/x86_64-macos-gnu/sys/attr.h  |  579 --
 lib/libc/include/x86_64-macos-gnu/sys/cdefs.h |  855 ---
 lib/libc/include/x86_64-macos-gnu/sys/event.h |  396 --
 lib/libc/include/x86_64-macos-gnu/sys/fcntl.h |  557 --
 .../include/x86_64-macos-gnu/sys/ioccom.h     |   99 -
 lib/libc/include/x86_64-macos-gnu/sys/kauth.h |  407 --
 .../x86_64-macos-gnu/sys/kern_control.h       |  151 -
 lib/libc/include/x86_64-macos-gnu/sys/mman.h  |  250 -
 lib/libc/include/x86_64-macos-gnu/sys/mount.h |  423 --
 lib/libc/include/x86_64-macos-gnu/sys/param.h |  253 -
 lib/libc/include/x86_64-macos-gnu/sys/proc.h  |  223 -
 .../include/x86_64-macos-gnu/sys/proc_info.h  |  799 ---
 .../include/x86_64-macos-gnu/sys/resource.h   |  458 --
 lib/libc/include/x86_64-macos-gnu/sys/shm.h   |  186 -
 .../include/x86_64-macos-gnu/sys/socket.h     |  732 ---
 .../include/x86_64-macos-gnu/sys/sockio.h     |  180 -
 lib/libc/include/x86_64-macos-gnu/sys/spawn.h |   77 -
 lib/libc/include/x86_64-macos-gnu/sys/stat.h  |  430 --
 .../include/x86_64-macos-gnu/sys/sysctl.h     |  775 ---
 .../include/x86_64-macos-gnu/sys/syslimits.h  |  117 -
 .../include/x86_64-macos-gnu/sys/ucontext.h   |   41 -
 lib/libc/include/x86_64-macos-gnu/sys/uio.h   |  100 -
 lib/libc/include/x86_64-macos-gnu/sys/un.h    |  105 -
 lib/libc/include/x86_64-macos-gnu/time.h      |  208 -
 lib/libc/include/x86_64-macos-gnu/ucontext.h  |   54 -
 .../x86_64-macos-gnu/xlocale/_inttypes.h      |   47 -
 .../include/x86_64-macos-gnu/xlocale/_wchar.h |  145 -
 .../x86_64-macos-gnu/xpc/availability.h       |  120 -
 lib/libc/include/x86_64-macos-gnu/xpc/base.h  |  211 -
 .../include/x86_64-macos-gnu/xpc/connection.h |  747 ---
 lib/libc/include/x86_64-macos-gnu/xpc/xpc.h   | 2663 --------
 289 files changed, 455 insertions(+), 60235 deletions(-)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/Availability.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/CommonCrypto/CommonDigest.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/TargetConditionals.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/_ctermid.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/ar.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/bsm/audit.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/dispatch/block.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/dispatch/dispatch.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/dispatch/group.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/dispatch/object.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/dispatch/queue.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/dispatch/semaphore.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/dispatch/source.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/dispatch/workloop.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/libkern/OSByteOrder.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/libkern/_OSByteOrder.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/libproc.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/mach-o/arch.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/mach-o/arm64/reloc.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/mach-o/compact_unwind_encoding.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/mach-o/dyld.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/mach-o/fat.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/mach-o/loader.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/mach-o/nlist.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/mach-o/ranlib.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/mach-o/reloc.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/mach-o/stab.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/mach-o/x86_64/reloc.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/mach/kern_return.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/mach/mach_port.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/mach/mach_traps.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/mach/mach_types.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/mach/machine.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/mach/machine/_structs.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/mach/machine/boolean.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/mach/machine/exception.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/mach/machine/kern_return.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/mach/machine/processor_info.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/mach/machine/rpc.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/mach/machine/thread_state.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/mach/machine/thread_status.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/mach/machine/vm_param.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/mach/machine/vm_types.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/mach/message.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/mach/port.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/mach/processor_set.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/mach/task.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/mach/task_info.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/mach/task_policy.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/mach/task_special_ports.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/mach/thread_act.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/mach/thread_special_ports.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/mach/thread_status.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/mach/vm_prot.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/mach/vm_statistics.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/mach/vm_types.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/machine/_mcontext.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/machine/_param.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/machine/_types.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/machine/endian.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/machine/limits.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/machine/param.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/machine/signal.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/machine/types.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/malloc/_malloc.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/malloc/malloc.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/math.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/net/if.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/net/if_var.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/net/route.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/netinet/in.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/netinet/tcp.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/netinet6/in6.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/objc/objc-api.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/objc/runtime.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/os/base.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/os/clock.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/os/object.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/os/workgroup.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/os/workgroup_base.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/os/workgroup_interval.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/os/workgroup_object.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/os/workgroup_parallel.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/pthread.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/pthread/sched.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/sched.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/signal.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/simd/common.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/simd/conversion.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/simd/logic.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/simd/math.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/simd/packed.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/simd/quaternion.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/spawn.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/stdio.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/stdlib.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/string.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/sys/_pthread/_pthread_attr_t.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/sys/_pthread/_pthread_cond_t.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/sys/_pthread/_pthread_condattr_t.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/sys/_pthread/_pthread_rwlock_t.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/sys/_pthread/_pthread_rwlockattr_t.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/sys/_pthread/_pthread_t.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/sys/_pthread/_pthread_types.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/sys/_select.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/sys/_symbol_aliasing.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/sys/_types/_fd_def.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/sys/_types/_int8_t.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/sys/_types/_ucontext.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/sys/acl.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/sys/attr.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/sys/cdefs.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/sys/event.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/sys/fcntl.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/sys/ioccom.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/sys/kauth.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/sys/kern_control.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/sys/mman.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/sys/mount.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/sys/param.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/sys/proc.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/sys/proc_info.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/sys/random.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/sys/resource.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/sys/shm.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/sys/socket.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/sys/sockio.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/sys/spawn.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/sys/stat.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/sys/sysctl.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/sys/syslimits.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/sys/ucontext.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/sys/uio.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/sys/un.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/ucontext.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/xlocale/_inttypes.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/xlocale/_wchar.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/xpc/availability.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/xpc/base.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/xpc/connection.h (100%)
 rename lib/libc/include/{aarch64-macos-gnu => any-macos-any}/xpc/xpc.h (100%)
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/Availability.h
 create mode 100644 lib/libc/include/x86_64-macos-gnu/AvailabilityVersions.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/TargetConditionals.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/_ctermid.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/bsm/audit.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/dispatch/block.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/dispatch/dispatch.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/dispatch/group.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/dispatch/object.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/dispatch/queue.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/dispatch/semaphore.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/dispatch/source.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/dispatch/workloop.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/libkern/OSByteOrder.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/libkern/_OSByteOrder.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/libproc.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/mach-o/dyld.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/mach-o/loader.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/mach/exception_types.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/mach/host_special_ports.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/mach/kern_return.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/mach/mach_init.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/mach/mach_port.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/mach/mach_traps.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/mach/mach_types.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/mach/machine.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/mach/machine/_structs.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/mach/machine/boolean.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/mach/machine/exception.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/mach/machine/kern_return.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/mach/machine/processor_info.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/mach/machine/rpc.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/mach/machine/thread_state.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/mach/machine/thread_status.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/mach/machine/vm_param.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/mach/machine/vm_types.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/mach/memory_object_types.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/mach/message.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/mach/port.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/mach/processor_set.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/mach/task.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/mach/task_info.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/mach/task_policy.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/mach/task_special_ports.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/mach/thread_act.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/mach/thread_special_ports.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/mach/thread_status.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/mach/vm_map.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/mach/vm_prot.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/mach/vm_statistics.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/mach/vm_types.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/mach_debug/ipc_info.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/machine/_mcontext.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/machine/_param.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/machine/_types.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/machine/endian.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/machine/limits.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/machine/param.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/machine/signal.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/machine/types.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/malloc/_malloc.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/malloc/malloc.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/math.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/net/if.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/net/if_var.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/net/route.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/netinet/in.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/netinet/tcp.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/netinet6/in6.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/objc/objc-api.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/objc/runtime.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/os/base.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/os/clock.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/os/object.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/os/workgroup.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/os/workgroup_base.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/os/workgroup_interval.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/os/workgroup_object.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/os/workgroup_parallel.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/pthread.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/pthread/sched.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/pthread_impl.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/sched.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/signal.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/simd/common.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/simd/conversion.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/simd/logic.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/simd/math.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/simd/packed.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/simd/quaternion.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/spawn.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/stdio.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/stdlib.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/string.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/sys/_pthread/_pthread_attr_t.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/sys/_pthread/_pthread_cond_t.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/sys/_pthread/_pthread_condattr_t.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/sys/_pthread/_pthread_rwlock_t.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/sys/_pthread/_pthread_rwlockattr_t.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/sys/_pthread/_pthread_t.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/sys/_pthread/_pthread_types.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/sys/_select.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/sys/_symbol_aliasing.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/sys/_types/_fd_def.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/sys/_types/_int8_t.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/sys/_types/_ucontext.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/sys/acl.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/sys/attr.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/sys/cdefs.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/sys/event.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/sys/fcntl.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/sys/ioccom.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/sys/kauth.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/sys/kern_control.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/sys/mman.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/sys/mount.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/sys/param.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/sys/proc.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/sys/proc_info.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/sys/resource.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/sys/shm.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/sys/socket.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/sys/sockio.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/sys/spawn.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/sys/stat.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/sys/sysctl.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/sys/syslimits.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/sys/ucontext.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/sys/uio.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/sys/un.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/time.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/ucontext.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/xlocale/_inttypes.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/xlocale/_wchar.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/xpc/availability.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/xpc/base.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/xpc/connection.h
 delete mode 100644 lib/libc/include/x86_64-macos-gnu/xpc/xpc.h

diff --git a/lib/libc/include/aarch64-macos-gnu/Availability.h b/lib/libc/include/any-macos-any/Availability.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/Availability.h
rename to lib/libc/include/any-macos-any/Availability.h
diff --git a/lib/libc/include/aarch64-macos-gnu/CommonCrypto/CommonDigest.h b/lib/libc/include/any-macos-any/CommonCrypto/CommonDigest.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/CommonCrypto/CommonDigest.h
rename to lib/libc/include/any-macos-any/CommonCrypto/CommonDigest.h
diff --git a/lib/libc/include/aarch64-macos-gnu/TargetConditionals.h b/lib/libc/include/any-macos-any/TargetConditionals.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/TargetConditionals.h
rename to lib/libc/include/any-macos-any/TargetConditionals.h
diff --git a/lib/libc/include/aarch64-macos-gnu/_ctermid.h b/lib/libc/include/any-macos-any/_ctermid.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/_ctermid.h
rename to lib/libc/include/any-macos-any/_ctermid.h
diff --git a/lib/libc/include/aarch64-macos-gnu/ar.h b/lib/libc/include/any-macos-any/ar.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/ar.h
rename to lib/libc/include/any-macos-any/ar.h
diff --git a/lib/libc/include/aarch64-macos-gnu/bsm/audit.h b/lib/libc/include/any-macos-any/bsm/audit.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/bsm/audit.h
rename to lib/libc/include/any-macos-any/bsm/audit.h
diff --git a/lib/libc/include/aarch64-macos-gnu/dispatch/block.h b/lib/libc/include/any-macos-any/dispatch/block.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/dispatch/block.h
rename to lib/libc/include/any-macos-any/dispatch/block.h
diff --git a/lib/libc/include/aarch64-macos-gnu/dispatch/dispatch.h b/lib/libc/include/any-macos-any/dispatch/dispatch.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/dispatch/dispatch.h
rename to lib/libc/include/any-macos-any/dispatch/dispatch.h
diff --git a/lib/libc/include/aarch64-macos-gnu/dispatch/group.h b/lib/libc/include/any-macos-any/dispatch/group.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/dispatch/group.h
rename to lib/libc/include/any-macos-any/dispatch/group.h
diff --git a/lib/libc/include/aarch64-macos-gnu/dispatch/object.h b/lib/libc/include/any-macos-any/dispatch/object.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/dispatch/object.h
rename to lib/libc/include/any-macos-any/dispatch/object.h
diff --git a/lib/libc/include/aarch64-macos-gnu/dispatch/queue.h b/lib/libc/include/any-macos-any/dispatch/queue.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/dispatch/queue.h
rename to lib/libc/include/any-macos-any/dispatch/queue.h
diff --git a/lib/libc/include/aarch64-macos-gnu/dispatch/semaphore.h b/lib/libc/include/any-macos-any/dispatch/semaphore.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/dispatch/semaphore.h
rename to lib/libc/include/any-macos-any/dispatch/semaphore.h
diff --git a/lib/libc/include/aarch64-macos-gnu/dispatch/source.h b/lib/libc/include/any-macos-any/dispatch/source.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/dispatch/source.h
rename to lib/libc/include/any-macos-any/dispatch/source.h
diff --git a/lib/libc/include/aarch64-macos-gnu/dispatch/workloop.h b/lib/libc/include/any-macos-any/dispatch/workloop.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/dispatch/workloop.h
rename to lib/libc/include/any-macos-any/dispatch/workloop.h
diff --git a/lib/libc/include/aarch64-macos-gnu/libkern/OSByteOrder.h b/lib/libc/include/any-macos-any/libkern/OSByteOrder.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/libkern/OSByteOrder.h
rename to lib/libc/include/any-macos-any/libkern/OSByteOrder.h
diff --git a/lib/libc/include/aarch64-macos-gnu/libkern/_OSByteOrder.h b/lib/libc/include/any-macos-any/libkern/_OSByteOrder.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/libkern/_OSByteOrder.h
rename to lib/libc/include/any-macos-any/libkern/_OSByteOrder.h
diff --git a/lib/libc/include/aarch64-macos-gnu/libproc.h b/lib/libc/include/any-macos-any/libproc.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/libproc.h
rename to lib/libc/include/any-macos-any/libproc.h
diff --git a/lib/libc/include/aarch64-macos-gnu/mach-o/arch.h b/lib/libc/include/any-macos-any/mach-o/arch.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/mach-o/arch.h
rename to lib/libc/include/any-macos-any/mach-o/arch.h
diff --git a/lib/libc/include/aarch64-macos-gnu/mach-o/arm64/reloc.h b/lib/libc/include/any-macos-any/mach-o/arm64/reloc.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/mach-o/arm64/reloc.h
rename to lib/libc/include/any-macos-any/mach-o/arm64/reloc.h
diff --git a/lib/libc/include/aarch64-macos-gnu/mach-o/compact_unwind_encoding.h b/lib/libc/include/any-macos-any/mach-o/compact_unwind_encoding.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/mach-o/compact_unwind_encoding.h
rename to lib/libc/include/any-macos-any/mach-o/compact_unwind_encoding.h
diff --git a/lib/libc/include/aarch64-macos-gnu/mach-o/dyld.h b/lib/libc/include/any-macos-any/mach-o/dyld.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/mach-o/dyld.h
rename to lib/libc/include/any-macos-any/mach-o/dyld.h
diff --git a/lib/libc/include/aarch64-macos-gnu/mach-o/fat.h b/lib/libc/include/any-macos-any/mach-o/fat.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/mach-o/fat.h
rename to lib/libc/include/any-macos-any/mach-o/fat.h
diff --git a/lib/libc/include/aarch64-macos-gnu/mach-o/loader.h b/lib/libc/include/any-macos-any/mach-o/loader.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/mach-o/loader.h
rename to lib/libc/include/any-macos-any/mach-o/loader.h
diff --git a/lib/libc/include/aarch64-macos-gnu/mach-o/nlist.h b/lib/libc/include/any-macos-any/mach-o/nlist.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/mach-o/nlist.h
rename to lib/libc/include/any-macos-any/mach-o/nlist.h
diff --git a/lib/libc/include/aarch64-macos-gnu/mach-o/ranlib.h b/lib/libc/include/any-macos-any/mach-o/ranlib.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/mach-o/ranlib.h
rename to lib/libc/include/any-macos-any/mach-o/ranlib.h
diff --git a/lib/libc/include/aarch64-macos-gnu/mach-o/reloc.h b/lib/libc/include/any-macos-any/mach-o/reloc.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/mach-o/reloc.h
rename to lib/libc/include/any-macos-any/mach-o/reloc.h
diff --git a/lib/libc/include/aarch64-macos-gnu/mach-o/stab.h b/lib/libc/include/any-macos-any/mach-o/stab.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/mach-o/stab.h
rename to lib/libc/include/any-macos-any/mach-o/stab.h
diff --git a/lib/libc/include/aarch64-macos-gnu/mach-o/x86_64/reloc.h b/lib/libc/include/any-macos-any/mach-o/x86_64/reloc.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/mach-o/x86_64/reloc.h
rename to lib/libc/include/any-macos-any/mach-o/x86_64/reloc.h
diff --git a/lib/libc/include/aarch64-macos-gnu/mach/kern_return.h b/lib/libc/include/any-macos-any/mach/kern_return.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/mach/kern_return.h
rename to lib/libc/include/any-macos-any/mach/kern_return.h
diff --git a/lib/libc/include/aarch64-macos-gnu/mach/mach_port.h b/lib/libc/include/any-macos-any/mach/mach_port.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/mach/mach_port.h
rename to lib/libc/include/any-macos-any/mach/mach_port.h
diff --git a/lib/libc/include/aarch64-macos-gnu/mach/mach_traps.h b/lib/libc/include/any-macos-any/mach/mach_traps.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/mach/mach_traps.h
rename to lib/libc/include/any-macos-any/mach/mach_traps.h
diff --git a/lib/libc/include/aarch64-macos-gnu/mach/mach_types.h b/lib/libc/include/any-macos-any/mach/mach_types.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/mach/mach_types.h
rename to lib/libc/include/any-macos-any/mach/mach_types.h
diff --git a/lib/libc/include/aarch64-macos-gnu/mach/machine.h b/lib/libc/include/any-macos-any/mach/machine.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/mach/machine.h
rename to lib/libc/include/any-macos-any/mach/machine.h
diff --git a/lib/libc/include/aarch64-macos-gnu/mach/machine/_structs.h b/lib/libc/include/any-macos-any/mach/machine/_structs.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/mach/machine/_structs.h
rename to lib/libc/include/any-macos-any/mach/machine/_structs.h
diff --git a/lib/libc/include/aarch64-macos-gnu/mach/machine/boolean.h b/lib/libc/include/any-macos-any/mach/machine/boolean.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/mach/machine/boolean.h
rename to lib/libc/include/any-macos-any/mach/machine/boolean.h
diff --git a/lib/libc/include/aarch64-macos-gnu/mach/machine/exception.h b/lib/libc/include/any-macos-any/mach/machine/exception.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/mach/machine/exception.h
rename to lib/libc/include/any-macos-any/mach/machine/exception.h
diff --git a/lib/libc/include/aarch64-macos-gnu/mach/machine/kern_return.h b/lib/libc/include/any-macos-any/mach/machine/kern_return.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/mach/machine/kern_return.h
rename to lib/libc/include/any-macos-any/mach/machine/kern_return.h
diff --git a/lib/libc/include/aarch64-macos-gnu/mach/machine/processor_info.h b/lib/libc/include/any-macos-any/mach/machine/processor_info.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/mach/machine/processor_info.h
rename to lib/libc/include/any-macos-any/mach/machine/processor_info.h
diff --git a/lib/libc/include/aarch64-macos-gnu/mach/machine/rpc.h b/lib/libc/include/any-macos-any/mach/machine/rpc.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/mach/machine/rpc.h
rename to lib/libc/include/any-macos-any/mach/machine/rpc.h
diff --git a/lib/libc/include/aarch64-macos-gnu/mach/machine/thread_state.h b/lib/libc/include/any-macos-any/mach/machine/thread_state.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/mach/machine/thread_state.h
rename to lib/libc/include/any-macos-any/mach/machine/thread_state.h
diff --git a/lib/libc/include/aarch64-macos-gnu/mach/machine/thread_status.h b/lib/libc/include/any-macos-any/mach/machine/thread_status.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/mach/machine/thread_status.h
rename to lib/libc/include/any-macos-any/mach/machine/thread_status.h
diff --git a/lib/libc/include/aarch64-macos-gnu/mach/machine/vm_param.h b/lib/libc/include/any-macos-any/mach/machine/vm_param.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/mach/machine/vm_param.h
rename to lib/libc/include/any-macos-any/mach/machine/vm_param.h
diff --git a/lib/libc/include/aarch64-macos-gnu/mach/machine/vm_types.h b/lib/libc/include/any-macos-any/mach/machine/vm_types.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/mach/machine/vm_types.h
rename to lib/libc/include/any-macos-any/mach/machine/vm_types.h
diff --git a/lib/libc/include/aarch64-macos-gnu/mach/message.h b/lib/libc/include/any-macos-any/mach/message.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/mach/message.h
rename to lib/libc/include/any-macos-any/mach/message.h
diff --git a/lib/libc/include/aarch64-macos-gnu/mach/port.h b/lib/libc/include/any-macos-any/mach/port.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/mach/port.h
rename to lib/libc/include/any-macos-any/mach/port.h
diff --git a/lib/libc/include/aarch64-macos-gnu/mach/processor_set.h b/lib/libc/include/any-macos-any/mach/processor_set.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/mach/processor_set.h
rename to lib/libc/include/any-macos-any/mach/processor_set.h
diff --git a/lib/libc/include/aarch64-macos-gnu/mach/task.h b/lib/libc/include/any-macos-any/mach/task.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/mach/task.h
rename to lib/libc/include/any-macos-any/mach/task.h
diff --git a/lib/libc/include/aarch64-macos-gnu/mach/task_info.h b/lib/libc/include/any-macos-any/mach/task_info.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/mach/task_info.h
rename to lib/libc/include/any-macos-any/mach/task_info.h
diff --git a/lib/libc/include/aarch64-macos-gnu/mach/task_policy.h b/lib/libc/include/any-macos-any/mach/task_policy.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/mach/task_policy.h
rename to lib/libc/include/any-macos-any/mach/task_policy.h
diff --git a/lib/libc/include/aarch64-macos-gnu/mach/task_special_ports.h b/lib/libc/include/any-macos-any/mach/task_special_ports.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/mach/task_special_ports.h
rename to lib/libc/include/any-macos-any/mach/task_special_ports.h
diff --git a/lib/libc/include/aarch64-macos-gnu/mach/thread_act.h b/lib/libc/include/any-macos-any/mach/thread_act.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/mach/thread_act.h
rename to lib/libc/include/any-macos-any/mach/thread_act.h
diff --git a/lib/libc/include/aarch64-macos-gnu/mach/thread_special_ports.h b/lib/libc/include/any-macos-any/mach/thread_special_ports.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/mach/thread_special_ports.h
rename to lib/libc/include/any-macos-any/mach/thread_special_ports.h
diff --git a/lib/libc/include/aarch64-macos-gnu/mach/thread_status.h b/lib/libc/include/any-macos-any/mach/thread_status.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/mach/thread_status.h
rename to lib/libc/include/any-macos-any/mach/thread_status.h
diff --git a/lib/libc/include/aarch64-macos-gnu/mach/vm_prot.h b/lib/libc/include/any-macos-any/mach/vm_prot.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/mach/vm_prot.h
rename to lib/libc/include/any-macos-any/mach/vm_prot.h
diff --git a/lib/libc/include/aarch64-macos-gnu/mach/vm_statistics.h b/lib/libc/include/any-macos-any/mach/vm_statistics.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/mach/vm_statistics.h
rename to lib/libc/include/any-macos-any/mach/vm_statistics.h
diff --git a/lib/libc/include/aarch64-macos-gnu/mach/vm_types.h b/lib/libc/include/any-macos-any/mach/vm_types.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/mach/vm_types.h
rename to lib/libc/include/any-macos-any/mach/vm_types.h
diff --git a/lib/libc/include/aarch64-macos-gnu/machine/_mcontext.h b/lib/libc/include/any-macos-any/machine/_mcontext.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/machine/_mcontext.h
rename to lib/libc/include/any-macos-any/machine/_mcontext.h
diff --git a/lib/libc/include/aarch64-macos-gnu/machine/_param.h b/lib/libc/include/any-macos-any/machine/_param.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/machine/_param.h
rename to lib/libc/include/any-macos-any/machine/_param.h
diff --git a/lib/libc/include/aarch64-macos-gnu/machine/_types.h b/lib/libc/include/any-macos-any/machine/_types.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/machine/_types.h
rename to lib/libc/include/any-macos-any/machine/_types.h
diff --git a/lib/libc/include/aarch64-macos-gnu/machine/endian.h b/lib/libc/include/any-macos-any/machine/endian.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/machine/endian.h
rename to lib/libc/include/any-macos-any/machine/endian.h
diff --git a/lib/libc/include/aarch64-macos-gnu/machine/limits.h b/lib/libc/include/any-macos-any/machine/limits.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/machine/limits.h
rename to lib/libc/include/any-macos-any/machine/limits.h
diff --git a/lib/libc/include/aarch64-macos-gnu/machine/param.h b/lib/libc/include/any-macos-any/machine/param.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/machine/param.h
rename to lib/libc/include/any-macos-any/machine/param.h
diff --git a/lib/libc/include/aarch64-macos-gnu/machine/signal.h b/lib/libc/include/any-macos-any/machine/signal.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/machine/signal.h
rename to lib/libc/include/any-macos-any/machine/signal.h
diff --git a/lib/libc/include/aarch64-macos-gnu/machine/types.h b/lib/libc/include/any-macos-any/machine/types.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/machine/types.h
rename to lib/libc/include/any-macos-any/machine/types.h
diff --git a/lib/libc/include/aarch64-macos-gnu/malloc/_malloc.h b/lib/libc/include/any-macos-any/malloc/_malloc.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/malloc/_malloc.h
rename to lib/libc/include/any-macos-any/malloc/_malloc.h
diff --git a/lib/libc/include/aarch64-macos-gnu/malloc/malloc.h b/lib/libc/include/any-macos-any/malloc/malloc.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/malloc/malloc.h
rename to lib/libc/include/any-macos-any/malloc/malloc.h
diff --git a/lib/libc/include/aarch64-macos-gnu/math.h b/lib/libc/include/any-macos-any/math.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/math.h
rename to lib/libc/include/any-macos-any/math.h
diff --git a/lib/libc/include/aarch64-macos-gnu/net/if.h b/lib/libc/include/any-macos-any/net/if.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/net/if.h
rename to lib/libc/include/any-macos-any/net/if.h
diff --git a/lib/libc/include/aarch64-macos-gnu/net/if_var.h b/lib/libc/include/any-macos-any/net/if_var.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/net/if_var.h
rename to lib/libc/include/any-macos-any/net/if_var.h
diff --git a/lib/libc/include/aarch64-macos-gnu/net/route.h b/lib/libc/include/any-macos-any/net/route.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/net/route.h
rename to lib/libc/include/any-macos-any/net/route.h
diff --git a/lib/libc/include/aarch64-macos-gnu/netinet/in.h b/lib/libc/include/any-macos-any/netinet/in.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/netinet/in.h
rename to lib/libc/include/any-macos-any/netinet/in.h
diff --git a/lib/libc/include/aarch64-macos-gnu/netinet/tcp.h b/lib/libc/include/any-macos-any/netinet/tcp.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/netinet/tcp.h
rename to lib/libc/include/any-macos-any/netinet/tcp.h
diff --git a/lib/libc/include/aarch64-macos-gnu/netinet6/in6.h b/lib/libc/include/any-macos-any/netinet6/in6.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/netinet6/in6.h
rename to lib/libc/include/any-macos-any/netinet6/in6.h
diff --git a/lib/libc/include/aarch64-macos-gnu/objc/objc-api.h b/lib/libc/include/any-macos-any/objc/objc-api.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/objc/objc-api.h
rename to lib/libc/include/any-macos-any/objc/objc-api.h
diff --git a/lib/libc/include/aarch64-macos-gnu/objc/runtime.h b/lib/libc/include/any-macos-any/objc/runtime.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/objc/runtime.h
rename to lib/libc/include/any-macos-any/objc/runtime.h
diff --git a/lib/libc/include/aarch64-macos-gnu/os/base.h b/lib/libc/include/any-macos-any/os/base.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/os/base.h
rename to lib/libc/include/any-macos-any/os/base.h
diff --git a/lib/libc/include/aarch64-macos-gnu/os/clock.h b/lib/libc/include/any-macos-any/os/clock.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/os/clock.h
rename to lib/libc/include/any-macos-any/os/clock.h
diff --git a/lib/libc/include/aarch64-macos-gnu/os/object.h b/lib/libc/include/any-macos-any/os/object.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/os/object.h
rename to lib/libc/include/any-macos-any/os/object.h
diff --git a/lib/libc/include/aarch64-macos-gnu/os/workgroup.h b/lib/libc/include/any-macos-any/os/workgroup.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/os/workgroup.h
rename to lib/libc/include/any-macos-any/os/workgroup.h
diff --git a/lib/libc/include/aarch64-macos-gnu/os/workgroup_base.h b/lib/libc/include/any-macos-any/os/workgroup_base.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/os/workgroup_base.h
rename to lib/libc/include/any-macos-any/os/workgroup_base.h
diff --git a/lib/libc/include/aarch64-macos-gnu/os/workgroup_interval.h b/lib/libc/include/any-macos-any/os/workgroup_interval.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/os/workgroup_interval.h
rename to lib/libc/include/any-macos-any/os/workgroup_interval.h
diff --git a/lib/libc/include/aarch64-macos-gnu/os/workgroup_object.h b/lib/libc/include/any-macos-any/os/workgroup_object.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/os/workgroup_object.h
rename to lib/libc/include/any-macos-any/os/workgroup_object.h
diff --git a/lib/libc/include/aarch64-macos-gnu/os/workgroup_parallel.h b/lib/libc/include/any-macos-any/os/workgroup_parallel.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/os/workgroup_parallel.h
rename to lib/libc/include/any-macos-any/os/workgroup_parallel.h
diff --git a/lib/libc/include/aarch64-macos-gnu/pthread.h b/lib/libc/include/any-macos-any/pthread.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/pthread.h
rename to lib/libc/include/any-macos-any/pthread.h
diff --git a/lib/libc/include/aarch64-macos-gnu/pthread/sched.h b/lib/libc/include/any-macos-any/pthread/sched.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/pthread/sched.h
rename to lib/libc/include/any-macos-any/pthread/sched.h
diff --git a/lib/libc/include/aarch64-macos-gnu/sched.h b/lib/libc/include/any-macos-any/sched.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/sched.h
rename to lib/libc/include/any-macos-any/sched.h
diff --git a/lib/libc/include/aarch64-macos-gnu/signal.h b/lib/libc/include/any-macos-any/signal.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/signal.h
rename to lib/libc/include/any-macos-any/signal.h
diff --git a/lib/libc/include/aarch64-macos-gnu/simd/common.h b/lib/libc/include/any-macos-any/simd/common.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/simd/common.h
rename to lib/libc/include/any-macos-any/simd/common.h
diff --git a/lib/libc/include/aarch64-macos-gnu/simd/conversion.h b/lib/libc/include/any-macos-any/simd/conversion.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/simd/conversion.h
rename to lib/libc/include/any-macos-any/simd/conversion.h
diff --git a/lib/libc/include/aarch64-macos-gnu/simd/logic.h b/lib/libc/include/any-macos-any/simd/logic.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/simd/logic.h
rename to lib/libc/include/any-macos-any/simd/logic.h
diff --git a/lib/libc/include/aarch64-macos-gnu/simd/math.h b/lib/libc/include/any-macos-any/simd/math.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/simd/math.h
rename to lib/libc/include/any-macos-any/simd/math.h
diff --git a/lib/libc/include/aarch64-macos-gnu/simd/packed.h b/lib/libc/include/any-macos-any/simd/packed.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/simd/packed.h
rename to lib/libc/include/any-macos-any/simd/packed.h
diff --git a/lib/libc/include/aarch64-macos-gnu/simd/quaternion.h b/lib/libc/include/any-macos-any/simd/quaternion.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/simd/quaternion.h
rename to lib/libc/include/any-macos-any/simd/quaternion.h
diff --git a/lib/libc/include/aarch64-macos-gnu/spawn.h b/lib/libc/include/any-macos-any/spawn.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/spawn.h
rename to lib/libc/include/any-macos-any/spawn.h
diff --git a/lib/libc/include/aarch64-macos-gnu/stdio.h b/lib/libc/include/any-macos-any/stdio.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/stdio.h
rename to lib/libc/include/any-macos-any/stdio.h
diff --git a/lib/libc/include/aarch64-macos-gnu/stdlib.h b/lib/libc/include/any-macos-any/stdlib.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/stdlib.h
rename to lib/libc/include/any-macos-any/stdlib.h
diff --git a/lib/libc/include/aarch64-macos-gnu/string.h b/lib/libc/include/any-macos-any/string.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/string.h
rename to lib/libc/include/any-macos-any/string.h
diff --git a/lib/libc/include/aarch64-macos-gnu/sys/_pthread/_pthread_attr_t.h b/lib/libc/include/any-macos-any/sys/_pthread/_pthread_attr_t.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/sys/_pthread/_pthread_attr_t.h
rename to lib/libc/include/any-macos-any/sys/_pthread/_pthread_attr_t.h
diff --git a/lib/libc/include/aarch64-macos-gnu/sys/_pthread/_pthread_cond_t.h b/lib/libc/include/any-macos-any/sys/_pthread/_pthread_cond_t.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/sys/_pthread/_pthread_cond_t.h
rename to lib/libc/include/any-macos-any/sys/_pthread/_pthread_cond_t.h
diff --git a/lib/libc/include/aarch64-macos-gnu/sys/_pthread/_pthread_condattr_t.h b/lib/libc/include/any-macos-any/sys/_pthread/_pthread_condattr_t.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/sys/_pthread/_pthread_condattr_t.h
rename to lib/libc/include/any-macos-any/sys/_pthread/_pthread_condattr_t.h
diff --git a/lib/libc/include/aarch64-macos-gnu/sys/_pthread/_pthread_rwlock_t.h b/lib/libc/include/any-macos-any/sys/_pthread/_pthread_rwlock_t.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/sys/_pthread/_pthread_rwlock_t.h
rename to lib/libc/include/any-macos-any/sys/_pthread/_pthread_rwlock_t.h
diff --git a/lib/libc/include/aarch64-macos-gnu/sys/_pthread/_pthread_rwlockattr_t.h b/lib/libc/include/any-macos-any/sys/_pthread/_pthread_rwlockattr_t.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/sys/_pthread/_pthread_rwlockattr_t.h
rename to lib/libc/include/any-macos-any/sys/_pthread/_pthread_rwlockattr_t.h
diff --git a/lib/libc/include/aarch64-macos-gnu/sys/_pthread/_pthread_t.h b/lib/libc/include/any-macos-any/sys/_pthread/_pthread_t.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/sys/_pthread/_pthread_t.h
rename to lib/libc/include/any-macos-any/sys/_pthread/_pthread_t.h
diff --git a/lib/libc/include/aarch64-macos-gnu/sys/_pthread/_pthread_types.h b/lib/libc/include/any-macos-any/sys/_pthread/_pthread_types.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/sys/_pthread/_pthread_types.h
rename to lib/libc/include/any-macos-any/sys/_pthread/_pthread_types.h
diff --git a/lib/libc/include/aarch64-macos-gnu/sys/_select.h b/lib/libc/include/any-macos-any/sys/_select.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/sys/_select.h
rename to lib/libc/include/any-macos-any/sys/_select.h
diff --git a/lib/libc/include/aarch64-macos-gnu/sys/_symbol_aliasing.h b/lib/libc/include/any-macos-any/sys/_symbol_aliasing.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/sys/_symbol_aliasing.h
rename to lib/libc/include/any-macos-any/sys/_symbol_aliasing.h
diff --git a/lib/libc/include/aarch64-macos-gnu/sys/_types/_fd_def.h b/lib/libc/include/any-macos-any/sys/_types/_fd_def.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/sys/_types/_fd_def.h
rename to lib/libc/include/any-macos-any/sys/_types/_fd_def.h
diff --git a/lib/libc/include/aarch64-macos-gnu/sys/_types/_int8_t.h b/lib/libc/include/any-macos-any/sys/_types/_int8_t.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/sys/_types/_int8_t.h
rename to lib/libc/include/any-macos-any/sys/_types/_int8_t.h
diff --git a/lib/libc/include/aarch64-macos-gnu/sys/_types/_ucontext.h b/lib/libc/include/any-macos-any/sys/_types/_ucontext.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/sys/_types/_ucontext.h
rename to lib/libc/include/any-macos-any/sys/_types/_ucontext.h
diff --git a/lib/libc/include/aarch64-macos-gnu/sys/acl.h b/lib/libc/include/any-macos-any/sys/acl.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/sys/acl.h
rename to lib/libc/include/any-macos-any/sys/acl.h
diff --git a/lib/libc/include/aarch64-macos-gnu/sys/attr.h b/lib/libc/include/any-macos-any/sys/attr.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/sys/attr.h
rename to lib/libc/include/any-macos-any/sys/attr.h
diff --git a/lib/libc/include/aarch64-macos-gnu/sys/cdefs.h b/lib/libc/include/any-macos-any/sys/cdefs.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/sys/cdefs.h
rename to lib/libc/include/any-macos-any/sys/cdefs.h
diff --git a/lib/libc/include/aarch64-macos-gnu/sys/event.h b/lib/libc/include/any-macos-any/sys/event.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/sys/event.h
rename to lib/libc/include/any-macos-any/sys/event.h
diff --git a/lib/libc/include/aarch64-macos-gnu/sys/fcntl.h b/lib/libc/include/any-macos-any/sys/fcntl.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/sys/fcntl.h
rename to lib/libc/include/any-macos-any/sys/fcntl.h
diff --git a/lib/libc/include/aarch64-macos-gnu/sys/ioccom.h b/lib/libc/include/any-macos-any/sys/ioccom.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/sys/ioccom.h
rename to lib/libc/include/any-macos-any/sys/ioccom.h
diff --git a/lib/libc/include/aarch64-macos-gnu/sys/kauth.h b/lib/libc/include/any-macos-any/sys/kauth.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/sys/kauth.h
rename to lib/libc/include/any-macos-any/sys/kauth.h
diff --git a/lib/libc/include/aarch64-macos-gnu/sys/kern_control.h b/lib/libc/include/any-macos-any/sys/kern_control.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/sys/kern_control.h
rename to lib/libc/include/any-macos-any/sys/kern_control.h
diff --git a/lib/libc/include/aarch64-macos-gnu/sys/mman.h b/lib/libc/include/any-macos-any/sys/mman.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/sys/mman.h
rename to lib/libc/include/any-macos-any/sys/mman.h
diff --git a/lib/libc/include/aarch64-macos-gnu/sys/mount.h b/lib/libc/include/any-macos-any/sys/mount.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/sys/mount.h
rename to lib/libc/include/any-macos-any/sys/mount.h
diff --git a/lib/libc/include/aarch64-macos-gnu/sys/param.h b/lib/libc/include/any-macos-any/sys/param.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/sys/param.h
rename to lib/libc/include/any-macos-any/sys/param.h
diff --git a/lib/libc/include/aarch64-macos-gnu/sys/proc.h b/lib/libc/include/any-macos-any/sys/proc.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/sys/proc.h
rename to lib/libc/include/any-macos-any/sys/proc.h
diff --git a/lib/libc/include/aarch64-macos-gnu/sys/proc_info.h b/lib/libc/include/any-macos-any/sys/proc_info.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/sys/proc_info.h
rename to lib/libc/include/any-macos-any/sys/proc_info.h
diff --git a/lib/libc/include/aarch64-macos-gnu/sys/random.h b/lib/libc/include/any-macos-any/sys/random.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/sys/random.h
rename to lib/libc/include/any-macos-any/sys/random.h
diff --git a/lib/libc/include/aarch64-macos-gnu/sys/resource.h b/lib/libc/include/any-macos-any/sys/resource.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/sys/resource.h
rename to lib/libc/include/any-macos-any/sys/resource.h
diff --git a/lib/libc/include/aarch64-macos-gnu/sys/shm.h b/lib/libc/include/any-macos-any/sys/shm.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/sys/shm.h
rename to lib/libc/include/any-macos-any/sys/shm.h
diff --git a/lib/libc/include/aarch64-macos-gnu/sys/socket.h b/lib/libc/include/any-macos-any/sys/socket.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/sys/socket.h
rename to lib/libc/include/any-macos-any/sys/socket.h
diff --git a/lib/libc/include/aarch64-macos-gnu/sys/sockio.h b/lib/libc/include/any-macos-any/sys/sockio.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/sys/sockio.h
rename to lib/libc/include/any-macos-any/sys/sockio.h
diff --git a/lib/libc/include/aarch64-macos-gnu/sys/spawn.h b/lib/libc/include/any-macos-any/sys/spawn.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/sys/spawn.h
rename to lib/libc/include/any-macos-any/sys/spawn.h
diff --git a/lib/libc/include/aarch64-macos-gnu/sys/stat.h b/lib/libc/include/any-macos-any/sys/stat.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/sys/stat.h
rename to lib/libc/include/any-macos-any/sys/stat.h
diff --git a/lib/libc/include/aarch64-macos-gnu/sys/sysctl.h b/lib/libc/include/any-macos-any/sys/sysctl.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/sys/sysctl.h
rename to lib/libc/include/any-macos-any/sys/sysctl.h
diff --git a/lib/libc/include/aarch64-macos-gnu/sys/syslimits.h b/lib/libc/include/any-macos-any/sys/syslimits.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/sys/syslimits.h
rename to lib/libc/include/any-macos-any/sys/syslimits.h
diff --git a/lib/libc/include/aarch64-macos-gnu/sys/ucontext.h b/lib/libc/include/any-macos-any/sys/ucontext.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/sys/ucontext.h
rename to lib/libc/include/any-macos-any/sys/ucontext.h
diff --git a/lib/libc/include/aarch64-macos-gnu/sys/uio.h b/lib/libc/include/any-macos-any/sys/uio.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/sys/uio.h
rename to lib/libc/include/any-macos-any/sys/uio.h
diff --git a/lib/libc/include/aarch64-macos-gnu/sys/un.h b/lib/libc/include/any-macos-any/sys/un.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/sys/un.h
rename to lib/libc/include/any-macos-any/sys/un.h
diff --git a/lib/libc/include/aarch64-macos-gnu/ucontext.h b/lib/libc/include/any-macos-any/ucontext.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/ucontext.h
rename to lib/libc/include/any-macos-any/ucontext.h
diff --git a/lib/libc/include/aarch64-macos-gnu/xlocale/_inttypes.h b/lib/libc/include/any-macos-any/xlocale/_inttypes.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/xlocale/_inttypes.h
rename to lib/libc/include/any-macos-any/xlocale/_inttypes.h
diff --git a/lib/libc/include/aarch64-macos-gnu/xlocale/_wchar.h b/lib/libc/include/any-macos-any/xlocale/_wchar.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/xlocale/_wchar.h
rename to lib/libc/include/any-macos-any/xlocale/_wchar.h
diff --git a/lib/libc/include/aarch64-macos-gnu/xpc/availability.h b/lib/libc/include/any-macos-any/xpc/availability.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/xpc/availability.h
rename to lib/libc/include/any-macos-any/xpc/availability.h
diff --git a/lib/libc/include/aarch64-macos-gnu/xpc/base.h b/lib/libc/include/any-macos-any/xpc/base.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/xpc/base.h
rename to lib/libc/include/any-macos-any/xpc/base.h
diff --git a/lib/libc/include/aarch64-macos-gnu/xpc/connection.h b/lib/libc/include/any-macos-any/xpc/connection.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/xpc/connection.h
rename to lib/libc/include/any-macos-any/xpc/connection.h
diff --git a/lib/libc/include/aarch64-macos-gnu/xpc/xpc.h b/lib/libc/include/any-macos-any/xpc/xpc.h
similarity index 100%
rename from lib/libc/include/aarch64-macos-gnu/xpc/xpc.h
rename to lib/libc/include/any-macos-any/xpc/xpc.h
diff --git a/lib/libc/include/x86_64-macos-gnu/Availability.h b/lib/libc/include/x86_64-macos-gnu/Availability.h
deleted file mode 100644
index bdfd794d89..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/Availability.h
+++ /dev/null
@@ -1,605 +0,0 @@
-/*
- * Copyright (c) 2007-2016 by Apple Inc.. All rights reserved.
- *
- * @APPLE_LICENSE_HEADER_START@
- * 
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this
- * file.
- * 
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- * 
- * @APPLE_LICENSE_HEADER_END@
- */
- 
-#ifndef __AVAILABILITY__
-#define __AVAILABILITY__
- /*     
-    These macros are for use in OS header files. They enable function prototypes
-    and Objective-C methods to be tagged with the OS version in which they
-    were first available; and, if applicable, the OS version in which they 
-    became deprecated.  
-     
-    The desktop Mac OS X and iOS each have different version numbers.
-    The __OSX_AVAILABLE_STARTING() macro allows you to specify both the desktop
-    and iOS version numbers.  For instance:
-        __OSX_AVAILABLE_STARTING(__MAC_10_2,__IPHONE_2_0)
-    means the function/method was first available on Mac OS X 10.2 on the desktop
-    and first available in iOS 2.0 on the iPhone.
-    
-    If a function is available on one platform, but not the other a _NA (not
-    applicable) parameter is used.  For instance:
-            __OSX_AVAILABLE_STARTING(__MAC_10_3,__IPHONE_NA)
-    means that the function/method was first available on Mac OS X 10.3, and it
-    currently not implemented on the iPhone.
-
-    At some point, a function/method may be deprecated.  That means Apple
-    recommends applications stop using the function, either because there is a 
-    better replacement or the functionality is being phased out.  Deprecated
-    functions/methods can be tagged with a __OSX_AVAILABLE_BUT_DEPRECATED()
-    macro which specifies the OS version where the function became available
-    as well as the OS version in which it became deprecated.  For instance:
-        __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0,__MAC_10_5,__IPHONE_NA,__IPHONE_NA)
-    means that the function/method was introduced in Mac OS X 10.0, then
-    became deprecated beginning in Mac OS X 10.5.  On iOS the function 
-    has never been available.  
-    
-    For these macros to function properly, a program must specify the OS version range 
-    it is targeting.  The min OS version is specified as an option to the compiler:
-    -mmacosx-version-min=10.x when building for Mac OS X, and -miphoneos-version-min=y.z
-    when building for the iPhone.  The upper bound for the OS version is rarely needed,
-    but it can be set on the command line via: -D__MAC_OS_X_VERSION_MAX_ALLOWED=10x0 for
-    Mac OS X and __IPHONE_OS_VERSION_MAX_ALLOWED = y0z00 for iOS.  
-    
-    Examples:
-
-        A function available in Mac OS X 10.5 and later, but not on the phone:
-        
-            extern void mymacfunc() __OSX_AVAILABLE_STARTING(__MAC_10_5,__IPHONE_NA);
-
-
-        An Objective-C method in Mac OS X 10.5 and later, but not on the phone:
-        
-            @interface MyClass : NSObject
-            -(void) mymacmethod __OSX_AVAILABLE_STARTING(__MAC_10_5,__IPHONE_NA);
-            @end
-
-        
-        An enum available on the phone, but not available on Mac OS X:
-        
-            #if __IPHONE_OS_VERSION_MIN_REQUIRED
-                enum { myEnum = 1 };
-            #endif
-           Note: this works when targeting the Mac OS X platform because 
-           __IPHONE_OS_VERSION_MIN_REQUIRED is undefined which evaluates to zero. 
-        
-
-        An enum with values added in different iPhoneOS versions:
-		
-			enum {
-			    myX  = 1,	// Usable on iPhoneOS 2.1 and later
-			    myY  = 2,	// Usable on iPhoneOS 3.0 and later
-			    myZ  = 3,	// Usable on iPhoneOS 3.0 and later
-				...
-		      Note: you do not want to use #if with enumeration values
-			  when a client needs to see all values at compile time
-			  and use runtime logic to only use the viable values.
-			  
-
-    It is also possible to use the *_VERSION_MIN_REQUIRED in source code to make one
-    source base that can be compiled to target a range of OS versions.  It is best
-    to not use the _MAC_* and __IPHONE_* macros for comparisons, but rather their values.
-    That is because you might get compiled on an old OS that does not define a later
-    OS version macro, and in the C preprocessor undefined values evaluate to zero
-    in expresssions, which could cause the #if expression to evaluate in an unexpected
-    way.
-    
-        #ifdef __MAC_OS_X_VERSION_MIN_REQUIRED
-            // code only compiled when targeting Mac OS X and not iPhone
-            // note use of 1050 instead of __MAC_10_5
-            #if __MAC_OS_X_VERSION_MIN_REQUIRED < 1050
-                // code in here might run on pre-Leopard OS
-            #else
-                // code here can assume Leopard or later
-            #endif
-        #endif
-
-
-*/
-
-/* 
- * __API_TO_BE_DEPRECATED is used as a version number in API that will be deprecated 
- * in an upcoming release. This soft deprecation is an intermediate step before formal 
- * deprecation to notify developers about the API before compiler warnings are generated.
- * You can find all places in your code that use soft deprecated API by redefining the 
- * value of this macro to your current minimum deployment target, for example:
- * (macOS)
- *   clang -D__API_TO_BE_DEPRECATED=10.12 <other compiler flags>
- * (iOS)
- *   clang -D__API_TO_BE_DEPRECATED=11.0 <other compiler flags>
- */
- 
-#ifndef __API_TO_BE_DEPRECATED
-#define __API_TO_BE_DEPRECATED 100000
-#endif
-
-#ifndef __MAC_10_0
-#define __MAC_10_0            1000
-#define __MAC_10_1            1010
-#define __MAC_10_2            1020
-#define __MAC_10_3            1030
-#define __MAC_10_4            1040
-#define __MAC_10_5            1050
-#define __MAC_10_6            1060
-#define __MAC_10_7            1070
-#define __MAC_10_8            1080
-#define __MAC_10_9            1090
-#define __MAC_10_10         101000
-#define __MAC_10_10_2       101002
-#define __MAC_10_10_3       101003
-#define __MAC_10_11         101100
-#define __MAC_10_11_2       101102
-#define __MAC_10_11_3       101103
-#define __MAC_10_11_4       101104
-#define __MAC_10_12         101200
-#define __MAC_10_12_1       101201
-#define __MAC_10_12_2       101202
-#define __MAC_10_12_4       101204
-#define __MAC_10_13         101300
-#define __MAC_10_13_1       101301
-#define __MAC_10_13_2       101302
-#define __MAC_10_13_4       101304
-#define __MAC_10_14         101400
-#define __MAC_10_14_1       101401
-#define __MAC_10_14_4       101404
-#define __MAC_10_15         101500
-#define __MAC_10_15_1       101501
-#define __MAC_10_15_4       101504
-/* __MAC_NA is not defined to a value but is uses as a token by macros to indicate that the API is unavailable */
-
-#define __IPHONE_2_0      20000
-#define __IPHONE_2_1      20100
-#define __IPHONE_2_2      20200
-#define __IPHONE_3_0      30000
-#define __IPHONE_3_1      30100
-#define __IPHONE_3_2      30200
-#define __IPHONE_4_0      40000
-#define __IPHONE_4_1      40100
-#define __IPHONE_4_2      40200
-#define __IPHONE_4_3      40300
-#define __IPHONE_5_0      50000
-#define __IPHONE_5_1      50100
-#define __IPHONE_6_0      60000
-#define __IPHONE_6_1      60100
-#define __IPHONE_7_0      70000
-#define __IPHONE_7_1      70100
-#define __IPHONE_8_0      80000
-#define __IPHONE_8_1      80100
-#define __IPHONE_8_2      80200
-#define __IPHONE_8_3      80300
-#define __IPHONE_8_4      80400
-#define __IPHONE_9_0      90000
-#define __IPHONE_9_1      90100
-#define __IPHONE_9_2      90200
-#define __IPHONE_9_3      90300
-#define __IPHONE_10_0    100000
-#define __IPHONE_10_1    100100
-#define __IPHONE_10_2    100200
-#define __IPHONE_10_3    100300
-#define __IPHONE_11_0    110000
-#define __IPHONE_11_1    110100
-#define __IPHONE_11_2    110200
-#define __IPHONE_11_3    110300
-#define __IPHONE_11_4    110400
-#define __IPHONE_12_0    120000
-#define __IPHONE_12_1    120100
-#define __IPHONE_12_2    120200
-#define __IPHONE_12_3    120300
-#define __IPHONE_13_0    130000
-#define __IPHONE_13_1    130100
-#define __IPHONE_13_2    130200
-#define __IPHONE_13_3    130300
-#define __IPHONE_13_4    130400
-#define __IPHONE_13_5    130500
-#define __IPHONE_13_6    130600
-/* __IPHONE_NA is not defined to a value but is uses as a token by macros to indicate that the API is unavailable */
-
-#define __TVOS_9_0        90000
-#define __TVOS_9_1        90100
-#define __TVOS_9_2        90200
-#define __TVOS_10_0      100000
-#define __TVOS_10_0_1    100001
-#define __TVOS_10_1      100100
-#define __TVOS_10_2      100200
-#define __TVOS_11_0      110000
-#define __TVOS_11_1      110100
-#define __TVOS_11_2      110200
-#define __TVOS_11_3      110300
-#define __TVOS_11_4      110400
-#define __TVOS_12_0      120000
-#define __TVOS_12_1      120100
-#define __TVOS_12_2      120200
-#define __TVOS_12_3      120300
-#define __TVOS_13_0      130000
-#define __TVOS_13_2      130200
-#define __TVOS_13_3      130300
-#define __TVOS_13_4      130400
-
-#define __WATCHOS_1_0     10000
-#define __WATCHOS_2_0     20000
-#define __WATCHOS_2_1     20100
-#define __WATCHOS_2_2     20200
-#define __WATCHOS_3_0     30000
-#define __WATCHOS_3_1     30100
-#define __WATCHOS_3_1_1   30101
-#define __WATCHOS_3_2     30200
-#define __WATCHOS_4_0     40000
-#define __WATCHOS_4_1     40100
-#define __WATCHOS_4_2     40200
-#define __WATCHOS_4_3     40300
-#define __WATCHOS_5_0     50000
-#define __WATCHOS_5_1     50100
-#define __WATCHOS_5_2     50200
-#define __WATCHOS_6_0     60000
-#define __WATCHOS_6_1     60100
-#define __WATCHOS_6_2     60200
-
-#define __DRIVERKIT_19_0 190000
-#endif /* __MAC_10_0 */
-
-#include <AvailabilityInternal.h>
-
-#ifdef __IPHONE_OS_VERSION_MIN_REQUIRED
-    #define __OSX_AVAILABLE_STARTING(_osx, _ios) __AVAILABILITY_INTERNAL##_ios
-    #define __OSX_AVAILABLE_BUT_DEPRECATED(_osxIntro, _osxDep, _iosIntro, _iosDep) \
-                                                    __AVAILABILITY_INTERNAL##_iosIntro##_DEP##_iosDep
-    #define __OSX_AVAILABLE_BUT_DEPRECATED_MSG(_osxIntro, _osxDep, _iosIntro, _iosDep, _msg) \
-                                                    __AVAILABILITY_INTERNAL##_iosIntro##_DEP##_iosDep##_MSG(_msg)
-
-#elif defined(__MAC_OS_X_VERSION_MIN_REQUIRED)
-
-   #if defined(__has_builtin)
-    #if __has_builtin(__is_target_arch)
-     #if __has_builtin(__is_target_vendor)
-      #if __has_builtin(__is_target_os)
-       #if __has_builtin(__is_target_environment)
-        #if __has_builtin(__is_target_variant_os)
-         #if __has_builtin(__is_target_variant_environment)
-          #if (__is_target_arch(x86_64) && __is_target_vendor(apple) && ((__is_target_os(ios) && __is_target_environment(macabi)) || (__is_target_variant_os(ios) && __is_target_variant_environment(macabi))))
-            #define __OSX_AVAILABLE_STARTING(_osx, _ios) __AVAILABILITY_INTERNAL##_osx __AVAILABILITY_INTERNAL##_ios
-            #define __OSX_AVAILABLE_BUT_DEPRECATED(_osxIntro, _osxDep, _iosIntro, _iosDep) \
-                                                            __AVAILABILITY_INTERNAL##_osxIntro##_DEP##_osxDep __AVAILABILITY_INTERNAL##_iosIntro##_DEP##_iosDep
-            #define __OSX_AVAILABLE_BUT_DEPRECATED_MSG(_osxIntro, _osxDep, _iosIntro, _iosDep, _msg) \
-                                                            __AVAILABILITY_INTERNAL##_osxIntro##_DEP##_osxDep##_MSG(_msg) __AVAILABILITY_INTERNAL##_iosIntro##_DEP##_iosDep##_MSG(_msg)
-          #endif /* # if __is_target_arch... */
-         #endif /* #if __has_builtin(__is_target_variant_environment) */
-        #endif /* #if __has_builtin(__is_target_variant_os) */
-       #endif /* #if __has_builtin(__is_target_environment) */
-      #endif /* #if __has_builtin(__is_target_os) */
-     #endif /* #if __has_builtin(__is_target_vendor) */
-    #endif /* #if __has_builtin(__is_target_arch) */
-   #endif /* #if defined(__has_builtin) */
-
-    #ifndef __OSX_AVAILABLE_STARTING
-      #if defined(__has_attribute) && defined(__has_feature)
-          #if __has_attribute(availability)      
-        #define __OSX_AVAILABLE_STARTING(_osx, _ios) __AVAILABILITY_INTERNAL##_osx
-        #define __OSX_AVAILABLE_BUT_DEPRECATED(_osxIntro, _osxDep, _iosIntro, _iosDep) \
-                                                        __AVAILABILITY_INTERNAL##_osxIntro##_DEP##_osxDep
-        #define __OSX_AVAILABLE_BUT_DEPRECATED_MSG(_osxIntro, _osxDep, _iosIntro, _iosDep, _msg) \
-                                                        __AVAILABILITY_INTERNAL##_osxIntro##_DEP##_osxDep##_MSG(_msg)
-        #else
-        #define __OSX_AVAILABLE_STARTING(_osx, _ios)
-        #define __OSX_AVAILABLE_BUT_DEPRECATED(_osxIntro, _osxDep, _iosIntro, _iosDep)
-        #define __OSX_AVAILABLE_BUT_DEPRECATED_MSG(_osxIntro, _osxDep, _iosIntro, _iosDep, _msg)
-        #endif
-      #else
-      #define __OSX_AVAILABLE_STARTING(_osx, _ios)
-      #define __OSX_AVAILABLE_BUT_DEPRECATED(_osxIntro, _osxDep, _iosIntro, _iosDep)
-      #define __OSX_AVAILABLE_BUT_DEPRECATED_MSG(_osxIntro, _osxDep, _iosIntro, _iosDep, _msg)
-    #endif
-#endif /* __OSX_AVAILABLE_STARTING */
-
-#else
-    #define __OSX_AVAILABLE_STARTING(_osx, _ios)
-    #define __OSX_AVAILABLE_BUT_DEPRECATED(_osxIntro, _osxDep, _iosIntro, _iosDep)
-    #define __OSX_AVAILABLE_BUT_DEPRECATED_MSG(_osxIntro, _osxDep, _iosIntro, _iosDep, _msg)
-#endif
-
-
-#if defined(__has_feature)
-  #if __has_feature(attribute_availability_with_message)
-    #define __OS_AVAILABILITY(_target, _availability)            __attribute__((availability(_target,_availability)))
-    #define __OS_AVAILABILITY_MSG(_target, _availability, _msg)  __attribute__((availability(_target,_availability,message=_msg)))
-  #elif __has_feature(attribute_availability)
-    #define __OS_AVAILABILITY(_target, _availability)            __attribute__((availability(_target,_availability)))
-    #define __OS_AVAILABILITY_MSG(_target, _availability, _msg)  __attribute__((availability(_target,_availability)))
-  #else
-    #define __OS_AVAILABILITY(_target, _availability)
-    #define __OS_AVAILABILITY_MSG(_target, _availability, _msg)
-  #endif
-#else
-    #define __OS_AVAILABILITY(_target, _availability)
-    #define __OS_AVAILABILITY_MSG(_target, _availability, _msg)
-#endif
-
-
-/* for use to document app extension usage */
-#if defined(__has_feature)
-  #if __has_feature(attribute_availability_app_extension)
-    #define __OSX_EXTENSION_UNAVAILABLE(_msg)  __OS_AVAILABILITY_MSG(macosx_app_extension,unavailable,_msg)
-    #define __IOS_EXTENSION_UNAVAILABLE(_msg)  __OS_AVAILABILITY_MSG(ios_app_extension,unavailable,_msg)
-  #else
-    #define __OSX_EXTENSION_UNAVAILABLE(_msg)
-    #define __IOS_EXTENSION_UNAVAILABLE(_msg)
-  #endif
-#else
-    #define __OSX_EXTENSION_UNAVAILABLE(_msg)
-    #define __IOS_EXTENSION_UNAVAILABLE(_msg)
-#endif
-
-#define __OS_EXTENSION_UNAVAILABLE(_msg)  __OSX_EXTENSION_UNAVAILABLE(_msg) __IOS_EXTENSION_UNAVAILABLE(_msg)
-
-
-
-/* for use marking APIs available info for Mac OSX */
-#if defined(__has_attribute)
-  #if __has_attribute(availability)
-    #define __OSX_UNAVAILABLE                    __OS_AVAILABILITY(macosx,unavailable)
-    #define __OSX_AVAILABLE(_vers)               __OS_AVAILABILITY(macosx,introduced=_vers)
-    #define __OSX_DEPRECATED(_start, _dep, _msg) __OSX_AVAILABLE(_start) __OS_AVAILABILITY_MSG(macosx,deprecated=_dep,_msg)
-  #endif
-#endif
-
-#ifndef __OSX_UNAVAILABLE
-  #define __OSX_UNAVAILABLE
-#endif
-
-#ifndef __OSX_AVAILABLE
-  #define __OSX_AVAILABLE(_vers)
-#endif
-
-#ifndef __OSX_DEPRECATED
-  #define __OSX_DEPRECATED(_start, _dep, _msg)
-#endif
-
-
-/* for use marking APIs available info for iOS */
-#if defined(__has_attribute)
-  #if __has_attribute(availability)
-    #define __IOS_UNAVAILABLE                    __OS_AVAILABILITY(ios,unavailable)
-    #define __IOS_PROHIBITED                     __OS_AVAILABILITY(ios,unavailable)
-    #define __IOS_AVAILABLE(_vers)               __OS_AVAILABILITY(ios,introduced=_vers)
-    #define __IOS_DEPRECATED(_start, _dep, _msg) __IOS_AVAILABLE(_start) __OS_AVAILABILITY_MSG(ios,deprecated=_dep,_msg)
-  #endif
-#endif
-
-#ifndef __IOS_UNAVAILABLE
-  #define __IOS_UNAVAILABLE
-#endif
-
-#ifndef __IOS_PROHIBITED
-  #define __IOS_PROHIBITED
-#endif
-
-#ifndef __IOS_AVAILABLE
-  #define __IOS_AVAILABLE(_vers)
-#endif
-
-#ifndef __IOS_DEPRECATED
-  #define __IOS_DEPRECATED(_start, _dep, _msg)
-#endif
-
-
-/* for use marking APIs available info for tvOS */
-#if defined(__has_feature)
-  #if __has_feature(attribute_availability_tvos)
-    #define __TVOS_UNAVAILABLE                    __OS_AVAILABILITY(tvos,unavailable)
-    #define __TVOS_PROHIBITED                     __OS_AVAILABILITY(tvos,unavailable)
-    #define __TVOS_AVAILABLE(_vers)               __OS_AVAILABILITY(tvos,introduced=_vers)
-    #define __TVOS_DEPRECATED(_start, _dep, _msg) __TVOS_AVAILABLE(_start) __OS_AVAILABILITY_MSG(tvos,deprecated=_dep,_msg)
-  #endif
-#endif
-
-#ifndef __TVOS_UNAVAILABLE
-  #define __TVOS_UNAVAILABLE
-#endif
-
-#ifndef __TVOS_PROHIBITED
-  #define __TVOS_PROHIBITED
-#endif
-
-#ifndef __TVOS_AVAILABLE
-  #define __TVOS_AVAILABLE(_vers)
-#endif
-
-#ifndef __TVOS_DEPRECATED
-  #define __TVOS_DEPRECATED(_start, _dep, _msg)
-#endif
-
-
-/* for use marking APIs available info for Watch OS */
-#if defined(__has_feature)
-  #if __has_feature(attribute_availability_watchos)
-    #define __WATCHOS_UNAVAILABLE                    __OS_AVAILABILITY(watchos,unavailable)
-    #define __WATCHOS_PROHIBITED                     __OS_AVAILABILITY(watchos,unavailable)
-    #define __WATCHOS_AVAILABLE(_vers)               __OS_AVAILABILITY(watchos,introduced=_vers)
-    #define __WATCHOS_DEPRECATED(_start, _dep, _msg) __WATCHOS_AVAILABLE(_start) __OS_AVAILABILITY_MSG(watchos,deprecated=_dep,_msg)
-  #endif
-#endif
-
-#ifndef __WATCHOS_UNAVAILABLE
-  #define __WATCHOS_UNAVAILABLE
-#endif
-
-#ifndef __WATCHOS_PROHIBITED
-  #define __WATCHOS_PROHIBITED
-#endif
-
-#ifndef __WATCHOS_AVAILABLE
-  #define __WATCHOS_AVAILABLE(_vers)
-#endif
-
-#ifndef __WATCHOS_DEPRECATED
-  #define __WATCHOS_DEPRECATED(_start, _dep, _msg)
-#endif
-
-
-/* for use marking APIs unavailable for swift */
-#if defined(__has_feature)
-  #if __has_feature(attribute_availability_swift)
-    #define __SWIFT_UNAVAILABLE                   __OS_AVAILABILITY(swift,unavailable)
-    #define __SWIFT_UNAVAILABLE_MSG(_msg)         __OS_AVAILABILITY_MSG(swift,unavailable,_msg)
-  #endif
-#endif
-
-#ifndef __SWIFT_UNAVAILABLE
-  #define __SWIFT_UNAVAILABLE
-#endif
-
-#ifndef __SWIFT_UNAVAILABLE_MSG
-  #define __SWIFT_UNAVAILABLE_MSG(_msg)
-#endif
-
-/*
- Macros for defining which versions/platform a given symbol can be used.
- 
- @see http://clang.llvm.org/docs/AttributeReference.html#availability
- 
- * Note that these macros are only compatible with clang compilers that
- * support the following target selection options:
- *
- * -mmacosx-version-min
- * -miphoneos-version-min
- * -mwatchos-version-min
- * -mtvos-version-min
- */
-
-#if defined(__has_feature) && defined(__has_attribute)
- #if __has_attribute(availability)
-
-    /*
-     * API Introductions
-     *
-     * Use to specify the release that a particular API became available.
-     *
-     * Platform names:
-     *   macos, ios, tvos, watchos
-     *
-     * Examples:
-     *    __API_AVAILABLE(macos(10.10))
-     *    __API_AVAILABLE(macos(10.9), ios(10.0))
-     *    __API_AVAILABLE(macos(10.4), ios(8.0), watchos(2.0), tvos(10.0))
-     *    __API_AVAILABLE(driverkit(19.0))
-     */
-    #define __API_AVAILABLE(...) __API_AVAILABLE_GET_MACRO(__VA_ARGS__,__API_AVAILABLE7, __API_AVAILABLE6, __API_AVAILABLE5, __API_AVAILABLE4, __API_AVAILABLE3, __API_AVAILABLE2, __API_AVAILABLE1, 0)(__VA_ARGS__)
-    
-    #define __API_AVAILABLE_BEGIN(...) _Pragma("clang attribute push") __API_AVAILABLE_BEGIN_GET_MACRO(__VA_ARGS__,__API_AVAILABLE_BEGIN7, __API_AVAILABLE_BEGIN6, __API_AVAILABLE_BEGIN5, __API_AVAILABLE_BEGIN4, __API_AVAILABLE_BEGIN3, __API_AVAILABLE_BEGIN2, __API_AVAILABLE_BEGIN1, 0)(__VA_ARGS__)
-    #define __API_AVAILABLE_END _Pragma("clang attribute pop")
-
-    /*
-     * API Deprecations
-     *
-     * Use to specify the release that a particular API became unavailable.
-     *
-     * Platform names:
-     *   macos, ios, tvos, watchos
-     *
-     * Examples:
-     *
-     *    __API_DEPRECATED("No longer supported", macos(10.4, 10.8))
-     *    __API_DEPRECATED("No longer supported", macos(10.4, 10.8), ios(2.0, 3.0), watchos(2.0, 3.0), tvos(9.0, 10.0))
-     *
-     *    __API_DEPRECATED_WITH_REPLACEMENT("-setName:", tvos(10.0, 10.4), ios(9.0, 10.0))
-     *    __API_DEPRECATED_WITH_REPLACEMENT("SomeClassName", macos(10.4, 10.6), watchos(2.0, 3.0))
-     */
-    #define __API_DEPRECATED(...) __API_DEPRECATED_MSG_GET_MACRO(__VA_ARGS__,__API_DEPRECATED_MSG8,__API_DEPRECATED_MSG7,__API_DEPRECATED_MSG6,__API_DEPRECATED_MSG5,__API_DEPRECATED_MSG4,__API_DEPRECATED_MSG3,__API_DEPRECATED_MSG2,__API_DEPRECATED_MSG1, 0)(__VA_ARGS__)
-    #define __API_DEPRECATED_WITH_REPLACEMENT(...) __API_DEPRECATED_REP_GET_MACRO(__VA_ARGS__,__API_DEPRECATED_REP8,__API_DEPRECATED_REP7,__API_DEPRECATED_REP6,__API_DEPRECATED_REP5,__API_DEPRECATED_REP4,__API_DEPRECATED_REP3,__API_DEPRECATED_REP2,__API_DEPRECATED_REP1, 0)(__VA_ARGS__)
-
-    #define __API_DEPRECATED_BEGIN(...) _Pragma("clang attribute push") __API_DEPRECATED_BEGIN_MSG_GET_MACRO(__VA_ARGS__,__API_DEPRECATED_BEGIN_MSG8,__API_DEPRECATED_BEGIN_MSG7, __API_DEPRECATED_BEGIN_MSG6, __API_DEPRECATED_BEGIN_MSG5, __API_DEPRECATED_BEGIN_MSG4, __API_DEPRECATED_BEGIN_MSG3, __API_DEPRECATED_BEGIN_MSG2, __API_DEPRECATED_BEGIN_MSG1, 0)(__VA_ARGS__)
-    #define __API_DEPRECATED_END _Pragma("clang attribute pop")
-
-    #define __API_DEPRECATED_WITH_REPLACEMENT_BEGIN(...) _Pragma("clang attribute push") __API_DEPRECATED_BEGIN_REP_GET_MACRO(__VA_ARGS__,__API_DEPRECATED_BEGIN_REP8,__API_DEPRECATED_BEGIN_REP7, __API_DEPRECATED_BEGIN_REP6, __API_DEPRECATED_BEGIN_REP5, __API_DEPRECATED_BEGIN_REP4, __API_DEPRECATED_BEGIN_REP3, __API_DEPRECATED_BEGIN_REP2, __API_DEPRECATED_BEGIN_REP1, 0)(__VA_ARGS__)
-    #define __API_DEPRECATED_WITH_REPLACEMENT_END _Pragma("clang attribute pop")
-
-    /*
-     * API Unavailability
-     * Use to specify that an API is unavailable for a particular platform.
-     *
-     * Example:
-     *    __API_UNAVAILABLE(macos)
-     *    __API_UNAVAILABLE(watchos, tvos)
-     */
-    #define __API_UNAVAILABLE(...) __API_UNAVAILABLE_GET_MACRO(__VA_ARGS__,__API_UNAVAILABLE7,__API_UNAVAILABLE6,__API_UNAVAILABLE5,__API_UNAVAILABLE4,__API_UNAVAILABLE3,__API_UNAVAILABLE2,__API_UNAVAILABLE1, 0)(__VA_ARGS__)
-
-    #define __API_UNAVAILABLE_BEGIN(...) _Pragma("clang attribute push") __API_UNAVAILABLE_BEGIN_GET_MACRO(__VA_ARGS__,__API_UNAVAILABLE_BEGIN7,__API_UNAVAILABLE_BEGIN6, __API_UNAVAILABLE_BEGIN5, __API_UNAVAILABLE_BEGIN4, __API_UNAVAILABLE_BEGIN3, __API_UNAVAILABLE_BEGIN2, __API_UNAVAILABLE_BEGIN1, 0)(__VA_ARGS__)
-    #define __API_UNAVAILABLE_END _Pragma("clang attribute pop")
- #else 
-
-    /* 
-     * Evaluate to nothing for compilers that don't support availability.
-     */
-    
-    #define __API_AVAILABLE(...)
-    #define __API_AVAILABLE_BEGIN(...)
-    #define __API_AVAILABLE_END
-    #define __API_DEPRECATED(...)
-    #define __API_DEPRECATED_WITH_REPLACEMENT(...)
-    #define __API_DEPRECATED_BEGIN(...)
-    #define __API_DEPRECATED_END
-    #define __API_DEPRECATED_WITH_REPLACEMENT_BEGIN(...)
-    #define __API_DEPRECATED_WITH_REPLACEMENT_END
-    #define __API_UNAVAILABLE(...)
-    #define __API_UNAVAILABLE_BEGIN(...)
-    #define __API_UNAVAILABLE_END
- #endif /* __has_attribute(availability) */
-#else
-
-    /* 
-     * Evaluate to nothing for compilers that don't support clang language extensions.
-     */
-    
-    #define __API_AVAILABLE(...)
-    #define __API_AVAILABLE_BEGIN(...)
-    #define __API_AVAILABLE_END
-    #define __API_DEPRECATED(...)
-    #define __API_DEPRECATED_WITH_REPLACEMENT(...)
-    #define __API_DEPRECATED_BEGIN(...)
-    #define __API_DEPRECATED_END
-    #define __API_DEPRECATED_WITH_REPLACEMENT_BEGIN(...)
-    #define __API_DEPRECATED_WITH_REPLACEMENT_END
-    #define __API_UNAVAILABLE(...)
-    #define __API_UNAVAILABLE_BEGIN(...)
-    #define __API_UNAVAILABLE_END
-#endif /*  #if defined(__has_feature) && defined(__has_attribute) */
-
-#if __has_include(<AvailabilityProhibitedInternal.h>)
-  #include <AvailabilityProhibitedInternal.h>
-#endif
-
-/*
- * If SPI decorations have not been defined elsewhere, disable them.
- */
-
-#ifndef __SPI_AVAILABLE
-  #define __SPI_AVAILABLE(...)
-#endif
-
-#ifndef __SPI_DEPRECATED
-  #define __SPI_DEPRECATED(...)
-#endif
-
-#ifndef __SPI_DEPRECATED_WITH_REPLACEMENT
-  #define __SPI_DEPRECATED_WITH_REPLACEMENT(...)
-#endif
-
-#endif /* __AVAILABILITY__ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/AvailabilityInternal.h b/lib/libc/include/x86_64-macos-gnu/AvailabilityInternal.h
index 11e6d1ed17..6a35a16782 100644
--- a/lib/libc/include/x86_64-macos-gnu/AvailabilityInternal.h
+++ b/lib/libc/include/x86_64-macos-gnu/AvailabilityInternal.h
@@ -45,6 +45,9 @@
     #ifdef __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__
         /* compiler sets __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ when -miphoneos-version-min is used */
         #define __IPHONE_OS_VERSION_MIN_REQUIRED __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__
+    /* set to 1 when RC_FALLBACK_PLATFORM=iphoneos */
+    #elif 0
+        #define __IPHONE_OS_VERSION_MIN_REQUIRED __IPHONE_14_0
     #endif
 #endif /* __IPHONE_OS_VERSION_MIN_REQUIRED */
 
@@ -52,7 +55,7 @@
     #ifdef __ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__
         /* compiler sets __ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__ when -mtvos-version-min is used */
         #define __TV_OS_VERSION_MIN_REQUIRED __ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__
-        #define __TV_OS_VERSION_MAX_ALLOWED __TVOS_13_0 
+        #define __TV_OS_VERSION_MAX_ALLOWED __TVOS_14_5
         /* for compatibility with existing code.  New code should use platform specific checks */
         #define __IPHONE_OS_VERSION_MIN_REQUIRED 90000
     #endif
@@ -62,7 +65,7 @@
     #ifdef __ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__
         /* compiler sets __ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__ when -mwatchos-version-min is used */
         #define __WATCH_OS_VERSION_MIN_REQUIRED __ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__
-        #define __WATCH_OS_VERSION_MAX_ALLOWED 60000
+        #define __WATCH_OS_VERSION_MAX_ALLOWED __WATCHOS_7_4
         /* for compatibility with existing code.  New code should use platform specific checks */
         #define __IPHONE_OS_VERSION_MIN_REQUIRED 90000
     #endif
@@ -72,7 +75,7 @@
     #ifdef __ENVIRONMENT_BRIDGE_OS_VERSION_MIN_REQUIRED__
         
         #define __BRIDGE_OS_VERSION_MIN_REQUIRED __ENVIRONMENT_BRIDGE_OS_VERSION_MIN_REQUIRED__
-        #define __BRIDGE_OS_VERSION_MAX_ALLOWED 20000
+        #define __BRIDGE_OS_VERSION_MAX_ALLOWED 50300
         /* for compatibility with existing code.  New code should use platform specific checks */
         #define __IPHONE_OS_VERSION_MIN_REQUIRED 110000
     #endif
@@ -87,14 +90,14 @@
 #ifdef __MAC_OS_X_VERSION_MIN_REQUIRED
     /* make sure a default max version is set */
     #ifndef __MAC_OS_X_VERSION_MAX_ALLOWED
-        #define __MAC_OS_X_VERSION_MAX_ALLOWED __MAC_10_15
+        #define __MAC_OS_X_VERSION_MAX_ALLOWED __MAC_11_3
     #endif
 #endif /* __MAC_OS_X_VERSION_MIN_REQUIRED */
 
 #ifdef __IPHONE_OS_VERSION_MIN_REQUIRED
     /* make sure a default max version is set */
     #ifndef __IPHONE_OS_VERSION_MAX_ALLOWED
-        #define __IPHONE_OS_VERSION_MAX_ALLOWED     __IPHONE_13_0
+        #define __IPHONE_OS_VERSION_MAX_ALLOWED     __IPHONE_14_5
     #endif
     /* make sure a valid min is set */
     #if __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_2_0
@@ -2887,7 +2890,7 @@
                #if __has_builtin(__is_target_environment)
                 #if __has_builtin(__is_target_variant_os)
                  #if __has_builtin(__is_target_variant_environment)
-                  #if (__is_target_arch(x86_64) && __is_target_vendor(apple) && __is_target_os(ios) && __is_target_environment(macabi))
+                  #if ((__is_target_arch(x86_64) || __is_target_arch(arm64) || __is_target_arch(arm64e)) && __is_target_vendor(apple) && __is_target_os(ios) && __is_target_environment(macabi))
                     #define __AVAILABILITY_INTERNAL__IPHONE_COMPAT_VERSION __attribute__((availability(ios,introduced=4.0)))
                     #define __AVAILABILITY_INTERNAL__IPHONE_COMPAT_VERSION_DEP__IPHONE_COMPAT_VERSION               __attribute__((availability(ios,unavailable)))
                     #define __AVAILABILITY_INTERNAL__IPHONE_COMPAT_VERSION_DEP__IPHONE_COMPAT_VERSION_MSG(_msg)     __attribute__((availability(ios,unavailable)))
@@ -4643,7 +4646,7 @@
 
 /*
  * Swift compiler version
- * Allows for project-agnostic “epochs” for frameworks imported into Swift via the Clang importer, like #if _compiler_version for Swift
+ * Allows for project-agnostic "epochs" for frameworks imported into Swift via the Clang importer, like #if _compiler_version for Swift
  * Example:
  *
  *  #if __swift_compiler_version_at_least(800, 2, 20)
diff --git a/lib/libc/include/x86_64-macos-gnu/AvailabilityMacros.h b/lib/libc/include/x86_64-macos-gnu/AvailabilityMacros.h
index 9cc7100ffe..74537c5bd8 100644
--- a/lib/libc/include/x86_64-macos-gnu/AvailabilityMacros.h
+++ b/lib/libc/include/x86_64-macos-gnu/AvailabilityMacros.h
@@ -117,9 +117,11 @@
 #define MAC_OS_X_VERSION_10_14_1    101401
 #define MAC_OS_X_VERSION_10_14_4    101404
 #define MAC_OS_X_VERSION_10_15      101500
-#define MAC_OS_X_VERSION_10_15_1    101501
+#define MAC_OS_VERSION_11_0         110000
+#define MAC_OS_VERSION_11_1         110100
+#define MAC_OS_VERSION_11_3         110300
 
-/*
+/* 
  * If min OS not specified, assume 10.4 for intel
  * Note: compiler driver may set _ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED_ based on MACOSX_DEPLOYMENT_TARGET environment variable
  */
@@ -144,10 +146,10 @@
  * if max OS not specified, assume larger of (10.15, min)
  */
 #ifndef MAC_OS_X_VERSION_MAX_ALLOWED
-    #if MAC_OS_X_VERSION_MIN_REQUIRED > MAC_OS_X_VERSION_10_15
+    #if MAC_OS_X_VERSION_MIN_REQUIRED > MAC_OS_VERSION_11_3
         #define MAC_OS_X_VERSION_MAX_ALLOWED MAC_OS_X_VERSION_MIN_REQUIRED
     #else
-        #define MAC_OS_X_VERSION_MAX_ALLOWED MAC_OS_X_VERSION_10_15
+        #define MAC_OS_X_VERSION_MAX_ALLOWED MAC_OS_VERSION_11_3
     #endif
 #endif
 
diff --git a/lib/libc/include/x86_64-macos-gnu/AvailabilityVersions.h b/lib/libc/include/x86_64-macos-gnu/AvailabilityVersions.h
new file mode 100644
index 0000000000..591e541d7f
--- /dev/null
+++ b/lib/libc/include/x86_64-macos-gnu/AvailabilityVersions.h
@@ -0,0 +1,216 @@
+/*
+ * Copyright (c) 2019 by Apple Inc.. All rights reserved.
+ *
+ * @APPLE_LICENSE_HEADER_START@
+ * 
+ * This file contains Original Code and/or Modifications of Original Code
+ * as defined in and that are subject to the Apple Public Source License
+ * Version 2.0 (the 'License'). You may not use this file except in
+ * compliance with the License. Please obtain a copy of the License at
+ * http://www.opensource.apple.com/apsl/ and read it before using this
+ * file.
+ * 
+ * The Original Code and all software distributed under the License are
+ * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
+ * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
+ * Please see the License for the specific language governing rights and
+ * limitations under the License.
+ * 
+ * @APPLE_LICENSE_HEADER_END@
+ */
+ 
+#ifndef __AVAILABILITY_VERSIONS__
+#define __AVAILABILITY_VERSIONS__
+
+#define __MAC_10_0            1000
+#define __MAC_10_1            1010
+#define __MAC_10_2            1020
+#define __MAC_10_3            1030
+#define __MAC_10_4            1040
+#define __MAC_10_5            1050
+#define __MAC_10_6            1060
+#define __MAC_10_7            1070
+#define __MAC_10_8            1080
+#define __MAC_10_9            1090
+#define __MAC_10_10         101000
+#define __MAC_10_10_2       101002
+#define __MAC_10_10_3       101003
+#define __MAC_10_11         101100
+#define __MAC_10_11_2       101102
+#define __MAC_10_11_3       101103
+#define __MAC_10_11_4       101104
+#define __MAC_10_12         101200
+#define __MAC_10_12_1       101201
+#define __MAC_10_12_2       101202
+#define __MAC_10_12_4       101204
+#define __MAC_10_13         101300
+#define __MAC_10_13_1       101301
+#define __MAC_10_13_2       101302
+#define __MAC_10_13_4       101304
+#define __MAC_10_14         101400
+#define __MAC_10_14_1       101401
+#define __MAC_10_14_4       101404
+#define __MAC_10_14_6       101406
+#define __MAC_10_15         101500
+#define __MAC_10_15_1       101501
+#define __MAC_10_15_4       101504
+#define __MAC_10_16         101600
+#define __MAC_11_0          110000
+#define __MAC_11_1          110100
+#define __MAC_11_3          110300
+/* __MAC_NA is not defined to a value but is used as a token by macros to indicate that the API is unavailable */
+
+#define __IPHONE_2_0      20000
+#define __IPHONE_2_1      20100
+#define __IPHONE_2_2      20200
+#define __IPHONE_3_0      30000
+#define __IPHONE_3_1      30100
+#define __IPHONE_3_2      30200
+#define __IPHONE_4_0      40000
+#define __IPHONE_4_1      40100
+#define __IPHONE_4_2      40200
+#define __IPHONE_4_3      40300
+#define __IPHONE_5_0      50000
+#define __IPHONE_5_1      50100
+#define __IPHONE_6_0      60000
+#define __IPHONE_6_1      60100
+#define __IPHONE_7_0      70000
+#define __IPHONE_7_1      70100
+#define __IPHONE_8_0      80000
+#define __IPHONE_8_1      80100
+#define __IPHONE_8_2      80200
+#define __IPHONE_8_3      80300
+#define __IPHONE_8_4      80400
+#define __IPHONE_9_0      90000
+#define __IPHONE_9_1      90100
+#define __IPHONE_9_2      90200
+#define __IPHONE_9_3      90300
+#define __IPHONE_10_0    100000
+#define __IPHONE_10_1    100100
+#define __IPHONE_10_2    100200
+#define __IPHONE_10_3    100300
+#define __IPHONE_11_0    110000
+#define __IPHONE_11_1    110100
+#define __IPHONE_11_2    110200
+#define __IPHONE_11_3    110300
+#define __IPHONE_11_4    110400
+#define __IPHONE_12_0    120000
+#define __IPHONE_12_1    120100
+#define __IPHONE_12_2    120200
+#define __IPHONE_12_3    120300
+#define __IPHONE_12_4    120400
+#define __IPHONE_13_0    130000
+#define __IPHONE_13_1    130100
+#define __IPHONE_13_2    130200
+#define __IPHONE_13_3    130300
+#define __IPHONE_13_4    130400
+#define __IPHONE_13_5    130500
+#define __IPHONE_13_6    130600
+#define __IPHONE_13_7    130700
+#define __IPHONE_14_0    140000
+#define __IPHONE_14_1    140100
+#define __IPHONE_14_2    140200
+#define __IPHONE_14_3    140300
+#define __IPHONE_14_5    140500
+/* __IPHONE_NA is not defined to a value but is used as a token by macros to indicate that the API is unavailable */
+
+#define __TVOS_9_0        90000
+#define __TVOS_9_1        90100
+#define __TVOS_9_2        90200
+#define __TVOS_10_0      100000
+#define __TVOS_10_0_1    100001
+#define __TVOS_10_1      100100
+#define __TVOS_10_2      100200
+#define __TVOS_11_0      110000
+#define __TVOS_11_1      110100
+#define __TVOS_11_2      110200
+#define __TVOS_11_3      110300
+#define __TVOS_11_4      110400
+#define __TVOS_12_0      120000
+#define __TVOS_12_1      120100
+#define __TVOS_12_2      120200
+#define __TVOS_12_3      120300
+#define __TVOS_12_4      120400
+#define __TVOS_13_0      130000
+#define __TVOS_13_2      130200
+#define __TVOS_13_3      130300
+#define __TVOS_13_4      130400
+#define __TVOS_14_0      140000
+#define __TVOS_14_1      140100
+#define __TVOS_14_2      140200
+#define __TVOS_14_3      140300
+#define __TVOS_14_5      140500
+
+#define __WATCHOS_1_0     10000
+#define __WATCHOS_2_0     20000
+#define __WATCHOS_2_1     20100
+#define __WATCHOS_2_2     20200
+#define __WATCHOS_3_0     30000
+#define __WATCHOS_3_1     30100
+#define __WATCHOS_3_1_1   30101
+#define __WATCHOS_3_2     30200
+#define __WATCHOS_4_0     40000
+#define __WATCHOS_4_1     40100
+#define __WATCHOS_4_2     40200
+#define __WATCHOS_4_3     40300
+#define __WATCHOS_5_0     50000
+#define __WATCHOS_5_1     50100
+#define __WATCHOS_5_2     50200
+#define __WATCHOS_5_3     50300
+#define __WATCHOS_6_0     60000
+#define __WATCHOS_6_1     60100
+#define __WATCHOS_6_2     60200
+#define __WATCHOS_7_0     70000
+#define __WATCHOS_7_1     70100
+#define __WATCHOS_7_2     70200
+#define __WATCHOS_7_3     70300
+#define __WATCHOS_7_4     70400
+
+/*
+ * Set up standard Mac OS X versions
+ */
+
+#if (!defined(_POSIX_C_SOURCE) && !defined(_XOPEN_SOURCE)) || defined(_DARWIN_C_SOURCE)
+
+#define MAC_OS_X_VERSION_10_0         1000
+#define MAC_OS_X_VERSION_10_1         1010
+#define MAC_OS_X_VERSION_10_2         1020
+#define MAC_OS_X_VERSION_10_3         1030
+#define MAC_OS_X_VERSION_10_4         1040
+#define MAC_OS_X_VERSION_10_5         1050
+#define MAC_OS_X_VERSION_10_6         1060
+#define MAC_OS_X_VERSION_10_7         1070
+#define MAC_OS_X_VERSION_10_8         1080
+#define MAC_OS_X_VERSION_10_9         1090
+#define MAC_OS_X_VERSION_10_10      101000
+#define MAC_OS_X_VERSION_10_10_2    101002
+#define MAC_OS_X_VERSION_10_10_3    101003
+#define MAC_OS_X_VERSION_10_11      101100
+#define MAC_OS_X_VERSION_10_11_2    101102
+#define MAC_OS_X_VERSION_10_11_3    101103
+#define MAC_OS_X_VERSION_10_11_4    101104
+#define MAC_OS_X_VERSION_10_12      101200
+#define MAC_OS_X_VERSION_10_12_1    101201
+#define MAC_OS_X_VERSION_10_12_2    101202
+#define MAC_OS_X_VERSION_10_12_4    101204
+#define MAC_OS_X_VERSION_10_13      101300
+#define MAC_OS_X_VERSION_10_13_1    101301
+#define MAC_OS_X_VERSION_10_13_2    101302
+#define MAC_OS_X_VERSION_10_13_4    101304
+#define MAC_OS_X_VERSION_10_14      101400
+#define MAC_OS_X_VERSION_10_14_1    101401
+#define MAC_OS_X_VERSION_10_14_4    101404
+#define MAC_OS_X_VERSION_10_14_6    101406
+#define MAC_OS_X_VERSION_10_15      101500
+#define MAC_OS_X_VERSION_10_15_1    101501
+#define MAC_OS_X_VERSION_10_16      101600
+#define MAC_OS_VERSION_11_0         110000
+
+#endif /* #if (!defined(_POSIX_C_SOURCE) && !defined(_XOPEN_SOURCE)) || defined(_DARWIN_C_SOURCE) */
+
+#define __DRIVERKIT_19_0 190000
+#define __DRIVERKIT_20_0 200000
+
+#endif /* __AVAILABILITY_VERSIONS__ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/TargetConditionals.h b/lib/libc/include/x86_64-macos-gnu/TargetConditionals.h
deleted file mode 100644
index 896956f33d..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/TargetConditionals.h
+++ /dev/null
@@ -1,502 +0,0 @@
-/*
- * Copyright (c) 2000-2014 by Apple Inc.. All rights reserved.
- *
- * @APPLE_LICENSE_HEADER_START@
- * 
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this
- * file.
- * 
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- * 
- * @APPLE_LICENSE_HEADER_END@
- */
- 
-/*
-     File:       TargetConditionals.h
- 
-     Contains:   Autoconfiguration of TARGET_ conditionals for Mac OS X and iPhone
-     
-                 Note:  TargetConditionals.h in 3.4 Universal Interfaces works
-                        with all compilers.  This header only recognizes compilers
-                        known to run on Mac OS X.
-  
-*/
-
-#ifndef __TARGETCONDITIONALS__
-#define __TARGETCONDITIONALS__
-
-/****************************************************************************************************
-
-    TARGET_CPU_*    
-    These conditionals specify which microprocessor instruction set is being
-    generated.  At most one of these is true, the rest are false.
-
-        TARGET_CPU_PPC          - Compiler is generating PowerPC instructions for 32-bit mode
-        TARGET_CPU_PPC64        - Compiler is generating PowerPC instructions for 64-bit mode
-        TARGET_CPU_68K          - Compiler is generating 680x0 instructions
-        TARGET_CPU_X86          - Compiler is generating x86 instructions for 32-bit mode
-        TARGET_CPU_X86_64       - Compiler is generating x86 instructions for 64-bit mode
-        TARGET_CPU_ARM          - Compiler is generating ARM instructions for 32-bit mode
-        TARGET_CPU_ARM64        - Compiler is generating ARM instructions for 64-bit mode
-        TARGET_CPU_MIPS         - Compiler is generating MIPS instructions
-        TARGET_CPU_SPARC        - Compiler is generating Sparc instructions
-        TARGET_CPU_ALPHA        - Compiler is generating Dec Alpha instructions
-
-
-    TARGET_OS_* 
-    These conditionals specify in which Operating System the generated code will
-    run.  Indention is used to show which conditionals are evolutionary subclasses.  
-    
-    The MAC/WIN32/UNIX conditionals are mutually exclusive.
-    The IOS/TV/WATCH conditionals are mutually exclusive.
-    
-    
-        TARGET_OS_WIN32           - Generated code will run under 32-bit Windows
-        TARGET_OS_UNIX            - Generated code will run under some Unix (not OSX) 
-        TARGET_OS_MAC             - Generated code will run under Mac OS X variant
-           TARGET_OS_OSX          - Generated code will run under OS X devices
-           TARGET_OS_IPHONE          - Generated code for firmware, devices, or simulator
-              TARGET_OS_IOS             - Generated code will run under iOS 
-              TARGET_OS_TV              - Generated code will run under Apple TV OS
-              TARGET_OS_WATCH           - Generated code will run under Apple Watch OS
-              TARGET_OS_BRIDGE          - Generated code will run under Bridge devices
-              TARGET_OS_MACCATALYST     - Generated code will run under macOS
-           TARGET_OS_SIMULATOR      - Generated code will run under a simulator
-       
-        TARGET_OS_EMBEDDED        - DEPRECATED: Use TARGET_OS_IPHONE and/or TARGET_OS_SIMULATOR instead
-        TARGET_IPHONE_SIMULATOR   - DEPRECATED: Same as TARGET_OS_SIMULATOR
-        TARGET_OS_NANO            - DEPRECATED: Same as TARGET_OS_WATCH
-
-      +----------------------------------------------------------------+
-      |                TARGET_OS_MAC                                   |
-      | +---+  +-----------------------------------------------------+ |
-      | |   |  |          TARGET_OS_IPHONE                           | |
-      | |OSX|  | +-----+ +----+ +-------+ +--------+ +-------------+ | |
-      | |   |  | | IOS | | TV | | WATCH | | BRIDGE | | MACCATALYST | | |
-      | |   |  | +-----+ +----+ +-------+ +--------+ +-------------+ | |
-      | +---+  +-----------------------------------------------------+ |
-      +----------------------------------------------------------------+
-
-    TARGET_RT_* 
-    These conditionals specify in which runtime the generated code will
-    run. This is needed when the OS and CPU support more than one runtime
-    (e.g. Mac OS X supports CFM and mach-o).
-
-        TARGET_RT_LITTLE_ENDIAN - Generated code uses little endian format for integers
-        TARGET_RT_BIG_ENDIAN    - Generated code uses big endian format for integers    
-        TARGET_RT_64_BIT        - Generated code uses 64-bit pointers    
-        TARGET_RT_MAC_CFM       - TARGET_OS_MAC is true and CFM68K or PowerPC CFM (TVectors) are used
-        TARGET_RT_MAC_MACHO     - TARGET_OS_MAC is true and Mach-O/dlyd runtime is used
-        
-
-****************************************************************************************************/
- 
- /*
- * TARGET_OS conditionals can be enabled via clang preprocessor extensions:
- *
- *      __is_target_arch
- *      __is_target_vendor
- *      __is_target_os
- *      __is_target_environment
- *
- *  “-target=x86_64-apple-ios12-macabi”
- *      TARGET_OS_MAC=1
- *      TARGET_OS_IPHONE=1
- *      TARGET_OS_IOS=1
- *      TARGET_OS_MACCATALYST=1
- *
- *  “-target=x86_64-apple-ios12-simulator”
- *      TARGET_OS_MAC=1
- *      TARGET_OS_IPHONE=1
- *      TARGET_OS_IOS=1
- *      TARGET_OS_SIMULATOR=1
- *
- * DYNAMIC_TARGETS_ENABLED indicates that the core TARGET_OS macros were enabled via clang preprocessor extensions.
- * If this value is not set, the macro enablements will fall back to the static behavior.
- * It is disabled by default.
- */
-
-#if defined(__has_builtin)
- #if __has_builtin(__is_target_arch)
-  #if __has_builtin(__is_target_vendor)
-   #if __has_builtin(__is_target_os)
-    #if __has_builtin(__is_target_environment)
-
-    /* “-target=x86_64-apple-ios12-macabi” */
-    #if __is_target_arch(x86_64) && __is_target_vendor(apple) && __is_target_os(ios) && __is_target_environment(macabi)
-        #define TARGET_OS_OSX               0
-        #define TARGET_OS_IPHONE            1
-        #define TARGET_OS_IOS               1
-        #define TARGET_OS_WATCH             0
-        
-        #define TARGET_OS_TV                0
-        #define TARGET_OS_SIMULATOR         0
-        #define TARGET_OS_EMBEDDED          0    
-        #define TARGET_OS_RTKIT             0
-        #define TARGET_OS_MACCATALYST       1
-        #define TARGET_OS_MACCATALYST            1
-        #ifndef TARGET_OS_UIKITFORMAC
-         #define TARGET_OS_UIKITFORMAC      1
-        #endif
-        #define TARGET_OS_DRIVERKIT         0
-        #define DYNAMIC_TARGETS_ENABLED     1
-    #endif 
-
-    /* “-target=x86_64-apple-ios12-simulator” */
-    #if __is_target_arch(x86_64) && __is_target_vendor(apple) && __is_target_os(ios) && __is_target_environment(simulator)
-        #define TARGET_OS_OSX               0
-        #define TARGET_OS_IPHONE            1
-        #define TARGET_OS_IOS               1
-        #define TARGET_OS_WATCH             0
-        
-        #define TARGET_OS_TV                0
-        #define TARGET_OS_SIMULATOR         1
-        #define TARGET_OS_EMBEDDED          0    
-        #define TARGET_OS_RTKIT             0
-        #define TARGET_OS_MACCATALYST       0
-        #define TARGET_OS_MACCATALYST            0
-        #ifndef TARGET_OS_UIKITFORMAC
-         #define TARGET_OS_UIKITFORMAC      0
-        #endif
-        #define TARGET_OS_DRIVERKIT         0
-        #define DYNAMIC_TARGETS_ENABLED     1
-    #endif 
-
-    /* -target=x86_64-apple-driverkit19.0 */
-    #if __is_target_arch(x86_64) && __is_target_vendor(apple) && __is_target_os(driverkit)
-        #define TARGET_OS_OSX               0
-        #define TARGET_OS_IPHONE            0
-        #define TARGET_OS_IOS               0
-        #define TARGET_OS_WATCH             0
-        
-        #define TARGET_OS_TV                0
-        #define TARGET_OS_SIMULATOR         0
-        #define TARGET_OS_EMBEDDED          0
-        #define TARGET_OS_RTKIT             0
-        #define TARGET_OS_MACCATALYST       0
-        #define TARGET_OS_MACCATALYST            0
-        #ifndef TARGET_OS_UIKITFORMAC
-         #define TARGET_OS_UIKITFORMAC      0
-        #endif
-        #define TARGET_OS_DRIVERKIT         1
-        #define DYNAMIC_TARGETS_ENABLED     1
-    #endif
-
-    #endif /* #if __has_builtin(__is_target_environment) */
-   #endif /* #if __has_builtin(__is_target_os) */
-  #endif /* #if __has_builtin(__is_target_vendor) */
- #endif /* #if __has_builtin(__is_target_arch) */
-#endif /* #if defined(__has_builtin) */
-
-
-#ifndef DYNAMIC_TARGETS_ENABLED
- #define DYNAMIC_TARGETS_ENABLED   0
-#endif /* DYNAMIC_TARGETS_ENABLED */
-
-/*
- *    gcc based compiler used on Mac OS X
- */
-#if defined(__GNUC__) && ( defined(__APPLE_CPP__) || defined(__APPLE_CC__) || defined(__MACOS_CLASSIC__) )
-    #define TARGET_OS_MAC               1
-    #define TARGET_OS_WIN32             0
-    #define TARGET_OS_UNIX              0
-
-    #if !DYNAMIC_TARGETS_ENABLED
-        #define TARGET_OS_OSX               1
-        #define TARGET_OS_IPHONE            0
-        #define TARGET_OS_IOS               0
-        #define TARGET_OS_WATCH             0
-        
-        #define TARGET_OS_TV                0
-        #define TARGET_OS_MACCATALYST       0
-        #define TARGET_OS_MACCATALYST            0
-        #ifndef TARGET_OS_UIKITFORMAC
-         #define TARGET_OS_UIKITFORMAC      0
-        #endif
-        #define TARGET_OS_SIMULATOR         0
-        #define TARGET_OS_EMBEDDED          0 
-        #define TARGET_OS_RTKIT             0 
-        #define TARGET_OS_DRIVERKIT         0
-    #endif
-    
-    #define TARGET_IPHONE_SIMULATOR     TARGET_OS_SIMULATOR /* deprecated */
-    #define TARGET_OS_NANO              TARGET_OS_WATCH /* deprecated */ 
-    #define TARGET_ABI_USES_IOS_VALUES  (TARGET_OS_IPHONE && !TARGET_OS_MACCATALYST)
-    #if defined(__ppc__)
-        #define TARGET_CPU_PPC          1
-        #define TARGET_CPU_PPC64        0
-        #define TARGET_CPU_68K          0
-        #define TARGET_CPU_X86          0
-        #define TARGET_CPU_X86_64       0
-        #define TARGET_CPU_ARM          0
-        #define TARGET_CPU_ARM64        0
-        #define TARGET_CPU_MIPS         0
-        #define TARGET_CPU_SPARC        0   
-        #define TARGET_CPU_ALPHA        0
-        #define TARGET_RT_LITTLE_ENDIAN 0
-        #define TARGET_RT_BIG_ENDIAN    1
-        #define TARGET_RT_64_BIT        0
-        #ifdef __MACOS_CLASSIC__
-           #define TARGET_RT_MAC_CFM    1
-           #define TARGET_RT_MAC_MACHO  0
-        #else
-           #define TARGET_RT_MAC_CFM    0
-           #define TARGET_RT_MAC_MACHO  1
-       #endif
-    #elif defined(__ppc64__) 
-        #define TARGET_CPU_PPC          0
-        #define TARGET_CPU_PPC64        1
-        #define TARGET_CPU_68K          0
-        #define TARGET_CPU_X86          0
-        #define TARGET_CPU_X86_64       0
-        #define TARGET_CPU_ARM          0
-        #define TARGET_CPU_ARM64        0
-        #define TARGET_CPU_MIPS         0
-        #define TARGET_CPU_SPARC        0   
-        #define TARGET_CPU_ALPHA        0
-        #define TARGET_RT_LITTLE_ENDIAN 0
-        #define TARGET_RT_BIG_ENDIAN    1
-        #define TARGET_RT_64_BIT        1
-        #define TARGET_RT_MAC_CFM       0
-        #define TARGET_RT_MAC_MACHO     1
-    #elif defined(__i386__) 
-        #define TARGET_CPU_PPC          0
-        #define TARGET_CPU_PPC64        0
-        #define TARGET_CPU_68K          0
-        #define TARGET_CPU_X86          1
-        #define TARGET_CPU_X86_64       0
-        #define TARGET_CPU_ARM          0
-        #define TARGET_CPU_ARM64        0
-        #define TARGET_CPU_MIPS         0
-        #define TARGET_CPU_SPARC        0
-        #define TARGET_CPU_ALPHA        0
-        #define TARGET_RT_MAC_CFM       0
-        #define TARGET_RT_MAC_MACHO     1
-        #define TARGET_RT_LITTLE_ENDIAN 1
-        #define TARGET_RT_BIG_ENDIAN    0
-        #define TARGET_RT_64_BIT        0
-    #elif defined(__x86_64__) 
-        #define TARGET_CPU_PPC          0
-        #define TARGET_CPU_PPC64        0
-        #define TARGET_CPU_68K          0
-        #define TARGET_CPU_X86          0
-        #define TARGET_CPU_X86_64       1
-        #define TARGET_CPU_ARM          0
-        #define TARGET_CPU_ARM64        0
-        #define TARGET_CPU_MIPS         0
-        #define TARGET_CPU_SPARC        0
-        #define TARGET_CPU_ALPHA        0
-        #define TARGET_RT_MAC_CFM       0
-        #define TARGET_RT_MAC_MACHO     1
-        #define TARGET_RT_LITTLE_ENDIAN 1
-        #define TARGET_RT_BIG_ENDIAN    0
-        #define TARGET_RT_64_BIT        1
-    #elif defined(__arm__) 
-        #define TARGET_CPU_PPC          0
-        #define TARGET_CPU_PPC64        0
-        #define TARGET_CPU_68K          0
-        #define TARGET_CPU_X86          0
-        #define TARGET_CPU_X86_64       0
-        #define TARGET_CPU_ARM          1
-        #define TARGET_CPU_ARM64        0
-        #define TARGET_CPU_MIPS         0
-        #define TARGET_CPU_SPARC        0
-        #define TARGET_CPU_ALPHA        0
-        #define TARGET_RT_MAC_CFM       0
-        #define TARGET_RT_MAC_MACHO     1
-        #define TARGET_RT_LITTLE_ENDIAN 1
-        #define TARGET_RT_BIG_ENDIAN    0
-        #define TARGET_RT_64_BIT        0
-    #elif defined(__arm64__)
-        #define TARGET_CPU_PPC          0
-        #define TARGET_CPU_PPC64        0
-        #define TARGET_CPU_68K          0
-        #define TARGET_CPU_X86          0
-        #define TARGET_CPU_X86_64       0
-        #define TARGET_CPU_ARM          0
-        #define TARGET_CPU_ARM64        1
-        #define TARGET_CPU_MIPS         0
-        #define TARGET_CPU_SPARC        0
-        #define TARGET_CPU_ALPHA        0
-        #define TARGET_RT_MAC_CFM       0
-        #define TARGET_RT_MAC_MACHO     1
-        #define TARGET_RT_LITTLE_ENDIAN 1
-        #define TARGET_RT_BIG_ENDIAN    0
-        #if __LP64__
-          #define TARGET_RT_64_BIT      1
-        #else
-          #define TARGET_RT_64_BIT      0
-        #endif
-    #else
-        #error unrecognized GNU C compiler
-    #endif
-
-
-
-/*
- *   CodeWarrior compiler from Metrowerks/Motorola
- */
-#elif defined(__MWERKS__)
-    #define TARGET_OS_MAC               1
-    #define TARGET_OS_WIN32             0
-    #define TARGET_OS_UNIX              0
-    #define TARGET_OS_EMBEDDED          0
-    #if defined(__POWERPC__)
-        #define TARGET_CPU_PPC          1
-        #define TARGET_CPU_PPC64        0
-        #define TARGET_CPU_68K          0
-        #define TARGET_CPU_X86          0
-        #define TARGET_CPU_MIPS         0
-        #define TARGET_CPU_SPARC        0
-        #define TARGET_CPU_ALPHA        0
-        #define TARGET_RT_LITTLE_ENDIAN 0
-        #define TARGET_RT_BIG_ENDIAN    1
-    #elif defined(__INTEL__)
-        #define TARGET_CPU_PPC          0
-        #define TARGET_CPU_PPC64        0
-        #define TARGET_CPU_68K          0
-        #define TARGET_CPU_X86          1
-        #define TARGET_CPU_MIPS         0
-        #define TARGET_CPU_SPARC        0
-        #define TARGET_CPU_ALPHA        0
-        #define TARGET_RT_LITTLE_ENDIAN 1
-        #define TARGET_RT_BIG_ENDIAN    0
-    #else
-        #error unknown Metrowerks CPU type
-    #endif
-    #define TARGET_RT_64_BIT            0
-    #ifdef __MACH__
-        #define TARGET_RT_MAC_CFM       0
-        #define TARGET_RT_MAC_MACHO     1
-    #else
-        #define TARGET_RT_MAC_CFM       1
-        #define TARGET_RT_MAC_MACHO     0
-    #endif
-
-/*
- *   unknown compiler
- */
-#else
-    #if defined(TARGET_CPU_PPC) && TARGET_CPU_PPC
-        #define TARGET_CPU_PPC64    0
-        #define TARGET_CPU_68K      0
-        #define TARGET_CPU_X86      0
-        #define TARGET_CPU_X86_64   0
-        #define TARGET_CPU_ARM      0
-        #define TARGET_CPU_ARM64    0
-        #define TARGET_CPU_MIPS     0
-        #define TARGET_CPU_SPARC    0
-        #define TARGET_CPU_ALPHA    0
-    #elif defined(TARGET_CPU_PPC64) && TARGET_CPU_PPC64
-        #define TARGET_CPU_PPC      0
-        #define TARGET_CPU_68K      0
-        #define TARGET_CPU_X86      0
-        #define TARGET_CPU_X86_64   0
-        #define TARGET_CPU_ARM      0
-        #define TARGET_CPU_ARM64    0
-        #define TARGET_CPU_MIPS     0
-        #define TARGET_CPU_SPARC    0
-        #define TARGET_CPU_ALPHA    0
-    #elif defined(TARGET_CPU_X86) && TARGET_CPU_X86
-        #define TARGET_CPU_PPC      0
-        #define TARGET_CPU_PPC64    0
-        #define TARGET_CPU_X86_64   0
-        #define TARGET_CPU_68K      0
-        #define TARGET_CPU_ARM      0
-        #define TARGET_CPU_ARM64    0
-        #define TARGET_CPU_MIPS     0
-        #define TARGET_CPU_SPARC    0
-        #define TARGET_CPU_ALPHA    0
-    #elif defined(TARGET_CPU_X86_64) && TARGET_CPU_X86_64
-        #define TARGET_CPU_PPC      0
-        #define TARGET_CPU_PPC64    0
-        #define TARGET_CPU_X86      0
-        #define TARGET_CPU_68K      0
-        #define TARGET_CPU_ARM      0
-        #define TARGET_CPU_ARM64    0
-        #define TARGET_CPU_MIPS     0
-        #define TARGET_CPU_SPARC    0
-        #define TARGET_CPU_ALPHA    0
-    #elif defined(TARGET_CPU_ARM) && TARGET_CPU_ARM
-        #define TARGET_CPU_PPC      0
-        #define TARGET_CPU_PPC64    0
-        #define TARGET_CPU_X86      0
-        #define TARGET_CPU_X86_64   0
-        #define TARGET_CPU_68K      0
-        #define TARGET_CPU_ARM64    0
-        #define TARGET_CPU_MIPS     0
-        #define TARGET_CPU_SPARC    0
-        #define TARGET_CPU_ALPHA    0
-    #elif defined(TARGET_CPU_ARM64) && TARGET_CPU_ARM64
-        #define TARGET_CPU_PPC      0
-        #define TARGET_CPU_PPC64    0
-        #define TARGET_CPU_X86      0
-        #define TARGET_CPU_X86_64   0
-        #define TARGET_CPU_68K      0
-        #define TARGET_CPU_ARM      0
-        #define TARGET_CPU_MIPS     0
-        #define TARGET_CPU_SPARC    0
-        #define TARGET_CPU_ALPHA    0
-    #else
-        /*
-            NOTE:   If your compiler errors out here then support for your compiler 
-            has not yet been added to TargetConditionals.h.  
-            
-            TargetConditionals.h is designed to be plug-and-play.  It auto detects
-            which compiler is being run and configures the TARGET_ conditionals
-            appropriately.  
-            
-            The short term work around is to set the TARGET_CPU_ and TARGET_OS_
-            on the command line to the compiler (e.g. -DTARGET_CPU_MIPS=1 -DTARGET_OS_UNIX=1)
-            
-            The long term solution is to add a new case to this file which
-            auto detects your compiler and sets up the TARGET_ conditionals.
-            Then submit the changes to Apple Computer.
-        */
-        #error TargetConditionals.h: unknown compiler (see comment above)
-        #define TARGET_CPU_PPC    0
-        #define TARGET_CPU_68K    0
-        #define TARGET_CPU_X86    0
-        #define TARGET_CPU_ARM    0
-        #define TARGET_CPU_ARM64  0
-        #define TARGET_CPU_MIPS   0
-        #define TARGET_CPU_SPARC  0
-        #define TARGET_CPU_ALPHA  0
-    #endif
-    #define TARGET_OS_MAC                1
-    #define TARGET_OS_WIN32              0
-    #define TARGET_OS_UNIX               0
-    #define TARGET_OS_EMBEDDED           0
-    #if TARGET_CPU_PPC || TARGET_CPU_PPC64
-        #define TARGET_RT_BIG_ENDIAN     1
-        #define TARGET_RT_LITTLE_ENDIAN  0
-    #else
-        #define TARGET_RT_BIG_ENDIAN     0
-        #define TARGET_RT_LITTLE_ENDIAN  1
-    #endif
-    #if TARGET_CPU_PPC64 || TARGET_CPU_X86_64
-        #define TARGET_RT_64_BIT         1
-    #else
-        #define TARGET_RT_64_BIT         0
-    #endif
-    #ifdef __MACH__
-        #define TARGET_RT_MAC_MACHO      1
-        #define TARGET_RT_MAC_CFM        0
-    #else
-        #define TARGET_RT_MAC_MACHO      0
-        #define TARGET_RT_MAC_CFM        1
-    #endif
-    
-#endif
-
-#endif  /* __TARGETCONDITIONALS__ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/_ctermid.h b/lib/libc/include/x86_64-macos-gnu/_ctermid.h
deleted file mode 100644
index b941ea10d4..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/_ctermid.h
+++ /dev/null
@@ -1,27 +0,0 @@
-/*
- * Copyright (c) 2000, 2002-2006, 2008-2010, 2012 Apple Inc. All rights reserved.
- *
- * @APPLE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this
- * file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_LICENSE_HEADER_END@
- */
-
-#ifndef _CTERMID_H_
-#define _CTERMID_H_
-char    *ctermid(char *);
-#endif
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/bsm/audit.h b/lib/libc/include/x86_64-macos-gnu/bsm/audit.h
deleted file mode 100644
index e65ccbfab6..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/bsm/audit.h
+++ /dev/null
@@ -1,378 +0,0 @@
-/*-
- * Copyright (c) 2005-2009 Apple Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- *
- * 1.  Redistributions of source code must retain the above copyright
- *     notice, this list of conditions and the following disclaimer.
- * 2.  Redistributions in binary form must reproduce the above copyright
- *     notice, this list of conditions and the following disclaimer in the
- *     documentation and/or other materials provided with the distribution.
- * 3.  Neither the name of Apple Inc. ("Apple") nor the names of
- *     its contributors may be used to endorse or promote products derived
- *     from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- * $P4: //depot/projects/trustedbsd/openbsm/sys/bsm/audit.h#10 $
- */
-
-#ifndef _BSM_AUDIT_H
-#define _BSM_AUDIT_H
-
-#include <sys/param.h>
-#include <sys/types.h>
-
-#define AUDIT_RECORD_MAGIC      0x828a0f1b
-#define MAX_AUDIT_RECORDS       20
-#define MAXAUDITDATA            (0x8000 - 1)
-#define MAX_AUDIT_RECORD_SIZE   MAXAUDITDATA
-#define MIN_AUDIT_FILE_SIZE     (512 * 1024)
-
-/*
- * Minimum noumber of free blocks on the filesystem containing the audit
- * log necessary to avoid a hard log rotation. DO NOT SET THIS VALUE TO 0
- * as the kernel does an unsigned compare, plus we want to leave a few blocks
- * free so userspace can terminate the log, etc.
- */
-#define AUDIT_HARD_LIMIT_FREE_BLOCKS    4
-
-/*
- * Triggers for the audit daemon.
- */
-#define AUDIT_TRIGGER_MIN               1
-#define AUDIT_TRIGGER_LOW_SPACE         1       /* Below low watermark. */
-#define AUDIT_TRIGGER_ROTATE_KERNEL     2       /* Kernel requests rotate. */
-#define AUDIT_TRIGGER_READ_FILE         3       /* Re-read config file. */
-#define AUDIT_TRIGGER_CLOSE_AND_DIE     4       /* Terminate audit. */
-#define AUDIT_TRIGGER_NO_SPACE          5       /* Below min free space. */
-#define AUDIT_TRIGGER_ROTATE_USER       6       /* User requests rotate. */
-#define AUDIT_TRIGGER_INITIALIZE        7       /* User initialize of auditd. */
-#define AUDIT_TRIGGER_EXPIRE_TRAILS     8       /* User expiration of trails. */
-#define AUDIT_TRIGGER_MAX               8
-
-/*
- * The special device filename (FreeBSD).
- */
-#define AUDITDEV_FILENAME       "audit"
-#define AUDIT_TRIGGER_FILE      ("/dev/" AUDITDEV_FILENAME)
-
-/*
- * Pre-defined audit IDs
- */
-#define AU_DEFAUDITID   (uid_t)(-1)
-#define AU_DEFAUDITSID   0
-#define AU_ASSIGN_ASID  -1
-
-/*
- * IPC types.
- */
-#define AT_IPC_MSG      ((unsigned char)1)      /* Message IPC id. */
-#define AT_IPC_SEM      ((unsigned char)2)      /* Semaphore IPC id. */
-#define AT_IPC_SHM      ((unsigned char)3)      /* Shared mem IPC id. */
-
-/*
- * Audit conditions.
- */
-#define AUC_UNSET               0
-#define AUC_AUDITING            1
-#define AUC_NOAUDIT             2
-#define AUC_DISABLED            -1
-
-/*
- * auditon(2) commands.
- */
-#define A_OLDGETPOLICY  2
-#define A_OLDSETPOLICY  3
-#define A_GETKMASK      4
-#define A_SETKMASK      5
-#define A_OLDGETQCTRL   6
-#define A_OLDSETQCTRL   7
-#define A_GETCWD        8
-#define A_GETCAR        9
-#define A_GETSTAT       12
-#define A_SETSTAT       13
-#define A_SETUMASK      14
-#define A_SETSMASK      15
-#define A_OLDGETCOND    20
-#define A_OLDSETCOND    21
-#define A_GETCLASS      22
-#define A_SETCLASS      23
-#define A_GETPINFO      24
-#define A_SETPMASK      25
-#define A_SETFSIZE      26
-#define A_GETFSIZE      27
-#define A_GETPINFO_ADDR 28
-#define A_GETKAUDIT     29
-#define A_SETKAUDIT     30
-#define A_SENDTRIGGER   31
-#define A_GETSINFO_ADDR 32
-#define A_GETPOLICY     33
-#define A_SETPOLICY     34
-#define A_GETQCTRL      35
-#define A_SETQCTRL      36
-#define A_GETCOND       37
-#define A_SETCOND       38
-#define A_GETSFLAGS     39
-#define A_SETSFLAGS     40
-#define A_GETCTLMODE    41
-#define A_SETCTLMODE    42
-#define A_GETEXPAFTER   43
-#define A_SETEXPAFTER   44
-
-/*
- * Audit policy controls.
- */
-#define AUDIT_CNT       0x0001
-#define AUDIT_AHLT      0x0002
-#define AUDIT_ARGV      0x0004
-#define AUDIT_ARGE      0x0008
-#define AUDIT_SEQ       0x0010
-#define AUDIT_WINDATA   0x0020
-#define AUDIT_USER      0x0040
-#define AUDIT_GROUP     0x0080
-#define AUDIT_TRAIL     0x0100
-#define AUDIT_PATH      0x0200
-#define AUDIT_SCNT      0x0400
-#define AUDIT_PUBLIC    0x0800
-#define AUDIT_ZONENAME  0x1000
-#define AUDIT_PERZONE   0x2000
-
-/*
- * Default audit queue control parameters.
- */
-#define AQ_HIWATER      100
-#define AQ_MAXHIGH      10000
-#define AQ_LOWATER      10
-#define AQ_BUFSZ        MAXAUDITDATA
-#define AQ_MAXBUFSZ     1048576
-
-/*
- * Default minimum percentage free space on file system.
- */
-#define AU_FS_MINFREE   20
-
-/*
- * Type definitions used indicating the length of variable length addresses
- * in tokens containing addresses, such as header fields.
- */
-#define AU_IPv4         4
-#define AU_IPv6         16
-
-/*
- * Reserved audit class mask indicating which classes are unable to have
- * events added or removed by unentitled processes.
- */
-#define AU_CLASS_MASK_RESERVED 0x10000000
-
-/*
- * Audit control modes
- */
-#define AUDIT_CTLMODE_NORMAL ((unsigned char)1)
-#define AUDIT_CTLMODE_EXTERNAL ((unsigned char)2)
-
-/*
- * Audit file expire_after op modes
- */
-#define AUDIT_EXPIRE_OP_AND ((unsigned char)0)
-#define AUDIT_EXPIRE_OP_OR ((unsigned char)1)
-
-__BEGIN_DECLS
-
-typedef uid_t           au_id_t;
-typedef pid_t           au_asid_t;
-typedef u_int16_t       au_event_t;
-typedef u_int16_t       au_emod_t;
-typedef u_int32_t       au_class_t;
-typedef u_int64_t       au_asflgs_t __attribute__ ((aligned(8)));
-typedef unsigned char   au_ctlmode_t;
-
-struct au_tid {
-	dev_t           port;
-	u_int32_t       machine;
-};
-typedef struct au_tid   au_tid_t;
-
-struct au_tid_addr {
-	dev_t           at_port;
-	u_int32_t       at_type;
-	u_int32_t       at_addr[4];
-};
-typedef struct au_tid_addr      au_tid_addr_t;
-
-struct au_mask {
-	unsigned int    am_success;     /* Success bits. */
-	unsigned int    am_failure;     /* Failure bits. */
-};
-typedef struct au_mask  au_mask_t;
-
-struct auditinfo {
-	au_id_t         ai_auid;        /* Audit user ID. */
-	au_mask_t       ai_mask;        /* Audit masks. */
-	au_tid_t        ai_termid;      /* Terminal ID. */
-	au_asid_t       ai_asid;        /* Audit session ID. */
-};
-typedef struct auditinfo        auditinfo_t;
-
-struct auditinfo_addr {
-	au_id_t         ai_auid;        /* Audit user ID. */
-	au_mask_t       ai_mask;        /* Audit masks. */
-	au_tid_addr_t   ai_termid;      /* Terminal ID. */
-	au_asid_t       ai_asid;        /* Audit session ID. */
-	au_asflgs_t     ai_flags;       /* Audit session flags. */
-};
-typedef struct auditinfo_addr   auditinfo_addr_t;
-
-struct auditpinfo {
-	pid_t           ap_pid;         /* ID of target process. */
-	au_id_t         ap_auid;        /* Audit user ID. */
-	au_mask_t       ap_mask;        /* Audit masks. */
-	au_tid_t        ap_termid;      /* Terminal ID. */
-	au_asid_t       ap_asid;        /* Audit session ID. */
-};
-typedef struct auditpinfo       auditpinfo_t;
-
-struct auditpinfo_addr {
-	pid_t           ap_pid;         /* ID of target process. */
-	au_id_t         ap_auid;        /* Audit user ID. */
-	au_mask_t       ap_mask;        /* Audit masks. */
-	au_tid_addr_t   ap_termid;      /* Terminal ID. */
-	au_asid_t       ap_asid;        /* Audit session ID. */
-	au_asflgs_t     ap_flags;       /* Audit session flags. */
-};
-typedef struct auditpinfo_addr  auditpinfo_addr_t;
-
-struct au_session {
-	auditinfo_addr_t        *as_aia_p;      /* Ptr to full audit info. */
-	au_mask_t                as_mask;       /* Process Audit Masks. */
-};
-typedef struct au_session       au_session_t;
-
-struct au_expire_after {
-	time_t age;             /* Age after which trail files should be expired */
-	size_t size;    /* Aggregate trail size when files should be expired */
-	unsigned char op_type; /* Operator used with the above values to determine when files should be expired */
-};
-typedef struct au_expire_after au_expire_after_t;
-
-/*
- * Contents of token_t are opaque outside of libbsm.
- */
-typedef struct au_token token_t;
-
-/*
- * Kernel audit queue control parameters:
- *                      Default:		Maximum:
- *      aq_hiwater:	AQ_HIWATER (100)	AQ_MAXHIGH (10000)
- *      aq_lowater:	AQ_LOWATER (10)		<aq_hiwater
- *      aq_bufsz:	AQ_BUFSZ (32767)	AQ_MAXBUFSZ (1048576)
- *      aq_delay:	20			20000 (not used)
- */
-struct au_qctrl {
-	int     aq_hiwater;     /* Max # of audit recs in queue when */
-	                        /* threads with new ARs get blocked. */
-
-	int     aq_lowater;     /* # of audit recs in queue when */
-	                        /* blocked threads get unblocked. */
-
-	int     aq_bufsz;       /* Max size of audit record for audit(2). */
-	int     aq_delay;       /* Queue delay (not used). */
-	int     aq_minfree;     /* Minimum filesystem percent free space. */
-};
-typedef struct au_qctrl au_qctrl_t;
-
-/*
- * Structure for the audit statistics.
- */
-struct audit_stat {
-	unsigned int    as_version;
-	unsigned int    as_numevent;
-	int             as_generated;
-	int             as_nonattrib;
-	int             as_kernel;
-	int             as_audit;
-	int             as_auditctl;
-	int             as_enqueue;
-	int             as_written;
-	int             as_wblocked;
-	int             as_rblocked;
-	int             as_dropped;
-	int             as_totalsize;
-	unsigned int    as_memused;
-};
-typedef struct audit_stat       au_stat_t;
-
-/*
- * Structure for the audit file statistics.
- */
-struct audit_fstat {
-	u_int64_t       af_filesz;
-	u_int64_t       af_currsz;
-};
-typedef struct audit_fstat      au_fstat_t;
-
-/*
- * Audit to event class mapping.
- */
-struct au_evclass_map {
-	au_event_t      ec_number;
-	au_class_t      ec_class;
-};
-typedef struct au_evclass_map   au_evclass_map_t;
-
-/*
- * Audit system calls.
- */
-#if !defined(_KERNEL) && !defined(KERNEL)
-int     audit(const void *, int);
-int     auditon(int, void *, int);
-int     auditctl(const char *);
-int     getauid(au_id_t *);
-int     setauid(const au_id_t *);
-int     getaudit_addr(struct auditinfo_addr *, int);
-int     setaudit_addr(const struct auditinfo_addr *, int);
-
-#if defined(__APPLE__)
-#include <Availability.h>
-
-/*
- * getaudit()/setaudit() are deprecated and have been replaced with
- * wrappers to the getaudit_addr()/setaudit_addr() syscalls above.
- */
-
-int     getaudit(struct auditinfo *)
-__OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8,
-    __IPHONE_2_0, __IPHONE_6_0);
-int     setaudit(const struct auditinfo *)
-__OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8,
-    __IPHONE_2_0, __IPHONE_6_0);
-#else
-
-int     getaudit(struct auditinfo *);
-int     setaudit(const struct auditinfo *);
-#endif /* !__APPLE__ */
-
-#ifdef __APPLE_API_PRIVATE
-#include <mach/port.h>
-mach_port_name_t audit_session_self(void);
-au_asid_t        audit_session_join(mach_port_name_t port);
-int              audit_session_port(au_asid_t asid, mach_port_name_t *portname);
-#endif /* __APPLE_API_PRIVATE */
-
-#endif /* defined(_KERNEL) || defined(KERNEL) */
-
-__END_DECLS
-
-#endif /* !_BSM_AUDIT_H */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/dispatch/block.h b/lib/libc/include/x86_64-macos-gnu/dispatch/block.h
deleted file mode 100644
index 5a28f48ce4..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/dispatch/block.h
+++ /dev/null
@@ -1,428 +0,0 @@
-/*
- * Copyright (c) 2014 Apple Inc. All rights reserved.
- *
- * @APPLE_APACHE_LICENSE_HEADER_START@
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @APPLE_APACHE_LICENSE_HEADER_END@
- */
-
-#ifndef __DISPATCH_BLOCK__
-#define __DISPATCH_BLOCK__
-
-#ifndef __DISPATCH_INDIRECT__
-#error "Please #include <dispatch/dispatch.h> instead of this file directly."
-#include <dispatch/base.h> // for HeaderDoc
-#endif
-
-#ifdef __BLOCKS__
-
-/*!
- * @group Dispatch block objects
- */
-
-DISPATCH_ASSUME_NONNULL_BEGIN
-
-__BEGIN_DECLS
-
-/*!
- * @typedef dispatch_block_flags_t
- * Flags to pass to the dispatch_block_create* functions.
- *
- * @const DISPATCH_BLOCK_BARRIER
- * Flag indicating that a dispatch block object should act as a barrier block
- * when submitted to a DISPATCH_QUEUE_CONCURRENT queue.
- * See dispatch_barrier_async() for details.
- * This flag has no effect when the dispatch block object is invoked directly.
- *
- * @const DISPATCH_BLOCK_DETACHED
- * Flag indicating that a dispatch block object should execute disassociated
- * from current execution context attributes such as os_activity_t
- * and properties of the current IPC request (if any). With regard to QoS class,
- * the behavior is the same as for DISPATCH_BLOCK_NO_QOS. If invoked directly,
- * the block object will remove the other attributes from the calling thread for
- * the duration of the block body (before applying attributes assigned to the
- * block object, if any). If submitted to a queue, the block object will be
- * executed with the attributes of the queue (or any attributes specifically
- * assigned to the block object).
- *
- * @const DISPATCH_BLOCK_ASSIGN_CURRENT
- * Flag indicating that a dispatch block object should be assigned the execution
- * context attributes that are current at the time the block object is created.
- * This applies to attributes such as QOS class, os_activity_t and properties of
- * the current IPC request (if any). If invoked directly, the block object will
- * apply these attributes to the calling thread for the duration of the block
- * body. If the block object is submitted to a queue, this flag replaces the
- * default behavior of associating the submitted block instance with the
- * execution context attributes that are current at the time of submission.
- * If a specific QOS class is assigned with DISPATCH_BLOCK_NO_QOS_CLASS or
- * dispatch_block_create_with_qos_class(), that QOS class takes precedence over
- * the QOS class assignment indicated by this flag.
- *
- * @const DISPATCH_BLOCK_NO_QOS_CLASS
- * Flag indicating that a dispatch block object should be not be assigned a QOS
- * class. If invoked directly, the block object will be executed with the QOS
- * class of the calling thread. If the block object is submitted to a queue,
- * this replaces the default behavior of associating the submitted block
- * instance with the QOS class current at the time of submission.
- * This flag is ignored if a specific QOS class is assigned with
- * dispatch_block_create_with_qos_class().
- *
- * @const DISPATCH_BLOCK_INHERIT_QOS_CLASS
- * Flag indicating that execution of a dispatch block object submitted to a
- * queue should prefer the QOS class assigned to the queue over the QOS class
- * assigned to the block (resp. associated with the block at the time of
- * submission). The latter will only be used if the queue in question does not
- * have an assigned QOS class, as long as doing so does not result in a QOS
- * class lower than the QOS class inherited from the queue's target queue.
- * This flag is the default when a dispatch block object is submitted to a queue
- * for asynchronous execution and has no effect when the dispatch block object
- * is invoked directly. It is ignored if DISPATCH_BLOCK_ENFORCE_QOS_CLASS is
- * also passed.
- *
- * @const DISPATCH_BLOCK_ENFORCE_QOS_CLASS
- * Flag indicating that execution of a dispatch block object submitted to a
- * queue should prefer the QOS class assigned to the block (resp. associated
- * with the block at the time of submission) over the QOS class assigned to the
- * queue, as long as doing so will not result in a lower QOS class.
- * This flag is the default when a dispatch block object is submitted to a queue
- * for synchronous execution or when the dispatch block object is invoked
- * directly.
- */
-DISPATCH_OPTIONS(dispatch_block_flags, unsigned long,
-	DISPATCH_BLOCK_BARRIER
-			DISPATCH_ENUM_API_AVAILABLE(macos(10.10), ios(8.0)) = 0x1,
-	DISPATCH_BLOCK_DETACHED
-			DISPATCH_ENUM_API_AVAILABLE(macos(10.10), ios(8.0)) = 0x2,
-	DISPATCH_BLOCK_ASSIGN_CURRENT
-			DISPATCH_ENUM_API_AVAILABLE(macos(10.10), ios(8.0)) = 0x4,
-	DISPATCH_BLOCK_NO_QOS_CLASS
-			DISPATCH_ENUM_API_AVAILABLE(macos(10.10), ios(8.0)) = 0x8,
-	DISPATCH_BLOCK_INHERIT_QOS_CLASS
-			DISPATCH_ENUM_API_AVAILABLE(macos(10.10), ios(8.0)) = 0x10,
-	DISPATCH_BLOCK_ENFORCE_QOS_CLASS
-			DISPATCH_ENUM_API_AVAILABLE(macos(10.10), ios(8.0)) = 0x20,
-);
-
-/*!
- * @function dispatch_block_create
- *
- * @abstract
- * Create a new dispatch block object on the heap from an existing block and
- * the given flags.
- *
- * @discussion
- * The provided block is Block_copy'ed to the heap and retained by the newly
- * created dispatch block object.
- *
- * The returned dispatch block object is intended to be submitted to a dispatch
- * queue with dispatch_async() and related functions, but may also be invoked
- * directly. Both operations can be performed an arbitrary number of times but
- * only the first completed execution of a dispatch block object can be waited
- * on with dispatch_block_wait() or observed with dispatch_block_notify().
- *
- * If the returned dispatch block object is submitted to a dispatch queue, the
- * submitted block instance will be associated with the QOS class current at the
- * time of submission, unless one of the following flags assigned a specific QOS
- * class (or no QOS class) at the time of block creation:
- *  - DISPATCH_BLOCK_ASSIGN_CURRENT
- *  - DISPATCH_BLOCK_NO_QOS_CLASS
- *  - DISPATCH_BLOCK_DETACHED
- * The QOS class the block object will be executed with also depends on the QOS
- * class assigned to the queue and which of the following flags was specified or
- * defaulted to:
- *  - DISPATCH_BLOCK_INHERIT_QOS_CLASS (default for asynchronous execution)
- *  - DISPATCH_BLOCK_ENFORCE_QOS_CLASS (default for synchronous execution)
- * See description of dispatch_block_flags_t for details.
- *
- * If the returned dispatch block object is submitted directly to a serial queue
- * and is configured to execute with a specific QOS class, the system will make
- * a best effort to apply the necessary QOS overrides to ensure that blocks
- * submitted earlier to the serial queue are executed at that same QOS class or
- * higher.
- *
- * @param flags
- * Configuration flags for the block object.
- * Passing a value that is not a bitwise OR of flags from dispatch_block_flags_t
- * results in NULL being returned.
- *
- * @param block
- * The block to create the dispatch block object from.
- *
- * @result
- * The newly created dispatch block object, or NULL.
- * When not building with Objective-C ARC, must be released with a -[release]
- * message or the Block_release() function.
- */
-API_AVAILABLE(macos(10.10), ios(8.0))
-DISPATCH_EXPORT DISPATCH_NONNULL2 DISPATCH_RETURNS_RETAINED_BLOCK
-DISPATCH_WARN_RESULT DISPATCH_NOTHROW
-dispatch_block_t
-dispatch_block_create(dispatch_block_flags_t flags, dispatch_block_t block);
-
-/*!
- * @function dispatch_block_create_with_qos_class
- *
- * @abstract
- * Create a new dispatch block object on the heap from an existing block and
- * the given flags, and assign it the specified QOS class and relative priority.
- *
- * @discussion
- * The provided block is Block_copy'ed to the heap and retained by the newly
- * created dispatch block object.
- *
- * The returned dispatch block object is intended to be submitted to a dispatch
- * queue with dispatch_async() and related functions, but may also be invoked
- * directly. Both operations can be performed an arbitrary number of times but
- * only the first completed execution of a dispatch block object can be waited
- * on with dispatch_block_wait() or observed with dispatch_block_notify().
- *
- * If invoked directly, the returned dispatch block object will be executed with
- * the assigned QOS class as long as that does not result in a lower QOS class
- * than what is current on the calling thread.
- *
- * If the returned dispatch block object is submitted to a dispatch queue, the
- * QOS class it will be executed with depends on the QOS class assigned to the
- * block, the QOS class assigned to the queue and which of the following flags
- * was specified or defaulted to:
- *  - DISPATCH_BLOCK_INHERIT_QOS_CLASS: default for asynchronous execution
- *  - DISPATCH_BLOCK_ENFORCE_QOS_CLASS: default for synchronous execution
- * See description of dispatch_block_flags_t for details.
- *
- * If the returned dispatch block object is submitted directly to a serial queue
- * and is configured to execute with a specific QOS class, the system will make
- * a best effort to apply the necessary QOS overrides to ensure that blocks
- * submitted earlier to the serial queue are executed at that same QOS class or
- * higher.
- *
- * @param flags
- * Configuration flags for the new block object.
- * Passing a value that is not a bitwise OR of flags from dispatch_block_flags_t
- * results in NULL being returned.
- *
- * @param qos_class
- * A QOS class value:
- *  - QOS_CLASS_USER_INTERACTIVE
- *  - QOS_CLASS_USER_INITIATED
- *  - QOS_CLASS_DEFAULT
- *  - QOS_CLASS_UTILITY
- *  - QOS_CLASS_BACKGROUND
- *  - QOS_CLASS_UNSPECIFIED
- * Passing QOS_CLASS_UNSPECIFIED is equivalent to specifying the
- * DISPATCH_BLOCK_NO_QOS_CLASS flag. Passing any other value results in NULL
- * being returned.
- *
- * @param relative_priority
- * A relative priority within the QOS class. This value is a negative
- * offset from the maximum supported scheduler priority for the given class.
- * Passing a value greater than zero or less than QOS_MIN_RELATIVE_PRIORITY
- * results in NULL being returned.
- *
- * @param block
- * The block to create the dispatch block object from.
- *
- * @result
- * The newly created dispatch block object, or NULL.
- * When not building with Objective-C ARC, must be released with a -[release]
- * message or the Block_release() function.
- */
-API_AVAILABLE(macos(10.10), ios(8.0))
-DISPATCH_EXPORT DISPATCH_NONNULL4 DISPATCH_RETURNS_RETAINED_BLOCK
-DISPATCH_WARN_RESULT DISPATCH_NOTHROW
-dispatch_block_t
-dispatch_block_create_with_qos_class(dispatch_block_flags_t flags,
-		dispatch_qos_class_t qos_class, int relative_priority,
-		dispatch_block_t block);
-
-/*!
- * @function dispatch_block_perform
- *
- * @abstract
- * Create, synchronously execute and release a dispatch block object from the
- * specified block and flags.
- *
- * @discussion
- * Behaves identically to the sequence
- * <code>
- * dispatch_block_t b = dispatch_block_create(flags, block);
- * b();
- * Block_release(b);
- * </code>
- * but may be implemented more efficiently internally by not requiring a copy
- * to the heap of the specified block or the allocation of a new block object.
- *
- * @param flags
- * Configuration flags for the temporary block object.
- * The result of passing a value that is not a bitwise OR of flags from
- * dispatch_block_flags_t is undefined.
- *
- * @param block
- * The block to create the temporary block object from.
- */
-API_AVAILABLE(macos(10.10), ios(8.0))
-DISPATCH_EXPORT DISPATCH_NONNULL2 DISPATCH_NOTHROW
-void
-dispatch_block_perform(dispatch_block_flags_t flags,
-		DISPATCH_NOESCAPE dispatch_block_t block);
-
-/*!
- * @function dispatch_block_wait
- *
- * @abstract
- * Wait synchronously until execution of the specified dispatch block object has
- * completed or until the specified timeout has elapsed.
- *
- * @discussion
- * This function will return immediately if execution of the block object has
- * already completed.
- *
- * It is not possible to wait for multiple executions of the same block object
- * with this interface; use dispatch_group_wait() for that purpose. A single
- * dispatch block object may either be waited on once and executed once,
- * or it may be executed any number of times. The behavior of any other
- * combination is undefined. Submission to a dispatch queue counts as an
- * execution, even if cancellation (dispatch_block_cancel) means the block's
- * code never runs.
- *
- * The result of calling this function from multiple threads simultaneously
- * with the same dispatch block object is undefined, but note that doing so
- * would violate the rules described in the previous paragraph.
- *
- * If this function returns indicating that the specified timeout has elapsed,
- * then that invocation does not count as the one allowed wait.
- *
- * If at the time this function is called, the specified dispatch block object
- * has been submitted directly to a serial queue, the system will make a best
- * effort to apply the necessary QOS overrides to ensure that the block and any
- * blocks submitted earlier to that serial queue are executed at the QOS class
- * (or higher) of the thread calling dispatch_block_wait().
- *
- * @param block
- * The dispatch block object to wait on.
- * The result of passing NULL or a block object not returned by one of the
- * dispatch_block_create* functions is undefined.
- *
- * @param timeout
- * When to timeout (see dispatch_time). As a convenience, there are the
- * DISPATCH_TIME_NOW and DISPATCH_TIME_FOREVER constants.
- *
- * @result
- * Returns zero on success (the dispatch block object completed within the
- * specified timeout) or non-zero on error (i.e. timed out).
- */
-API_AVAILABLE(macos(10.10), ios(8.0))
-DISPATCH_EXPORT DISPATCH_NONNULL1 DISPATCH_NOTHROW
-long
-dispatch_block_wait(dispatch_block_t block, dispatch_time_t timeout);
-
-/*!
- * @function dispatch_block_notify
- *
- * @abstract
- * Schedule a notification block to be submitted to a queue when the execution
- * of a specified dispatch block object has completed.
- *
- * @discussion
- * This function will submit the notification block immediately if execution of
- * the observed block object has already completed.
- *
- * It is not possible to be notified of multiple executions of the same block
- * object with this interface, use dispatch_group_notify() for that purpose.
- *
- * A single dispatch block object may either be observed one or more times
- * and executed once, or it may be executed any number of times. The behavior
- * of any other combination is undefined. Submission to a dispatch queue
- * counts as an execution, even if cancellation (dispatch_block_cancel) means
- * the block's code never runs.
- *
- * If multiple notification blocks are scheduled for a single block object,
- * there is no defined order in which the notification blocks will be submitted
- * to their associated queues.
- *
- * @param block
- * The dispatch block object to observe.
- * The result of passing NULL or a block object not returned by one of the
- * dispatch_block_create* functions is undefined.
- *
- * @param queue
- * The queue to which the supplied notification block will be submitted when
- * the observed block completes.
- *
- * @param notification_block
- * The notification block to submit when the observed block object completes.
- */
-API_AVAILABLE(macos(10.10), ios(8.0))
-DISPATCH_EXPORT DISPATCH_NONNULL_ALL DISPATCH_NOTHROW
-void
-dispatch_block_notify(dispatch_block_t block, dispatch_queue_t queue,
-		dispatch_block_t notification_block);
-
-/*!
- * @function dispatch_block_cancel
- *
- * @abstract
- * Asynchronously cancel the specified dispatch block object.
- *
- * @discussion
- * Cancellation causes any future execution of the dispatch block object to
- * return immediately, but does not affect any execution of the block object
- * that is already in progress.
- *
- * Release of any resources associated with the block object will be delayed
- * until execution of the block object is next attempted (or any execution
- * already in progress completes).
- *
- * NOTE: care needs to be taken to ensure that a block object that may be
- *       canceled does not capture any resources that require execution of the
- *       block body in order to be released (e.g. memory allocated with
- *       malloc(3) that the block body calls free(3) on). Such resources will
- *       be leaked if the block body is never executed due to cancellation.
- *
- * @param block
- * The dispatch block object to cancel.
- * The result of passing NULL or a block object not returned by one of the
- * dispatch_block_create* functions is undefined.
- */
-API_AVAILABLE(macos(10.10), ios(8.0))
-DISPATCH_EXPORT DISPATCH_NONNULL_ALL DISPATCH_NOTHROW
-void
-dispatch_block_cancel(dispatch_block_t block);
-
-/*!
- * @function dispatch_block_testcancel
- *
- * @abstract
- * Tests whether the given dispatch block object has been canceled.
- *
- * @param block
- * The dispatch block object to test.
- * The result of passing NULL or a block object not returned by one of the
- * dispatch_block_create* functions is undefined.
- *
- * @result
- * Non-zero if canceled and zero if not canceled.
- */
-API_AVAILABLE(macos(10.10), ios(8.0))
-DISPATCH_EXPORT DISPATCH_NONNULL_ALL DISPATCH_WARN_RESULT DISPATCH_PURE
-DISPATCH_NOTHROW
-long
-dispatch_block_testcancel(dispatch_block_t block);
-
-__END_DECLS
-
-DISPATCH_ASSUME_NONNULL_END
-
-#endif // __BLOCKS__
-
-#endif // __DISPATCH_BLOCK__
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/dispatch/dispatch.h b/lib/libc/include/x86_64-macos-gnu/dispatch/dispatch.h
deleted file mode 100644
index 7d5356aab6..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/dispatch/dispatch.h
+++ /dev/null
@@ -1,75 +0,0 @@
-/*
- * Copyright (c) 2008-2013 Apple Inc. All rights reserved.
- *
- * @APPLE_APACHE_LICENSE_HEADER_START@
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @APPLE_APACHE_LICENSE_HEADER_END@
- */
-
-#ifndef __DISPATCH_PUBLIC__
-#define __DISPATCH_PUBLIC__
-
-#ifdef __APPLE__
-#include <Availability.h>
-#include <os/availability.h>
-#include <TargetConditionals.h>
-#include <os/base.h>
-#elif defined(_WIN32)
-#include <os/generic_win_base.h>
-#elif defined(__unix__)
-#include <os/generic_unix_base.h>
-#endif
-
-#include <sys/types.h>
-#include <stddef.h>
-#include <stdint.h>
-#include <stdbool.h>
-#include <stdarg.h>
-#if defined(__unix__) || (defined(__APPLE__) && defined(__MACH__))
-#include <unistd.h>
-#endif
-#include <fcntl.h>
-
-#if (defined(__linux__) || defined(__FreeBSD__)) && defined(__has_feature)
-#if __has_feature(modules)
-#if !defined(__arm__)
-#include <stdio.h> // for off_t (to match Glibc.modulemap)
-#endif
-#endif
-#endif
-
-#define DISPATCH_API_VERSION 20181008
-
-#ifndef __DISPATCH_INDIRECT__
-#define __DISPATCH_INDIRECT__
-#endif
-
-#include <os/object.h>
-#include <dispatch/base.h>
-#include <dispatch/time.h>
-#include <dispatch/object.h>
-#include <dispatch/queue.h>
-#include <dispatch/block.h>
-#include <dispatch/source.h>
-#include <dispatch/group.h>
-#include <dispatch/semaphore.h>
-#include <dispatch/once.h>
-#include <dispatch/data.h>
-#include <dispatch/io.h>
-#include <dispatch/workloop.h>
-
-#undef __DISPATCH_INDIRECT__
-
-#endif
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/dispatch/group.h b/lib/libc/include/x86_64-macos-gnu/dispatch/group.h
deleted file mode 100644
index bb9bad30e3..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/dispatch/group.h
+++ /dev/null
@@ -1,279 +0,0 @@
-/*
- * Copyright (c) 2008-2013 Apple Inc. All rights reserved.
- *
- * @APPLE_APACHE_LICENSE_HEADER_START@
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @APPLE_APACHE_LICENSE_HEADER_END@
- */
-
-#ifndef __DISPATCH_GROUP__
-#define __DISPATCH_GROUP__
-
-#ifndef __DISPATCH_INDIRECT__
-#error "Please #include <dispatch/dispatch.h> instead of this file directly."
-#include <dispatch/base.h> // for HeaderDoc
-#endif
-
-DISPATCH_ASSUME_NONNULL_BEGIN
-
-/*!
- * @typedef dispatch_group_t
- * @abstract
- * A group of blocks submitted to queues for asynchronous invocation.
- */
-DISPATCH_DECL(dispatch_group);
-
-__BEGIN_DECLS
-
-/*!
- * @function dispatch_group_create
- *
- * @abstract
- * Creates new group with which blocks may be associated.
- *
- * @discussion
- * This function creates a new group with which blocks may be associated.
- * The dispatch group may be used to wait for the completion of the blocks it
- * references. The group object memory is freed with dispatch_release().
- *
- * @result
- * The newly created group, or NULL on failure.
- */
-API_AVAILABLE(macos(10.6), ios(4.0))
-DISPATCH_EXPORT DISPATCH_MALLOC DISPATCH_RETURNS_RETAINED DISPATCH_WARN_RESULT
-DISPATCH_NOTHROW
-dispatch_group_t
-dispatch_group_create(void);
-
-/*!
- * @function dispatch_group_async
- *
- * @abstract
- * Submits a block to a dispatch queue and associates the block with the given
- * dispatch group.
- *
- * @discussion
- * Submits a block to a dispatch queue and associates the block with the given
- * dispatch group. The dispatch group may be used to wait for the completion
- * of the blocks it references.
- *
- * @param group
- * A dispatch group to associate with the submitted block.
- * The result of passing NULL in this parameter is undefined.
- *
- * @param queue
- * The dispatch queue to which the block will be submitted for asynchronous
- * invocation.
- *
- * @param block
- * The block to perform asynchronously.
- */
-#ifdef __BLOCKS__
-API_AVAILABLE(macos(10.6), ios(4.0))
-DISPATCH_EXPORT DISPATCH_NONNULL_ALL DISPATCH_NOTHROW
-void
-dispatch_group_async(dispatch_group_t group,
-	dispatch_queue_t queue,
-	dispatch_block_t block);
-#endif /* __BLOCKS__ */
-
-/*!
- * @function dispatch_group_async_f
- *
- * @abstract
- * Submits a function to a dispatch queue and associates the block with the
- * given dispatch group.
- *
- * @discussion
- * See dispatch_group_async() for details.
- *
- * @param group
- * A dispatch group to associate with the submitted function.
- * The result of passing NULL in this parameter is undefined.
- *
- * @param queue
- * The dispatch queue to which the function will be submitted for asynchronous
- * invocation.
- *
- * @param context
- * The application-defined context parameter to pass to the function.
- *
- * @param work
- * The application-defined function to invoke on the target queue. The first
- * parameter passed to this function is the context provided to
- * dispatch_group_async_f().
- */
-API_AVAILABLE(macos(10.6), ios(4.0))
-DISPATCH_EXPORT DISPATCH_NONNULL1 DISPATCH_NONNULL2 DISPATCH_NONNULL4
-DISPATCH_NOTHROW
-void
-dispatch_group_async_f(dispatch_group_t group,
-	dispatch_queue_t queue,
-	void *_Nullable context,
-	dispatch_function_t work);
-
-/*!
- * @function dispatch_group_wait
- *
- * @abstract
- * Wait synchronously until all the blocks associated with a group have
- * completed or until the specified timeout has elapsed.
- *
- * @discussion
- * This function waits for the completion of the blocks associated with the
- * given dispatch group, and returns after all blocks have completed or when
- * the specified timeout has elapsed.
- *
- * This function will return immediately if there are no blocks associated
- * with the dispatch group (i.e. the group is empty).
- *
- * The result of calling this function from multiple threads simultaneously
- * with the same dispatch group is undefined.
- *
- * After the successful return of this function, the dispatch group is empty.
- * It may either be released with dispatch_release() or re-used for additional
- * blocks. See dispatch_group_async() for more information.
- *
- * @param group
- * The dispatch group to wait on.
- * The result of passing NULL in this parameter is undefined.
- *
- * @param timeout
- * When to timeout (see dispatch_time). As a convenience, there are the
- * DISPATCH_TIME_NOW and DISPATCH_TIME_FOREVER constants.
- *
- * @result
- * Returns zero on success (all blocks associated with the group completed
- * within the specified timeout) or non-zero on error (i.e. timed out).
- */
-API_AVAILABLE(macos(10.6), ios(4.0))
-DISPATCH_EXPORT DISPATCH_NONNULL_ALL DISPATCH_NOTHROW
-long
-dispatch_group_wait(dispatch_group_t group, dispatch_time_t timeout);
-
-/*!
- * @function dispatch_group_notify
- *
- * @abstract
- * Schedule a block to be submitted to a queue when all the blocks associated
- * with a group have completed.
- *
- * @discussion
- * This function schedules a notification block to be submitted to the specified
- * queue once all blocks associated with the dispatch group have completed.
- *
- * If no blocks are associated with the dispatch group (i.e. the group is empty)
- * then the notification block will be submitted immediately.
- *
- * The group will be empty at the time the notification block is submitted to
- * the target queue. The group may either be released with dispatch_release()
- * or reused for additional operations.
- * See dispatch_group_async() for more information.
- *
- * @param group
- * The dispatch group to observe.
- * The result of passing NULL in this parameter is undefined.
- *
- * @param queue
- * The queue to which the supplied block will be submitted when the group
- * completes.
- *
- * @param block
- * The block to submit when the group completes.
- */
-#ifdef __BLOCKS__
-API_AVAILABLE(macos(10.6), ios(4.0))
-DISPATCH_EXPORT DISPATCH_NONNULL_ALL DISPATCH_NOTHROW
-void
-dispatch_group_notify(dispatch_group_t group,
-	dispatch_queue_t queue,
-	dispatch_block_t block);
-#endif /* __BLOCKS__ */
-
-/*!
- * @function dispatch_group_notify_f
- *
- * @abstract
- * Schedule a function to be submitted to a queue when all the blocks
- * associated with a group have completed.
- *
- * @discussion
- * See dispatch_group_notify() for details.
- *
- * @param group
- * The dispatch group to observe.
- * The result of passing NULL in this parameter is undefined.
- *
- * @param context
- * The application-defined context parameter to pass to the function.
- *
- * @param work
- * The application-defined function to invoke on the target queue. The first
- * parameter passed to this function is the context provided to
- * dispatch_group_notify_f().
- */
-API_AVAILABLE(macos(10.6), ios(4.0))
-DISPATCH_EXPORT DISPATCH_NONNULL1 DISPATCH_NONNULL2 DISPATCH_NONNULL4
-DISPATCH_NOTHROW
-void
-dispatch_group_notify_f(dispatch_group_t group,
-	dispatch_queue_t queue,
-	void *_Nullable context,
-	dispatch_function_t work);
-
-/*!
- * @function dispatch_group_enter
- *
- * @abstract
- * Manually indicate a block has entered the group
- *
- * @discussion
- * Calling this function indicates another block has joined the group through
- * a means other than dispatch_group_async(). Calls to this function must be
- * balanced with dispatch_group_leave().
- *
- * @param group
- * The dispatch group to update.
- * The result of passing NULL in this parameter is undefined.
- */
-API_AVAILABLE(macos(10.6), ios(4.0))
-DISPATCH_EXPORT DISPATCH_NONNULL_ALL DISPATCH_NOTHROW
-void
-dispatch_group_enter(dispatch_group_t group);
-
-/*!
- * @function dispatch_group_leave
- *
- * @abstract
- * Manually indicate a block in the group has completed
- *
- * @discussion
- * Calling this function indicates block has completed and left the dispatch
- * group by a means other than dispatch_group_async().
- *
- * @param group
- * The dispatch group to update.
- * The result of passing NULL in this parameter is undefined.
- */
-API_AVAILABLE(macos(10.6), ios(4.0))
-DISPATCH_EXPORT DISPATCH_NONNULL_ALL DISPATCH_NOTHROW
-void
-dispatch_group_leave(dispatch_group_t group);
-
-__END_DECLS
-
-DISPATCH_ASSUME_NONNULL_END
-
-#endif
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/dispatch/object.h b/lib/libc/include/x86_64-macos-gnu/dispatch/object.h
deleted file mode 100644
index 3d89eb1fe6..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/dispatch/object.h
+++ /dev/null
@@ -1,606 +0,0 @@
-/*
- * Copyright (c) 2008-2012 Apple Inc. All rights reserved.
- *
- * @APPLE_APACHE_LICENSE_HEADER_START@
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @APPLE_APACHE_LICENSE_HEADER_END@
- */
-
-#ifndef __DISPATCH_OBJECT__
-#define __DISPATCH_OBJECT__
-
-#ifndef __DISPATCH_INDIRECT__
-#error "Please #include <dispatch/dispatch.h> instead of this file directly."
-#include <dispatch/base.h> // for HeaderDoc
-#endif
-
-#if __has_include(<sys/qos.h>)
-#include <sys/qos.h>
-#endif
-
-DISPATCH_ASSUME_NONNULL_BEGIN
-
-/*!
- * @typedef dispatch_object_t
- *
- * @abstract
- * Abstract base type for all dispatch objects.
- * The details of the type definition are language-specific.
- *
- * @discussion
- * Dispatch objects are reference counted via calls to dispatch_retain() and
- * dispatch_release().
- */
-
-#if OS_OBJECT_USE_OBJC
-/*
- * By default, dispatch objects are declared as Objective-C types when building
- * with an Objective-C compiler. This allows them to participate in ARC, in RR
- * management by the Blocks runtime and in leaks checking by the static
- * analyzer, and enables them to be added to Cocoa collections.
- * See <os/object.h> for details.
- */
-OS_OBJECT_DECL_CLASS(dispatch_object);
-
-#if OS_OBJECT_SWIFT3
-#define DISPATCH_DECL(name) OS_OBJECT_DECL_SUBCLASS_SWIFT(name, dispatch_object)
-#define DISPATCH_DECL_SUBCLASS(name, base) OS_OBJECT_DECL_SUBCLASS_SWIFT(name, base)
-#else // OS_OBJECT_SWIFT3
-#define DISPATCH_DECL(name) OS_OBJECT_DECL_SUBCLASS(name, dispatch_object)
-#define DISPATCH_DECL_SUBCLASS(name, base) OS_OBJECT_DECL_SUBCLASS(name, base)
-
-DISPATCH_INLINE DISPATCH_ALWAYS_INLINE DISPATCH_NONNULL_ALL DISPATCH_NOTHROW
-void
-_dispatch_object_validate(dispatch_object_t object)
-{
-	void *isa = *(void *volatile*)(OS_OBJECT_BRIDGE void*)object;
-	(void)isa;
-}
-#endif // OS_OBJECT_SWIFT3
-
-#define DISPATCH_GLOBAL_OBJECT(type, object) ((OS_OBJECT_BRIDGE type)&(object))
-#define DISPATCH_RETURNS_RETAINED OS_OBJECT_RETURNS_RETAINED
-#elif defined(__cplusplus) && !defined(__DISPATCH_BUILDING_DISPATCH__)
-/*
- * Dispatch objects are NOT C++ objects. Nevertheless, we can at least keep C++
- * aware of type compatibility.
- */
-typedef struct dispatch_object_s {
-private:
-	dispatch_object_s();
-	~dispatch_object_s();
-	dispatch_object_s(const dispatch_object_s &);
-	void operator=(const dispatch_object_s &);
-} *dispatch_object_t;
-#define DISPATCH_DECL(name) \
-		typedef struct name##_s : public dispatch_object_s {} *name##_t
-#define DISPATCH_DECL_SUBCLASS(name, base) \
-		typedef struct name##_s : public base##_s {} *name##_t
-#define DISPATCH_GLOBAL_OBJECT(type, object) (static_cast<type>(&(object)))
-#define DISPATCH_RETURNS_RETAINED
-#else /* Plain C */
-typedef union {
-	struct _os_object_s *_os_obj;
-	struct dispatch_object_s *_do;
-	struct dispatch_queue_s *_dq;
-	struct dispatch_queue_attr_s *_dqa;
-	struct dispatch_group_s *_dg;
-	struct dispatch_source_s *_ds;
-	struct dispatch_channel_s *_dch;
-	struct dispatch_mach_s *_dm;
-	struct dispatch_mach_msg_s *_dmsg;
-	struct dispatch_semaphore_s *_dsema;
-	struct dispatch_data_s *_ddata;
-	struct dispatch_io_s *_dchannel;
-} dispatch_object_t DISPATCH_TRANSPARENT_UNION;
-#define DISPATCH_DECL(name) typedef struct name##_s *name##_t
-#define DISPATCH_DECL_SUBCLASS(name, base) typedef base##_t name##_t
-#define DISPATCH_GLOBAL_OBJECT(type, object) ((type)&(object))
-#define DISPATCH_RETURNS_RETAINED
-#endif
-
-#if OS_OBJECT_SWIFT3 && OS_OBJECT_USE_OBJC
-#define DISPATCH_SOURCE_TYPE_DECL(name) \
-		DISPATCH_EXPORT struct dispatch_source_type_s \
-				_dispatch_source_type_##name; \
-		OS_OBJECT_DECL_PROTOCOL(dispatch_source_##name, <OS_dispatch_source>); \
-		OS_OBJECT_CLASS_IMPLEMENTS_PROTOCOL( \
-				dispatch_source, dispatch_source_##name)
-#define DISPATCH_SOURCE_DECL(name) \
-		DISPATCH_DECL(name); \
-		OS_OBJECT_DECL_PROTOCOL(name, <NSObject>); \
-		OS_OBJECT_CLASS_IMPLEMENTS_PROTOCOL(name, name)
-#ifndef DISPATCH_DATA_DECL
-#define DISPATCH_DATA_DECL(name) OS_OBJECT_DECL_SWIFT(name)
-#endif // DISPATCH_DATA_DECL
-#else
-#define DISPATCH_SOURCE_DECL(name) \
-		DISPATCH_DECL(name);
-#define DISPATCH_DATA_DECL(name) DISPATCH_DECL(name)
-#define DISPATCH_SOURCE_TYPE_DECL(name) \
-		DISPATCH_EXPORT const struct dispatch_source_type_s \
-		_dispatch_source_type_##name
-#endif
-
-#ifdef __BLOCKS__
-/*!
- * @typedef dispatch_block_t
- *
- * @abstract
- * The type of blocks submitted to dispatch queues, which take no arguments
- * and have no return value.
- *
- * @discussion
- * When not building with Objective-C ARC, a block object allocated on or
- * copied to the heap must be released with a -[release] message or the
- * Block_release() function.
- *
- * The declaration of a block literal allocates storage on the stack.
- * Therefore, this is an invalid construct:
- * <code>
- * dispatch_block_t block;
- * if (x) {
- *     block = ^{ printf("true\n"); };
- * } else {
- *     block = ^{ printf("false\n"); };
- * }
- * block(); // unsafe!!!
- * </code>
- *
- * What is happening behind the scenes:
- * <code>
- * if (x) {
- *     struct Block __tmp_1 = ...; // setup details
- *     block = &__tmp_1;
- * } else {
- *     struct Block __tmp_2 = ...; // setup details
- *     block = &__tmp_2;
- * }
- * </code>
- *
- * As the example demonstrates, the address of a stack variable is escaping the
- * scope in which it is allocated. That is a classic C bug.
- *
- * Instead, the block literal must be copied to the heap with the Block_copy()
- * function or by sending it a -[copy] message.
- */
-typedef void (^dispatch_block_t)(void);
-#endif // __BLOCKS__
-
-__BEGIN_DECLS
-
-/*!
- * @typedef dispatch_qos_class_t
- * Alias for qos_class_t type.
- */
-#if __has_include(<sys/qos.h>)
-typedef qos_class_t dispatch_qos_class_t;
-#else
-typedef unsigned int dispatch_qos_class_t;
-#endif
-
-/*!
- * @function dispatch_retain
- *
- * @abstract
- * Increment the reference count of a dispatch object.
- *
- * @discussion
- * Calls to dispatch_retain() must be balanced with calls to
- * dispatch_release().
- *
- * @param object
- * The object to retain.
- * The result of passing NULL in this parameter is undefined.
- */
-API_AVAILABLE(macos(10.6), ios(4.0))
-DISPATCH_EXPORT DISPATCH_NONNULL_ALL DISPATCH_NOTHROW
-DISPATCH_SWIFT_UNAVAILABLE("Can't be used with ARC")
-void
-dispatch_retain(dispatch_object_t object);
-#if OS_OBJECT_USE_OBJC_RETAIN_RELEASE
-#undef dispatch_retain
-#define dispatch_retain(object) \
-		__extension__({ dispatch_object_t _o = (object); \
-		_dispatch_object_validate(_o); (void)[_o retain]; })
-#endif
-
-/*!
- * @function dispatch_release
- *
- * @abstract
- * Decrement the reference count of a dispatch object.
- *
- * @discussion
- * A dispatch object is asynchronously deallocated once all references are
- * released (i.e. the reference count becomes zero). The system does not
- * guarantee that a given client is the last or only reference to a given
- * object.
- *
- * @param object
- * The object to release.
- * The result of passing NULL in this parameter is undefined.
- */
-API_AVAILABLE(macos(10.6), ios(4.0))
-DISPATCH_EXPORT DISPATCH_NONNULL_ALL DISPATCH_NOTHROW
-DISPATCH_SWIFT_UNAVAILABLE("Can't be used with ARC")
-void
-dispatch_release(dispatch_object_t object);
-#if OS_OBJECT_USE_OBJC_RETAIN_RELEASE
-#undef dispatch_release
-#define dispatch_release(object) \
-		__extension__({ dispatch_object_t _o = (object); \
-		_dispatch_object_validate(_o); [_o release]; })
-#endif
-
-/*!
- * @function dispatch_get_context
- *
- * @abstract
- * Returns the application defined context of the object.
- *
- * @param object
- * The result of passing NULL in this parameter is undefined.
- *
- * @result
- * The context of the object; may be NULL.
- */
-API_AVAILABLE(macos(10.6), ios(4.0))
-DISPATCH_EXPORT DISPATCH_NONNULL_ALL DISPATCH_PURE DISPATCH_WARN_RESULT
-DISPATCH_NOTHROW
-void *_Nullable
-dispatch_get_context(dispatch_object_t object);
-
-/*!
- * @function dispatch_set_context
- *
- * @abstract
- * Associates an application defined context with the object.
- *
- * @param object
- * The result of passing NULL in this parameter is undefined.
- *
- * @param context
- * The new client defined context for the object. This may be NULL.
- *
- */
-API_AVAILABLE(macos(10.6), ios(4.0))
-DISPATCH_EXPORT DISPATCH_NOTHROW
-void
-dispatch_set_context(dispatch_object_t object, void *_Nullable context);
-
-/*!
- * @function dispatch_set_finalizer_f
- *
- * @abstract
- * Set the finalizer function for a dispatch object.
- *
- * @param object
- * The dispatch object to modify.
- * The result of passing NULL in this parameter is undefined.
- *
- * @param finalizer
- * The finalizer function pointer.
- *
- * @discussion
- * A dispatch object's finalizer will be invoked on the object's target queue
- * after all references to the object have been released. This finalizer may be
- * used by the application to release any resources associated with the object,
- * such as freeing the object's context.
- * The context parameter passed to the finalizer function is the current
- * context of the dispatch object at the time the finalizer call is made.
- */
-API_AVAILABLE(macos(10.6), ios(4.0))
-DISPATCH_EXPORT DISPATCH_NOTHROW
-void
-dispatch_set_finalizer_f(dispatch_object_t object,
-		dispatch_function_t _Nullable finalizer);
-
-/*!
- * @function dispatch_activate
- *
- * @abstract
- * Activates the specified dispatch object.
- *
- * @discussion
- * Dispatch objects such as queues and sources may be created in an inactive
- * state. Objects in this state have to be activated before any blocks
- * associated with them will be invoked.
- *
- * The target queue of inactive objects can be changed using
- * dispatch_set_target_queue(). Change of target queue is no longer permitted
- * once an initially inactive object has been activated.
- *
- * Calling dispatch_activate() on an active object has no effect.
- * Releasing the last reference count on an inactive object is undefined.
- *
- * @param object
- * The object to be activated.
- * The result of passing NULL in this parameter is undefined.
- */
-API_AVAILABLE(macos(10.12), ios(10.0), tvos(10.0), watchos(3.0))
-DISPATCH_EXPORT DISPATCH_NONNULL_ALL DISPATCH_NOTHROW
-void
-dispatch_activate(dispatch_object_t object);
-
-/*!
- * @function dispatch_suspend
- *
- * @abstract
- * Suspends the invocation of blocks on a dispatch object.
- *
- * @discussion
- * A suspended object will not invoke any blocks associated with it. The
- * suspension of an object will occur after any running block associated with
- * the object completes.
- *
- * Calls to dispatch_suspend() must be balanced with calls
- * to dispatch_resume().
- *
- * @param object
- * The object to be suspended.
- * The result of passing NULL in this parameter is undefined.
- */
-API_AVAILABLE(macos(10.6), ios(4.0))
-DISPATCH_EXPORT DISPATCH_NONNULL_ALL DISPATCH_NOTHROW
-void
-dispatch_suspend(dispatch_object_t object);
-
-/*!
- * @function dispatch_resume
- *
- * @abstract
- * Resumes the invocation of blocks on a dispatch object.
- *
- * @discussion
- * Dispatch objects can be suspended with dispatch_suspend(), which increments
- * an internal suspension count. dispatch_resume() is the inverse operation,
- * and consumes suspension counts. When the last suspension count is consumed,
- * blocks associated with the object will be invoked again.
- *
- * For backward compatibility reasons, dispatch_resume() on an inactive and not
- * otherwise suspended dispatch source object has the same effect as calling
- * dispatch_activate(). For new code, using dispatch_activate() is preferred.
- *
- * If the specified object has zero suspension count and is not an inactive
- * source, this function will result in an assertion and the process being
- * terminated.
- *
- * @param object
- * The object to be resumed.
- * The result of passing NULL in this parameter is undefined.
- */
-API_AVAILABLE(macos(10.6), ios(4.0))
-DISPATCH_EXPORT DISPATCH_NONNULL_ALL DISPATCH_NOTHROW
-void
-dispatch_resume(dispatch_object_t object);
-
-/*!
- * @function dispatch_set_qos_class_floor
- *
- * @abstract
- * Sets the QOS class floor on a dispatch queue, source or workloop.
- *
- * @discussion
- * The QOS class of workitems submitted to this object asynchronously will be
- * elevated to at least the specified QOS class floor. The QOS of the workitem
- * will be used if higher than the floor even when the workitem has been created
- * without "ENFORCE" semantics.
- *
- * Setting the QOS class floor is equivalent to the QOS effects of configuring
- * a queue whose target queue has a QoS class set to the same value.
- *
- * @param object
- * A dispatch queue, workloop, or source to configure.
- * The object must be inactive.
- *
- * Passing another object type or an object that has been activated is undefined
- * and will cause the process to be terminated.
- *
- * @param qos_class
- * A QOS class value:
- *  - QOS_CLASS_USER_INTERACTIVE
- *  - QOS_CLASS_USER_INITIATED
- *  - QOS_CLASS_DEFAULT
- *  - QOS_CLASS_UTILITY
- *  - QOS_CLASS_BACKGROUND
- * Passing any other value is undefined.
- *
- * @param relative_priority
- * A relative priority within the QOS class. This value is a negative
- * offset from the maximum supported scheduler priority for the given class.
- * Passing a value greater than zero or less than QOS_MIN_RELATIVE_PRIORITY
- * is undefined.
- */
-API_AVAILABLE(macos(10.14), ios(12.0), tvos(12.0), watchos(5.0))
-DISPATCH_EXPORT DISPATCH_NOTHROW
-void
-dispatch_set_qos_class_floor(dispatch_object_t object,
-		dispatch_qos_class_t qos_class, int relative_priority);
-
-#ifdef __BLOCKS__
-/*!
- * @function dispatch_wait
- *
- * @abstract
- * Wait synchronously for an object or until the specified timeout has elapsed.
- *
- * @discussion
- * Type-generic macro that maps to dispatch_block_wait, dispatch_group_wait or
- * dispatch_semaphore_wait, depending on the type of the first argument.
- * See documentation for these functions for more details.
- * This function is unavailable for any other object type.
- *
- * @param object
- * The object to wait on.
- * The result of passing NULL in this parameter is undefined.
- *
- * @param timeout
- * When to timeout (see dispatch_time). As a convenience, there are the
- * DISPATCH_TIME_NOW and DISPATCH_TIME_FOREVER constants.
- *
- * @result
- * Returns zero on success or non-zero on error (i.e. timed out).
- */
-DISPATCH_UNAVAILABLE
-DISPATCH_EXPORT DISPATCH_NONNULL1 DISPATCH_NOTHROW
-long
-dispatch_wait(void *object, dispatch_time_t timeout);
-#if __has_extension(c_generic_selections)
-#define dispatch_wait(object, timeout) \
-		_Generic((object), \
-			dispatch_block_t:dispatch_block_wait, \
-			dispatch_group_t:dispatch_group_wait, \
-			dispatch_semaphore_t:dispatch_semaphore_wait \
-		)((object),(timeout))
-#endif
-
-/*!
- * @function dispatch_notify
- *
- * @abstract
- * Schedule a notification block to be submitted to a queue when the execution
- * of a specified object has completed.
- *
- * @discussion
- * Type-generic macro that maps to dispatch_block_notify or
- * dispatch_group_notify, depending on the type of the first argument.
- * See documentation for these functions for more details.
- * This function is unavailable for any other object type.
- *
- * @param object
- * The object to observe.
- * The result of passing NULL in this parameter is undefined.
- *
- * @param queue
- * The queue to which the supplied notification block will be submitted when
- * the observed object completes.
- *
- * @param notification_block
- * The block to submit when the observed object completes.
- */
-DISPATCH_UNAVAILABLE
-DISPATCH_EXPORT DISPATCH_NONNULL_ALL DISPATCH_NOTHROW
-void
-dispatch_notify(void *object, dispatch_object_t queue,
-		dispatch_block_t notification_block);
-#if __has_extension(c_generic_selections)
-#define dispatch_notify(object, queue, notification_block) \
-		_Generic((object), \
-			dispatch_block_t:dispatch_block_notify, \
-			dispatch_group_t:dispatch_group_notify \
-		)((object),(queue), (notification_block))
-#endif
-
-/*!
- * @function dispatch_cancel
- *
- * @abstract
- * Cancel the specified object.
- *
- * @discussion
- * Type-generic macro that maps to dispatch_block_cancel or
- * dispatch_source_cancel, depending on the type of the first argument.
- * See documentation for these functions for more details.
- * This function is unavailable for any other object type.
- *
- * @param object
- * The object to cancel.
- * The result of passing NULL in this parameter is undefined.
- */
-DISPATCH_UNAVAILABLE
-DISPATCH_EXPORT DISPATCH_NONNULL_ALL DISPATCH_NOTHROW
-void
-dispatch_cancel(void *object);
-#if __has_extension(c_generic_selections)
-#define dispatch_cancel(object) \
-		_Generic((object), \
-			dispatch_block_t:dispatch_block_cancel, \
-			dispatch_source_t:dispatch_source_cancel \
-		)((object))
-#endif
-
-/*!
- * @function dispatch_testcancel
- *
- * @abstract
- * Test whether the specified object has been canceled
- *
- * @discussion
- * Type-generic macro that maps to dispatch_block_testcancel or
- * dispatch_source_testcancel, depending on the type of the first argument.
- * See documentation for these functions for more details.
- * This function is unavailable for any other object type.
- *
- * @param object
- * The object to test.
- * The result of passing NULL in this parameter is undefined.
- *
- * @result
- * Non-zero if canceled and zero if not canceled.
- */
-DISPATCH_UNAVAILABLE
-DISPATCH_EXPORT DISPATCH_NONNULL_ALL DISPATCH_WARN_RESULT DISPATCH_PURE
-DISPATCH_NOTHROW
-long
-dispatch_testcancel(void *object);
-#if __has_extension(c_generic_selections)
-#define dispatch_testcancel(object) \
-		_Generic((object), \
-			dispatch_block_t:dispatch_block_testcancel, \
-			dispatch_source_t:dispatch_source_testcancel \
-		)((object))
-#endif
-#endif // __BLOCKS__
-
-/*!
- * @function dispatch_debug
- *
- * @abstract
- * Programmatically log debug information about a dispatch object.
- *
- * @discussion
- * Programmatically log debug information about a dispatch object. By default,
- * the log output is sent to syslog at notice level. In the debug version of
- * the library, the log output is sent to a file in /var/tmp.
- * The log output destination can be configured via the LIBDISPATCH_LOG
- * environment variable, valid values are: YES, NO, syslog, stderr, file.
- *
- * This function is deprecated and will be removed in a future release.
- * Objective-C callers may use -debugDescription instead.
- *
- * @param object
- * The object to introspect.
- *
- * @param message
- * The message to log above and beyond the introspection.
- */
-API_DEPRECATED("unsupported interface", macos(10.6,10.9), ios(4.0,6.0))
-DISPATCH_EXPORT DISPATCH_NONNULL2 DISPATCH_NOTHROW DISPATCH_COLD
-__attribute__((__format__(printf,2,3)))
-void
-dispatch_debug(dispatch_object_t object, const char *message, ...);
-
-API_DEPRECATED("unsupported interface", macos(10.6,10.9), ios(4.0,6.0))
-DISPATCH_EXPORT DISPATCH_NONNULL2 DISPATCH_NOTHROW DISPATCH_COLD
-__attribute__((__format__(printf,2,0)))
-void
-dispatch_debugv(dispatch_object_t object, const char *message, va_list ap);
-
-__END_DECLS
-
-DISPATCH_ASSUME_NONNULL_END
-
-#endif
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/dispatch/queue.h b/lib/libc/include/x86_64-macos-gnu/dispatch/queue.h
deleted file mode 100644
index f644b0266d..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/dispatch/queue.h
+++ /dev/null
@@ -1,1674 +0,0 @@
-/*
- * Copyright (c) 2008-2014 Apple Inc. All rights reserved.
- *
- * @APPLE_APACHE_LICENSE_HEADER_START@
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @APPLE_APACHE_LICENSE_HEADER_END@
- */
-
-#ifndef __DISPATCH_QUEUE__
-#define __DISPATCH_QUEUE__
-
-#ifndef __DISPATCH_INDIRECT__
-#error "Please #include <dispatch/dispatch.h> instead of this file directly."
-#include <dispatch/base.h> // for HeaderDoc
-#endif
-
-DISPATCH_ASSUME_NONNULL_BEGIN
-
-/*!
- * @header
- *
- * Dispatch is an abstract model for expressing concurrency via simple but
- * powerful API.
- *
- * At the core, dispatch provides serial FIFO queues to which blocks may be
- * submitted. Blocks submitted to these dispatch queues are invoked on a pool
- * of threads fully managed by the system. No guarantee is made regarding
- * which thread a block will be invoked on; however, it is guaranteed that only
- * one block submitted to the FIFO dispatch queue will be invoked at a time.
- *
- * When multiple queues have blocks to be processed, the system is free to
- * allocate additional threads to invoke the blocks concurrently. When the
- * queues become empty, these threads are automatically released.
- */
-
-/*!
- * @typedef dispatch_queue_t
- *
- * @abstract
- * Dispatch queues invoke workitems submitted to them.
- *
- * @discussion
- * Dispatch queues come in many flavors, the most common one being the dispatch
- * serial queue (See dispatch_queue_serial_t).
- *
- * The system manages a pool of threads which process dispatch queues and invoke
- * workitems submitted to them.
- *
- * Conceptually a dispatch queue may have its own thread of execution, and
- * interaction between queues is highly asynchronous.
- *
- * Dispatch queues are reference counted via calls to dispatch_retain() and
- * dispatch_release(). Pending workitems submitted to a queue also hold a
- * reference to the queue until they have finished. Once all references to a
- * queue have been released, the queue will be deallocated by the system.
- */
-DISPATCH_DECL(dispatch_queue);
-
-/*!
- * @typedef dispatch_queue_global_t
- *
- * @abstract
- * Dispatch global concurrent queues are an abstraction around the system thread
- * pool which invokes workitems that are submitted to dispatch queues.
- *
- * @discussion
- * Dispatch global concurrent queues provide buckets of priorities on top of the
- * thread pool the system manages. The system will decide how many threads
- * to allocate to this pool depending on demand and system load. In particular,
- * the system tries to maintain a good level of concurrency for this resource,
- * and will create new threads when too many existing worker threads block in
- * system calls.
- *
- * The global concurrent queues are a shared resource and as such it is the
- * responsiblity of every user of this resource to not submit an unbounded
- * amount of work to this pool, especially work that may block, as this can
- * cause the system to spawn very large numbers of threads (aka. thread
- * explosion).
- *
- * Work items submitted to the global concurrent queues have no ordering
- * guarantee with respect to the order of submission, and workitems submitted
- * to these queues may be invoked concurrently.
- *
- * Dispatch global concurrent queues are well-known global objects that are
- * returned by dispatch_get_global_queue(). These objects cannot be modified.
- * Calls to dispatch_suspend(), dispatch_resume(), dispatch_set_context(), etc.,
- * will have no effect when used with queues of this type.
- */
-DISPATCH_DECL_SUBCLASS(dispatch_queue_global, dispatch_queue);
-
-/*!
- * @typedef dispatch_queue_serial_t
- *
- * @abstract
- * Dispatch serial queues invoke workitems submitted to them serially in FIFO
- * order.
- *
- * @discussion
- * Dispatch serial queues are lightweight objects to which workitems may be
- * submitted to be invoked in FIFO order. A serial queue will only invoke one
- * workitem at a time, but independent serial queues may each invoke their work
- * items concurrently with respect to each other.
- *
- * Serial queues can target each other (See dispatch_set_target_queue()). The
- * serial queue at the bottom of a queue hierarchy provides an exclusion
- * context: at most one workitem submitted to any of the queues in such
- * a hiearchy will run at any given time.
- *
- * Such hierarchies provide a natural construct to organize an application
- * subsystem around.
- *
- * Serial queues are created by passing a dispatch queue attribute derived from
- * DISPATCH_QUEUE_SERIAL to dispatch_queue_create_with_target().
- */
-DISPATCH_DECL_SUBCLASS(dispatch_queue_serial, dispatch_queue);
-
-/*!
- * @typedef dispatch_queue_main_t
- *
- * @abstract
- * The type of the default queue that is bound to the main thread.
- *
- * @discussion
- * The main queue is a serial queue (See dispatch_queue_serial_t) which is bound
- * to the main thread of an application.
- *
- * In order to invoke workitems submitted to the main queue, the application
- * must call dispatch_main(), NSApplicationMain(), or use a CFRunLoop on the
- * main thread.
- *
- * The main queue is a well known global object that is made automatically on
- * behalf of the main thread during process initialization and is returned by
- * dispatch_get_main_queue(). This object cannot be modified.  Calls to
- * dispatch_suspend(), dispatch_resume(), dispatch_set_context(), etc., will
- * have no effect when used on the main queue.
- */
-DISPATCH_DECL_SUBCLASS(dispatch_queue_main, dispatch_queue_serial);
-
-/*!
- * @typedef dispatch_queue_concurrent_t
- *
- * @abstract
- * Dispatch concurrent queues invoke workitems submitted to them concurrently,
- * and admit a notion of barrier workitems.
- *
- * @discussion
- * Dispatch concurrent queues are lightweight objects to which regular and
- * barrier workitems may be submited. Barrier workitems are invoked in
- * exclusion of any other kind of workitem in FIFO order.
- *
- * Regular workitems can be invoked concurrently for the same concurrent queue,
- * in any order. However, regular workitems will not be invoked before any
- * barrier workitem submited ahead of them has been invoked.
- *
- * In other words, if a serial queue is equivalent to a mutex in the Dispatch
- * world, a concurrent queue is equivalent to a reader-writer lock, where
- * regular items are readers and barriers are writers.
- *
- * Concurrent queues are created by passing a dispatch queue attribute derived
- * from DISPATCH_QUEUE_CONCURRENT to dispatch_queue_create_with_target().
- *
- * Caveat:
- * Dispatch concurrent queues at this time do not implement priority inversion
- * avoidance when lower priority regular workitems (readers) are being invoked
- * and are preventing a higher priority barrier (writer) from being invoked.
- */
-DISPATCH_DECL_SUBCLASS(dispatch_queue_concurrent, dispatch_queue);
-
-__BEGIN_DECLS
-
-/*!
- * @function dispatch_async
- *
- * @abstract
- * Submits a block for asynchronous execution on a dispatch queue.
- *
- * @discussion
- * The dispatch_async() function is the fundamental mechanism for submitting
- * blocks to a dispatch queue.
- *
- * Calls to dispatch_async() always return immediately after the block has
- * been submitted, and never wait for the block to be invoked.
- *
- * The target queue determines whether the block will be invoked serially or
- * concurrently with respect to other blocks submitted to that same queue.
- * Serial queues are processed concurrently with respect to each other.
- *
- * @param queue
- * The target dispatch queue to which the block is submitted.
- * The system will hold a reference on the target queue until the block
- * has finished.
- * The result of passing NULL in this parameter is undefined.
- *
- * @param block
- * The block to submit to the target dispatch queue. This function performs
- * Block_copy() and Block_release() on behalf of callers.
- * The result of passing NULL in this parameter is undefined.
- */
-#ifdef __BLOCKS__
-API_AVAILABLE(macos(10.6), ios(4.0))
-DISPATCH_EXPORT DISPATCH_NONNULL_ALL DISPATCH_NOTHROW
-void
-dispatch_async(dispatch_queue_t queue, dispatch_block_t block);
-#endif
-
-/*!
- * @function dispatch_async_f
- *
- * @abstract
- * Submits a function for asynchronous execution on a dispatch queue.
- *
- * @discussion
- * See dispatch_async() for details.
- *
- * @param queue
- * The target dispatch queue to which the function is submitted.
- * The system will hold a reference on the target queue until the function
- * has returned.
- * The result of passing NULL in this parameter is undefined.
- *
- * @param context
- * The application-defined context parameter to pass to the function.
- *
- * @param work
- * The application-defined function to invoke on the target queue. The first
- * parameter passed to this function is the context provided to
- * dispatch_async_f().
- * The result of passing NULL in this parameter is undefined.
- */
-API_AVAILABLE(macos(10.6), ios(4.0))
-DISPATCH_EXPORT DISPATCH_NONNULL1 DISPATCH_NONNULL3 DISPATCH_NOTHROW
-void
-dispatch_async_f(dispatch_queue_t queue,
-		void *_Nullable context, dispatch_function_t work);
-
-/*!
- * @function dispatch_sync
- *
- * @abstract
- * Submits a block for synchronous execution on a dispatch queue.
- *
- * @discussion
- * Submits a workitem to a dispatch queue like dispatch_async(), however
- * dispatch_sync() will not return until the workitem has finished.
- *
- * Work items submitted to a queue with dispatch_sync() do not observe certain
- * queue attributes of that queue when invoked (such as autorelease frequency
- * and QOS class).
- *
- * Calls to dispatch_sync() targeting the current queue will result
- * in dead-lock. Use of dispatch_sync() is also subject to the same
- * multi-party dead-lock problems that may result from the use of a mutex.
- * Use of dispatch_async() is preferred.
- *
- * Unlike dispatch_async(), no retain is performed on the target queue. Because
- * calls to this function are synchronous, the dispatch_sync() "borrows" the
- * reference of the caller.
- *
- * As an optimization, dispatch_sync() invokes the workitem on the thread which
- * submitted the workitem, except when the passed queue is the main queue or
- * a queue targetting it (See dispatch_queue_main_t,
- * dispatch_set_target_queue()).
- *
- * @param queue
- * The target dispatch queue to which the block is submitted.
- * The result of passing NULL in this parameter is undefined.
- *
- * @param block
- * The block to be invoked on the target dispatch queue.
- * The result of passing NULL in this parameter is undefined.
- */
-#ifdef __BLOCKS__
-API_AVAILABLE(macos(10.6), ios(4.0))
-DISPATCH_EXPORT DISPATCH_NONNULL_ALL DISPATCH_NOTHROW
-void
-dispatch_sync(dispatch_queue_t queue, DISPATCH_NOESCAPE dispatch_block_t block);
-#endif
-
-/*!
- * @function dispatch_sync_f
- *
- * @abstract
- * Submits a function for synchronous execution on a dispatch queue.
- *
- * @discussion
- * See dispatch_sync() for details.
- *
- * @param queue
- * The target dispatch queue to which the function is submitted.
- * The result of passing NULL in this parameter is undefined.
- *
- * @param context
- * The application-defined context parameter to pass to the function.
- *
- * @param work
- * The application-defined function to invoke on the target queue. The first
- * parameter passed to this function is the context provided to
- * dispatch_sync_f().
- * The result of passing NULL in this parameter is undefined.
- */
-API_AVAILABLE(macos(10.6), ios(4.0))
-DISPATCH_EXPORT DISPATCH_NONNULL1 DISPATCH_NONNULL3 DISPATCH_NOTHROW
-void
-dispatch_sync_f(dispatch_queue_t queue,
-		void *_Nullable context, dispatch_function_t work);
-
-/*!
- * @function dispatch_async_and_wait
- *
- * @abstract
- * Submits a block for synchronous execution on a dispatch queue.
- *
- * @discussion
- * Submits a workitem to a dispatch queue like dispatch_async(), however
- * dispatch_async_and_wait() will not return until the workitem has finished.
- *
- * Like functions of the dispatch_sync family, dispatch_async_and_wait() is
- * subject to dead-lock (See dispatch_sync() for details).
- *
- * However, dispatch_async_and_wait() differs from functions of the
- * dispatch_sync family in two fundamental ways: how it respects queue
- * attributes and how it chooses the execution context invoking the workitem.
- *
- * <b>Differences with dispatch_sync()</b>
- *
- * Work items submitted to a queue with dispatch_async_and_wait() observe all
- * queue attributes of that queue when invoked (inluding autorelease frequency
- * or QOS class).
- *
- * When the runtime has brought up a thread to invoke the asynchronous workitems
- * already submitted to the specified queue, that servicing thread will also be
- * used to execute synchronous work submitted to the queue with
- * dispatch_async_and_wait().
- *
- * However, if the runtime has not brought up a thread to service the specified
- * queue (because it has no workitems enqueued, or only synchronous workitems),
- * then dispatch_async_and_wait() will invoke the workitem on the calling thread,
- * similar to the behaviour of functions in the dispatch_sync family.
- *
- * As an exception, if the queue the work is submitted to doesn't target
- * a global concurrent queue (for example because it targets the main queue),
- * then the workitem will never be invoked by the thread calling
- * dispatch_async_and_wait().
- *
- * In other words, dispatch_async_and_wait() is similar to submitting
- * a dispatch_block_create()d workitem to a queue and then waiting on it, as
- * shown in the code example below. However, dispatch_async_and_wait() is
- * significantly more efficient when a new thread is not required to execute
- * the workitem (as it will use the stack of the submitting thread instead of
- * requiring heap allocations).
- *
- * <code>
- *     dispatch_block_t b = dispatch_block_create(0, block);
- *     dispatch_async(queue, b);
- *     dispatch_block_wait(b, DISPATCH_TIME_FOREVER);
- *     Block_release(b);
- * </code>
- *
- * @param queue
- * The target dispatch queue to which the block is submitted.
- * The result of passing NULL in this parameter is undefined.
- *
- * @param block
- * The block to be invoked on the target dispatch queue.
- * The result of passing NULL in this parameter is undefined.
- */
-#ifdef __BLOCKS__
-API_AVAILABLE(macos(10.14), ios(12.0), tvos(12.0), watchos(5.0))
-DISPATCH_EXPORT DISPATCH_NONNULL_ALL DISPATCH_NOTHROW
-void
-dispatch_async_and_wait(dispatch_queue_t queue,
-		DISPATCH_NOESCAPE dispatch_block_t block);
-#endif
-
-/*!
- * @function dispatch_async_and_wait_f
- *
- * @abstract
- * Submits a function for synchronous execution on a dispatch queue.
- *
- * @discussion
- * See dispatch_async_and_wait() for details.
- *
- * @param queue
- * The target dispatch queue to which the function is submitted.
- * The result of passing NULL in this parameter is undefined.
- *
- * @param context
- * The application-defined context parameter to pass to the function.
- *
- * @param work
- * The application-defined function to invoke on the target queue. The first
- * parameter passed to this function is the context provided to
- * dispatch_async_and_wait_f().
- * The result of passing NULL in this parameter is undefined.
- */
-API_AVAILABLE(macos(10.14), ios(12.0), tvos(12.0), watchos(5.0))
-DISPATCH_EXPORT DISPATCH_NONNULL1 DISPATCH_NONNULL3 DISPATCH_NOTHROW
-void
-dispatch_async_and_wait_f(dispatch_queue_t queue,
-		void *_Nullable context, dispatch_function_t work);
-
-
-#if defined(__APPLE__) && \
-		(defined(__IPHONE_OS_VERSION_MIN_REQUIRED) && \
-		__IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_7_0) || \
-		(defined(__MAC_OS_X_VERSION_MIN_REQUIRED) && \
-		__MAC_OS_X_VERSION_MIN_REQUIRED < __MAC_10_9)
-#define DISPATCH_APPLY_AUTO_AVAILABLE 0
-#define DISPATCH_APPLY_QUEUE_ARG_NULLABILITY _Nonnull
-#else
-#define DISPATCH_APPLY_AUTO_AVAILABLE 1
-#define DISPATCH_APPLY_QUEUE_ARG_NULLABILITY _Nullable
-#endif
-
-/*!
- * @constant DISPATCH_APPLY_AUTO
- *
- * @abstract
- * Constant to pass to dispatch_apply() or dispatch_apply_f() to request that
- * the system automatically use worker threads that match the configuration of
- * the current thread as closely as possible.
- *
- * @discussion
- * When submitting a block for parallel invocation, passing this constant as the
- * queue argument will automatically use the global concurrent queue that
- * matches the Quality of Service of the caller most closely.
- *
- * No assumptions should be made about which global concurrent queue will
- * actually be used.
- *
- * Using this constant deploys backward to macOS 10.9, iOS 7.0 and any tvOS or
- * watchOS version.
- */
-#if DISPATCH_APPLY_AUTO_AVAILABLE
-#define DISPATCH_APPLY_AUTO ((dispatch_queue_t _Nonnull)0)
-#endif
-
-/*!
- * @function dispatch_apply
- *
- * @abstract
- * Submits a block to a dispatch queue for parallel invocation.
- *
- * @discussion
- * Submits a block to a dispatch queue for parallel invocation. This function
- * waits for the task block to complete before returning. If the specified queue
- * is concurrent, the block may be invoked concurrently, and it must therefore
- * be reentrant safe.
- *
- * Each invocation of the block will be passed the current index of iteration.
- *
- * @param iterations
- * The number of iterations to perform.
- *
- * @param queue
- * The dispatch queue to which the block is submitted.
- * The preferred value to pass is DISPATCH_APPLY_AUTO to automatically use
- * a queue appropriate for the calling thread.
- *
- * @param block
- * The block to be invoked the specified number of iterations.
- * The result of passing NULL in this parameter is undefined.
- */
-#ifdef __BLOCKS__
-API_AVAILABLE(macos(10.6), ios(4.0))
-DISPATCH_EXPORT DISPATCH_NONNULL3 DISPATCH_NOTHROW
-void
-dispatch_apply(size_t iterations,
-		dispatch_queue_t DISPATCH_APPLY_QUEUE_ARG_NULLABILITY queue,
-		DISPATCH_NOESCAPE void (^block)(size_t));
-#endif
-
-/*!
- * @function dispatch_apply_f
- *
- * @abstract
- * Submits a function to a dispatch queue for parallel invocation.
- *
- * @discussion
- * See dispatch_apply() for details.
- *
- * @param iterations
- * The number of iterations to perform.
- *
- * @param queue
- * The dispatch queue to which the function is submitted.
- * The preferred value to pass is DISPATCH_APPLY_AUTO to automatically use
- * a queue appropriate for the calling thread.
- *
- * @param context
- * The application-defined context parameter to pass to the function.
- *
- * @param work
- * The application-defined function to invoke on the specified queue. The first
- * parameter passed to this function is the context provided to
- * dispatch_apply_f(). The second parameter passed to this function is the
- * current index of iteration.
- * The result of passing NULL in this parameter is undefined.
- */
-API_AVAILABLE(macos(10.6), ios(4.0))
-DISPATCH_EXPORT DISPATCH_NONNULL4 DISPATCH_NOTHROW
-void
-dispatch_apply_f(size_t iterations,
-		dispatch_queue_t DISPATCH_APPLY_QUEUE_ARG_NULLABILITY queue,
-		void *_Nullable context, void (*work)(void *_Nullable, size_t));
-
-/*!
- * @function dispatch_get_current_queue
- *
- * @abstract
- * Returns the queue on which the currently executing block is running.
- *
- * @discussion
- * Returns the queue on which the currently executing block is running.
- *
- * When dispatch_get_current_queue() is called outside of the context of a
- * submitted block, it will return the default concurrent queue.
- *
- * Recommended for debugging and logging purposes only:
- * The code must not make any assumptions about the queue returned, unless it
- * is one of the global queues or a queue the code has itself created.
- * The code must not assume that synchronous execution onto a queue is safe
- * from deadlock if that queue is not the one returned by
- * dispatch_get_current_queue().
- *
- * When dispatch_get_current_queue() is called on the main thread, it may
- * or may not return the same value as dispatch_get_main_queue(). Comparing
- * the two is not a valid way to test whether code is executing on the
- * main thread (see dispatch_assert_queue() and dispatch_assert_queue_not()).
- *
- * This function is deprecated and will be removed in a future release.
- *
- * @result
- * Returns the current queue.
- */
-API_DEPRECATED("unsupported interface", macos(10.6,10.9), ios(4.0,6.0))
-DISPATCH_EXPORT DISPATCH_PURE DISPATCH_WARN_RESULT DISPATCH_NOTHROW
-dispatch_queue_t
-dispatch_get_current_queue(void);
-
-API_AVAILABLE(macos(10.6), ios(4.0))
-DISPATCH_EXPORT
-struct dispatch_queue_s _dispatch_main_q;
-
-/*!
- * @function dispatch_get_main_queue
- *
- * @abstract
- * Returns the default queue that is bound to the main thread.
- *
- * @discussion
- * In order to invoke blocks submitted to the main queue, the application must
- * call dispatch_main(), NSApplicationMain(), or use a CFRunLoop on the main
- * thread.
- *
- * The main queue is meant to be used in application context to interact with
- * the main thread and the main runloop.
- *
- * Because the main queue doesn't behave entirely like a regular serial queue,
- * it may have unwanted side-effects when used in processes that are not UI apps
- * (daemons). For such processes, the main queue should be avoided.
- *
- * @see dispatch_queue_main_t
- *
- * @result
- * Returns the main queue. This queue is created automatically on behalf of
- * the main thread before main() is called.
- */
-DISPATCH_INLINE DISPATCH_ALWAYS_INLINE DISPATCH_CONST DISPATCH_NOTHROW
-dispatch_queue_main_t
-dispatch_get_main_queue(void)
-{
-	return DISPATCH_GLOBAL_OBJECT(dispatch_queue_main_t, _dispatch_main_q);
-}
-
-/*!
- * @typedef dispatch_queue_priority_t
- * Type of dispatch_queue_priority
- *
- * @constant DISPATCH_QUEUE_PRIORITY_HIGH
- * Items dispatched to the queue will run at high priority,
- * i.e. the queue will be scheduled for execution before
- * any default priority or low priority queue.
- *
- * @constant DISPATCH_QUEUE_PRIORITY_DEFAULT
- * Items dispatched to the queue will run at the default
- * priority, i.e. the queue will be scheduled for execution
- * after all high priority queues have been scheduled, but
- * before any low priority queues have been scheduled.
- *
- * @constant DISPATCH_QUEUE_PRIORITY_LOW
- * Items dispatched to the queue will run at low priority,
- * i.e. the queue will be scheduled for execution after all
- * default priority and high priority queues have been
- * scheduled.
- *
- * @constant DISPATCH_QUEUE_PRIORITY_BACKGROUND
- * Items dispatched to the queue will run at background priority, i.e. the queue
- * will be scheduled for execution after all higher priority queues have been
- * scheduled and the system will run items on this queue on a thread with
- * background status as per setpriority(2) (i.e. disk I/O is throttled and the
- * thread's scheduling priority is set to lowest value).
- */
-#define DISPATCH_QUEUE_PRIORITY_HIGH 2
-#define DISPATCH_QUEUE_PRIORITY_DEFAULT 0
-#define DISPATCH_QUEUE_PRIORITY_LOW (-2)
-#define DISPATCH_QUEUE_PRIORITY_BACKGROUND INT16_MIN
-
-typedef long dispatch_queue_priority_t;
-
-/*!
- * @function dispatch_get_global_queue
- *
- * @abstract
- * Returns a well-known global concurrent queue of a given quality of service
- * class.
- *
- * @discussion
- * See dispatch_queue_global_t.
- *
- * @param identifier
- * A quality of service class defined in qos_class_t or a priority defined in
- * dispatch_queue_priority_t.
- *
- * It is recommended to use quality of service class values to identify the
- * well-known global concurrent queues:
- *  - QOS_CLASS_USER_INTERACTIVE
- *  - QOS_CLASS_USER_INITIATED
- *  - QOS_CLASS_DEFAULT
- *  - QOS_CLASS_UTILITY
- *  - QOS_CLASS_BACKGROUND
- *
- * The global concurrent queues may still be identified by their priority,
- * which map to the following QOS classes:
- *  - DISPATCH_QUEUE_PRIORITY_HIGH:         QOS_CLASS_USER_INITIATED
- *  - DISPATCH_QUEUE_PRIORITY_DEFAULT:      QOS_CLASS_DEFAULT
- *  - DISPATCH_QUEUE_PRIORITY_LOW:          QOS_CLASS_UTILITY
- *  - DISPATCH_QUEUE_PRIORITY_BACKGROUND:   QOS_CLASS_BACKGROUND
- *
- * @param flags
- * Reserved for future use. Passing any value other than zero may result in
- * a NULL return value.
- *
- * @result
- * Returns the requested global queue or NULL if the requested global queue
- * does not exist.
- */
-API_AVAILABLE(macos(10.6), ios(4.0))
-DISPATCH_EXPORT DISPATCH_CONST DISPATCH_WARN_RESULT DISPATCH_NOTHROW
-dispatch_queue_global_t
-dispatch_get_global_queue(long identifier, unsigned long flags);
-
-/*!
- * @typedef dispatch_queue_attr_t
- *
- * @abstract
- * Attribute for dispatch queues.
- */
-DISPATCH_DECL(dispatch_queue_attr);
-
-/*!
- * @const DISPATCH_QUEUE_SERIAL
- *
- * @discussion
- * An attribute that can be used to create a dispatch queue that invokes blocks
- * serially in FIFO order.
- *
- * See dispatch_queue_serial_t.
- */
-#define DISPATCH_QUEUE_SERIAL NULL
-
-/*!
- * @const DISPATCH_QUEUE_SERIAL_INACTIVE
- *
- * @discussion
- * An attribute that can be used to create a dispatch queue that invokes blocks
- * serially in FIFO order, and that is initially inactive.
- *
- * See dispatch_queue_attr_make_initially_inactive().
- */
-#define DISPATCH_QUEUE_SERIAL_INACTIVE \
-		dispatch_queue_attr_make_initially_inactive(DISPATCH_QUEUE_SERIAL)
-
-/*!
- * @const DISPATCH_QUEUE_CONCURRENT
- *
- * @discussion
- * An attribute that can be used to create a dispatch queue that may invoke
- * blocks concurrently and supports barrier blocks submitted with the dispatch
- * barrier API.
- *
- * See dispatch_queue_concurrent_t.
- */
-#define DISPATCH_QUEUE_CONCURRENT \
-		DISPATCH_GLOBAL_OBJECT(dispatch_queue_attr_t, \
-		_dispatch_queue_attr_concurrent)
-API_AVAILABLE(macos(10.7), ios(4.3))
-DISPATCH_EXPORT
-struct dispatch_queue_attr_s _dispatch_queue_attr_concurrent;
-
-/*!
- * @const DISPATCH_QUEUE_CONCURRENT_INACTIVE
- *
- * @discussion
- * An attribute that can be used to create a dispatch queue that may invoke
- * blocks concurrently and supports barrier blocks submitted with the dispatch
- * barrier API, and that is initially inactive.
- *
- * See dispatch_queue_attr_make_initially_inactive().
- */
-#define DISPATCH_QUEUE_CONCURRENT_INACTIVE \
-		dispatch_queue_attr_make_initially_inactive(DISPATCH_QUEUE_CONCURRENT)
-
-/*!
- * @function dispatch_queue_attr_make_initially_inactive
- *
- * @abstract
- * Returns an attribute value which may be provided to dispatch_queue_create()
- * or dispatch_queue_create_with_target(), in order to make the created queue
- * initially inactive.
- *
- * @discussion
- * Dispatch queues may be created in an inactive state. Queues in this state
- * have to be activated before any blocks associated with them will be invoked.
- *
- * A queue in inactive state cannot be deallocated, dispatch_activate() must be
- * called before the last reference to a queue created with this attribute is
- * released.
- *
- * The target queue of a queue in inactive state can be changed using
- * dispatch_set_target_queue(). Change of target queue is no longer permitted
- * once an initially inactive queue has been activated.
- *
- * @param attr
- * A queue attribute value to be combined with the initially inactive attribute.
- *
- * @return
- * Returns an attribute value which may be provided to dispatch_queue_create()
- * and dispatch_queue_create_with_target().
- * The new value combines the attributes specified by the 'attr' parameter with
- * the initially inactive attribute.
- */
-API_AVAILABLE(macos(10.12), ios(10.0), tvos(10.0), watchos(3.0))
-DISPATCH_EXPORT DISPATCH_WARN_RESULT DISPATCH_PURE DISPATCH_NOTHROW
-dispatch_queue_attr_t
-dispatch_queue_attr_make_initially_inactive(
-		dispatch_queue_attr_t _Nullable attr);
-
-/*!
- * @const DISPATCH_QUEUE_SERIAL_WITH_AUTORELEASE_POOL
- *
- * @discussion
- * A dispatch queue created with this attribute invokes blocks serially in FIFO
- * order, and surrounds execution of any block submitted asynchronously to it
- * with the equivalent of a individual Objective-C <code>@autoreleasepool</code>
- * scope.
- *
- * See dispatch_queue_attr_make_with_autorelease_frequency().
- */
-#define DISPATCH_QUEUE_SERIAL_WITH_AUTORELEASE_POOL \
-		dispatch_queue_attr_make_with_autorelease_frequency(\
-				DISPATCH_QUEUE_SERIAL, DISPATCH_AUTORELEASE_FREQUENCY_WORK_ITEM)
-
-/*!
- * @const DISPATCH_QUEUE_CONCURRENT_WITH_AUTORELEASE_POOL
- *
- * @discussion
- * A dispatch queue created with this attribute may invokes blocks concurrently
- * and supports barrier blocks submitted with the dispatch barrier API. It also
- * surrounds execution of any block submitted asynchronously to it with the
- * equivalent of a individual Objective-C <code>@autoreleasepool</code>
- *
- * See dispatch_queue_attr_make_with_autorelease_frequency().
- */
-#define DISPATCH_QUEUE_CONCURRENT_WITH_AUTORELEASE_POOL \
-		dispatch_queue_attr_make_with_autorelease_frequency(\
-				DISPATCH_QUEUE_CONCURRENT, DISPATCH_AUTORELEASE_FREQUENCY_WORK_ITEM)
-
-/*!
- * @typedef dispatch_autorelease_frequency_t
- * Values to pass to the dispatch_queue_attr_make_with_autorelease_frequency()
- * function.
- *
- * @const DISPATCH_AUTORELEASE_FREQUENCY_INHERIT
- * Dispatch queues with this autorelease frequency inherit the behavior from
- * their target queue. This is the default behavior for manually created queues.
- *
- * @const DISPATCH_AUTORELEASE_FREQUENCY_WORK_ITEM
- * Dispatch queues with this autorelease frequency push and pop an autorelease
- * pool around the execution of every block that was submitted to it
- * asynchronously.
- * @see dispatch_queue_attr_make_with_autorelease_frequency().
- *
- * @const DISPATCH_AUTORELEASE_FREQUENCY_NEVER
- * Dispatch queues with this autorelease frequency never set up an individual
- * autorelease pool around the execution of a block that is submitted to it
- * asynchronously. This is the behavior of the global concurrent queues.
- */
-DISPATCH_ENUM(dispatch_autorelease_frequency, unsigned long,
-	DISPATCH_AUTORELEASE_FREQUENCY_INHERIT DISPATCH_ENUM_API_AVAILABLE(
-			macos(10.12), ios(10.0), tvos(10.0), watchos(3.0)) = 0,
-	DISPATCH_AUTORELEASE_FREQUENCY_WORK_ITEM DISPATCH_ENUM_API_AVAILABLE(
-			macos(10.12), ios(10.0), tvos(10.0), watchos(3.0)) = 1,
-	DISPATCH_AUTORELEASE_FREQUENCY_NEVER DISPATCH_ENUM_API_AVAILABLE(
-			macos(10.12), ios(10.0), tvos(10.0), watchos(3.0)) = 2,
-);
-
-/*!
- * @function dispatch_queue_attr_make_with_autorelease_frequency
- *
- * @abstract
- * Returns a dispatch queue attribute value with the autorelease frequency
- * set to the specified value.
- *
- * @discussion
- * When a queue uses the per-workitem autorelease frequency (either directly
- * or inherithed from its target queue), any block submitted asynchronously to
- * this queue (via dispatch_async(), dispatch_barrier_async(),
- * dispatch_group_notify(), etc...) is executed as if surrounded by a individual
- * Objective-C <code>@autoreleasepool</code> scope.
- *
- * Autorelease frequency has no effect on blocks that are submitted
- * synchronously to a queue (via dispatch_sync(), dispatch_barrier_sync()).
- *
- * The global concurrent queues have the DISPATCH_AUTORELEASE_FREQUENCY_NEVER
- * behavior. Manually created dispatch queues use
- * DISPATCH_AUTORELEASE_FREQUENCY_INHERIT by default.
- *
- * Queues created with this attribute cannot change target queues after having
- * been activated. See dispatch_set_target_queue() and dispatch_activate().
- *
- * @param attr
- * A queue attribute value to be combined with the specified autorelease
- * frequency or NULL.
- *
- * @param frequency
- * The requested autorelease frequency.
- *
- * @return
- * Returns an attribute value which may be provided to dispatch_queue_create()
- * or NULL if an invalid autorelease frequency was requested.
- * This new value combines the attributes specified by the 'attr' parameter and
- * the chosen autorelease frequency.
- */
-API_AVAILABLE(macos(10.12), ios(10.0), tvos(10.0), watchos(3.0))
-DISPATCH_EXPORT DISPATCH_WARN_RESULT DISPATCH_PURE DISPATCH_NOTHROW
-dispatch_queue_attr_t
-dispatch_queue_attr_make_with_autorelease_frequency(
-		dispatch_queue_attr_t _Nullable attr,
-		dispatch_autorelease_frequency_t frequency);
-
-/*!
- * @function dispatch_queue_attr_make_with_qos_class
- *
- * @abstract
- * Returns an attribute value which may be provided to dispatch_queue_create()
- * or dispatch_queue_create_with_target(), in order to assign a QOS class and
- * relative priority to the queue.
- *
- * @discussion
- * When specified in this manner, the QOS class and relative priority take
- * precedence over those inherited from the dispatch queue's target queue (if
- * any) as long that does not result in a lower QOS class and relative priority.
- *
- * The global queue priorities map to the following QOS classes:
- *  - DISPATCH_QUEUE_PRIORITY_HIGH:         QOS_CLASS_USER_INITIATED
- *  - DISPATCH_QUEUE_PRIORITY_DEFAULT:      QOS_CLASS_DEFAULT
- *  - DISPATCH_QUEUE_PRIORITY_LOW:          QOS_CLASS_UTILITY
- *  - DISPATCH_QUEUE_PRIORITY_BACKGROUND:   QOS_CLASS_BACKGROUND
- *
- * Example:
- * <code>
- *	dispatch_queue_t queue;
- *	dispatch_queue_attr_t attr;
- *	attr = dispatch_queue_attr_make_with_qos_class(DISPATCH_QUEUE_SERIAL,
- *			QOS_CLASS_UTILITY, 0);
- *	queue = dispatch_queue_create("com.example.myqueue", attr);
- * </code>
- *
- * The QOS class and relative priority set this way on a queue have no effect on
- * blocks that are submitted synchronously to a queue (via dispatch_sync(),
- * dispatch_barrier_sync()).
- *
- * @param attr
- * A queue attribute value to be combined with the QOS class, or NULL.
- *
- * @param qos_class
- * A QOS class value:
- *  - QOS_CLASS_USER_INTERACTIVE
- *  - QOS_CLASS_USER_INITIATED
- *  - QOS_CLASS_DEFAULT
- *  - QOS_CLASS_UTILITY
- *  - QOS_CLASS_BACKGROUND
- * Passing any other value results in NULL being returned.
- *
- * @param relative_priority
- * A relative priority within the QOS class. This value is a negative
- * offset from the maximum supported scheduler priority for the given class.
- * Passing a value greater than zero or less than QOS_MIN_RELATIVE_PRIORITY
- * results in NULL being returned.
- *
- * @return
- * Returns an attribute value which may be provided to dispatch_queue_create()
- * and dispatch_queue_create_with_target(), or NULL if an invalid QOS class was
- * requested.
- * The new value combines the attributes specified by the 'attr' parameter and
- * the new QOS class and relative priority.
- */
-API_AVAILABLE(macos(10.10), ios(8.0))
-DISPATCH_EXPORT DISPATCH_WARN_RESULT DISPATCH_PURE DISPATCH_NOTHROW
-dispatch_queue_attr_t
-dispatch_queue_attr_make_with_qos_class(dispatch_queue_attr_t _Nullable attr,
-		dispatch_qos_class_t qos_class, int relative_priority);
-
-/*!
- * @const DISPATCH_TARGET_QUEUE_DEFAULT
- * @discussion Constant to pass to the dispatch_queue_create_with_target(),
- * dispatch_set_target_queue() and dispatch_source_create() functions to
- * indicate that the default target queue for the object type in question
- * should be used.
- */
-#define DISPATCH_TARGET_QUEUE_DEFAULT NULL
-
-/*!
- * @function dispatch_queue_create_with_target
- *
- * @abstract
- * Creates a new dispatch queue with a specified target queue.
- *
- * @discussion
- * Dispatch queues created with the DISPATCH_QUEUE_SERIAL or a NULL attribute
- * invoke blocks serially in FIFO order.
- *
- * Dispatch queues created with the DISPATCH_QUEUE_CONCURRENT attribute may
- * invoke blocks concurrently (similarly to the global concurrent queues, but
- * potentially with more overhead), and support barrier blocks submitted with
- * the dispatch barrier API, which e.g. enables the implementation of efficient
- * reader-writer schemes.
- *
- * When a dispatch queue is no longer needed, it should be released with
- * dispatch_release(). Note that any pending blocks submitted asynchronously to
- * a queue will hold a reference to that queue. Therefore a queue will not be
- * deallocated until all pending blocks have finished.
- *
- * When using a dispatch queue attribute @a attr specifying a QoS class (derived
- * from the result of dispatch_queue_attr_make_with_qos_class()), passing the
- * result of dispatch_get_global_queue() in @a target will ignore the QoS class
- * of that global queue and will use the global queue with the QoS class
- * specified by attr instead.
- *
- * Queues created with dispatch_queue_create_with_target() cannot have their
- * target queue changed, unless created inactive (See
- * dispatch_queue_attr_make_initially_inactive()), in which case the target
- * queue can be changed until the newly created queue is activated with
- * dispatch_activate().
- *
- * @param label
- * A string label to attach to the queue.
- * This parameter is optional and may be NULL.
- *
- * @param attr
- * A predefined attribute such as DISPATCH_QUEUE_SERIAL,
- * DISPATCH_QUEUE_CONCURRENT, or the result of a call to
- * a dispatch_queue_attr_make_with_* function.
- *
- * @param target
- * The target queue for the newly created queue. The target queue is retained.
- * If this parameter is DISPATCH_TARGET_QUEUE_DEFAULT, sets the queue's target
- * queue to the default target queue for the given queue type.
- *
- * @result
- * The newly created dispatch queue.
- */
-API_AVAILABLE(macos(10.12), ios(10.0), tvos(10.0), watchos(3.0))
-DISPATCH_EXPORT DISPATCH_MALLOC DISPATCH_RETURNS_RETAINED DISPATCH_WARN_RESULT
-DISPATCH_NOTHROW
-dispatch_queue_t
-dispatch_queue_create_with_target(const char *_Nullable label,
-		dispatch_queue_attr_t _Nullable attr, dispatch_queue_t _Nullable target)
-		DISPATCH_ALIAS_V2(dispatch_queue_create_with_target);
-
-/*!
- * @function dispatch_queue_create
- *
- * @abstract
- * Creates a new dispatch queue to which blocks may be submitted.
- *
- * @discussion
- * Dispatch queues created with the DISPATCH_QUEUE_SERIAL or a NULL attribute
- * invoke blocks serially in FIFO order.
- *
- * Dispatch queues created with the DISPATCH_QUEUE_CONCURRENT attribute may
- * invoke blocks concurrently (similarly to the global concurrent queues, but
- * potentially with more overhead), and support barrier blocks submitted with
- * the dispatch barrier API, which e.g. enables the implementation of efficient
- * reader-writer schemes.
- *
- * When a dispatch queue is no longer needed, it should be released with
- * dispatch_release(). Note that any pending blocks submitted asynchronously to
- * a queue will hold a reference to that queue. Therefore a queue will not be
- * deallocated until all pending blocks have finished.
- *
- * Passing the result of the dispatch_queue_attr_make_with_qos_class() function
- * to the attr parameter of this function allows a quality of service class and
- * relative priority to be specified for the newly created queue.
- * The quality of service class so specified takes precedence over the quality
- * of service class of the newly created dispatch queue's target queue (if any)
- * as long that does not result in a lower QOS class and relative priority.
- *
- * When no quality of service class is specified, the target queue of a newly
- * created dispatch queue is the default priority global concurrent queue.
- *
- * @param label
- * A string label to attach to the queue.
- * This parameter is optional and may be NULL.
- *
- * @param attr
- * A predefined attribute such as DISPATCH_QUEUE_SERIAL,
- * DISPATCH_QUEUE_CONCURRENT, or the result of a call to
- * a dispatch_queue_attr_make_with_* function.
- *
- * @result
- * The newly created dispatch queue.
- */
-API_AVAILABLE(macos(10.6), ios(4.0))
-DISPATCH_EXPORT DISPATCH_MALLOC DISPATCH_RETURNS_RETAINED DISPATCH_WARN_RESULT
-DISPATCH_NOTHROW
-dispatch_queue_t
-dispatch_queue_create(const char *_Nullable label,
-		dispatch_queue_attr_t _Nullable attr);
-
-/*!
- * @const DISPATCH_CURRENT_QUEUE_LABEL
- * @discussion Constant to pass to the dispatch_queue_get_label() function to
- * retrieve the label of the current queue.
- */
-#define DISPATCH_CURRENT_QUEUE_LABEL NULL
-
-/*!
- * @function dispatch_queue_get_label
- *
- * @abstract
- * Returns the label of the given queue, as specified when the queue was
- * created, or the empty string if a NULL label was specified.
- *
- * Passing DISPATCH_CURRENT_QUEUE_LABEL will return the label of the current
- * queue.
- *
- * @param queue
- * The queue to query, or DISPATCH_CURRENT_QUEUE_LABEL.
- *
- * @result
- * The label of the queue.
- */
-API_AVAILABLE(macos(10.6), ios(4.0))
-DISPATCH_EXPORT DISPATCH_PURE DISPATCH_WARN_RESULT DISPATCH_NOTHROW
-const char *
-dispatch_queue_get_label(dispatch_queue_t _Nullable queue);
-
-/*!
- * @function dispatch_queue_get_qos_class
- *
- * @abstract
- * Returns the QOS class and relative priority of the given queue.
- *
- * @discussion
- * If the given queue was created with an attribute value returned from
- * dispatch_queue_attr_make_with_qos_class(), this function returns the QOS
- * class and relative priority specified at that time; for any other attribute
- * value it returns a QOS class of QOS_CLASS_UNSPECIFIED and a relative
- * priority of 0.
- *
- * If the given queue is one of the global queues, this function returns its
- * assigned QOS class value as documented under dispatch_get_global_queue() and
- * a relative priority of 0; in the case of the main queue it returns the QOS
- * value provided by qos_class_main() and a relative priority of 0.
- *
- * @param queue
- * The queue to query.
- *
- * @param relative_priority_ptr
- * A pointer to an int variable to be filled with the relative priority offset
- * within the QOS class, or NULL.
- *
- * @return
- * A QOS class value:
- *	- QOS_CLASS_USER_INTERACTIVE
- *	- QOS_CLASS_USER_INITIATED
- *	- QOS_CLASS_DEFAULT
- *	- QOS_CLASS_UTILITY
- *	- QOS_CLASS_BACKGROUND
- *	- QOS_CLASS_UNSPECIFIED
- */
-API_AVAILABLE(macos(10.10), ios(8.0))
-DISPATCH_EXPORT DISPATCH_WARN_RESULT DISPATCH_NONNULL1 DISPATCH_NOTHROW
-dispatch_qos_class_t
-dispatch_queue_get_qos_class(dispatch_queue_t queue,
-		int *_Nullable relative_priority_ptr);
-
-/*!
- * @function dispatch_set_target_queue
- *
- * @abstract
- * Sets the target queue for the given object.
- *
- * @discussion
- * An object's target queue is responsible for processing the object.
- *
- * When no quality of service class and relative priority is specified for a
- * dispatch queue at the time of creation, a dispatch queue's quality of service
- * class is inherited from its target queue. The dispatch_get_global_queue()
- * function may be used to obtain a target queue of a specific quality of
- * service class, however the use of dispatch_queue_attr_make_with_qos_class()
- * is recommended instead.
- *
- * Blocks submitted to a serial queue whose target queue is another serial
- * queue will not be invoked concurrently with blocks submitted to the target
- * queue or to any other queue with that same target queue.
- *
- * The result of introducing a cycle into the hierarchy of target queues is
- * undefined.
- *
- * A dispatch source's target queue specifies where its event handler and
- * cancellation handler blocks will be submitted.
- *
- * A dispatch I/O channel's target queue specifies where where its I/O
- * operations are executed. If the channel's target queue's priority is set to
- * DISPATCH_QUEUE_PRIORITY_BACKGROUND, then the I/O operations performed by
- * dispatch_io_read() or dispatch_io_write() on that queue will be
- * throttled when there is I/O contention.
- *
- * For all other dispatch object types, the only function of the target queue
- * is to determine where an object's finalizer function is invoked.
- *
- * In general, changing the target queue of an object is an asynchronous
- * operation that doesn't take effect immediately, and doesn't affect blocks
- * already associated with the specified object.
- *
- * However, if an object is inactive at the time dispatch_set_target_queue() is
- * called, then the target queue change takes effect immediately, and will
- * affect blocks already associated with the specified object. After an
- * initially inactive object has been activated, calling
- * dispatch_set_target_queue() results in an assertion and the process being
- * terminated.
- *
- * If a dispatch queue is active and targeted by other dispatch objects,
- * changing its target queue results in undefined behavior.
- *
- * @param object
- * The object to modify.
- * The result of passing NULL in this parameter is undefined.
- *
- * @param queue
- * The new target queue for the object. The queue is retained, and the
- * previous target queue, if any, is released.
- * If queue is DISPATCH_TARGET_QUEUE_DEFAULT, set the object's target queue
- * to the default target queue for the given object type.
- */
-API_AVAILABLE(macos(10.6), ios(4.0))
-DISPATCH_EXPORT DISPATCH_NOTHROW
-void
-dispatch_set_target_queue(dispatch_object_t object,
-		dispatch_queue_t _Nullable queue);
-
-/*!
- * @function dispatch_main
- *
- * @abstract
- * Execute blocks submitted to the main queue.
- *
- * @discussion
- * This function "parks" the main thread and waits for blocks to be submitted
- * to the main queue. This function never returns.
- *
- * Applications that call NSApplicationMain() or CFRunLoopRun() on the
- * main thread do not need to call dispatch_main().
- */
-API_AVAILABLE(macos(10.6), ios(4.0))
-DISPATCH_EXPORT DISPATCH_NOTHROW DISPATCH_NORETURN
-void
-dispatch_main(void);
-
-/*!
- * @function dispatch_after
- *
- * @abstract
- * Schedule a block for execution on a given queue at a specified time.
- *
- * @discussion
- * Passing DISPATCH_TIME_NOW as the "when" parameter is supported, but not as
- * optimal as calling dispatch_async() instead. Passing DISPATCH_TIME_FOREVER
- * is undefined.
- *
- * @param when
- * A temporal milestone returned by dispatch_time() or dispatch_walltime().
- *
- * @param queue
- * A queue to which the given block will be submitted at the specified time.
- * The result of passing NULL in this parameter is undefined.
- *
- * @param block
- * The block of code to execute.
- * The result of passing NULL in this parameter is undefined.
- */
-#ifdef __BLOCKS__
-API_AVAILABLE(macos(10.6), ios(4.0))
-DISPATCH_EXPORT DISPATCH_NONNULL2 DISPATCH_NONNULL3 DISPATCH_NOTHROW
-void
-dispatch_after(dispatch_time_t when, dispatch_queue_t queue,
-		dispatch_block_t block);
-#endif
-
-/*!
- * @function dispatch_after_f
- *
- * @abstract
- * Schedule a function for execution on a given queue at a specified time.
- *
- * @discussion
- * See dispatch_after() for details.
- *
- * @param when
- * A temporal milestone returned by dispatch_time() or dispatch_walltime().
- *
- * @param queue
- * A queue to which the given function will be submitted at the specified time.
- * The result of passing NULL in this parameter is undefined.
- *
- * @param context
- * The application-defined context parameter to pass to the function.
- *
- * @param work
- * The application-defined function to invoke on the target queue. The first
- * parameter passed to this function is the context provided to
- * dispatch_after_f().
- * The result of passing NULL in this parameter is undefined.
- */
-API_AVAILABLE(macos(10.6), ios(4.0))
-DISPATCH_EXPORT DISPATCH_NONNULL2 DISPATCH_NONNULL4 DISPATCH_NOTHROW
-void
-dispatch_after_f(dispatch_time_t when, dispatch_queue_t queue,
-		void *_Nullable context, dispatch_function_t work);
-
-/*!
- * @functiongroup Dispatch Barrier API
- * The dispatch barrier API is a mechanism for submitting barrier blocks to a
- * dispatch queue, analogous to the dispatch_async()/dispatch_sync() API.
- * It enables the implementation of efficient reader/writer schemes.
- * Barrier blocks only behave specially when submitted to queues created with
- * the DISPATCH_QUEUE_CONCURRENT attribute; on such a queue, a barrier block
- * will not run until all blocks submitted to the queue earlier have completed,
- * and any blocks submitted to the queue after a barrier block will not run
- * until the barrier block has completed.
- * When submitted to a a global queue or to a queue not created with the
- * DISPATCH_QUEUE_CONCURRENT attribute, barrier blocks behave identically to
- * blocks submitted with the dispatch_async()/dispatch_sync() API.
- */
-
-/*!
- * @function dispatch_barrier_async
- *
- * @abstract
- * Submits a barrier block for asynchronous execution on a dispatch queue.
- *
- * @discussion
- * Submits a block to a dispatch queue like dispatch_async(), but marks that
- * block as a barrier (relevant only on DISPATCH_QUEUE_CONCURRENT queues).
- *
- * See dispatch_async() for details and "Dispatch Barrier API" for a description
- * of the barrier semantics.
- *
- * @param queue
- * The target dispatch queue to which the block is submitted.
- * The system will hold a reference on the target queue until the block
- * has finished.
- * The result of passing NULL in this parameter is undefined.
- *
- * @param block
- * The block to submit to the target dispatch queue. This function performs
- * Block_copy() and Block_release() on behalf of callers.
- * The result of passing NULL in this parameter is undefined.
- */
-#ifdef __BLOCKS__
-API_AVAILABLE(macos(10.7), ios(4.3))
-DISPATCH_EXPORT DISPATCH_NONNULL_ALL DISPATCH_NOTHROW
-void
-dispatch_barrier_async(dispatch_queue_t queue, dispatch_block_t block);
-#endif
-
-/*!
- * @function dispatch_barrier_async_f
- *
- * @abstract
- * Submits a barrier function for asynchronous execution on a dispatch queue.
- *
- * @discussion
- * Submits a function to a dispatch queue like dispatch_async_f(), but marks
- * that function as a barrier (relevant only on DISPATCH_QUEUE_CONCURRENT
- * queues).
- *
- * See dispatch_async_f() for details and "Dispatch Barrier API" for a
- * description of the barrier semantics.
- *
- * @param queue
- * The target dispatch queue to which the function is submitted.
- * The system will hold a reference on the target queue until the function
- * has returned.
- * The result of passing NULL in this parameter is undefined.
- *
- * @param context
- * The application-defined context parameter to pass to the function.
- *
- * @param work
- * The application-defined function to invoke on the target queue. The first
- * parameter passed to this function is the context provided to
- * dispatch_barrier_async_f().
- * The result of passing NULL in this parameter is undefined.
- */
-API_AVAILABLE(macos(10.7), ios(4.3))
-DISPATCH_EXPORT DISPATCH_NONNULL1 DISPATCH_NONNULL3 DISPATCH_NOTHROW
-void
-dispatch_barrier_async_f(dispatch_queue_t queue,
-		void *_Nullable context, dispatch_function_t work);
-
-/*!
- * @function dispatch_barrier_sync
- *
- * @abstract
- * Submits a barrier block for synchronous execution on a dispatch queue.
- *
- * @discussion
- * Submits a block to a dispatch queue like dispatch_sync(), but marks that
- * block as a barrier (relevant only on DISPATCH_QUEUE_CONCURRENT queues).
- *
- * See dispatch_sync() for details and "Dispatch Barrier API" for a description
- * of the barrier semantics.
- *
- * @param queue
- * The target dispatch queue to which the block is submitted.
- * The result of passing NULL in this parameter is undefined.
- *
- * @param block
- * The block to be invoked on the target dispatch queue.
- * The result of passing NULL in this parameter is undefined.
- */
-#ifdef __BLOCKS__
-API_AVAILABLE(macos(10.7), ios(4.3))
-DISPATCH_EXPORT DISPATCH_NONNULL_ALL DISPATCH_NOTHROW
-void
-dispatch_barrier_sync(dispatch_queue_t queue,
-		DISPATCH_NOESCAPE dispatch_block_t block);
-#endif
-
-/*!
- * @function dispatch_barrier_sync_f
- *
- * @abstract
- * Submits a barrier function for synchronous execution on a dispatch queue.
- *
- * @discussion
- * Submits a function to a dispatch queue like dispatch_sync_f(), but marks that
- * fuction as a barrier (relevant only on DISPATCH_QUEUE_CONCURRENT queues).
- *
- * See dispatch_sync_f() for details.
- *
- * @param queue
- * The target dispatch queue to which the function is submitted.
- * The result of passing NULL in this parameter is undefined.
- *
- * @param context
- * The application-defined context parameter to pass to the function.
- *
- * @param work
- * The application-defined function to invoke on the target queue. The first
- * parameter passed to this function is the context provided to
- * dispatch_barrier_sync_f().
- * The result of passing NULL in this parameter is undefined.
- */
-API_AVAILABLE(macos(10.7), ios(4.3))
-DISPATCH_EXPORT DISPATCH_NONNULL1 DISPATCH_NONNULL3 DISPATCH_NOTHROW
-void
-dispatch_barrier_sync_f(dispatch_queue_t queue,
-		void *_Nullable context, dispatch_function_t work);
-
-/*!
- * @function dispatch_barrier_async_and_wait
- *
- * @abstract
- * Submits a block for synchronous execution on a dispatch queue.
- *
- * @discussion
- * Submits a block to a dispatch queue like dispatch_async_and_wait(), but marks
- * that block as a barrier (relevant only on DISPATCH_QUEUE_CONCURRENT
- * queues).
- *
- * See "Dispatch Barrier API" for a description of the barrier semantics.
- *
- * @param queue
- * The target dispatch queue to which the block is submitted.
- * The result of passing NULL in this parameter is undefined.
- *
- * @param work
- * The application-defined block to invoke on the target queue.
- * The result of passing NULL in this parameter is undefined.
- */
-#ifdef __BLOCKS__
-API_AVAILABLE(macos(10.14), ios(12.0), tvos(12.0), watchos(5.0))
-DISPATCH_EXPORT DISPATCH_NONNULL_ALL DISPATCH_NOTHROW
-void
-dispatch_barrier_async_and_wait(dispatch_queue_t queue,
-		DISPATCH_NOESCAPE dispatch_block_t block);
-#endif
-
-/*!
- * @function dispatch_barrier_async_and_wait_f
- *
- * @abstract
- * Submits a function for synchronous execution on a dispatch queue.
- *
- * @discussion
- * Submits a function to a dispatch queue like dispatch_async_and_wait_f(), but
- * marks that function as a barrier (relevant only on DISPATCH_QUEUE_CONCURRENT
- * queues).
- *
- * See "Dispatch Barrier API" for a description of the barrier semantics.
- *
- * @param queue
- * The target dispatch queue to which the function is submitted.
- * The result of passing NULL in this parameter is undefined.
- *
- * @param context
- * The application-defined context parameter to pass to the function.
- *
- * @param work
- * The application-defined function to invoke on the target queue. The first
- * parameter passed to this function is the context provided to
- * dispatch_barrier_async_and_wait_f().
- * The result of passing NULL in this parameter is undefined.
- */
-API_AVAILABLE(macos(10.14), ios(12.0), tvos(12.0), watchos(5.0))
-DISPATCH_EXPORT DISPATCH_NONNULL1 DISPATCH_NONNULL3 DISPATCH_NOTHROW
-void
-dispatch_barrier_async_and_wait_f(dispatch_queue_t queue,
-		void *_Nullable context, dispatch_function_t work);
-
-/*!
- * @functiongroup Dispatch queue-specific contexts
- * This API allows different subsystems to associate context to a shared queue
- * without risk of collision and to retrieve that context from blocks executing
- * on that queue or any of its child queues in the target queue hierarchy.
- */
-
-/*!
- * @function dispatch_queue_set_specific
- *
- * @abstract
- * Associates a subsystem-specific context with a dispatch queue, for a key
- * unique to the subsystem.
- *
- * @discussion
- * The specified destructor will be invoked with the context on the default
- * priority global concurrent queue when a new context is set for the same key,
- * or after all references to the queue have been released.
- *
- * @param queue
- * The dispatch queue to modify.
- * The result of passing NULL in this parameter is undefined.
- *
- * @param key
- * The key to set the context for, typically a pointer to a static variable
- * specific to the subsystem. Keys are only compared as pointers and never
- * dereferenced. Passing a string constant directly is not recommended.
- * The NULL key is reserved and attempts to set a context for it are ignored.
- *
- * @param context
- * The new subsystem-specific context for the object. This may be NULL.
- *
- * @param destructor
- * The destructor function pointer. This may be NULL and is ignored if context
- * is NULL.
- */
-API_AVAILABLE(macos(10.7), ios(5.0))
-DISPATCH_EXPORT DISPATCH_NONNULL1 DISPATCH_NOTHROW
-void
-dispatch_queue_set_specific(dispatch_queue_t queue, const void *key,
-		void *_Nullable context, dispatch_function_t _Nullable destructor);
-
-/*!
- * @function dispatch_queue_get_specific
- *
- * @abstract
- * Returns the subsystem-specific context associated with a dispatch queue, for
- * a key unique to the subsystem.
- *
- * @discussion
- * Returns the context for the specified key if it has been set on the specified
- * queue.
- *
- * @param queue
- * The dispatch queue to query.
- * The result of passing NULL in this parameter is undefined.
- *
- * @param key
- * The key to get the context for, typically a pointer to a static variable
- * specific to the subsystem. Keys are only compared as pointers and never
- * dereferenced. Passing a string constant directly is not recommended.
- *
- * @result
- * The context for the specified key or NULL if no context was found.
- */
-API_AVAILABLE(macos(10.7), ios(5.0))
-DISPATCH_EXPORT DISPATCH_NONNULL1 DISPATCH_PURE DISPATCH_WARN_RESULT
-DISPATCH_NOTHROW
-void *_Nullable
-dispatch_queue_get_specific(dispatch_queue_t queue, const void *key);
-
-/*!
- * @function dispatch_get_specific
- *
- * @abstract
- * Returns the current subsystem-specific context for a key unique to the
- * subsystem.
- *
- * @discussion
- * When called from a block executing on a queue, returns the context for the
- * specified key if it has been set on the queue, otherwise returns the result
- * of dispatch_get_specific() executed on the queue's target queue or NULL
- * if the current queue is a global concurrent queue.
- *
- * @param key
- * The key to get the context for, typically a pointer to a static variable
- * specific to the subsystem. Keys are only compared as pointers and never
- * dereferenced. Passing a string constant directly is not recommended.
- *
- * @result
- * The context for the specified key or NULL if no context was found.
- */
-API_AVAILABLE(macos(10.7), ios(5.0))
-DISPATCH_EXPORT DISPATCH_PURE DISPATCH_WARN_RESULT DISPATCH_NOTHROW
-void *_Nullable
-dispatch_get_specific(const void *key);
-
-/*!
- * @functiongroup Dispatch assertion API
- *
- * This API asserts at runtime that code is executing in (or out of) the context
- * of a given queue. It can be used to check that a block accessing a resource
- * does so from the proper queue protecting the resource. It also can be used
- * to verify that a block that could cause a deadlock if run on a given queue
- * never executes on that queue.
- */
-
-/*!
- * @function dispatch_assert_queue
- *
- * @abstract
- * Verifies that the current block is executing on a given dispatch queue.
- *
- * @discussion
- * Some code expects to be run on a specific dispatch queue. This function
- * verifies that that expectation is true.
- *
- * If the currently executing block was submitted to the specified queue or to
- * any queue targeting it (see dispatch_set_target_queue()), this function
- * returns.
- *
- * If the currently executing block was submitted with a synchronous API
- * (dispatch_sync(), dispatch_barrier_sync(), ...), the context of the
- * submitting block is also evaluated (recursively).
- * If a synchronously submitting block is found that was itself submitted to
- * the specified queue or to any queue targeting it, this function returns.
- *
- * Otherwise this function asserts: it logs an explanation to the system log and
- * terminates the application.
- *
- * Passing the result of dispatch_get_main_queue() to this function verifies
- * that the current block was submitted to the main queue, or to a queue
- * targeting it, or is running on the main thread (in any context).
- *
- * When dispatch_assert_queue() is called outside of the context of a
- * submitted block (for example from the context of a thread created manually
- * with pthread_create()) then this function will also assert and terminate
- * the application.
- *
- * The variant dispatch_assert_queue_debug() is compiled out when the
- * preprocessor macro NDEBUG is defined. (See also assert(3)).
- *
- * @param queue
- * The dispatch queue that the current block is expected to run on.
- * The result of passing NULL in this parameter is undefined.
- */
-API_AVAILABLE(macos(10.12), ios(10.0), tvos(10.0), watchos(3.0))
-DISPATCH_EXPORT DISPATCH_NONNULL1
-void
-dispatch_assert_queue(dispatch_queue_t queue)
-		DISPATCH_ALIAS_V2(dispatch_assert_queue);
-
-/*!
- * @function dispatch_assert_queue_barrier
- *
- * @abstract
- * Verifies that the current block is executing on a given dispatch queue,
- * and that the block acts as a barrier on that queue.
- *
- * @discussion
- * This behaves exactly like dispatch_assert_queue(), with the additional check
- * that the current block acts as a barrier on the specified queue, which is
- * always true if the specified queue is serial (see DISPATCH_BLOCK_BARRIER or
- * dispatch_barrier_async() for details).
- *
- * The variant dispatch_assert_queue_barrier_debug() is compiled out when the
- * preprocessor macro NDEBUG is defined. (See also assert()).
- *
- * @param queue
- * The dispatch queue that the current block is expected to run as a barrier on.
- * The result of passing NULL in this parameter is undefined.
- */
-API_AVAILABLE(macos(10.12), ios(10.0), tvos(10.0), watchos(3.0))
-DISPATCH_EXPORT DISPATCH_NONNULL1
-void
-dispatch_assert_queue_barrier(dispatch_queue_t queue);
-
-/*!
- * @function dispatch_assert_queue_not
- *
- * @abstract
- * Verifies that the current block is not executing on a given dispatch queue.
- *
- * @discussion
- * This function is the equivalent of dispatch_assert_queue() with the test for
- * equality inverted. That means that it will terminate the application when
- * dispatch_assert_queue() would return, and vice-versa. See discussion there.
- *
- * The variant dispatch_assert_queue_not_debug() is compiled out when the
- * preprocessor macro NDEBUG is defined. (See also assert(3)).
- *
- * @param queue
- * The dispatch queue that the current block is expected not to run on.
- * The result of passing NULL in this parameter is undefined.
- */
-API_AVAILABLE(macos(10.12), ios(10.0), tvos(10.0), watchos(3.0))
-DISPATCH_EXPORT DISPATCH_NONNULL1
-void
-dispatch_assert_queue_not(dispatch_queue_t queue)
-		DISPATCH_ALIAS_V2(dispatch_assert_queue_not);
-
-#ifdef NDEBUG
-#define dispatch_assert_queue_debug(q) ((void)(0 && (q)))
-#define dispatch_assert_queue_barrier_debug(q) ((void)(0 && (q)))
-#define dispatch_assert_queue_not_debug(q) ((void)(0 && (q)))
-#else
-#define dispatch_assert_queue_debug(q) dispatch_assert_queue(q)
-#define dispatch_assert_queue_barrier_debug(q) dispatch_assert_queue_barrier(q)
-#define dispatch_assert_queue_not_debug(q) dispatch_assert_queue_not(q)
-#endif
-
-__END_DECLS
-
-DISPATCH_ASSUME_NONNULL_END
-
-#endif
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/dispatch/semaphore.h b/lib/libc/include/x86_64-macos-gnu/dispatch/semaphore.h
deleted file mode 100644
index 156fb800f3..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/dispatch/semaphore.h
+++ /dev/null
@@ -1,117 +0,0 @@
-/*
- * Copyright (c) 2008-2013 Apple Inc. All rights reserved.
- *
- * @APPLE_APACHE_LICENSE_HEADER_START@
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @APPLE_APACHE_LICENSE_HEADER_END@
- */
-
-#ifndef __DISPATCH_SEMAPHORE__
-#define __DISPATCH_SEMAPHORE__
-
-#ifndef __DISPATCH_INDIRECT__
-#error "Please #include <dispatch/dispatch.h> instead of this file directly."
-#include <dispatch/base.h> // for HeaderDoc
-#endif
-
-DISPATCH_ASSUME_NONNULL_BEGIN
-
-/*!
- * @typedef dispatch_semaphore_t
- *
- * @abstract
- * A counting semaphore.
- */
-DISPATCH_DECL(dispatch_semaphore);
-
-__BEGIN_DECLS
-
-/*!
- * @function dispatch_semaphore_create
- *
- * @abstract
- * Creates new counting semaphore with an initial value.
- *
- * @discussion
- * Passing zero for the value is useful for when two threads need to reconcile
- * the completion of a particular event. Passing a value greater than zero is
- * useful for managing a finite pool of resources, where the pool size is equal
- * to the value.
- *
- * @param value
- * The starting value for the semaphore. Passing a value less than zero will
- * cause NULL to be returned.
- *
- * @result
- * The newly created semaphore, or NULL on failure.
- */
-API_AVAILABLE(macos(10.6), ios(4.0))
-DISPATCH_EXPORT DISPATCH_MALLOC DISPATCH_RETURNS_RETAINED DISPATCH_WARN_RESULT
-DISPATCH_NOTHROW
-dispatch_semaphore_t
-dispatch_semaphore_create(long value);
-
-/*!
- * @function dispatch_semaphore_wait
- *
- * @abstract
- * Wait (decrement) for a semaphore.
- *
- * @discussion
- * Decrement the counting semaphore. If the resulting value is less than zero,
- * this function waits for a signal to occur before returning.
- *
- * @param dsema
- * The semaphore. The result of passing NULL in this parameter is undefined.
- *
- * @param timeout
- * When to timeout (see dispatch_time). As a convenience, there are the
- * DISPATCH_TIME_NOW and DISPATCH_TIME_FOREVER constants.
- *
- * @result
- * Returns zero on success, or non-zero if the timeout occurred.
- */
-API_AVAILABLE(macos(10.6), ios(4.0))
-DISPATCH_EXPORT DISPATCH_NONNULL_ALL DISPATCH_NOTHROW
-long
-dispatch_semaphore_wait(dispatch_semaphore_t dsema, dispatch_time_t timeout);
-
-/*!
- * @function dispatch_semaphore_signal
- *
- * @abstract
- * Signal (increment) a semaphore.
- *
- * @discussion
- * Increment the counting semaphore. If the previous value was less than zero,
- * this function wakes a waiting thread before returning.
- *
- * @param dsema The counting semaphore.
- * The result of passing NULL in this parameter is undefined.
- *
- * @result
- * This function returns non-zero if a thread is woken. Otherwise, zero is
- * returned.
- */
-API_AVAILABLE(macos(10.6), ios(4.0))
-DISPATCH_EXPORT DISPATCH_NONNULL_ALL DISPATCH_NOTHROW
-long
-dispatch_semaphore_signal(dispatch_semaphore_t dsema);
-
-__END_DECLS
-
-DISPATCH_ASSUME_NONNULL_END
-
-#endif /* __DISPATCH_SEMAPHORE__ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/dispatch/source.h b/lib/libc/include/x86_64-macos-gnu/dispatch/source.h
deleted file mode 100644
index 968b9ff89e..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/dispatch/source.h
+++ /dev/null
@@ -1,780 +0,0 @@
-/*
- * Copyright (c) 2008-2013 Apple Inc. All rights reserved.
- *
- * @APPLE_APACHE_LICENSE_HEADER_START@
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @APPLE_APACHE_LICENSE_HEADER_END@
- */
-
-#ifndef __DISPATCH_SOURCE__
-#define __DISPATCH_SOURCE__
-
-#ifndef __DISPATCH_INDIRECT__
-#error "Please #include <dispatch/dispatch.h> instead of this file directly."
-#include <dispatch/base.h> // for HeaderDoc
-#endif
-
-#if TARGET_OS_MAC
-#include <mach/port.h>
-#include <mach/message.h>
-#endif
-
-#if !defined(_WIN32)
-#include <sys/signal.h>
-#endif
-
-DISPATCH_ASSUME_NONNULL_BEGIN
-
-/*!
- * @header
- * The dispatch framework provides a suite of interfaces for monitoring low-
- * level system objects (file descriptors, Mach ports, signals, VFS nodes, etc.)
- * for activity and automatically submitting event handler blocks to dispatch
- * queues when such activity occurs.
- *
- * This suite of interfaces is known as the Dispatch Source API.
- */
-
-/*!
- * @typedef dispatch_source_t
- *
- * @abstract
- * Dispatch sources are used to automatically submit event handler blocks to
- * dispatch queues in response to external events.
- */
-DISPATCH_SOURCE_DECL(dispatch_source);
-
-__BEGIN_DECLS
-
-/*!
- * @typedef dispatch_source_type_t
- *
- * @abstract
- * Constants of this type represent the class of low-level system object that
- * is being monitored by the dispatch source. Constants of this type are
- * passed as a parameter to dispatch_source_create() and determine how the
- * handle argument is interpreted (i.e. as a file descriptor, mach port,
- * signal number, process identifier, etc.), and how the mask argument is
- * interpreted.
- */
-typedef const struct dispatch_source_type_s *dispatch_source_type_t;
-
-/*!
- * @const DISPATCH_SOURCE_TYPE_DATA_ADD
- * @discussion A dispatch source that coalesces data obtained via calls to
- * dispatch_source_merge_data(). An ADD is used to coalesce the data.
- * The handle is unused (pass zero for now).
- * The mask is unused (pass zero for now).
- */
-#define DISPATCH_SOURCE_TYPE_DATA_ADD (&_dispatch_source_type_data_add)
-API_AVAILABLE(macos(10.6), ios(4.0))
-DISPATCH_SOURCE_TYPE_DECL(data_add);
-
-/*!
- * @const DISPATCH_SOURCE_TYPE_DATA_OR
- * @discussion A dispatch source that coalesces data obtained via calls to
- * dispatch_source_merge_data(). A bitwise OR is used to coalesce the data.
- * The handle is unused (pass zero for now).
- * The mask is unused (pass zero for now).
- */
-#define DISPATCH_SOURCE_TYPE_DATA_OR (&_dispatch_source_type_data_or)
-API_AVAILABLE(macos(10.6), ios(4.0))
-DISPATCH_SOURCE_TYPE_DECL(data_or);
-
-/*!
- * @const DISPATCH_SOURCE_TYPE_DATA_REPLACE
- * @discussion A dispatch source that tracks data obtained via calls to
- * dispatch_source_merge_data(). Newly obtained data values replace existing
- * data values not yet delivered to the source handler
- *
- * A data value of zero will cause the source handler to not be invoked.
- *
- * The handle is unused (pass zero for now).
- * The mask is unused (pass zero for now).
- */
-#define DISPATCH_SOURCE_TYPE_DATA_REPLACE (&_dispatch_source_type_data_replace)
-API_AVAILABLE(macos(10.13), ios(11.0), tvos(11.0), watchos(4.0))
-DISPATCH_SOURCE_TYPE_DECL(data_replace);
-
-/*!
- * @const DISPATCH_SOURCE_TYPE_MACH_SEND
- * @discussion A dispatch source that monitors a Mach port for dead name
- * notifications (send right no longer has any corresponding receive right).
- * The handle is a Mach port with a send or send-once right (mach_port_t).
- * The mask is a mask of desired events from dispatch_source_mach_send_flags_t.
- */
-#define DISPATCH_SOURCE_TYPE_MACH_SEND (&_dispatch_source_type_mach_send)
-API_AVAILABLE(macos(10.6), ios(4.0)) DISPATCH_LINUX_UNAVAILABLE()
-DISPATCH_SOURCE_TYPE_DECL(mach_send);
-
-/*!
- * @const DISPATCH_SOURCE_TYPE_MACH_RECV
- * @discussion A dispatch source that monitors a Mach port for pending messages.
- * The handle is a Mach port with a receive right (mach_port_t).
- * The mask is a mask of desired events from dispatch_source_mach_recv_flags_t,
- * but no flags are currently defined (pass zero for now).
- */
-#define DISPATCH_SOURCE_TYPE_MACH_RECV (&_dispatch_source_type_mach_recv)
-API_AVAILABLE(macos(10.6), ios(4.0)) DISPATCH_LINUX_UNAVAILABLE()
-DISPATCH_SOURCE_TYPE_DECL(mach_recv);
-
-/*!
- * @const DISPATCH_SOURCE_TYPE_MEMORYPRESSURE
- * @discussion A dispatch source that monitors the system for changes in
- * memory pressure condition.
- * The handle is unused (pass zero for now).
- * The mask is a mask of desired events from
- * dispatch_source_memorypressure_flags_t.
- */
-#define DISPATCH_SOURCE_TYPE_MEMORYPRESSURE \
-		(&_dispatch_source_type_memorypressure)
-API_AVAILABLE(macos(10.9), ios(8.0)) DISPATCH_LINUX_UNAVAILABLE()
-DISPATCH_SOURCE_TYPE_DECL(memorypressure);
-
-/*!
- * @const DISPATCH_SOURCE_TYPE_PROC
- * @discussion A dispatch source that monitors an external process for events
- * defined by dispatch_source_proc_flags_t.
- * The handle is a process identifier (pid_t).
- * The mask is a mask of desired events from dispatch_source_proc_flags_t.
- */
-#define DISPATCH_SOURCE_TYPE_PROC (&_dispatch_source_type_proc)
-API_AVAILABLE(macos(10.6), ios(4.0)) DISPATCH_LINUX_UNAVAILABLE()
-DISPATCH_SOURCE_TYPE_DECL(proc);
-
-/*!
- * @const DISPATCH_SOURCE_TYPE_READ
- * @discussion A dispatch source that monitors a file descriptor for pending
- * bytes available to be read.
- * The handle is a file descriptor (int).
- * The mask is unused (pass zero for now).
- */
-#define DISPATCH_SOURCE_TYPE_READ (&_dispatch_source_type_read)
-API_AVAILABLE(macos(10.6), ios(4.0))
-DISPATCH_SOURCE_TYPE_DECL(read);
-
-/*!
- * @const DISPATCH_SOURCE_TYPE_SIGNAL
- * @discussion A dispatch source that monitors the current process for signals.
- * The handle is a signal number (int).
- * The mask is unused (pass zero for now).
- */
-#define DISPATCH_SOURCE_TYPE_SIGNAL (&_dispatch_source_type_signal)
-API_AVAILABLE(macos(10.6), ios(4.0))
-DISPATCH_SOURCE_TYPE_DECL(signal);
-
-/*!
- * @const DISPATCH_SOURCE_TYPE_TIMER
- * @discussion A dispatch source that submits the event handler block based
- * on a timer.
- * The handle is unused (pass zero for now).
- * The mask specifies which flags from dispatch_source_timer_flags_t to apply.
- */
-#define DISPATCH_SOURCE_TYPE_TIMER (&_dispatch_source_type_timer)
-API_AVAILABLE(macos(10.6), ios(4.0))
-DISPATCH_SOURCE_TYPE_DECL(timer);
-
-/*!
- * @const DISPATCH_SOURCE_TYPE_VNODE
- * @discussion A dispatch source that monitors a file descriptor for events
- * defined by dispatch_source_vnode_flags_t.
- * The handle is a file descriptor (int).
- * The mask is a mask of desired events from dispatch_source_vnode_flags_t.
- */
-#define DISPATCH_SOURCE_TYPE_VNODE (&_dispatch_source_type_vnode)
-API_AVAILABLE(macos(10.6), ios(4.0)) DISPATCH_LINUX_UNAVAILABLE()
-DISPATCH_SOURCE_TYPE_DECL(vnode);
-
-/*!
- * @const DISPATCH_SOURCE_TYPE_WRITE
- * @discussion A dispatch source that monitors a file descriptor for available
- * buffer space to write bytes.
- * The handle is a file descriptor (int).
- * The mask is unused (pass zero for now).
- */
-#define DISPATCH_SOURCE_TYPE_WRITE (&_dispatch_source_type_write)
-API_AVAILABLE(macos(10.6), ios(4.0))
-DISPATCH_SOURCE_TYPE_DECL(write);
-
-/*!
- * @typedef dispatch_source_mach_send_flags_t
- * Type of dispatch_source_mach_send flags
- *
- * @constant DISPATCH_MACH_SEND_DEAD
- * The receive right corresponding to the given send right was destroyed.
- */
-#define DISPATCH_MACH_SEND_DEAD	0x1
-
-typedef unsigned long dispatch_source_mach_send_flags_t;
-
-/*!
- * @typedef dispatch_source_mach_recv_flags_t
- * Type of dispatch_source_mach_recv flags
- */
-typedef unsigned long dispatch_source_mach_recv_flags_t;
-
-/*!
- * @typedef dispatch_source_memorypressure_flags_t
- * Type of dispatch_source_memorypressure flags
- *
- * @constant DISPATCH_MEMORYPRESSURE_NORMAL
- * The system memory pressure condition has returned to normal.
- *
- * @constant DISPATCH_MEMORYPRESSURE_WARN
- * The system memory pressure condition has changed to warning.
- *
- * @constant DISPATCH_MEMORYPRESSURE_CRITICAL
- * The system memory pressure condition has changed to critical.
- *
- * @discussion
- * Elevated memory pressure is a system-wide condition that applications
- * registered for this source should react to by changing their future memory
- * use behavior, e.g. by reducing cache sizes of newly initiated operations
- * until memory pressure returns back to normal.
- * NOTE: applications should NOT traverse and discard existing caches for past
- * operations when the system memory pressure enters an elevated state, as that
- * is likely to trigger VM operations that will further aggravate system memory
- * pressure.
- */
-
-#define DISPATCH_MEMORYPRESSURE_NORMAL		0x01
-#define DISPATCH_MEMORYPRESSURE_WARN		0x02
-#define DISPATCH_MEMORYPRESSURE_CRITICAL	0x04
-
-typedef unsigned long dispatch_source_memorypressure_flags_t;
-
-/*!
- * @typedef dispatch_source_proc_flags_t
- * Type of dispatch_source_proc flags
- *
- * @constant DISPATCH_PROC_EXIT
- * The process has exited (perhaps cleanly, perhaps not).
- *
- * @constant DISPATCH_PROC_FORK
- * The process has created one or more child processes.
- *
- * @constant DISPATCH_PROC_EXEC
- * The process has become another executable image via
- * exec*() or posix_spawn*().
- *
- * @constant DISPATCH_PROC_SIGNAL
- * A Unix signal was delivered to the process.
- */
-#define DISPATCH_PROC_EXIT		0x80000000
-#define DISPATCH_PROC_FORK		0x40000000
-#define DISPATCH_PROC_EXEC		0x20000000
-#define DISPATCH_PROC_SIGNAL	0x08000000
-
-typedef unsigned long dispatch_source_proc_flags_t;
-
-/*!
- * @typedef dispatch_source_vnode_flags_t
- * Type of dispatch_source_vnode flags
- *
- * @constant DISPATCH_VNODE_DELETE
- * The filesystem object was deleted from the namespace.
- *
- * @constant DISPATCH_VNODE_WRITE
- * The filesystem object data changed.
- *
- * @constant DISPATCH_VNODE_EXTEND
- * The filesystem object changed in size.
- *
- * @constant DISPATCH_VNODE_ATTRIB
- * The filesystem object metadata changed.
- *
- * @constant DISPATCH_VNODE_LINK
- * The filesystem object link count changed.
- *
- * @constant DISPATCH_VNODE_RENAME
- * The filesystem object was renamed in the namespace.
- *
- * @constant DISPATCH_VNODE_REVOKE
- * The filesystem object was revoked.
- *
- * @constant DISPATCH_VNODE_FUNLOCK
- * The filesystem object was unlocked.
- */
-
-#define DISPATCH_VNODE_DELETE	0x1
-#define DISPATCH_VNODE_WRITE	0x2
-#define DISPATCH_VNODE_EXTEND	0x4
-#define DISPATCH_VNODE_ATTRIB	0x8
-#define DISPATCH_VNODE_LINK		0x10
-#define DISPATCH_VNODE_RENAME	0x20
-#define DISPATCH_VNODE_REVOKE	0x40
-#define DISPATCH_VNODE_FUNLOCK	0x100
-
-typedef unsigned long dispatch_source_vnode_flags_t;
-
-/*!
- * @typedef dispatch_source_timer_flags_t
- * Type of dispatch_source_timer flags
- *
- * @constant DISPATCH_TIMER_STRICT
- * Specifies that the system should make a best effort to strictly observe the
- * leeway value specified for the timer via dispatch_source_set_timer(), even
- * if that value is smaller than the default leeway value that would be applied
- * to the timer otherwise. A minimal amount of leeway will be applied to the
- * timer even if this flag is specified.
- *
- * CAUTION: Use of this flag may override power-saving techniques employed by
- * the system and cause higher power consumption, so it must be used with care
- * and only when absolutely necessary.
- */
-
-#define DISPATCH_TIMER_STRICT 0x1
-
-typedef unsigned long dispatch_source_timer_flags_t;
-
-/*!
- * @function dispatch_source_create
- *
- * @abstract
- * Creates a new dispatch source to monitor low-level system objects and auto-
- * matically submit a handler block to a dispatch queue in response to events.
- *
- * @discussion
- * Dispatch sources are not reentrant. Any events received while the dispatch
- * source is suspended or while the event handler block is currently executing
- * will be coalesced and delivered after the dispatch source is resumed or the
- * event handler block has returned.
- *
- * Dispatch sources are created in an inactive state. After creating the
- * source and setting any desired attributes (i.e. the handler, context, etc.),
- * a call must be made to dispatch_activate() in order to begin event delivery.
- *
- * Calling dispatch_set_target_queue() on a source once it has been activated
- * is not allowed (see dispatch_activate() and dispatch_set_target_queue()).
- *
- * For backward compatibility reasons, dispatch_resume() on an inactive,
- * and not otherwise suspended source has the same effect as calling
- * dispatch_activate(). For new code, using dispatch_activate() is preferred.
- *
- * @param type
- * Declares the type of the dispatch source. Must be one of the defined
- * dispatch_source_type_t constants.
- *
- * @param handle
- * The underlying system handle to monitor. The interpretation of this argument
- * is determined by the constant provided in the type parameter.
- *
- * @param mask
- * A mask of flags specifying which events are desired. The interpretation of
- * this argument is determined by the constant provided in the type parameter.
- *
- * @param queue
- * The dispatch queue to which the event handler block will be submitted.
- * If queue is DISPATCH_TARGET_QUEUE_DEFAULT, the source will submit the event
- * handler block to the default priority global queue.
- *
- * @result
- * The newly created dispatch source. Or NULL if invalid arguments are passed.
- */
-API_AVAILABLE(macos(10.6), ios(4.0))
-DISPATCH_EXPORT DISPATCH_MALLOC DISPATCH_RETURNS_RETAINED DISPATCH_WARN_RESULT
-DISPATCH_NOTHROW
-dispatch_source_t
-dispatch_source_create(dispatch_source_type_t type,
-	uintptr_t handle,
-	unsigned long mask,
-	dispatch_queue_t _Nullable queue);
-
-/*!
- * @function dispatch_source_set_event_handler
- *
- * @abstract
- * Sets the event handler block for the given dispatch source.
- *
- * @param source
- * The dispatch source to modify.
- * The result of passing NULL in this parameter is undefined.
- *
- * @param handler
- * The event handler block to submit to the source's target queue.
- */
-#ifdef __BLOCKS__
-API_AVAILABLE(macos(10.6), ios(4.0))
-DISPATCH_EXPORT DISPATCH_NONNULL1 DISPATCH_NOTHROW
-void
-dispatch_source_set_event_handler(dispatch_source_t source,
-	dispatch_block_t _Nullable handler);
-#endif /* __BLOCKS__ */
-
-/*!
- * @function dispatch_source_set_event_handler_f
- *
- * @abstract
- * Sets the event handler function for the given dispatch source.
- *
- * @param source
- * The dispatch source to modify.
- * The result of passing NULL in this parameter is undefined.
- *
- * @param handler
- * The event handler function to submit to the source's target queue.
- * The context parameter passed to the event handler function is the context of
- * the dispatch source current at the time the event handler was set.
- */
-API_AVAILABLE(macos(10.6), ios(4.0))
-DISPATCH_EXPORT DISPATCH_NONNULL1 DISPATCH_NOTHROW
-void
-dispatch_source_set_event_handler_f(dispatch_source_t source,
-	dispatch_function_t _Nullable handler);
-
-/*!
- * @function dispatch_source_set_cancel_handler
- *
- * @abstract
- * Sets the cancellation handler block for the given dispatch source.
- *
- * @discussion
- * The cancellation handler (if specified) will be submitted to the source's
- * target queue in response to a call to dispatch_source_cancel() once the
- * system has released all references to the source's underlying handle and
- * the source's event handler block has returned.
- *
- * IMPORTANT:
- * Source cancellation and a cancellation handler are required for file
- * descriptor and mach port based sources in order to safely close the
- * descriptor or destroy the port.
- * Closing the descriptor or port before the cancellation handler is invoked may
- * result in a race condition. If a new descriptor is allocated with the same
- * value as the recently closed descriptor while the source's event handler is
- * still running, the event handler may read/write data to the wrong descriptor.
- *
- * @param source
- * The dispatch source to modify.
- * The result of passing NULL in this parameter is undefined.
- *
- * @param handler
- * The cancellation handler block to submit to the source's target queue.
- */
-#ifdef __BLOCKS__
-API_AVAILABLE(macos(10.6), ios(4.0))
-DISPATCH_EXPORT DISPATCH_NONNULL1 DISPATCH_NOTHROW
-void
-dispatch_source_set_cancel_handler(dispatch_source_t source,
-	dispatch_block_t _Nullable handler);
-#endif /* __BLOCKS__ */
-
-/*!
- * @function dispatch_source_set_cancel_handler_f
- *
- * @abstract
- * Sets the cancellation handler function for the given dispatch source.
- *
- * @discussion
- * See dispatch_source_set_cancel_handler() for more details.
- *
- * @param source
- * The dispatch source to modify.
- * The result of passing NULL in this parameter is undefined.
- *
- * @param handler
- * The cancellation handler function to submit to the source's target queue.
- * The context parameter passed to the event handler function is the current
- * context of the dispatch source at the time the handler call is made.
- */
-API_AVAILABLE(macos(10.6), ios(4.0))
-DISPATCH_EXPORT DISPATCH_NONNULL1 DISPATCH_NOTHROW
-void
-dispatch_source_set_cancel_handler_f(dispatch_source_t source,
-	dispatch_function_t _Nullable handler);
-
-/*!
- * @function dispatch_source_cancel
- *
- * @abstract
- * Asynchronously cancel the dispatch source, preventing any further invocation
- * of its event handler block.
- *
- * @discussion
- * Cancellation prevents any further invocation of the event handler block for
- * the specified dispatch source, but does not interrupt an event handler
- * block that is already in progress.
- *
- * The cancellation handler is submitted to the source's target queue once the
- * the source's event handler has finished, indicating it is now safe to close
- * the source's handle (i.e. file descriptor or mach port).
- *
- * See dispatch_source_set_cancel_handler() for more information.
- *
- * @param source
- * The dispatch source to be canceled.
- * The result of passing NULL in this parameter is undefined.
- */
-API_AVAILABLE(macos(10.6), ios(4.0))
-DISPATCH_EXPORT DISPATCH_NONNULL_ALL DISPATCH_NOTHROW
-void
-dispatch_source_cancel(dispatch_source_t source);
-
-/*!
- * @function dispatch_source_testcancel
- *
- * @abstract
- * Tests whether the given dispatch source has been canceled.
- *
- * @param source
- * The dispatch source to be tested.
- * The result of passing NULL in this parameter is undefined.
- *
- * @result
- * Non-zero if canceled and zero if not canceled.
- */
-API_AVAILABLE(macos(10.6), ios(4.0))
-DISPATCH_EXPORT DISPATCH_NONNULL_ALL DISPATCH_WARN_RESULT DISPATCH_PURE
-DISPATCH_NOTHROW
-long
-dispatch_source_testcancel(dispatch_source_t source);
-
-/*!
- * @function dispatch_source_get_handle
- *
- * @abstract
- * Returns the underlying system handle associated with this dispatch source.
- *
- * @param source
- * The result of passing NULL in this parameter is undefined.
- *
- * @result
- * The return value should be interpreted according to the type of the dispatch
- * source, and may be one of the following handles:
- *
- *  DISPATCH_SOURCE_TYPE_DATA_ADD:        n/a
- *  DISPATCH_SOURCE_TYPE_DATA_OR:         n/a
- *  DISPATCH_SOURCE_TYPE_DATA_REPLACE:    n/a
- *  DISPATCH_SOURCE_TYPE_MACH_SEND:       mach port (mach_port_t)
- *  DISPATCH_SOURCE_TYPE_MACH_RECV:       mach port (mach_port_t)
- *  DISPATCH_SOURCE_TYPE_MEMORYPRESSURE   n/a
- *  DISPATCH_SOURCE_TYPE_PROC:            process identifier (pid_t)
- *  DISPATCH_SOURCE_TYPE_READ:            file descriptor (int)
- *  DISPATCH_SOURCE_TYPE_SIGNAL:          signal number (int)
- *  DISPATCH_SOURCE_TYPE_TIMER:           n/a
- *  DISPATCH_SOURCE_TYPE_VNODE:           file descriptor (int)
- *  DISPATCH_SOURCE_TYPE_WRITE:           file descriptor (int)
- */
-API_AVAILABLE(macos(10.6), ios(4.0))
-DISPATCH_EXPORT DISPATCH_NONNULL_ALL DISPATCH_WARN_RESULT DISPATCH_PURE
-DISPATCH_NOTHROW
-uintptr_t
-dispatch_source_get_handle(dispatch_source_t source);
-
-/*!
- * @function dispatch_source_get_mask
- *
- * @abstract
- * Returns the mask of events monitored by the dispatch source.
- *
- * @param source
- * The result of passing NULL in this parameter is undefined.
- *
- * @result
- * The return value should be interpreted according to the type of the dispatch
- * source, and may be one of the following flag sets:
- *
- *  DISPATCH_SOURCE_TYPE_DATA_ADD:        n/a
- *  DISPATCH_SOURCE_TYPE_DATA_OR:         n/a
- *  DISPATCH_SOURCE_TYPE_DATA_REPLACE:    n/a
- *  DISPATCH_SOURCE_TYPE_MACH_SEND:       dispatch_source_mach_send_flags_t
- *  DISPATCH_SOURCE_TYPE_MACH_RECV:       dispatch_source_mach_recv_flags_t
- *  DISPATCH_SOURCE_TYPE_MEMORYPRESSURE   dispatch_source_memorypressure_flags_t
- *  DISPATCH_SOURCE_TYPE_PROC:            dispatch_source_proc_flags_t
- *  DISPATCH_SOURCE_TYPE_READ:            n/a
- *  DISPATCH_SOURCE_TYPE_SIGNAL:          n/a
- *  DISPATCH_SOURCE_TYPE_TIMER:           dispatch_source_timer_flags_t
- *  DISPATCH_SOURCE_TYPE_VNODE:           dispatch_source_vnode_flags_t
- *  DISPATCH_SOURCE_TYPE_WRITE:           n/a
- */
-API_AVAILABLE(macos(10.6), ios(4.0))
-DISPATCH_EXPORT DISPATCH_NONNULL_ALL DISPATCH_WARN_RESULT DISPATCH_PURE
-DISPATCH_NOTHROW
-unsigned long
-dispatch_source_get_mask(dispatch_source_t source);
-
-/*!
- * @function dispatch_source_get_data
- *
- * @abstract
- * Returns pending data for the dispatch source.
- *
- * @discussion
- * This function is intended to be called from within the event handler block.
- * The result of calling this function outside of the event handler callback is
- * undefined.
- *
- * @param source
- * The result of passing NULL in this parameter is undefined.
- *
- * @result
- * The return value should be interpreted according to the type of the dispatch
- * source, and may be one of the following:
- *
- *  DISPATCH_SOURCE_TYPE_DATA_ADD:        application defined data
- *  DISPATCH_SOURCE_TYPE_DATA_OR:         application defined data
- *  DISPATCH_SOURCE_TYPE_DATA_REPLACE:    application defined data
- *  DISPATCH_SOURCE_TYPE_MACH_SEND:       dispatch_source_mach_send_flags_t
- *  DISPATCH_SOURCE_TYPE_MACH_RECV:       dispatch_source_mach_recv_flags_t
- *  DISPATCH_SOURCE_TYPE_MEMORYPRESSURE   dispatch_source_memorypressure_flags_t
- *  DISPATCH_SOURCE_TYPE_PROC:            dispatch_source_proc_flags_t
- *  DISPATCH_SOURCE_TYPE_READ:            estimated bytes available to read
- *  DISPATCH_SOURCE_TYPE_SIGNAL:          number of signals delivered since
- *                                            the last handler invocation
- *  DISPATCH_SOURCE_TYPE_TIMER:           number of times the timer has fired
- *                                            since the last handler invocation
- *  DISPATCH_SOURCE_TYPE_VNODE:           dispatch_source_vnode_flags_t
- *  DISPATCH_SOURCE_TYPE_WRITE:           estimated buffer space available
- */
-API_AVAILABLE(macos(10.6), ios(4.0))
-DISPATCH_EXPORT DISPATCH_NONNULL_ALL DISPATCH_WARN_RESULT DISPATCH_PURE
-DISPATCH_NOTHROW
-unsigned long
-dispatch_source_get_data(dispatch_source_t source);
-
-/*!
- * @function dispatch_source_merge_data
- *
- * @abstract
- * Merges data into a dispatch source of type DISPATCH_SOURCE_TYPE_DATA_ADD,
- * DISPATCH_SOURCE_TYPE_DATA_OR or DISPATCH_SOURCE_TYPE_DATA_REPLACE,
- * and submits its event handler block to its target queue.
- *
- * @param source
- * The result of passing NULL in this parameter is undefined.
- *
- * @param value
- * The value to coalesce with the pending data using a logical OR or an ADD
- * as specified by the dispatch source type. A value of zero has no effect
- * and will not result in the submission of the event handler block.
- */
-API_AVAILABLE(macos(10.6), ios(4.0))
-DISPATCH_EXPORT DISPATCH_NONNULL_ALL DISPATCH_NOTHROW
-void
-dispatch_source_merge_data(dispatch_source_t source, unsigned long value);
-
-/*!
- * @function dispatch_source_set_timer
- *
- * @abstract
- * Sets a start time, interval, and leeway value for a timer source.
- *
- * @discussion
- * Once this function returns, any pending source data accumulated for the
- * previous timer values has been cleared; the next fire of the timer will
- * occur at 'start', and every 'interval' nanoseconds thereafter until the
- * timer source is canceled.
- *
- * Any fire of the timer may be delayed by the system in order to improve power
- * consumption and system performance. The upper limit to the allowable delay
- * may be configured with the 'leeway' argument, the lower limit is under the
- * control of the system.
- *
- * For the initial timer fire at 'start', the upper limit to the allowable
- * delay is set to 'leeway' nanoseconds. For the subsequent timer fires at
- * 'start' + N * 'interval', the upper limit is MIN('leeway','interval'/2).
- *
- * The lower limit to the allowable delay may vary with process state such as
- * visibility of application UI. If the specified timer source was created with
- * a mask of DISPATCH_TIMER_STRICT, the system will make a best effort to
- * strictly observe the provided 'leeway' value even if it is smaller than the
- * current lower limit. Note that a minimal amount of delay is to be expected
- * even if this flag is specified.
- *
- * The 'start' argument also determines which clock will be used for the timer:
- * If 'start' is DISPATCH_TIME_NOW or was created with dispatch_time(3), the
- * timer is based on up time (which is obtained from mach_absolute_time() on
- * Apple platforms). If 'start' was created with dispatch_walltime(3), the
- * timer is based on gettimeofday(3).
- *
- * Calling this function has no effect if the timer source has already been
- * canceled.
- *
- * @param start
- * The start time of the timer. See dispatch_time() and dispatch_walltime()
- * for more information.
- *
- * @param interval
- * The nanosecond interval for the timer. Use DISPATCH_TIME_FOREVER for a
- * one-shot timer.
- *
- * @param leeway
- * The nanosecond leeway for the timer.
- */
-API_AVAILABLE(macos(10.6), ios(4.0))
-DISPATCH_EXPORT DISPATCH_NONNULL_ALL DISPATCH_NOTHROW
-void
-dispatch_source_set_timer(dispatch_source_t source,
-	dispatch_time_t start,
-	uint64_t interval,
-	uint64_t leeway);
-
-/*!
- * @function dispatch_source_set_registration_handler
- *
- * @abstract
- * Sets the registration handler block for the given dispatch source.
- *
- * @discussion
- * The registration handler (if specified) will be submitted to the source's
- * target queue once the corresponding kevent() has been registered with the
- * system, following the initial dispatch_resume() of the source.
- *
- * If a source is already registered when the registration handler is set, the
- * registration handler will be invoked immediately.
- *
- * @param source
- * The dispatch source to modify.
- * The result of passing NULL in this parameter is undefined.
- *
- * @param handler
- * The registration handler block to submit to the source's target queue.
- */
-#ifdef __BLOCKS__
-API_AVAILABLE(macos(10.7), ios(4.3))
-DISPATCH_EXPORT DISPATCH_NONNULL1 DISPATCH_NOTHROW
-void
-dispatch_source_set_registration_handler(dispatch_source_t source,
-	dispatch_block_t _Nullable handler);
-#endif /* __BLOCKS__ */
-
-/*!
- * @function dispatch_source_set_registration_handler_f
- *
- * @abstract
- * Sets the registration handler function for the given dispatch source.
- *
- * @discussion
- * See dispatch_source_set_registration_handler() for more details.
- *
- * @param source
- * The dispatch source to modify.
- * The result of passing NULL in this parameter is undefined.
- *
- * @param handler
- * The registration handler function to submit to the source's target queue.
- * The context parameter passed to the registration handler function is the
- * current context of the dispatch source at the time the handler call is made.
- */
-API_AVAILABLE(macos(10.7), ios(4.3))
-DISPATCH_EXPORT DISPATCH_NONNULL1 DISPATCH_NOTHROW
-void
-dispatch_source_set_registration_handler_f(dispatch_source_t source,
-	dispatch_function_t _Nullable handler);
-
-__END_DECLS
-
-DISPATCH_ASSUME_NONNULL_END
-
-#endif
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/dispatch/workloop.h b/lib/libc/include/x86_64-macos-gnu/dispatch/workloop.h
deleted file mode 100644
index dcd1db43cc..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/dispatch/workloop.h
+++ /dev/null
@@ -1,136 +0,0 @@
-/*
- * Copyright (c) 2017-2019 Apple Inc. All rights reserved.
- *
- * @APPLE_APACHE_LICENSE_HEADER_START@
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @APPLE_APACHE_LICENSE_HEADER_END@
- */
-
-#ifndef __DISPATCH_WORKLOOP__
-#define __DISPATCH_WORKLOOP__
-
-#ifndef __DISPATCH_INDIRECT__
-#error "Please #include <dispatch/dispatch.h> instead of this file directly."
-#include <dispatch/base.h> // for HeaderDoc
-#endif
-
-DISPATCH_ASSUME_NONNULL_BEGIN
-
-__BEGIN_DECLS
-
-/*!
- * @typedef dispatch_workloop_t
- *
- * @abstract
- * Dispatch workloops invoke workitems submitted to them in priority order.
- *
- * @discussion
- * A dispatch workloop is a flavor of dispatch_queue_t that is a priority
- * ordered queue (using the QOS class of the submitted workitems as the
- * ordering).
- *
- * Between each workitem invocation, the workloop will evaluate whether higher
- * priority workitems have since been submitted, either directly to the
- * workloop or to any queues that target the workloop, and execute these first.
- *
- * Serial queues targeting a workloop maintain FIFO execution of their
- * workitems. However, the workloop may reorder workitems submitted to
- * independent serial queues targeting it with respect to each other,
- * based on their priorities, while preserving FIFO execution with respect to
- * each serial queue.
- *
- * A dispatch workloop is a "subclass" of dispatch_queue_t which can be passed
- * to all APIs accepting a dispatch queue, except for functions from the
- * dispatch_sync() family. dispatch_async_and_wait() must be used for workloop
- * objects. Functions from the dispatch_sync() family on queues targeting
- * a workloop are still permitted but discouraged for performance reasons.
- */
-DISPATCH_DECL_SUBCLASS(dispatch_workloop, dispatch_queue);
-
-/*!
- * @function dispatch_workloop_create
- *
- * @abstract
- * Creates a new dispatch workloop to which workitems may be submitted.
- *
- * @param label
- * A string label to attach to the workloop.
- *
- * @result
- * The newly created dispatch workloop.
- */
-API_AVAILABLE(macos(10.14), ios(12.0), tvos(12.0), watchos(5.0))
-DISPATCH_EXPORT DISPATCH_MALLOC DISPATCH_RETURNS_RETAINED DISPATCH_WARN_RESULT
-DISPATCH_NOTHROW
-dispatch_workloop_t
-dispatch_workloop_create(const char *_Nullable label);
-
-/*!
- * @function dispatch_workloop_create_inactive
- *
- * @abstract
- * Creates a new inactive dispatch workloop that can be setup and then
- * activated.
- *
- * @discussion
- * Creating an inactive workloop allows for it to receive further configuration
- * before it is activated, and workitems can be submitted to it.
- *
- * Submitting workitems to an inactive workloop is undefined and will cause the
- * process to be terminated.
- *
- * @param label
- * A string label to attach to the workloop.
- *
- * @result
- * The newly created dispatch workloop.
- */
-API_AVAILABLE(macos(10.14), ios(12.0), tvos(12.0), watchos(5.0))
-DISPATCH_EXPORT DISPATCH_MALLOC DISPATCH_RETURNS_RETAINED DISPATCH_WARN_RESULT
-DISPATCH_NOTHROW
-dispatch_workloop_t
-dispatch_workloop_create_inactive(const char *_Nullable label);
-
-/*!
- * @function dispatch_workloop_set_autorelease_frequency
- *
- * @abstract
- * Sets the autorelease frequency of the workloop.
- *
- * @discussion
- * See dispatch_queue_attr_make_with_autorelease_frequency().
- * The default policy for a workloop is
- * DISPATCH_AUTORELEASE_FREQUENCY_WORK_ITEM.
- *
- * @param workloop
- * The dispatch workloop to modify.
- *
- * This workloop must be inactive, passing an activated object is undefined
- * and will cause the process to be terminated.
- *
- * @param frequency
- * The requested autorelease frequency.
- */
-API_AVAILABLE(macos(10.14), ios(12.0), tvos(12.0), watchos(5.0))
-DISPATCH_EXPORT DISPATCH_NONNULL_ALL DISPATCH_NOTHROW
-void
-dispatch_workloop_set_autorelease_frequency(dispatch_workloop_t workloop,
-		dispatch_autorelease_frequency_t frequency);
-
-__END_DECLS
-
-DISPATCH_ASSUME_NONNULL_END
-
-#endif
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/i386/_param.h b/lib/libc/include/x86_64-macos-gnu/i386/_param.h
index d8f7b3d4bf..b89bc39692 100644
--- a/lib/libc/include/x86_64-macos-gnu/i386/_param.h
+++ b/lib/libc/include/x86_64-macos-gnu/i386/_param.h
@@ -37,10 +37,10 @@
  * cast to any desired pointer type.
  */
 #define __DARWIN_ALIGNBYTES     (sizeof(__darwin_size_t) - 1)
-#define __DARWIN_ALIGN(p)       ((__darwin_size_t)((char *)(__darwin_size_t)(p) + __DARWIN_ALIGNBYTES) &~ __DARWIN_ALIGNBYTES)
+#define __DARWIN_ALIGN(p)       ((__darwin_size_t)((__darwin_size_t)(p) + __DARWIN_ALIGNBYTES) &~ __DARWIN_ALIGNBYTES)
 
 #define      __DARWIN_ALIGNBYTES32     (sizeof(__uint32_t) - 1)
-#define       __DARWIN_ALIGN32(p)       ((__darwin_size_t)((char *)(__darwin_size_t)(p) + __DARWIN_ALIGNBYTES32) &~ __DARWIN_ALIGNBYTES32)
+#define       __DARWIN_ALIGN32(p)       ((__darwin_size_t)((__darwin_size_t)(p) + __DARWIN_ALIGNBYTES32) &~ __DARWIN_ALIGNBYTES32)
 
 
 #endif /* _I386__PARAM_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/libkern/OSAtomicDeprecated.h b/lib/libc/include/x86_64-macos-gnu/libkern/OSAtomicDeprecated.h
index aef009bc04..6dc880b0d4 100644
--- a/lib/libc/include/x86_64-macos-gnu/libkern/OSAtomicDeprecated.h
+++ b/lib/libc/include/x86_64-macos-gnu/libkern/OSAtomicDeprecated.h
@@ -35,13 +35,14 @@
  * is preferred.
  */
 
+#include    <Availability.h>
+
 #if !(defined(OSATOMIC_USE_INLINED) && OSATOMIC_USE_INLINED)
 
 #include    <sys/cdefs.h>
 #include    <stddef.h>
 #include    <stdint.h>
 #include    <stdbool.h>
-#include    <Availability.h>
 
 #ifndef OSATOMIC_DEPRECATED
 #define OSATOMIC_DEPRECATED 1
@@ -161,7 +162,7 @@ __OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0)
 int32_t	OSAtomicAdd32Barrier( int32_t __theAmount, volatile int32_t *__theValue );
 
 
-#if __MAC_OS_X_VERSION_MIN_REQUIRED >= __MAC_10_10 || __IPHONE_OS_VERSION_MIN_REQUIRED >= __IPHONE_7_1
+#if __MAC_OS_X_VERSION_MIN_REQUIRED >= __MAC_10_10 || __IPHONE_OS_VERSION_MIN_REQUIRED >= __IPHONE_7_1 || TARGET_OS_DRIVERKIT
 
 /*! @abstract Atomically increments a 32-bit value.
     @result Returns the new value.
@@ -248,7 +249,7 @@ int64_t	OSAtomicAdd64Barrier( int64_t __theAmount,
 		volatile OSAtomic_int64_aligned64_t *__theValue );
 
 
-#if __MAC_OS_X_VERSION_MIN_REQUIRED >= __MAC_10_10 || __IPHONE_OS_VERSION_MIN_REQUIRED >= __IPHONE_7_1
+#if __MAC_OS_X_VERSION_MIN_REQUIRED >= __MAC_10_10 || __IPHONE_OS_VERSION_MIN_REQUIRED >= __IPHONE_7_1 || TARGET_OS_DRIVERKIT
 
 /*! @abstract Atomically increments a 64-bit value.
     @result Returns the new value.
@@ -361,7 +362,7 @@ int32_t	OSAtomicOr32Orig( uint32_t __theMask, volatile uint32_t *__theValue );
 	This function performs the bitwise OR of the value given by <code>__theMask</code>
 	with the value in the memory location referenced by <code>__theValue</code>,
 	storing the result back to that memory location atomically.
- 
+
 	This function is equivalent to {@link OSAtomicOr32Orig}
 	except that it also introduces a barrier.
     @result Returns the original value referenced by <code>__theValue</code>.
@@ -481,7 +482,7 @@ int32_t	OSAtomicXor32Orig( uint32_t __theMask, volatile uint32_t *__theValue );
 OSATOMIC_BARRIER_DEPRECATED_REPLACE_WITH(atomic_fetch_xor)
 __OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_3_2)
 int32_t	OSAtomicXor32OrigBarrier( uint32_t __theMask, volatile uint32_t *__theValue );
- 
+
 
 /*! @group Compare and swap
  * Functions in this group return true if the swap occured.  There are several versions,
@@ -587,7 +588,7 @@ bool	OSAtomicCompareAndSwapIntBarrier( int __oldValue, int __newValue, volatile
 	match, this function stores the value from <code>__newValue</code> into
 	that memory location atomically.
 
-	This function is equivalent to {@link OSAtomicCompareAndSwap32} on 32-bit architectures, 
+	This function is equivalent to {@link OSAtomicCompareAndSwap32} on 32-bit architectures,
 	or {@link OSAtomicCompareAndSwap64} on 64-bit architectures.
     @result Returns TRUE on a match, FALSE otherwise.
  */
@@ -606,7 +607,7 @@ bool	OSAtomicCompareAndSwapLong( long __oldValue, long __newValue, volatile long
 	This function is equivalent to {@link OSAtomicCompareAndSwapLong}
 	except that it also introduces a barrier.
 
-	This function is equivalent to {@link OSAtomicCompareAndSwap32} on 32-bit architectures, 
+	This function is equivalent to {@link OSAtomicCompareAndSwap32} on 32-bit architectures,
 	or {@link OSAtomicCompareAndSwap64} on 64-bit architectures.
     @result Returns TRUE on a match, FALSE otherwise.
  */
@@ -706,7 +707,7 @@ bool    OSAtomicTestAndSetBarrier( uint32_t __n, volatile void *__theAddress );
 	For example, if <code>__theAddress</code> points to a 64-bit value,
 	to compare the value of the most significant bit, you would specify
 	<code>56</code> for <code>__n</code>.
- 
+
     @result
 	Returns the original value of the bit being tested.
  */
@@ -719,15 +720,15 @@ bool    OSAtomicTestAndClear( uint32_t __n, volatile void *__theAddress );
     @discussion
 	This function tests a bit in the value referenced by <code>__theAddress</code>
 	and if it is not cleared, clears it.
- 
+
 	The bit is chosen by the value of <code>__n</code> such that the
 	operation will be performed on bit <code>(0x80 >> (__n & 7))</code>
 	of byte <code>((char *)__theAddress + (n >> 3))</code>.
- 
+
 	For example, if <code>__theAddress</code> points to a 64-bit value,
 	to compare the value of the most significant bit, you would specify
 	<code>56</code> for <code>__n</code>.
- 
+
 	This function is equivalent to {@link OSAtomicTestAndSet}
 	except that it also introduces a barrier.
     @result
@@ -736,7 +737,7 @@ bool    OSAtomicTestAndClear( uint32_t __n, volatile void *__theAddress );
 OSATOMIC_BARRIER_DEPRECATED_REPLACE_WITH(atomic_fetch_and)
 __OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0)
 bool    OSAtomicTestAndClearBarrier( uint32_t __n, volatile void *__theAddress );
- 
+
 
 /*! @group Memory barriers */
 
@@ -1174,4 +1175,92 @@ __END_DECLS
 
 #endif // defined(OSATOMIC_USE_INLINED) && OSATOMIC_USE_INLINED
 
+#if TARGET_OS_OSX || TARGET_OS_DRIVERKIT
+
+__BEGIN_DECLS
+
+/*! @group Lockless atomic fifo enqueue and dequeue
+ * These routines manipulate singly-linked FIFO lists.
+ *
+ * This API is deprecated and no longer recommended
+ */
+
+/*! @abstract The data structure for a fifo queue head.
+    @discussion
+	You should always initialize a fifo queue head structure with the
+	initialization vector {@link OS_ATOMIC_FIFO_QUEUE_INIT} before use.
+ */
+#if defined(__LP64__)
+
+typedef	volatile struct {
+	void	*opaque1;
+	void	*opaque2;
+	int	 opaque3;
+} __attribute__ ((aligned (16))) OSFifoQueueHead;
+
+#else
+
+typedef	volatile struct {
+	void	*opaque1;
+	void	*opaque2;
+	int	 opaque3;
+} OSFifoQueueHead;
+
+#endif
+/*! @abstract The initialization vector for a fifo queue head. */
+#define OS_ATOMIC_FIFO_QUEUE_INIT   { NULL, NULL, 0 }
+
+/*! @abstract Enqueue an element onto a list.
+    @discussion
+	Memory barriers are incorporated as needed to permit thread-safe access
+	to the queue element.
+    @param __list
+	The list on which you want to enqueue the element.
+    @param __new
+	The element to add.
+    @param __offset
+	The "offset" parameter is the offset (in bytes) of the link field
+	from the beginning of the data structure being queued (<code>__new</code>).
+	The link field should be a pointer type.
+	The <code>__offset</code> value needs to be same for all enqueuing and
+	dequeuing operations on the same list, even if different structure types
+	are enqueued on that list.  The use of <code>offsetset()</code>, defined in
+	<code>stddef.h</code> is the common way to specify the <code>__offset</code>
+	value.
+
+	@note
+	This API is deprecated and no longer recommended
+ */
+__API_DEPRECATED("No longer supported", macos(10.7, 11.0))
+void  OSAtomicFifoEnqueue( OSFifoQueueHead *__list, void *__new, size_t __offset);
+
+/*! @abstract Dequeue an element from a list.
+    @discussion
+	Memory barriers are incorporated as needed to permit thread-safe access
+	to the queue element.
+    @param __list
+	The list from which you want to dequeue an element.
+    @param __offset
+	The "offset" parameter is the offset (in bytes) of the link field
+	from the beginning of the data structure being dequeued (<code>__new</code>).
+	The link field should be a pointer type.
+	The <code>__offset</code> value needs to be same for all enqueuing and
+	dequeuing operations on the same list, even if different structure types
+	are enqueued on that list.  The use of <code>offsetset()</code>, defined in
+	<code>stddef.h</code> is the common way to specify the <code>__offset</code>
+	value.
+    @result
+	Returns the oldest enqueued element, or <code>NULL</code> if the
+	list is empty.
+
+	@note
+	This API is deprecated and no longer recommended
+ */
+__API_DEPRECATED("No longer supported", macos(10.7, 11.0))
+void* OSAtomicFifoDequeue( OSFifoQueueHead *__list, size_t __offset);
+
+__END_DECLS
+
+#endif /* TARGET_OS_OSX || TARGET_OS_DRIVERKIT */
+
 #endif /* _OSATOMIC_DEPRECATED_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/libkern/OSAtomicQueue.h b/lib/libc/include/x86_64-macos-gnu/libkern/OSAtomicQueue.h
index 3f673861e3..66033fc834 100644
--- a/lib/libc/include/x86_64-macos-gnu/libkern/OSAtomicQueue.h
+++ b/lib/libc/include/x86_64-macos-gnu/libkern/OSAtomicQueue.h
@@ -28,6 +28,7 @@
 #include    <sys/cdefs.h>
 #include    <stdint.h>
 #include    <stdbool.h>
+#include    "OSAtomicDeprecated.h"
 
 #include    <Availability.h>
 
@@ -109,83 +110,6 @@ void  OSAtomicEnqueue( OSQueueHead *__list, void *__new, size_t __offset);
 __OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_4_0)
 void* OSAtomicDequeue( OSQueueHead *__list, size_t __offset);
 
-#if defined(__x86_64__) || defined(__i386__)
-
-/*! @group Lockless atomic fifo enqueue and dequeue
- * These routines manipulate singly-linked FIFO lists.
- */
-
-/*! @abstract The data structure for a fifo queue head.
-    @discussion
-	You should always initialize a fifo queue head structure with the
-	initialization vector {@link OS_ATOMIC_FIFO_QUEUE_INIT} before use.
- */
-#if defined(__x86_64__)
-
-typedef	volatile struct {
-	void	*opaque1;
-	void	*opaque2;
-	int	 opaque3;
-} __attribute__ ((aligned (16))) OSFifoQueueHead;
-
-#else
-
-typedef	volatile struct {
-	void	*opaque1;
-	void	*opaque2;
-	int	 opaque3;
-} OSFifoQueueHead;
-
-#endif
-
-/*! @abstract The initialization vector for a fifo queue head. */
-#define OS_ATOMIC_FIFO_QUEUE_INIT   { NULL, NULL, 0 }
-
-/*! @abstract Enqueue an element onto a list.
-    @discussion
-	Memory barriers are incorporated as needed to permit thread-safe access
-	to the queue element.
-    @param __list
-	The list on which you want to enqueue the element.
-    @param __new
-	The element to add.
-    @param __offset
-	The "offset" parameter is the offset (in bytes) of the link field
-	from the beginning of the data structure being queued (<code>__new</code>).
-	The link field should be a pointer type.
-	The <code>__offset</code> value needs to be same for all enqueuing and
-	dequeuing operations on the same list, even if different structure types
-	are enqueued on that list.  The use of <code>offsetset()</code>, defined in
-	<code>stddef.h</code> is the common way to specify the <code>__offset</code>
-	value.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_NA)
-void  OSAtomicFifoEnqueue( OSFifoQueueHead *__list, void *__new, size_t __offset);
-
-/*! @abstract Dequeue an element from a list.
-    @discussion
-	Memory barriers are incorporated as needed to permit thread-safe access
-	to the queue element.
-    @param __list
-	The list from which you want to dequeue an element.
-    @param __offset
-	The "offset" parameter is the offset (in bytes) of the link field
-	from the beginning of the data structure being dequeued (<code>__new</code>).
-	The link field should be a pointer type.
-	The <code>__offset</code> value needs to be same for all enqueuing and
-	dequeuing operations on the same list, even if different structure types
-	are enqueued on that list.  The use of <code>offsetset()</code>, defined in
-	<code>stddef.h</code> is the common way to specify the <code>__offset</code>
-	value.
-    @result
-	Returns the oldest enqueued element, or <code>NULL</code> if the
-	list is empty.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_NA)
-void* OSAtomicFifoDequeue( OSFifoQueueHead *__list, size_t __offset);
-
-#endif /* __i386__ || __x86_64__ */
-
 __END_DECLS
 
 #endif /* _OSATOMICQUEUE_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/libkern/OSByteOrder.h b/lib/libc/include/x86_64-macos-gnu/libkern/OSByteOrder.h
deleted file mode 100644
index 25563e26e7..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/libkern/OSByteOrder.h
+++ /dev/null
@@ -1,305 +0,0 @@
-/*
- * Copyright (c) 2000-2006 Apple Computer, Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-
-#ifndef _OS_OSBYTEORDER_H
-#define _OS_OSBYTEORDER_H
-
-#include <stdint.h>
-#include <libkern/_OSByteOrder.h>
-
-/* Macros for swapping constant values in the preprocessing stage. */
-#define OSSwapConstInt16(x)     __DARWIN_OSSwapConstInt16(x)
-#define OSSwapConstInt32(x)     __DARWIN_OSSwapConstInt32(x)
-#define OSSwapConstInt64(x)     __DARWIN_OSSwapConstInt64(x)
-
-#if defined(__GNUC__)
-
-#if (defined(__i386__) || defined(__x86_64__))
-#include <libkern/i386/OSByteOrder.h>
-#else
-#include <libkern/machine/OSByteOrder.h>
-#endif
-
-#else /* ! __GNUC__ */
-
-#include <libkern/machine/OSByteOrder.h>
-
-#endif /* __GNUC__ */
-
-#define OSSwapInt16(x)  __DARWIN_OSSwapInt16(x)
-#define OSSwapInt32(x)  __DARWIN_OSSwapInt32(x)
-#define OSSwapInt64(x)  __DARWIN_OSSwapInt64(x)
-
-enum {
-	OSUnknownByteOrder,
-	OSLittleEndian,
-	OSBigEndian
-};
-
-OS_INLINE
-int32_t
-OSHostByteOrder(void)
-{
-#if defined(__LITTLE_ENDIAN__)
-	return OSLittleEndian;
-#elif defined(__BIG_ENDIAN__)
-	return OSBigEndian;
-#else
-	return OSUnknownByteOrder;
-#endif
-}
-
-#define OSReadBigInt(x, y)              OSReadBigInt32(x, y)
-#define OSWriteBigInt(x, y, z)          OSWriteBigInt32(x, y, z)
-#define OSSwapBigToHostInt(x)           OSSwapBigToHostInt32(x)
-#define OSSwapHostToBigInt(x)           OSSwapHostToBigInt32(x)
-#define OSReadLittleInt(x, y)           OSReadLittleInt32(x, y)
-#define OSWriteLittleInt(x, y, z)       OSWriteLittleInt32(x, y, z)
-#define OSSwapHostToLittleInt(x)        OSSwapHostToLittleInt32(x)
-#define OSSwapLittleToHostInt(x)        OSSwapLittleToHostInt32(x)
-
-/* Functions for loading native endian values. */
-
-OS_INLINE
-uint16_t
-_OSReadInt16(
-	const volatile void               * base,
-	uintptr_t                     byteOffset
-	)
-{
-	return *(volatile uint16_t *)((uintptr_t)base + byteOffset);
-}
-
-OS_INLINE
-uint32_t
-_OSReadInt32(
-	const volatile void               * base,
-	uintptr_t                     byteOffset
-	)
-{
-	return *(volatile uint32_t *)((uintptr_t)base + byteOffset);
-}
-
-OS_INLINE
-uint64_t
-_OSReadInt64(
-	const volatile void               * base,
-	uintptr_t                     byteOffset
-	)
-{
-	return *(volatile uint64_t *)((uintptr_t)base + byteOffset);
-}
-
-/* Functions for storing native endian values. */
-
-OS_INLINE
-void
-_OSWriteInt16(
-	volatile void               * base,
-	uintptr_t                     byteOffset,
-	uint16_t                      data
-	)
-{
-	*(volatile uint16_t *)((uintptr_t)base + byteOffset) = data;
-}
-
-OS_INLINE
-void
-_OSWriteInt32(
-	volatile void               * base,
-	uintptr_t                     byteOffset,
-	uint32_t                      data
-	)
-{
-	*(volatile uint32_t *)((uintptr_t)base + byteOffset) = data;
-}
-
-OS_INLINE
-void
-_OSWriteInt64(
-	volatile void               * base,
-	uintptr_t                     byteOffset,
-	uint64_t                      data
-	)
-{
-	*(volatile uint64_t *)((uintptr_t)base + byteOffset) = data;
-}
-
-#if             defined(__BIG_ENDIAN__)
-
-/* Functions for loading big endian to host endianess. */
-
-#define OSReadBigInt16(base, byteOffset) _OSReadInt16(base, byteOffset)
-#define OSReadBigInt32(base, byteOffset) _OSReadInt32(base, byteOffset)
-#define OSReadBigInt64(base, byteOffset) _OSReadInt64(base, byteOffset)
-
-/* Functions for storing host endianess to big endian. */
-
-#define OSWriteBigInt16(base, byteOffset, data) _OSWriteInt16(base, byteOffset, data)
-#define OSWriteBigInt32(base, byteOffset, data) _OSWriteInt32(base, byteOffset, data)
-#define OSWriteBigInt64(base, byteOffset, data) _OSWriteInt64(base, byteOffset, data)
-
-/* Functions for loading little endian to host endianess. */
-
-#define OSReadLittleInt16(base, byteOffset) OSReadSwapInt16(base, byteOffset)
-#define OSReadLittleInt32(base, byteOffset) OSReadSwapInt32(base, byteOffset)
-#define OSReadLittleInt64(base, byteOffset) OSReadSwapInt64(base, byteOffset)
-
-/* Functions for storing host endianess to little endian. */
-
-#define OSWriteLittleInt16(base, byteOffset, data) OSWriteSwapInt16(base, byteOffset, data)
-#define OSWriteLittleInt32(base, byteOffset, data) OSWriteSwapInt32(base, byteOffset, data)
-#define OSWriteLittleInt64(base, byteOffset, data) OSWriteSwapInt64(base, byteOffset, data)
-
-/* Host endianess to big endian byte swapping macros for constants. */
-
-#define OSSwapHostToBigConstInt16(x) ((uint16_t)(x))
-#define OSSwapHostToBigConstInt32(x) ((uint32_t)(x))
-#define OSSwapHostToBigConstInt64(x) ((uint64_t)(x))
-
-/* Generic host endianess to big endian byte swapping functions. */
-
-#define OSSwapHostToBigInt16(x) ((uint16_t)(x))
-#define OSSwapHostToBigInt32(x) ((uint32_t)(x))
-#define OSSwapHostToBigInt64(x) ((uint64_t)(x))
-
-/* Host endianess to little endian byte swapping macros for constants. */
-
-#define OSSwapHostToLittleConstInt16(x) OSSwapConstInt16(x)
-#define OSSwapHostToLittleConstInt32(x) OSSwapConstInt32(x)
-#define OSSwapHostToLittleConstInt64(x) OSSwapConstInt64(x)
-
-/* Generic host endianess to little endian byte swapping functions. */
-
-#define OSSwapHostToLittleInt16(x) OSSwapInt16(x)
-#define OSSwapHostToLittleInt32(x) OSSwapInt32(x)
-#define OSSwapHostToLittleInt64(x) OSSwapInt64(x)
-
-/* Big endian to host endianess byte swapping macros for constants. */
-
-#define OSSwapBigToHostConstInt16(x) ((uint16_t)(x))
-#define OSSwapBigToHostConstInt32(x) ((uint32_t)(x))
-#define OSSwapBigToHostConstInt64(x) ((uint64_t)(x))
-
-/* Generic big endian to host endianess byte swapping functions. */
-
-#define OSSwapBigToHostInt16(x) ((uint16_t)(x))
-#define OSSwapBigToHostInt32(x) ((uint32_t)(x))
-#define OSSwapBigToHostInt64(x) ((uint64_t)(x))
-
-/* Little endian to host endianess byte swapping macros for constants. */
-
-#define OSSwapLittleToHostConstInt16(x) OSSwapConstInt16(x)
-#define OSSwapLittleToHostConstInt32(x) OSSwapConstInt32(x)
-#define OSSwapLittleToHostConstInt64(x) OSSwapConstInt64(x)
-
-/* Generic little endian to host endianess byte swapping functions. */
-
-#define OSSwapLittleToHostInt16(x) OSSwapInt16(x)
-#define OSSwapLittleToHostInt32(x) OSSwapInt32(x)
-#define OSSwapLittleToHostInt64(x) OSSwapInt64(x)
-
-#elif           defined(__LITTLE_ENDIAN__)
-
-/* Functions for loading big endian to host endianess. */
-
-#define OSReadBigInt16(base, byteOffset) OSReadSwapInt16(base, byteOffset)
-#define OSReadBigInt32(base, byteOffset) OSReadSwapInt32(base, byteOffset)
-#define OSReadBigInt64(base, byteOffset) OSReadSwapInt64(base, byteOffset)
-
-/* Functions for storing host endianess to big endian. */
-
-#define OSWriteBigInt16(base, byteOffset, data) OSWriteSwapInt16(base, byteOffset, data)
-#define OSWriteBigInt32(base, byteOffset, data) OSWriteSwapInt32(base, byteOffset, data)
-#define OSWriteBigInt64(base, byteOffset, data) OSWriteSwapInt64(base, byteOffset, data)
-
-/* Functions for loading little endian to host endianess. */
-
-#define OSReadLittleInt16(base, byteOffset) _OSReadInt16(base, byteOffset)
-#define OSReadLittleInt32(base, byteOffset) _OSReadInt32(base, byteOffset)
-#define OSReadLittleInt64(base, byteOffset) _OSReadInt64(base, byteOffset)
-
-/* Functions for storing host endianess to little endian. */
-
-#define OSWriteLittleInt16(base, byteOffset, data) _OSWriteInt16(base, byteOffset, data)
-#define OSWriteLittleInt32(base, byteOffset, data) _OSWriteInt32(base, byteOffset, data)
-#define OSWriteLittleInt64(base, byteOffset, data) _OSWriteInt64(base, byteOffset, data)
-
-/* Host endianess to big endian byte swapping macros for constants. */
-
-#define OSSwapHostToBigConstInt16(x) OSSwapConstInt16(x)
-#define OSSwapHostToBigConstInt32(x) OSSwapConstInt32(x)
-#define OSSwapHostToBigConstInt64(x) OSSwapConstInt64(x)
-
-/* Generic host endianess to big endian byte swapping functions. */
-
-#define OSSwapHostToBigInt16(x) OSSwapInt16(x)
-#define OSSwapHostToBigInt32(x) OSSwapInt32(x)
-#define OSSwapHostToBigInt64(x) OSSwapInt64(x)
-
-/* Host endianess to little endian byte swapping macros for constants. */
-
-#define OSSwapHostToLittleConstInt16(x) ((uint16_t)(x))
-#define OSSwapHostToLittleConstInt32(x) ((uint32_t)(x))
-#define OSSwapHostToLittleConstInt64(x) ((uint64_t)(x))
-
-/* Generic host endianess to little endian byte swapping functions. */
-
-#define OSSwapHostToLittleInt16(x) ((uint16_t)(x))
-#define OSSwapHostToLittleInt32(x) ((uint32_t)(x))
-#define OSSwapHostToLittleInt64(x) ((uint64_t)(x))
-
-/* Big endian to host endianess byte swapping macros for constants. */
-
-#define OSSwapBigToHostConstInt16(x) OSSwapConstInt16(x)
-#define OSSwapBigToHostConstInt32(x) OSSwapConstInt32(x)
-#define OSSwapBigToHostConstInt64(x) OSSwapConstInt64(x)
-
-/* Generic big endian to host endianess byte swapping functions. */
-
-#define OSSwapBigToHostInt16(x) OSSwapInt16(x)
-#define OSSwapBigToHostInt32(x) OSSwapInt32(x)
-#define OSSwapBigToHostInt64(x) OSSwapInt64(x)
-
-/* Little endian to host endianess byte swapping macros for constants. */
-
-#define OSSwapLittleToHostConstInt16(x) ((uint16_t)(x))
-#define OSSwapLittleToHostConstInt32(x) ((uint32_t)(x))
-#define OSSwapLittleToHostConstInt64(x) ((uint64_t)(x))
-
-/* Generic little endian to host endianess byte swapping functions. */
-
-#define OSSwapLittleToHostInt16(x) ((uint16_t)(x))
-#define OSSwapLittleToHostInt32(x) ((uint32_t)(x))
-#define OSSwapLittleToHostInt64(x) ((uint64_t)(x))
-
-#else
-#error Unknown endianess.
-#endif
-
-#endif /* ! _OS_OSBYTEORDER_H */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/libkern/_OSByteOrder.h b/lib/libc/include/x86_64-macos-gnu/libkern/_OSByteOrder.h
deleted file mode 100644
index 06614c63ea..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/libkern/_OSByteOrder.h
+++ /dev/null
@@ -1,130 +0,0 @@
-/*
- * Copyright (c) 2006 Apple Computer, Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-
-#ifndef _OS__OSBYTEORDER_H
-#define _OS__OSBYTEORDER_H
-
-/*
- * This header is normally included from <libkern/OSByteOrder.h>.  However,
- * <sys/_endian.h> also includes this in the case of little-endian
- * architectures, so that we can map OSByteOrder routines to the hton* and ntoh*
- * macros.  This results in the asymmetry below; we only include
- * <libkern/arch/_OSByteOrder.h> for little-endian architectures.
- */
-
-#include <sys/_types.h>
-
-/* Macros for swapping constant values in the preprocessing stage. */
-#define __DARWIN_OSSwapConstInt16(x) \
-    ((__uint16_t)((((__uint16_t)(x) & 0xff00) >> 8) | \
-	        (((__uint16_t)(x) & 0x00ff) << 8)))
-
-#define __DARWIN_OSSwapConstInt32(x) \
-    ((__uint32_t)((((__uint32_t)(x) & 0xff000000) >> 24) | \
-	        (((__uint32_t)(x) & 0x00ff0000) >>  8) | \
-	        (((__uint32_t)(x) & 0x0000ff00) <<  8) | \
-	        (((__uint32_t)(x) & 0x000000ff) << 24)))
-
-#define __DARWIN_OSSwapConstInt64(x) \
-    ((__uint64_t)((((__uint64_t)(x) & 0xff00000000000000ULL) >> 56) | \
-	        (((__uint64_t)(x) & 0x00ff000000000000ULL) >> 40) | \
-	        (((__uint64_t)(x) & 0x0000ff0000000000ULL) >> 24) | \
-	        (((__uint64_t)(x) & 0x000000ff00000000ULL) >>  8) | \
-	        (((__uint64_t)(x) & 0x00000000ff000000ULL) <<  8) | \
-	        (((__uint64_t)(x) & 0x0000000000ff0000ULL) << 24) | \
-	        (((__uint64_t)(x) & 0x000000000000ff00ULL) << 40) | \
-	        (((__uint64_t)(x) & 0x00000000000000ffULL) << 56)))
-
-#if defined(__GNUC__)
-
-#if defined(__i386__) || defined(__x86_64__)
-#include <libkern/i386/_OSByteOrder.h>
-#endif
-
-
-
-#define __DARWIN_OSSwapInt16(x) \
-    ((__uint16_t)(__builtin_constant_p(x) ? __DARWIN_OSSwapConstInt16(x) : _OSSwapInt16(x)))
-
-#define __DARWIN_OSSwapInt32(x) \
-    (__builtin_constant_p(x) ? __DARWIN_OSSwapConstInt32(x) : _OSSwapInt32(x))
-
-#define __DARWIN_OSSwapInt64(x) \
-    (__builtin_constant_p(x) ? __DARWIN_OSSwapConstInt64(x) : _OSSwapInt64(x))
-
-#else /* ! __GNUC__ */
-
-#if defined(__i386__) || defined(__x86_64__)
-
-#if !defined(__DARWIN_OS_INLINE)
-# if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
-#        define __DARWIN_OS_INLINE static inline
-# elif defined(__MWERKS__) || defined(__cplusplus)
-#        define __DARWIN_OS_INLINE static inline
-# else
-#        define __DARWIN_OS_INLINE static __inline__
-# endif
-#endif
-
-__DARWIN_OS_INLINE
-uint16_t
-_OSSwapInt16(
-	uint16_t                    data
-	)
-{
-	return __DARWIN_OSSwapConstInt16(data);
-}
-
-__DARWIN_OS_INLINE
-uint32_t
-_OSSwapInt32(
-	uint32_t                    data
-	)
-{
-	return __DARWIN_OSSwapConstInt32(data);
-}
-
-__DARWIN_OS_INLINE
-uint64_t
-_OSSwapInt64(
-	uint64_t                    data
-	)
-{
-	return __DARWIN_OSSwapConstInt64(data);
-}
-#endif
-
-#define __DARWIN_OSSwapInt16(x) _OSSwapInt16(x)
-
-#define __DARWIN_OSSwapInt32(x) _OSSwapInt32(x)
-
-#define __DARWIN_OSSwapInt64(x) _OSSwapInt64(x)
-
-#endif /* __GNUC__ */
-
-#endif /* ! _OS__OSBYTEORDER_H */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/libproc.h b/lib/libc/include/x86_64-macos-gnu/libproc.h
deleted file mode 100644
index 4094fe40ef..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/libproc.h
+++ /dev/null
@@ -1,187 +0,0 @@
-/*
- * Copyright (c) 2006, 2007, 2010 Apple Inc. All rights reserved.
- *
- * @APPLE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this
- * file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_LICENSE_HEADER_END@
- */
-#ifndef _LIBPROC_H_
-#define _LIBPROC_H_
-
-#include <sys/cdefs.h>
-#include <sys/param.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <sys/mount.h>
-#include <sys/resource.h>
-#include <stdint.h>
-#include <stdbool.h>
-#include <mach/message.h> /* for audit_token_t */
-
-#include <sys/proc_info.h>
-
-#include <Availability.h>
-#include <os/availability.h>
-
-/*
- * This header file contains private interfaces to obtain process information.
- * These interfaces are subject to change in future releases.
- */
-
-/*!
- *       @define PROC_LISTPIDSPATH_PATH_IS_VOLUME
- *       @discussion This flag indicates that all processes that hold open
- *               file references on the volume associated with the specified
- *               path should be returned.
- */
-#define PROC_LISTPIDSPATH_PATH_IS_VOLUME        1
-
-
-/*!
- *       @define PROC_LISTPIDSPATH_EXCLUDE_EVTONLY
- *       @discussion This flag indicates that file references that were opened
- *               with the O_EVTONLY flag should be excluded from the matching
- *               criteria.
- */
-#define PROC_LISTPIDSPATH_EXCLUDE_EVTONLY       2
-
-__BEGIN_DECLS
-
-
-/*!
- *       @function proc_listpidspath
- *       @discussion A function which will search through the current
- *               processes looking for open file references which match
- *               a specified path or volume.
- *       @param type types of processes to be searched (see proc_listpids)
- *       @param typeinfo adjunct information for type
- *       @param path file or volume path
- *       @param pathflags flags to control which files should be considered
- *               during the process search.
- *       @param buffer a C array of int-sized values to be filled with
- *               process identifiers that hold an open file reference
- *               matching the specified path or volume.  Pass NULL to
- *               obtain the minimum buffer size needed to hold the
- *               currently active processes.
- *       @param buffersize the size (in bytes) of the provided buffer.
- *       @result the number of bytes of data returned in the provided buffer;
- *               -1 if an error was encountered;
- */
-int     proc_listpidspath(uint32_t      type,
-    uint32_t      typeinfo,
-    const char    *path,
-    uint32_t      pathflags,
-    void          *buffer,
-    int           buffersize) __OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_2_0);
-
-int proc_listpids(uint32_t type, uint32_t typeinfo, void *buffer, int buffersize) __OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_2_0);
-int proc_listallpids(void * buffer, int buffersize) __OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_4_1);
-int proc_listpgrppids(pid_t pgrpid, void * buffer, int buffersize) __OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_4_1);
-int proc_listchildpids(pid_t ppid, void * buffer, int buffersize) __OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_4_1);
-int proc_pidinfo(int pid, int flavor, uint64_t arg, void *buffer, int buffersize) __OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_2_0);
-int proc_pidfdinfo(int pid, int fd, int flavor, void * buffer, int buffersize) __OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_2_0);
-int proc_pidfileportinfo(int pid, uint32_t fileport, int flavor, void *buffer, int buffersize) __OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_4_3);
-int proc_name(int pid, void * buffer, uint32_t buffersize) __OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_2_0);
-int proc_regionfilename(int pid, uint64_t address, void * buffer, uint32_t buffersize) __OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_2_0);
-int proc_kmsgbuf(void * buffer, uint32_t buffersize) __OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_2_0);
-int proc_pidpath(int pid, void * buffer, uint32_t  buffersize) __OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_2_0);
-int proc_pidpath_audittoken(audit_token_t *audittoken, void * buffer, uint32_t  buffersize) API_AVAILABLE(macos(11.0), ios(14.0), watchos(7.0), tvos(14.0));
-int proc_libversion(int *major, int * minor) __OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_2_0);
-
-/*
- * Return resource usage information for the given pid, which can be a live process or a zombie.
- *
- * Returns 0 on success; or -1 on failure, with errno set to indicate the specific error.
- */
-int proc_pid_rusage(int pid, int flavor, rusage_info_t *buffer) __OSX_AVAILABLE_STARTING(__MAC_10_9, __IPHONE_7_0);
-
-/*
- * A process can use the following api to set its own process control
- * state on resoure starvation. The argument can have one of the PROC_SETPC_XX values
- */
-#define PROC_SETPC_NONE         0
-#define PROC_SETPC_THROTTLEMEM  1
-#define PROC_SETPC_SUSPEND      2
-#define PROC_SETPC_TERMINATE    3
-
-int proc_setpcontrol(const int control) __OSX_AVAILABLE_STARTING(__MAC_10_6, __IPHONE_3_2);
-int proc_setpcontrol(const int control);
-
-int proc_track_dirty(pid_t pid, uint32_t flags);
-int proc_set_dirty(pid_t pid, bool dirty);
-int proc_get_dirty(pid_t pid, uint32_t *flags);
-int proc_clear_dirty(pid_t pid, uint32_t flags);
-
-int proc_terminate(pid_t pid, int *sig);
-
-/*
- * NO_SMT means that on an SMT CPU, this thread must be scheduled alone,
- * with the paired CPU idle.
- *
- * Set NO_SMT on the current proc (all existing and future threads)
- * This attribute is inherited on fork and exec
- */
-int proc_set_no_smt(void) __API_AVAILABLE(macos(11.0));
-
-/* Set NO_SMT on the current thread */
-int proc_setthread_no_smt(void) __API_AVAILABLE(macos(11.0));
-
-/*
- * CPU Security Mitigation APIs
- *
- * Set CPU security mitigation on the current proc (all existing and future threads)
- * This attribute is inherited on fork and exec
- */
-int proc_set_csm(uint32_t flags) __API_AVAILABLE(macos(11.0));
-
-/* Set CPU security mitigation on the current thread */
-int proc_setthread_csm(uint32_t flags) __API_AVAILABLE(macos(11.0));
-
-/*
- * flags for CPU Security Mitigation APIs
- * PROC_CSM_ALL should be used in most cases,
- * the individual flags are provided only for performance evaluation etc
- */
-#define PROC_CSM_ALL         0x0001  /* Set all available mitigations */
-#define PROC_CSM_NOSMT       0x0002  /* Set NO_SMT - see above */
-#define PROC_CSM_TECS        0x0004  /* Execute VERW on every return to user mode */
-
-#ifdef PRIVATE
-#include <sys/event.h>
-/*
- * Enumerate potential userspace pointers embedded in kernel data structures.
- * Currently inspects kqueues only.
- *
- * NOTE: returned "pointers" are opaque user-supplied values and thus not
- * guaranteed to address valid objects or be pointers at all.
- *
- * Returns the number of pointers found (which may exceed buffersize), or -1 on
- * failure and errno set appropriately.
- */
-int proc_list_uptrs(pid_t pid, uint64_t *buffer, uint32_t buffersize);
-
-int proc_list_dynkqueueids(int pid, kqueue_id_t *buf, uint32_t bufsz);
-int proc_piddynkqueueinfo(int pid, int flavor, kqueue_id_t kq_id, void *buffer,
-    int buffersize);
-#endif /* PRIVATE */
-
-int proc_udata_info(int pid, int flavor, void *buffer, int buffersize);
-
-__END_DECLS
-
-#endif /*_LIBPROC_H_ */
diff --git a/lib/libc/include/x86_64-macos-gnu/mach-o/dyld.h b/lib/libc/include/x86_64-macos-gnu/mach-o/dyld.h
deleted file mode 100644
index 0b293cbd09..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/mach-o/dyld.h
+++ /dev/null
@@ -1,263 +0,0 @@
-/*
- * Copyright (c) 1999-2008 Apple Inc. All rights reserved.
- *
- * @APPLE_LICENSE_HEADER_START@
- * 
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this
- * file.
- * 
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- * 
- * @APPLE_LICENSE_HEADER_END@
- */
-#ifndef _MACH_O_DYLD_H_
-#define _MACH_O_DYLD_H_
-
-
-#include <stddef.h>
-#include <stdint.h>
-#include <stdbool.h>
-
-#include <mach-o/loader.h>
-#include <Availability.h>
-
-#if __cplusplus
-extern "C" {
-#endif 
-
-#ifdef __DRIVERKIT_19_0
- #define DYLD_DRIVERKIT_UNAVAILABLE __API_UNAVAILABLE(driverkit)
-#else
- #define DYLD_DRIVERKIT_UNAVAILABLE
-#endif
-
-/*
- * The following functions allow you to iterate through all loaded images.  
- * This is not a thread safe operation.  Another thread can add or remove
- * an image during the iteration.  
- *
- * Many uses of these routines can be replace by a call to dladdr() which 
- * will return the mach_header and name of an image, given an address in 
- * the image. dladdr() is thread safe.
- */
-extern uint32_t                    _dyld_image_count(void)                              __OSX_AVAILABLE_STARTING(__MAC_10_1, __IPHONE_2_0);
-extern const struct mach_header*   _dyld_get_image_header(uint32_t image_index)         __OSX_AVAILABLE_STARTING(__MAC_10_1, __IPHONE_2_0);
-extern intptr_t                    _dyld_get_image_vmaddr_slide(uint32_t image_index)   __OSX_AVAILABLE_STARTING(__MAC_10_1, __IPHONE_2_0);
-extern const char*                 _dyld_get_image_name(uint32_t image_index)           __OSX_AVAILABLE_STARTING(__MAC_10_1, __IPHONE_2_0);
-
-
-/*
- * The following functions allow you to install callbacks which will be called   
- * by dyld whenever an image is loaded or unloaded.  During a call to _dyld_register_func_for_add_image()
- * the callback func is called for every existing image.  Later, it is called as each new image
- * is loaded and bound (but initializers not yet run).  The callback registered with
- * _dyld_register_func_for_remove_image() is called after any terminators in an image are run
- * and before the image is un-memory-mapped.
- */
-extern void _dyld_register_func_for_add_image(void (*func)(const struct mach_header* mh, intptr_t vmaddr_slide))    __OSX_AVAILABLE_STARTING(__MAC_10_1, __IPHONE_2_0);
-extern void _dyld_register_func_for_remove_image(void (*func)(const struct mach_header* mh, intptr_t vmaddr_slide)) __OSX_AVAILABLE_STARTING(__MAC_10_1, __IPHONE_2_0);
-
-
-/*
- * NSVersionOfRunTimeLibrary() returns the current_version number of the currently dylib 
- * specifed by the libraryName.  The libraryName parameter would be "bar" for /path/libbar.3.dylib and
- * "Foo" for /path/Foo.framework/Versions/A/Foo.  It returns -1 if no such library is loaded.
- */
-extern int32_t NSVersionOfRunTimeLibrary(const char* libraryName)            __OSX_AVAILABLE_STARTING(__MAC_10_1, __IPHONE_2_0);
-
-
-/*
- * NSVersionOfLinkTimeLibrary() returns the current_version number that the main executable was linked
- * against at build time.  The libraryName parameter would be "bar" for /path/libbar.3.dylib and
- * "Foo" for /path/Foo.framework/Versions/A/Foo.  It returns -1 if the main executable did not link
- * against the specified library.
- */
-extern int32_t NSVersionOfLinkTimeLibrary(const char* libraryName)           __OSX_AVAILABLE_STARTING(__MAC_10_1, __IPHONE_2_0);
-
-
-/*
- * _NSGetExecutablePath() copies the path of the main executable into the buffer. The bufsize parameter
- * should initially be the size of the buffer.  The function returns 0 if the path was successfully copied,
- * and *bufsize is left unchanged. It returns -1 if the buffer is not large enough, and *bufsize is set 
- * to the size required. 
- * 
- * Note that _NSGetExecutablePath will return "a path" to the executable not a "real path" to the executable. 
- * That is the path may be a symbolic link and not the real file. With deep directories the total bufsize 
- * needed could be more than MAXPATHLEN.
- */
-extern int _NSGetExecutablePath(char* buf, uint32_t* bufsize)                 __OSX_AVAILABLE_STARTING(__MAC_10_2, __IPHONE_2_0);
-
-
-
-/*
- * Registers a function to be called when the current thread terminates.
- * Called by c++ compiler to implement destructors on thread_local object variables.
- */
-extern void _tlv_atexit(void (*termFunc)(void* objAddr), void* objAddr)      __OSX_AVAILABLE_STARTING(__MAC_10_10, __IPHONE_8_0);
-
-
-/*
- * Never called. On-disk thread local variables contain a pointer to this.  Once
- * the thread local is prepared, the pointer changes to a real handler such as tlv_get_addr.
- */
-extern void _tlv_bootstrap(void)                                             __OSX_AVAILABLE_STARTING(__MAC_10_10, __IPHONE_8_0) DYLD_DRIVERKIT_UNAVAILABLE ;
-
-/*
- * The following dyld API's are deprecated as of Mac OS X 10.5.  They are either  
- * no longer necessary or are superceeded by dlopen and friends in <dlfcn.h>.
- * dlopen/dlsym/dlclose have been available since Mac OS X 10.3 and work with 
- * dylibs and bundles.  
- *
- *    NSAddImage                           -> dlopen
- *    NSLookupSymbolInImage                -> dlsym
- *    NSCreateObjectFileImageFromFile      -> dlopen
- *    NSDestroyObjectFileImage             -> dlclose
- *    NSLinkModule                         -> not needed when dlopen used
- *    NSUnLinkModule                       -> not needed when dlclose used
- *    NSLookupSymbolInModule               -> dlsym
- *    _dyld_image_containing_address       -> dladdr
- *    NSLinkEditError                      -> dlerror
- *
- */
-
-#ifndef ENUM_DYLD_BOOL
-#define ENUM_DYLD_BOOL
-  #undef FALSE
-  #undef TRUE
-  enum DYLD_BOOL { FALSE, TRUE };
-#endif /* ENUM_DYLD_BOOL */
-
-
-/* Object file image API */
-typedef enum {
-    NSObjectFileImageFailure, /* for this a message is printed on stderr */
-    NSObjectFileImageSuccess,
-    NSObjectFileImageInappropriateFile,
-    NSObjectFileImageArch,
-    NSObjectFileImageFormat, /* for this a message is printed on stderr */
-    NSObjectFileImageAccess
-} NSObjectFileImageReturnCode;
-
-typedef struct __NSObjectFileImage* NSObjectFileImage;
-
-
-
-/* NSObjectFileImage can only be used with MH_BUNDLE files */
-extern NSObjectFileImageReturnCode NSCreateObjectFileImageFromFile(const char* pathName, NSObjectFileImage *objectFileImage)               __API_UNAVAILABLE(ios, tvos, watchos)  DYLD_DRIVERKIT_UNAVAILABLE  __OSX_DEPRECATED(10.1, 10.5, "dlopen()");
-extern NSObjectFileImageReturnCode NSCreateObjectFileImageFromMemory(const void *address, size_t size, NSObjectFileImage *objectFileImage) __API_UNAVAILABLE(ios, tvos, watchos)  DYLD_DRIVERKIT_UNAVAILABLE  __OSX_DEPRECATED(10.1, 10.5, "");
-extern bool                        NSDestroyObjectFileImage(NSObjectFileImage objectFileImage)                                             __API_UNAVAILABLE(ios, tvos, watchos)  DYLD_DRIVERKIT_UNAVAILABLE  __OSX_DEPRECATED(10.1, 10.5, "dlclose()");
-
-extern uint32_t     NSSymbolDefinitionCountInObjectFileImage(NSObjectFileImage objectFileImage)                   __API_UNAVAILABLE(ios, tvos, watchos)  DYLD_DRIVERKIT_UNAVAILABLE  __OSX_DEPRECATED(10.1, 10.5, "");
-extern const char*  NSSymbolDefinitionNameInObjectFileImage(NSObjectFileImage objectFileImage, uint32_t ordinal)  __API_UNAVAILABLE(ios, tvos, watchos)  DYLD_DRIVERKIT_UNAVAILABLE  __OSX_DEPRECATED(10.1, 10.5, "");
-extern uint32_t     NSSymbolReferenceCountInObjectFileImage(NSObjectFileImage objectFileImage)                    __API_UNAVAILABLE(ios, tvos, watchos)  DYLD_DRIVERKIT_UNAVAILABLE  __OSX_DEPRECATED(10.1, 10.5, "");
-extern const char*  NSSymbolReferenceNameInObjectFileImage(NSObjectFileImage objectFileImage, uint32_t ordinal, bool *tentative_definition) __API_UNAVAILABLE(ios, tvos, watchos)  DYLD_DRIVERKIT_UNAVAILABLE  __OSX_DEPRECATED(10.1, 10.5, "");
-extern bool         NSIsSymbolDefinedInObjectFileImage(NSObjectFileImage objectFileImage, const char* symbolName) __API_UNAVAILABLE(ios, tvos, watchos)  DYLD_DRIVERKIT_UNAVAILABLE  __OSX_DEPRECATED(10.1, 10.4, "dlsym()");
-extern void*        NSGetSectionDataInObjectFileImage(NSObjectFileImage objectFileImage, const char* segmentName, const char* sectionName, size_t *size) __API_UNAVAILABLE(ios, tvos, watchos)  DYLD_DRIVERKIT_UNAVAILABLE  __OSX_DEPRECATED(10.1, 10.5, "getsectiondata()");
-
-typedef struct __NSModule* NSModule;
-extern const char*  NSNameOfModule(NSModule m)         __API_UNAVAILABLE(ios, tvos, watchos)  DYLD_DRIVERKIT_UNAVAILABLE  __OSX_DEPRECATED(10.1, 10.5, "");
-extern const char*  NSLibraryNameForModule(NSModule m) __API_UNAVAILABLE(ios, tvos, watchos)  DYLD_DRIVERKIT_UNAVAILABLE  __OSX_DEPRECATED(10.1, 10.5, "");
-
-extern NSModule NSLinkModule(NSObjectFileImage objectFileImage, const char* moduleName, uint32_t options) __API_UNAVAILABLE(ios, tvos, watchos)  DYLD_DRIVERKIT_UNAVAILABLE  __OSX_DEPRECATED(10.1, 10.5, "dlopen()");
-#define NSLINKMODULE_OPTION_NONE                         0x0
-#define NSLINKMODULE_OPTION_BINDNOW                      0x1
-#define NSLINKMODULE_OPTION_PRIVATE                      0x2
-#define NSLINKMODULE_OPTION_RETURN_ON_ERROR              0x4
-#define NSLINKMODULE_OPTION_DONT_CALL_MOD_INIT_ROUTINES  0x8
-#define NSLINKMODULE_OPTION_TRAILING_PHYS_NAME          0x10
-
-extern bool NSUnLinkModule(NSModule module, uint32_t options) __API_UNAVAILABLE(ios, tvos, watchos)  DYLD_DRIVERKIT_UNAVAILABLE  __OSX_DEPRECATED(10.1, 10.5, "");
-#define NSUNLINKMODULE_OPTION_NONE                  0x0
-#define NSUNLINKMODULE_OPTION_KEEP_MEMORY_MAPPED    0x1
-#define NSUNLINKMODULE_OPTION_RESET_LAZY_REFERENCES	0x2
-
-/* symbol API */
-typedef struct __NSSymbol* NSSymbol;
-extern bool     NSIsSymbolNameDefined(const char* symbolName)                                                    __API_UNAVAILABLE(ios, tvos, watchos)  DYLD_DRIVERKIT_UNAVAILABLE  __OSX_DEPRECATED(10.1, 10.4, "dlsym()");
-extern bool     NSIsSymbolNameDefinedWithHint(const char* symbolName, const char* libraryNameHint)               __API_UNAVAILABLE(ios, tvos, watchos)  DYLD_DRIVERKIT_UNAVAILABLE  __OSX_DEPRECATED(10.1, 10.4, "dlsym()");
-extern bool     NSIsSymbolNameDefinedInImage(const struct mach_header* image, const char* symbolName)            __API_UNAVAILABLE(ios, tvos, watchos)  DYLD_DRIVERKIT_UNAVAILABLE  __OSX_DEPRECATED(10.1, 10.4, "dlsym()");
-extern NSSymbol NSLookupAndBindSymbol(const char* symbolName)                                                    __API_UNAVAILABLE(ios, tvos, watchos)  DYLD_DRIVERKIT_UNAVAILABLE  __OSX_DEPRECATED(10.1, 10.4, "dlsym()");
-extern NSSymbol NSLookupAndBindSymbolWithHint(const char* symbolName, const char* libraryNameHint)               __API_UNAVAILABLE(ios, tvos, watchos)  DYLD_DRIVERKIT_UNAVAILABLE  __OSX_DEPRECATED(10.1, 10.4, "dlsym()");
-extern NSSymbol NSLookupSymbolInModule(NSModule module, const char* symbolName)                                  __API_UNAVAILABLE(ios, tvos, watchos)  DYLD_DRIVERKIT_UNAVAILABLE  __OSX_DEPRECATED(10.1, 10.5, "dlsym()");
-extern NSSymbol NSLookupSymbolInImage(const struct mach_header* image, const char* symbolName, uint32_t options) __API_UNAVAILABLE(ios, tvos, watchos)  DYLD_DRIVERKIT_UNAVAILABLE  __OSX_DEPRECATED(10.1, 10.5, "dlsym()");
-#define NSLOOKUPSYMBOLINIMAGE_OPTION_BIND            0x0
-#define NSLOOKUPSYMBOLINIMAGE_OPTION_BIND_NOW        0x1
-#define NSLOOKUPSYMBOLINIMAGE_OPTION_BIND_FULLY      0x2
-#define NSLOOKUPSYMBOLINIMAGE_OPTION_RETURN_ON_ERROR 0x4
-extern const char*  NSNameOfSymbol(NSSymbol symbol)    __API_UNAVAILABLE(ios, tvos, watchos)  DYLD_DRIVERKIT_UNAVAILABLE  __OSX_DEPRECATED(10.1, 10.5, "");
-extern void *       NSAddressOfSymbol(NSSymbol symbol) __API_UNAVAILABLE(ios, tvos, watchos)  DYLD_DRIVERKIT_UNAVAILABLE  __OSX_DEPRECATED(10.1, 10.5, "dlsym()");
-extern NSModule     NSModuleForSymbol(NSSymbol symbol) __API_UNAVAILABLE(ios, tvos, watchos)  DYLD_DRIVERKIT_UNAVAILABLE  __OSX_DEPRECATED(10.1, 10.5, "dladdr()");
-
-/* error handling API */
-typedef enum {
-    NSLinkEditFileAccessError,
-    NSLinkEditFileFormatError,
-    NSLinkEditMachResourceError,
-    NSLinkEditUnixResourceError,
-    NSLinkEditOtherError,
-    NSLinkEditWarningError,
-    NSLinkEditMultiplyDefinedError,
-    NSLinkEditUndefinedError
-} NSLinkEditErrors;
-
-/*
- * For the NSLinkEditErrors value NSLinkEditOtherError these are the values
- * passed to the link edit error handler as the errorNumber (what would be an
- * errno value for NSLinkEditUnixResourceError or a kern_return_t value for
- * NSLinkEditMachResourceError).
- */
-typedef enum {
-    NSOtherErrorRelocation, 
-    NSOtherErrorLazyBind,
-    NSOtherErrorIndrLoop,
-    NSOtherErrorLazyInit,
-    NSOtherErrorInvalidArgs
-} NSOtherErrorNumbers;
-
-extern void NSLinkEditError(NSLinkEditErrors *c, int *errorNumber, const char** fileName, const char** errorString) __API_UNAVAILABLE(ios, tvos, watchos)  DYLD_DRIVERKIT_UNAVAILABLE  __OSX_DEPRECATED(10.1, 10.5, "dlerror()");
-
-typedef struct {
-     void     (*undefined)(const char* symbolName);
-     NSModule (*multiple)(NSSymbol s, NSModule oldModule, NSModule newModule); 
-     void     (*linkEdit)(NSLinkEditErrors errorClass, int errorNumber,
-                          const char* fileName, const char* errorString);
-} NSLinkEditErrorHandlers;
-
-extern void NSInstallLinkEditErrorHandlers(const NSLinkEditErrorHandlers *handlers) __API_UNAVAILABLE(ios, tvos, watchos)  DYLD_DRIVERKIT_UNAVAILABLE  __OSX_DEPRECATED(10.1, 10.5, "");
-
-extern bool                      NSAddLibrary(const char* pathName)                   __API_UNAVAILABLE(ios, tvos, watchos)  DYLD_DRIVERKIT_UNAVAILABLE  __OSX_DEPRECATED(10.1, 10.4, "dlopen()");
-extern bool                      NSAddLibraryWithSearching(const char* pathName)      __API_UNAVAILABLE(ios, tvos, watchos)  DYLD_DRIVERKIT_UNAVAILABLE  __OSX_DEPRECATED(10.1, 10.4, "dlopen()");
-extern const struct mach_header* NSAddImage(const char* image_name, uint32_t options) __API_UNAVAILABLE(ios, tvos, watchos)  DYLD_DRIVERKIT_UNAVAILABLE  __OSX_DEPRECATED(10.1, 10.5, "dlopen()");
-#define NSADDIMAGE_OPTION_NONE                  	0x0
-#define NSADDIMAGE_OPTION_RETURN_ON_ERROR       	0x1
-#define NSADDIMAGE_OPTION_WITH_SEARCHING        	0x2
-#define NSADDIMAGE_OPTION_RETURN_ONLY_IF_LOADED 	0x4
-#define NSADDIMAGE_OPTION_MATCH_FILENAME_BY_INSTALLNAME	0x8
-
-extern bool _dyld_present(void)                                                              __API_UNAVAILABLE(ios, tvos, watchos)  DYLD_DRIVERKIT_UNAVAILABLE  __OSX_DEPRECATED(10.1, 10.5, "always true");
-extern bool _dyld_launched_prebound(void)                                                    __API_UNAVAILABLE(ios, tvos, watchos)  DYLD_DRIVERKIT_UNAVAILABLE  __OSX_DEPRECATED(10.1, 10.5, "moot");
-extern bool _dyld_all_twolevel_modules_prebound(void)                                        __API_UNAVAILABLE(ios, tvos, watchos)  DYLD_DRIVERKIT_UNAVAILABLE  __OSX_DEPRECATED(10.3, 10.5, "moot");
-extern bool _dyld_bind_fully_image_containing_address(const void* address)                   __API_UNAVAILABLE(ios, tvos, watchos)  DYLD_DRIVERKIT_UNAVAILABLE  __OSX_DEPRECATED(10.1, 10.5, "dlopen(RTLD_NOW)");
-extern bool _dyld_image_containing_address(const void* address)                              __API_UNAVAILABLE(ios, tvos, watchos)  DYLD_DRIVERKIT_UNAVAILABLE  __OSX_DEPRECATED(10.3, 10.5, "dladdr()");
-extern void _dyld_lookup_and_bind(const char* symbol_name, void **address, NSModule* module) __API_UNAVAILABLE(ios, tvos, watchos)  DYLD_DRIVERKIT_UNAVAILABLE  __OSX_DEPRECATED(10.1, 10.4, "dlsym()");
-extern void _dyld_lookup_and_bind_with_hint(const char* symbol_name, const char* library_name_hint, void** address, NSModule* module) __API_UNAVAILABLE(ios, tvos, watchos)  DYLD_DRIVERKIT_UNAVAILABLE  __OSX_DEPRECATED(10.1, 10.4, "dlsym()");
-extern void _dyld_lookup_and_bind_fully(const char* symbol_name, void** address, NSModule* module) __API_UNAVAILABLE(ios, tvos, watchos)  DYLD_DRIVERKIT_UNAVAILABLE  __OSX_DEPRECATED(10.1, 10.5, "dlsym()");
-
-extern const struct mach_header*  _dyld_get_image_header_containing_address(const void* address) __API_UNAVAILABLE(ios, tvos, watchos)  DYLD_DRIVERKIT_UNAVAILABLE  __OSX_DEPRECATED(10.3, 10.5, "dladdr()");
-
-
-#if __cplusplus
-}
-#endif 
-
-#endif /* _MACH_O_DYLD_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/mach-o/loader.h b/lib/libc/include/x86_64-macos-gnu/mach-o/loader.h
deleted file mode 100644
index a088105205..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/mach-o/loader.h
+++ /dev/null
@@ -1,1577 +0,0 @@
-/*
- * Copyright (c) 1999-2010 Apple Inc.  All Rights Reserved.
- *
- * @APPLE_LICENSE_HEADER_START@
- * 
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this
- * file.
- * 
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- * 
- * @APPLE_LICENSE_HEADER_END@
- */
-#ifndef _MACHO_LOADER_H_
-#define _MACHO_LOADER_H_
-
-/*
- * This file describes the format of mach object files.
- */
-#include <stdint.h>
-
-/*
- * <mach/machine.h> is needed here for the cpu_type_t and cpu_subtype_t types
- * and contains the constants for the possible values of these types.
- */
-#include <mach/machine.h>
-
-/*
- * <mach/vm_prot.h> is needed here for the vm_prot_t type and contains the 
- * constants that are or'ed together for the possible values of this type.
- */
-#include <mach/vm_prot.h>
-
-/*
- * <machine/thread_status.h> is expected to define the flavors of the thread
- * states and the structures of those flavors for each machine.
- */
-#include <mach/machine/thread_status.h>
-#include <architecture/byte_order.h>
-
-/*
- * The 32-bit mach header appears at the very beginning of the object file for
- * 32-bit architectures.
- */
-struct mach_header {
-	uint32_t	magic;		/* mach magic number identifier */
-	cpu_type_t	cputype;	/* cpu specifier */
-	cpu_subtype_t	cpusubtype;	/* machine specifier */
-	uint32_t	filetype;	/* type of file */
-	uint32_t	ncmds;		/* number of load commands */
-	uint32_t	sizeofcmds;	/* the size of all the load commands */
-	uint32_t	flags;		/* flags */
-};
-
-/* Constant for the magic field of the mach_header (32-bit architectures) */
-#define	MH_MAGIC	0xfeedface	/* the mach magic number */
-#define MH_CIGAM	0xcefaedfe	/* NXSwapInt(MH_MAGIC) */
-
-/*
- * The 64-bit mach header appears at the very beginning of object files for
- * 64-bit architectures.
- */
-struct mach_header_64 {
-	uint32_t	magic;		/* mach magic number identifier */
-	cpu_type_t	cputype;	/* cpu specifier */
-	cpu_subtype_t	cpusubtype;	/* machine specifier */
-	uint32_t	filetype;	/* type of file */
-	uint32_t	ncmds;		/* number of load commands */
-	uint32_t	sizeofcmds;	/* the size of all the load commands */
-	uint32_t	flags;		/* flags */
-	uint32_t	reserved;	/* reserved */
-};
-
-/* Constant for the magic field of the mach_header_64 (64-bit architectures) */
-#define MH_MAGIC_64 0xfeedfacf /* the 64-bit mach magic number */
-#define MH_CIGAM_64 0xcffaedfe /* NXSwapInt(MH_MAGIC_64) */
-
-/*
- * The layout of the file depends on the filetype.  For all but the MH_OBJECT
- * file type the segments are padded out and aligned on a segment alignment
- * boundary for efficient demand pageing.  The MH_EXECUTE, MH_FVMLIB, MH_DYLIB,
- * MH_DYLINKER and MH_BUNDLE file types also have the headers included as part
- * of their first segment.
- * 
- * The file type MH_OBJECT is a compact format intended as output of the
- * assembler and input (and possibly output) of the link editor (the .o
- * format).  All sections are in one unnamed segment with no segment padding. 
- * This format is used as an executable format when the file is so small the
- * segment padding greatly increases its size.
- *
- * The file type MH_PRELOAD is an executable format intended for things that
- * are not executed under the kernel (proms, stand alones, kernels, etc).  The
- * format can be executed under the kernel but may demand paged it and not
- * preload it before execution.
- *
- * A core file is in MH_CORE format and can be any in an arbritray legal
- * Mach-O file.
- *
- * Constants for the filetype field of the mach_header
- */
-#define	MH_OBJECT	0x1		/* relocatable object file */
-#define	MH_EXECUTE	0x2		/* demand paged executable file */
-#define	MH_FVMLIB	0x3		/* fixed VM shared library file */
-#define	MH_CORE		0x4		/* core file */
-#define	MH_PRELOAD	0x5		/* preloaded executable file */
-#define	MH_DYLIB	0x6		/* dynamically bound shared library */
-#define	MH_DYLINKER	0x7		/* dynamic link editor */
-#define	MH_BUNDLE	0x8		/* dynamically bound bundle file */
-#define	MH_DYLIB_STUB	0x9		/* shared library stub for static */
-					/*  linking only, no section contents */
-#define	MH_DSYM		0xa		/* companion file with only debug */
-					/*  sections */
-#define	MH_KEXT_BUNDLE	0xb		/* x86_64 kexts */
-
-/* Constants for the flags field of the mach_header */
-#define	MH_NOUNDEFS	0x1		/* the object file has no undefined
-					   references */
-#define	MH_INCRLINK	0x2		/* the object file is the output of an
-					   incremental link against a base file
-					   and can't be link edited again */
-#define MH_DYLDLINK	0x4		/* the object file is input for the
-					   dynamic linker and can't be staticly
-					   link edited again */
-#define MH_BINDATLOAD	0x8		/* the object file's undefined
-					   references are bound by the dynamic
-					   linker when loaded. */
-#define MH_PREBOUND	0x10		/* the file has its dynamic undefined
-					   references prebound. */
-#define MH_SPLIT_SEGS	0x20		/* the file has its read-only and
-					   read-write segments split */
-#define MH_LAZY_INIT	0x40		/* the shared library init routine is
-					   to be run lazily via catching memory
-					   faults to its writeable segments
-					   (obsolete) */
-#define MH_TWOLEVEL	0x80		/* the image is using two-level name
-					   space bindings */
-#define MH_FORCE_FLAT	0x100		/* the executable is forcing all images
-					   to use flat name space bindings */
-#define MH_NOMULTIDEFS	0x200		/* this umbrella guarantees no multiple
-					   defintions of symbols in its
-					   sub-images so the two-level namespace
-					   hints can always be used. */
-#define MH_NOFIXPREBINDING 0x400	/* do not have dyld notify the
-					   prebinding agent about this
-					   executable */
-#define MH_PREBINDABLE  0x800           /* the binary is not prebound but can
-					   have its prebinding redone. only used
-                                           when MH_PREBOUND is not set. */
-#define MH_ALLMODSBOUND 0x1000		/* indicates that this binary binds to
-                                           all two-level namespace modules of
-					   its dependent libraries. only used
-					   when MH_PREBINDABLE and MH_TWOLEVEL
-					   are both set. */ 
-#define MH_SUBSECTIONS_VIA_SYMBOLS 0x2000/* safe to divide up the sections into
-					    sub-sections via symbols for dead
-					    code stripping */
-#define MH_CANONICAL    0x4000		/* the binary has been canonicalized
-					   via the unprebind operation */
-#define MH_WEAK_DEFINES	0x8000		/* the final linked image contains
-					   external weak symbols */
-#define MH_BINDS_TO_WEAK 0x10000	/* the final linked image uses
-					   weak symbols */
-
-#define MH_ALLOW_STACK_EXECUTION 0x20000/* When this bit is set, all stacks 
-					   in the task will be given stack
-					   execution privilege.  Only used in
-					   MH_EXECUTE filetypes. */
-#define MH_ROOT_SAFE 0x40000           /* When this bit is set, the binary 
-					  declares it is safe for use in
-					  processes with uid zero */
-                                         
-#define MH_SETUID_SAFE 0x80000         /* When this bit is set, the binary 
-					  declares it is safe for use in
-					  processes when issetugid() is true */
-
-#define MH_NO_REEXPORTED_DYLIBS 0x100000 /* When this bit is set on a dylib, 
-					  the static linker does not need to
-					  examine dependent dylibs to see
-					  if any are re-exported */
-#define	MH_PIE 0x200000			/* When this bit is set, the OS will
-					   load the main executable at a
-					   random address.  Only used in
-					   MH_EXECUTE filetypes. */
-#define	MH_DEAD_STRIPPABLE_DYLIB 0x400000 /* Only for use on dylibs.  When
-					     linking against a dylib that
-					     has this bit set, the static linker
-					     will automatically not create a
-					     LC_LOAD_DYLIB load command to the
-					     dylib if no symbols are being
-					     referenced from the dylib. */
-#define MH_HAS_TLV_DESCRIPTORS 0x800000 /* Contains a section of type 
-					    S_THREAD_LOCAL_VARIABLES */
-
-#define MH_NO_HEAP_EXECUTION 0x1000000	/* When this bit is set, the OS will
-					   run the main executable with
-					   a non-executable heap even on
-					   platforms (e.g. i386) that don't
-					   require it. Only used in MH_EXECUTE
-					   filetypes. */
-
-#define MH_APP_EXTENSION_SAFE 0x02000000 /* The code was linked for use in an
-					    application extension. */
-
-#define	MH_NLIST_OUTOFSYNC_WITH_DYLDINFO 0x04000000 /* The external symbols
-					   listed in the nlist symbol table do
-					   not include all the symbols listed in
-					   the dyld info. */
-
-#define	MH_SIM_SUPPORT 0x08000000	/* Allow LC_MIN_VERSION_MACOS and
-					   LC_BUILD_VERSION load commands with
-					   the platforms macOS, macCatalyst,
-					   iOSSimulator, tvOSSimulator and
-					   watchOSSimulator. */
-					   
-#define MH_DYLIB_IN_CACHE 0x80000000	/* Only for use on dylibs. When this bit
-					   is set, the dylib is part of the dyld
-					   shared cache, rather than loose in
-					   the filesystem. */
-
-/*
- * The load commands directly follow the mach_header.  The total size of all
- * of the commands is given by the sizeofcmds field in the mach_header.  All
- * load commands must have as their first two fields cmd and cmdsize.  The cmd
- * field is filled in with a constant for that command type.  Each command type
- * has a structure specifically for it.  The cmdsize field is the size in bytes
- * of the particular load command structure plus anything that follows it that
- * is a part of the load command (i.e. section structures, strings, etc.).  To
- * advance to the next load command the cmdsize can be added to the offset or
- * pointer of the current load command.  The cmdsize for 32-bit architectures
- * MUST be a multiple of 4 bytes and for 64-bit architectures MUST be a multiple
- * of 8 bytes (these are forever the maximum alignment of any load commands).
- * The padded bytes must be zero.  All tables in the object file must also
- * follow these rules so the file can be memory mapped.  Otherwise the pointers
- * to these tables will not work well or at all on some machines.  With all
- * padding zeroed like objects will compare byte for byte.
- */
-struct load_command {
-	uint32_t cmd;		/* type of load command */
-	uint32_t cmdsize;	/* total size of command in bytes */
-};
-
-/*
- * After MacOS X 10.1 when a new load command is added that is required to be
- * understood by the dynamic linker for the image to execute properly the
- * LC_REQ_DYLD bit will be or'ed into the load command constant.  If the dynamic
- * linker sees such a load command it it does not understand will issue a
- * "unknown load command required for execution" error and refuse to use the
- * image.  Other load commands without this bit that are not understood will
- * simply be ignored.
- */
-#define LC_REQ_DYLD 0x80000000
-
-/* Constants for the cmd field of all load commands, the type */
-#define	LC_SEGMENT	0x1	/* segment of this file to be mapped */
-#define	LC_SYMTAB	0x2	/* link-edit stab symbol table info */
-#define	LC_SYMSEG	0x3	/* link-edit gdb symbol table info (obsolete) */
-#define	LC_THREAD	0x4	/* thread */
-#define	LC_UNIXTHREAD	0x5	/* unix thread (includes a stack) */
-#define	LC_LOADFVMLIB	0x6	/* load a specified fixed VM shared library */
-#define	LC_IDFVMLIB	0x7	/* fixed VM shared library identification */
-#define	LC_IDENT	0x8	/* object identification info (obsolete) */
-#define LC_FVMFILE	0x9	/* fixed VM file inclusion (internal use) */
-#define LC_PREPAGE      0xa     /* prepage command (internal use) */
-#define	LC_DYSYMTAB	0xb	/* dynamic link-edit symbol table info */
-#define	LC_LOAD_DYLIB	0xc	/* load a dynamically linked shared library */
-#define	LC_ID_DYLIB	0xd	/* dynamically linked shared lib ident */
-#define LC_LOAD_DYLINKER 0xe	/* load a dynamic linker */
-#define LC_ID_DYLINKER	0xf	/* dynamic linker identification */
-#define	LC_PREBOUND_DYLIB 0x10	/* modules prebound for a dynamically */
-				/*  linked shared library */
-#define	LC_ROUTINES	0x11	/* image routines */
-#define	LC_SUB_FRAMEWORK 0x12	/* sub framework */
-#define	LC_SUB_UMBRELLA 0x13	/* sub umbrella */
-#define	LC_SUB_CLIENT	0x14	/* sub client */
-#define	LC_SUB_LIBRARY  0x15	/* sub library */
-#define	LC_TWOLEVEL_HINTS 0x16	/* two-level namespace lookup hints */
-#define	LC_PREBIND_CKSUM  0x17	/* prebind checksum */
-
-/*
- * load a dynamically linked shared library that is allowed to be missing
- * (all symbols are weak imported).
- */
-#define	LC_LOAD_WEAK_DYLIB (0x18 | LC_REQ_DYLD)
-
-#define	LC_SEGMENT_64	0x19	/* 64-bit segment of this file to be
-				   mapped */
-#define	LC_ROUTINES_64	0x1a	/* 64-bit image routines */
-#define LC_UUID		0x1b	/* the uuid */
-#define LC_RPATH       (0x1c | LC_REQ_DYLD)    /* runpath additions */
-#define LC_CODE_SIGNATURE 0x1d	/* local of code signature */
-#define LC_SEGMENT_SPLIT_INFO 0x1e /* local of info to split segments */
-#define LC_REEXPORT_DYLIB (0x1f | LC_REQ_DYLD) /* load and re-export dylib */
-#define	LC_LAZY_LOAD_DYLIB 0x20	/* delay load of dylib until first use */
-#define	LC_ENCRYPTION_INFO 0x21	/* encrypted segment information */
-#define	LC_DYLD_INFO 	0x22	/* compressed dyld information */
-#define	LC_DYLD_INFO_ONLY (0x22|LC_REQ_DYLD)	/* compressed dyld information only */
-#define	LC_LOAD_UPWARD_DYLIB (0x23 | LC_REQ_DYLD) /* load upward dylib */
-#define LC_VERSION_MIN_MACOSX 0x24   /* build for MacOSX min OS version */
-#define LC_VERSION_MIN_IPHONEOS 0x25 /* build for iPhoneOS min OS version */
-#define LC_FUNCTION_STARTS 0x26 /* compressed table of function start addresses */
-#define LC_DYLD_ENVIRONMENT 0x27 /* string for dyld to treat
-				    like environment variable */
-#define LC_MAIN (0x28|LC_REQ_DYLD) /* replacement for LC_UNIXTHREAD */
-#define LC_DATA_IN_CODE 0x29 /* table of non-instructions in __text */
-#define LC_SOURCE_VERSION 0x2A /* source version used to build binary */
-#define LC_DYLIB_CODE_SIGN_DRS 0x2B /* Code signing DRs copied from linked dylibs */
-#define	LC_ENCRYPTION_INFO_64 0x2C /* 64-bit encrypted segment information */
-#define LC_LINKER_OPTION 0x2D /* linker options in MH_OBJECT files */
-#define LC_LINKER_OPTIMIZATION_HINT 0x2E /* optimization hints in MH_OBJECT files */
-#define LC_VERSION_MIN_TVOS 0x2F /* build for AppleTV min OS version */
-#define LC_VERSION_MIN_WATCHOS 0x30 /* build for Watch min OS version */
-#define LC_NOTE 0x31 /* arbitrary data included within a Mach-O file */
-#define LC_BUILD_VERSION 0x32 /* build for platform min OS version */
-#define LC_DYLD_EXPORTS_TRIE (0x33 | LC_REQ_DYLD) /* used with linkedit_data_command, payload is trie */
-#define LC_DYLD_CHAINED_FIXUPS (0x34 | LC_REQ_DYLD) /* used with linkedit_data_command */
-
-/*
- * A variable length string in a load command is represented by an lc_str
- * union.  The strings are stored just after the load command structure and
- * the offset is from the start of the load command structure.  The size
- * of the string is reflected in the cmdsize field of the load command.
- * Once again any padded bytes to bring the cmdsize field to a multiple
- * of 4 bytes must be zero.
- */
-union lc_str {
-	uint32_t	offset;	/* offset to the string */
-#ifndef __LP64__
-	char		*ptr;	/* pointer to the string */
-#endif 
-};
-
-/*
- * The segment load command indicates that a part of this file is to be
- * mapped into the task's address space.  The size of this segment in memory,
- * vmsize, maybe equal to or larger than the amount to map from this file,
- * filesize.  The file is mapped starting at fileoff to the beginning of
- * the segment in memory, vmaddr.  The rest of the memory of the segment,
- * if any, is allocated zero fill on demand.  The segment's maximum virtual
- * memory protection and initial virtual memory protection are specified
- * by the maxprot and initprot fields.  If the segment has sections then the
- * section structures directly follow the segment command and their size is
- * reflected in cmdsize.
- */
-struct segment_command { /* for 32-bit architectures */
-	uint32_t	cmd;		/* LC_SEGMENT */
-	uint32_t	cmdsize;	/* includes sizeof section structs */
-	char		segname[16];	/* segment name */
-	uint32_t	vmaddr;		/* memory address of this segment */
-	uint32_t	vmsize;		/* memory size of this segment */
-	uint32_t	fileoff;	/* file offset of this segment */
-	uint32_t	filesize;	/* amount to map from the file */
-	vm_prot_t	maxprot;	/* maximum VM protection */
-	vm_prot_t	initprot;	/* initial VM protection */
-	uint32_t	nsects;		/* number of sections in segment */
-	uint32_t	flags;		/* flags */
-};
-
-/*
- * The 64-bit segment load command indicates that a part of this file is to be
- * mapped into a 64-bit task's address space.  If the 64-bit segment has
- * sections then section_64 structures directly follow the 64-bit segment
- * command and their size is reflected in cmdsize.
- */
-struct segment_command_64 { /* for 64-bit architectures */
-	uint32_t	cmd;		/* LC_SEGMENT_64 */
-	uint32_t	cmdsize;	/* includes sizeof section_64 structs */
-	char		segname[16];	/* segment name */
-	uint64_t	vmaddr;		/* memory address of this segment */
-	uint64_t	vmsize;		/* memory size of this segment */
-	uint64_t	fileoff;	/* file offset of this segment */
-	uint64_t	filesize;	/* amount to map from the file */
-	vm_prot_t	maxprot;	/* maximum VM protection */
-	vm_prot_t	initprot;	/* initial VM protection */
-	uint32_t	nsects;		/* number of sections in segment */
-	uint32_t	flags;		/* flags */
-};
-
-/* Constants for the flags field of the segment_command */
-#define	SG_HIGHVM	0x1	/* the file contents for this segment is for
-				   the high part of the VM space, the low part
-				   is zero filled (for stacks in core files) */
-#define	SG_FVMLIB	0x2	/* this segment is the VM that is allocated by
-				   a fixed VM library, for overlap checking in
-				   the link editor */
-#define	SG_NORELOC	0x4	/* this segment has nothing that was relocated
-				   in it and nothing relocated to it, that is
-				   it maybe safely replaced without relocation*/
-#define SG_PROTECTED_VERSION_1	0x8 /* This segment is protected.  If the
-				       segment starts at file offset 0, the
-				       first page of the segment is not
-				       protected.  All other pages of the
-				       segment are protected. */
-#define SG_READ_ONLY    0x10 /* This segment is made read-only after fixups */
-
-
-
-/*
- * A segment is made up of zero or more sections.  Non-MH_OBJECT files have
- * all of their segments with the proper sections in each, and padded to the
- * specified segment alignment when produced by the link editor.  The first
- * segment of a MH_EXECUTE and MH_FVMLIB format file contains the mach_header
- * and load commands of the object file before its first section.  The zero
- * fill sections are always last in their segment (in all formats).  This
- * allows the zeroed segment padding to be mapped into memory where zero fill
- * sections might be. The gigabyte zero fill sections, those with the section
- * type S_GB_ZEROFILL, can only be in a segment with sections of this type.
- * These segments are then placed after all other segments.
- *
- * The MH_OBJECT format has all of its sections in one segment for
- * compactness.  There is no padding to a specified segment boundary and the
- * mach_header and load commands are not part of the segment.
- *
- * Sections with the same section name, sectname, going into the same segment,
- * segname, are combined by the link editor.  The resulting section is aligned
- * to the maximum alignment of the combined sections and is the new section's
- * alignment.  The combined sections are aligned to their original alignment in
- * the combined section.  Any padded bytes to get the specified alignment are
- * zeroed.
- *
- * The format of the relocation entries referenced by the reloff and nreloc
- * fields of the section structure for mach object files is described in the
- * header file <reloc.h>.
- */
-struct section { /* for 32-bit architectures */
-	char		sectname[16];	/* name of this section */
-	char		segname[16];	/* segment this section goes in */
-	uint32_t	addr;		/* memory address of this section */
-	uint32_t	size;		/* size in bytes of this section */
-	uint32_t	offset;		/* file offset of this section */
-	uint32_t	align;		/* section alignment (power of 2) */
-	uint32_t	reloff;		/* file offset of relocation entries */
-	uint32_t	nreloc;		/* number of relocation entries */
-	uint32_t	flags;		/* flags (section type and attributes)*/
-	uint32_t	reserved1;	/* reserved (for offset or index) */
-	uint32_t	reserved2;	/* reserved (for count or sizeof) */
-};
-
-struct section_64 { /* for 64-bit architectures */
-	char		sectname[16];	/* name of this section */
-	char		segname[16];	/* segment this section goes in */
-	uint64_t	addr;		/* memory address of this section */
-	uint64_t	size;		/* size in bytes of this section */
-	uint32_t	offset;		/* file offset of this section */
-	uint32_t	align;		/* section alignment (power of 2) */
-	uint32_t	reloff;		/* file offset of relocation entries */
-	uint32_t	nreloc;		/* number of relocation entries */
-	uint32_t	flags;		/* flags (section type and attributes)*/
-	uint32_t	reserved1;	/* reserved (for offset or index) */
-	uint32_t	reserved2;	/* reserved (for count or sizeof) */
-	uint32_t	reserved3;	/* reserved */
-};
-
-/*
- * The flags field of a section structure is separated into two parts a section
- * type and section attributes.  The section types are mutually exclusive (it
- * can only have one type) but the section attributes are not (it may have more
- * than one attribute).
- */
-#define SECTION_TYPE		 0x000000ff	/* 256 section types */
-#define SECTION_ATTRIBUTES	 0xffffff00	/*  24 section attributes */
-
-/* Constants for the type of a section */
-#define	S_REGULAR		0x0	/* regular section */
-#define	S_ZEROFILL		0x1	/* zero fill on demand section */
-#define	S_CSTRING_LITERALS	0x2	/* section with only literal C strings*/
-#define	S_4BYTE_LITERALS	0x3	/* section with only 4 byte literals */
-#define	S_8BYTE_LITERALS	0x4	/* section with only 8 byte literals */
-#define	S_LITERAL_POINTERS	0x5	/* section with only pointers to */
-					/*  literals */
-/*
- * For the two types of symbol pointers sections and the symbol stubs section
- * they have indirect symbol table entries.  For each of the entries in the
- * section the indirect symbol table entries, in corresponding order in the
- * indirect symbol table, start at the index stored in the reserved1 field
- * of the section structure.  Since the indirect symbol table entries
- * correspond to the entries in the section the number of indirect symbol table
- * entries is inferred from the size of the section divided by the size of the
- * entries in the section.  For symbol pointers sections the size of the entries
- * in the section is 4 bytes and for symbol stubs sections the byte size of the
- * stubs is stored in the reserved2 field of the section structure.
- */
-#define	S_NON_LAZY_SYMBOL_POINTERS	0x6	/* section with only non-lazy
-						   symbol pointers */
-#define	S_LAZY_SYMBOL_POINTERS		0x7	/* section with only lazy symbol
-						   pointers */
-#define	S_SYMBOL_STUBS			0x8	/* section with only symbol
-						   stubs, byte size of stub in
-						   the reserved2 field */
-#define	S_MOD_INIT_FUNC_POINTERS	0x9	/* section with only function
-						   pointers for initialization*/
-#define	S_MOD_TERM_FUNC_POINTERS	0xa	/* section with only function
-						   pointers for termination */
-#define	S_COALESCED			0xb	/* section contains symbols that
-						   are to be coalesced */
-#define	S_GB_ZEROFILL			0xc	/* zero fill on demand section
-						   (that can be larger than 4
-						   gigabytes) */
-#define	S_INTERPOSING			0xd	/* section with only pairs of
-						   function pointers for
-						   interposing */
-#define	S_16BYTE_LITERALS		0xe	/* section with only 16 byte
-						   literals */
-#define	S_DTRACE_DOF			0xf	/* section contains 
-						   DTrace Object Format */
-#define	S_LAZY_DYLIB_SYMBOL_POINTERS	0x10	/* section with only lazy
-						   symbol pointers to lazy
-						   loaded dylibs */
-/*
- * Section types to support thread local variables
- */
-#define S_THREAD_LOCAL_REGULAR                   0x11  /* template of initial 
-							  values for TLVs */
-#define S_THREAD_LOCAL_ZEROFILL                  0x12  /* template of initial 
-							  values for TLVs */
-#define S_THREAD_LOCAL_VARIABLES                 0x13  /* TLV descriptors */
-#define S_THREAD_LOCAL_VARIABLE_POINTERS         0x14  /* pointers to TLV 
-                                                          descriptors */
-#define S_THREAD_LOCAL_INIT_FUNCTION_POINTERS    0x15  /* functions to call
-							  to initialize TLV
-							  values */
-#define S_INIT_FUNC_OFFSETS                      0x16  /* 32-bit offsets to
-							  initializers */
-
-/*
- * Constants for the section attributes part of the flags field of a section
- * structure.
- */
-#define SECTION_ATTRIBUTES_USR	 0xff000000	/* User setable attributes */
-#define S_ATTR_PURE_INSTRUCTIONS 0x80000000	/* section contains only true
-						   machine instructions */
-#define S_ATTR_NO_TOC 		 0x40000000	/* section contains coalesced
-						   symbols that are not to be
-						   in a ranlib table of
-						   contents */
-#define S_ATTR_STRIP_STATIC_SYMS 0x20000000	/* ok to strip static symbols
-						   in this section in files
-						   with the MH_DYLDLINK flag */
-#define S_ATTR_NO_DEAD_STRIP	 0x10000000	/* no dead stripping */
-#define S_ATTR_LIVE_SUPPORT	 0x08000000	/* blocks are live if they
-						   reference live blocks */
-#define S_ATTR_SELF_MODIFYING_CODE 0x04000000	/* Used with i386 code stubs
-						   written on by dyld */
-/*
- * If a segment contains any sections marked with S_ATTR_DEBUG then all
- * sections in that segment must have this attribute.  No section other than
- * a section marked with this attribute may reference the contents of this
- * section.  A section with this attribute may contain no symbols and must have
- * a section type S_REGULAR.  The static linker will not copy section contents
- * from sections with this attribute into its output file.  These sections
- * generally contain DWARF debugging info.
- */ 
-#define	S_ATTR_DEBUG		 0x02000000	/* a debug section */
-#define SECTION_ATTRIBUTES_SYS	 0x00ffff00	/* system setable attributes */
-#define S_ATTR_SOME_INSTRUCTIONS 0x00000400	/* section contains some
-						   machine instructions */
-#define S_ATTR_EXT_RELOC	 0x00000200	/* section has external
-						   relocation entries */
-#define S_ATTR_LOC_RELOC	 0x00000100	/* section has local
-						   relocation entries */
-
-
-/*
- * The names of segments and sections in them are mostly meaningless to the
- * link-editor.  But there are few things to support traditional UNIX
- * executables that require the link-editor and assembler to use some names
- * agreed upon by convention.
- *
- * The initial protection of the "__TEXT" segment has write protection turned
- * off (not writeable).
- *
- * The link-editor will allocate common symbols at the end of the "__common"
- * section in the "__DATA" segment.  It will create the section and segment
- * if needed.
- */
-
-/* The currently known segment names and the section names in those segments */
-
-#define	SEG_PAGEZERO	"__PAGEZERO"	/* the pagezero segment which has no */
-					/* protections and catches NULL */
-					/* references for MH_EXECUTE files */
-
-
-#define	SEG_TEXT	"__TEXT"	/* the tradition UNIX text segment */
-#define	SECT_TEXT	"__text"	/* the real text part of the text */
-					/* section no headers, and no padding */
-#define SECT_FVMLIB_INIT0 "__fvmlib_init0"	/* the fvmlib initialization */
-						/*  section */
-#define SECT_FVMLIB_INIT1 "__fvmlib_init1"	/* the section following the */
-					        /*  fvmlib initialization */
-						/*  section */
-
-#define	SEG_DATA	"__DATA"	/* the tradition UNIX data segment */
-#define	SECT_DATA	"__data"	/* the real initialized data section */
-					/* no padding, no bss overlap */
-#define	SECT_BSS	"__bss"		/* the real uninitialized data section*/
-					/* no padding */
-#define SECT_COMMON	"__common"	/* the section common symbols are */
-					/* allocated in by the link editor */
-
-#define	SEG_OBJC	"__OBJC"	/* objective-C runtime segment */
-#define SECT_OBJC_SYMBOLS "__symbol_table"	/* symbol table */
-#define SECT_OBJC_MODULES "__module_info"	/* module information */
-#define SECT_OBJC_STRINGS "__selector_strs"	/* string table */
-#define SECT_OBJC_REFS "__selector_refs"	/* string table */
-
-#define	SEG_ICON	 "__ICON"	/* the icon segment */
-#define	SECT_ICON_HEADER "__header"	/* the icon headers */
-#define	SECT_ICON_TIFF   "__tiff"	/* the icons in tiff format */
-
-#define	SEG_LINKEDIT	"__LINKEDIT"	/* the segment containing all structs */
-					/* created and maintained by the link */
-					/* editor.  Created with -seglinkedit */
-					/* option to ld(1) for MH_EXECUTE and */
-					/* FVMLIB file types only */
-
-#define SEG_UNIXSTACK	"__UNIXSTACK"	/* the unix stack segment */
-
-#define SEG_IMPORT	"__IMPORT"	/* the segment for the self (dyld) */
-					/* modifing code stubs that has read, */
-					/* write and execute permissions */
-
-/*
- * Fixed virtual memory shared libraries are identified by two things.  The
- * target pathname (the name of the library as found for execution), and the
- * minor version number.  The address of where the headers are loaded is in
- * header_addr. (THIS IS OBSOLETE and no longer supported).
- */
-struct fvmlib {
-	union lc_str	name;		/* library's target pathname */
-	uint32_t	minor_version;	/* library's minor version number */
-	uint32_t	header_addr;	/* library's header address */
-};
-
-/*
- * A fixed virtual shared library (filetype == MH_FVMLIB in the mach header)
- * contains a fvmlib_command (cmd == LC_IDFVMLIB) to identify the library.
- * An object that uses a fixed virtual shared library also contains a
- * fvmlib_command (cmd == LC_LOADFVMLIB) for each library it uses.
- * (THIS IS OBSOLETE and no longer supported).
- */
-struct fvmlib_command {
-	uint32_t	cmd;		/* LC_IDFVMLIB or LC_LOADFVMLIB */
-	uint32_t	cmdsize;	/* includes pathname string */
-	struct fvmlib	fvmlib;		/* the library identification */
-};
-
-/*
- * Dynamicly linked shared libraries are identified by two things.  The
- * pathname (the name of the library as found for execution), and the
- * compatibility version number.  The pathname must match and the compatibility
- * number in the user of the library must be greater than or equal to the
- * library being used.  The time stamp is used to record the time a library was
- * built and copied into user so it can be use to determined if the library used
- * at runtime is exactly the same as used to built the program.
- */
-struct dylib {
-    union lc_str  name;			/* library's path name */
-    uint32_t timestamp;			/* library's build time stamp */
-    uint32_t current_version;		/* library's current version number */
-    uint32_t compatibility_version;	/* library's compatibility vers number*/
-};
-
-/*
- * A dynamically linked shared library (filetype == MH_DYLIB in the mach header)
- * contains a dylib_command (cmd == LC_ID_DYLIB) to identify the library.
- * An object that uses a dynamically linked shared library also contains a
- * dylib_command (cmd == LC_LOAD_DYLIB, LC_LOAD_WEAK_DYLIB, or
- * LC_REEXPORT_DYLIB) for each library it uses.
- */
-struct dylib_command {
-	uint32_t	cmd;		/* LC_ID_DYLIB, LC_LOAD_{,WEAK_}DYLIB,
-					   LC_REEXPORT_DYLIB */
-	uint32_t	cmdsize;	/* includes pathname string */
-	struct dylib	dylib;		/* the library identification */
-};
-
-/*
- * A dynamically linked shared library may be a subframework of an umbrella
- * framework.  If so it will be linked with "-umbrella umbrella_name" where
- * Where "umbrella_name" is the name of the umbrella framework. A subframework
- * can only be linked against by its umbrella framework or other subframeworks
- * that are part of the same umbrella framework.  Otherwise the static link
- * editor produces an error and states to link against the umbrella framework.
- * The name of the umbrella framework for subframeworks is recorded in the
- * following structure.
- */
-struct sub_framework_command {
-	uint32_t	cmd;		/* LC_SUB_FRAMEWORK */
-	uint32_t	cmdsize;	/* includes umbrella string */
-	union lc_str 	umbrella;	/* the umbrella framework name */
-};
-
-/*
- * For dynamically linked shared libraries that are subframework of an umbrella
- * framework they can allow clients other than the umbrella framework or other
- * subframeworks in the same umbrella framework.  To do this the subframework
- * is built with "-allowable_client client_name" and an LC_SUB_CLIENT load
- * command is created for each -allowable_client flag.  The client_name is
- * usually a framework name.  It can also be a name used for bundles clients
- * where the bundle is built with "-client_name client_name".
- */
-struct sub_client_command {
-	uint32_t	cmd;		/* LC_SUB_CLIENT */
-	uint32_t	cmdsize;	/* includes client string */
-	union lc_str 	client;		/* the client name */
-};
-
-/*
- * A dynamically linked shared library may be a sub_umbrella of an umbrella
- * framework.  If so it will be linked with "-sub_umbrella umbrella_name" where
- * Where "umbrella_name" is the name of the sub_umbrella framework.  When
- * staticly linking when -twolevel_namespace is in effect a twolevel namespace 
- * umbrella framework will only cause its subframeworks and those frameworks
- * listed as sub_umbrella frameworks to be implicited linked in.  Any other
- * dependent dynamic libraries will not be linked it when -twolevel_namespace
- * is in effect.  The primary library recorded by the static linker when
- * resolving a symbol in these libraries will be the umbrella framework.
- * Zero or more sub_umbrella frameworks may be use by an umbrella framework.
- * The name of a sub_umbrella framework is recorded in the following structure.
- */
-struct sub_umbrella_command {
-	uint32_t	cmd;		/* LC_SUB_UMBRELLA */
-	uint32_t	cmdsize;	/* includes sub_umbrella string */
-	union lc_str 	sub_umbrella;	/* the sub_umbrella framework name */
-};
-
-/*
- * A dynamically linked shared library may be a sub_library of another shared
- * library.  If so it will be linked with "-sub_library library_name" where
- * Where "library_name" is the name of the sub_library shared library.  When
- * staticly linking when -twolevel_namespace is in effect a twolevel namespace 
- * shared library will only cause its subframeworks and those frameworks
- * listed as sub_umbrella frameworks and libraries listed as sub_libraries to
- * be implicited linked in.  Any other dependent dynamic libraries will not be
- * linked it when -twolevel_namespace is in effect.  The primary library
- * recorded by the static linker when resolving a symbol in these libraries
- * will be the umbrella framework (or dynamic library). Zero or more sub_library
- * shared libraries may be use by an umbrella framework or (or dynamic library).
- * The name of a sub_library framework is recorded in the following structure.
- * For example /usr/lib/libobjc_profile.A.dylib would be recorded as "libobjc".
- */
-struct sub_library_command {
-	uint32_t	cmd;		/* LC_SUB_LIBRARY */
-	uint32_t	cmdsize;	/* includes sub_library string */
-	union lc_str 	sub_library;	/* the sub_library name */
-};
-
-/*
- * A program (filetype == MH_EXECUTE) that is
- * prebound to its dynamic libraries has one of these for each library that
- * the static linker used in prebinding.  It contains a bit vector for the
- * modules in the library.  The bits indicate which modules are bound (1) and
- * which are not (0) from the library.  The bit for module 0 is the low bit
- * of the first byte.  So the bit for the Nth module is:
- * (linked_modules[N/8] >> N%8) & 1
- */
-struct prebound_dylib_command {
-	uint32_t	cmd;		/* LC_PREBOUND_DYLIB */
-	uint32_t	cmdsize;	/* includes strings */
-	union lc_str	name;		/* library's path name */
-	uint32_t	nmodules;	/* number of modules in library */
-	union lc_str	linked_modules;	/* bit vector of linked modules */
-};
-
-/*
- * A program that uses a dynamic linker contains a dylinker_command to identify
- * the name of the dynamic linker (LC_LOAD_DYLINKER).  And a dynamic linker
- * contains a dylinker_command to identify the dynamic linker (LC_ID_DYLINKER).
- * A file can have at most one of these.
- * This struct is also used for the LC_DYLD_ENVIRONMENT load command and
- * contains string for dyld to treat like environment variable.
- */
-struct dylinker_command {
-	uint32_t	cmd;		/* LC_ID_DYLINKER, LC_LOAD_DYLINKER or
-					   LC_DYLD_ENVIRONMENT */
-	uint32_t	cmdsize;	/* includes pathname string */
-	union lc_str    name;		/* dynamic linker's path name */
-};
-
-/*
- * Thread commands contain machine-specific data structures suitable for
- * use in the thread state primitives.  The machine specific data structures
- * follow the struct thread_command as follows.
- * Each flavor of machine specific data structure is preceded by an uint32_t
- * constant for the flavor of that data structure, an uint32_t that is the
- * count of uint32_t's of the size of the state data structure and then
- * the state data structure follows.  This triple may be repeated for many
- * flavors.  The constants for the flavors, counts and state data structure
- * definitions are expected to be in the header file <machine/thread_status.h>.
- * These machine specific data structures sizes must be multiples of
- * 4 bytes.  The cmdsize reflects the total size of the thread_command
- * and all of the sizes of the constants for the flavors, counts and state
- * data structures.
- *
- * For executable objects that are unix processes there will be one
- * thread_command (cmd == LC_UNIXTHREAD) created for it by the link-editor.
- * This is the same as a LC_THREAD, except that a stack is automatically
- * created (based on the shell's limit for the stack size).  Command arguments
- * and environment variables are copied onto that stack.
- */
-struct thread_command {
-	uint32_t	cmd;		/* LC_THREAD or  LC_UNIXTHREAD */
-	uint32_t	cmdsize;	/* total size of this command */
-	/* uint32_t flavor		   flavor of thread state */
-	/* uint32_t count		   count of uint32_t's in thread state */
-	/* struct XXX_thread_state state   thread state for this flavor */
-	/* ... */
-};
-
-/*
- * The routines command contains the address of the dynamic shared library 
- * initialization routine and an index into the module table for the module
- * that defines the routine.  Before any modules are used from the library the
- * dynamic linker fully binds the module that defines the initialization routine
- * and then calls it.  This gets called before any module initialization
- * routines (used for C++ static constructors) in the library.
- */
-struct routines_command { /* for 32-bit architectures */
-	uint32_t	cmd;		/* LC_ROUTINES */
-	uint32_t	cmdsize;	/* total size of this command */
-	uint32_t	init_address;	/* address of initialization routine */
-	uint32_t	init_module;	/* index into the module table that */
-				        /*  the init routine is defined in */
-	uint32_t	reserved1;
-	uint32_t	reserved2;
-	uint32_t	reserved3;
-	uint32_t	reserved4;
-	uint32_t	reserved5;
-	uint32_t	reserved6;
-};
-
-/*
- * The 64-bit routines command.  Same use as above.
- */
-struct routines_command_64 { /* for 64-bit architectures */
-	uint32_t	cmd;		/* LC_ROUTINES_64 */
-	uint32_t	cmdsize;	/* total size of this command */
-	uint64_t	init_address;	/* address of initialization routine */
-	uint64_t	init_module;	/* index into the module table that */
-					/*  the init routine is defined in */
-	uint64_t	reserved1;
-	uint64_t	reserved2;
-	uint64_t	reserved3;
-	uint64_t	reserved4;
-	uint64_t	reserved5;
-	uint64_t	reserved6;
-};
-
-/*
- * The symtab_command contains the offsets and sizes of the link-edit 4.3BSD
- * "stab" style symbol table information as described in the header files
- * <nlist.h> and <stab.h>.
- */
-struct symtab_command {
-	uint32_t	cmd;		/* LC_SYMTAB */
-	uint32_t	cmdsize;	/* sizeof(struct symtab_command) */
-	uint32_t	symoff;		/* symbol table offset */
-	uint32_t	nsyms;		/* number of symbol table entries */
-	uint32_t	stroff;		/* string table offset */
-	uint32_t	strsize;	/* string table size in bytes */
-};
-
-/*
- * This is the second set of the symbolic information which is used to support
- * the data structures for the dynamically link editor.
- *
- * The original set of symbolic information in the symtab_command which contains
- * the symbol and string tables must also be present when this load command is
- * present.  When this load command is present the symbol table is organized
- * into three groups of symbols:
- *	local symbols (static and debugging symbols) - grouped by module
- *	defined external symbols - grouped by module (sorted by name if not lib)
- *	undefined external symbols (sorted by name if MH_BINDATLOAD is not set,
- *	     			    and in order the were seen by the static
- *				    linker if MH_BINDATLOAD is set)
- * In this load command there are offsets and counts to each of the three groups
- * of symbols.
- *
- * This load command contains a the offsets and sizes of the following new
- * symbolic information tables:
- *	table of contents
- *	module table
- *	reference symbol table
- *	indirect symbol table
- * The first three tables above (the table of contents, module table and
- * reference symbol table) are only present if the file is a dynamically linked
- * shared library.  For executable and object modules, which are files
- * containing only one module, the information that would be in these three
- * tables is determined as follows:
- * 	table of contents - the defined external symbols are sorted by name
- *	module table - the file contains only one module so everything in the
- *		       file is part of the module.
- *	reference symbol table - is the defined and undefined external symbols
- *
- * For dynamically linked shared library files this load command also contains
- * offsets and sizes to the pool of relocation entries for all sections
- * separated into two groups:
- *	external relocation entries
- *	local relocation entries
- * For executable and object modules the relocation entries continue to hang
- * off the section structures.
- */
-struct dysymtab_command {
-    uint32_t cmd;	/* LC_DYSYMTAB */
-    uint32_t cmdsize;	/* sizeof(struct dysymtab_command) */
-
-    /*
-     * The symbols indicated by symoff and nsyms of the LC_SYMTAB load command
-     * are grouped into the following three groups:
-     *    local symbols (further grouped by the module they are from)
-     *    defined external symbols (further grouped by the module they are from)
-     *    undefined symbols
-     *
-     * The local symbols are used only for debugging.  The dynamic binding
-     * process may have to use them to indicate to the debugger the local
-     * symbols for a module that is being bound.
-     *
-     * The last two groups are used by the dynamic binding process to do the
-     * binding (indirectly through the module table and the reference symbol
-     * table when this is a dynamically linked shared library file).
-     */
-    uint32_t ilocalsym;	/* index to local symbols */
-    uint32_t nlocalsym;	/* number of local symbols */
-
-    uint32_t iextdefsym;/* index to externally defined symbols */
-    uint32_t nextdefsym;/* number of externally defined symbols */
-
-    uint32_t iundefsym;	/* index to undefined symbols */
-    uint32_t nundefsym;	/* number of undefined symbols */
-
-    /*
-     * For the for the dynamic binding process to find which module a symbol
-     * is defined in the table of contents is used (analogous to the ranlib
-     * structure in an archive) which maps defined external symbols to modules
-     * they are defined in.  This exists only in a dynamically linked shared
-     * library file.  For executable and object modules the defined external
-     * symbols are sorted by name and is use as the table of contents.
-     */
-    uint32_t tocoff;	/* file offset to table of contents */
-    uint32_t ntoc;	/* number of entries in table of contents */
-
-    /*
-     * To support dynamic binding of "modules" (whole object files) the symbol
-     * table must reflect the modules that the file was created from.  This is
-     * done by having a module table that has indexes and counts into the merged
-     * tables for each module.  The module structure that these two entries
-     * refer to is described below.  This exists only in a dynamically linked
-     * shared library file.  For executable and object modules the file only
-     * contains one module so everything in the file belongs to the module.
-     */
-    uint32_t modtaboff;	/* file offset to module table */
-    uint32_t nmodtab;	/* number of module table entries */
-
-    /*
-     * To support dynamic module binding the module structure for each module
-     * indicates the external references (defined and undefined) each module
-     * makes.  For each module there is an offset and a count into the
-     * reference symbol table for the symbols that the module references.
-     * This exists only in a dynamically linked shared library file.  For
-     * executable and object modules the defined external symbols and the
-     * undefined external symbols indicates the external references.
-     */
-    uint32_t extrefsymoff;	/* offset to referenced symbol table */
-    uint32_t nextrefsyms;	/* number of referenced symbol table entries */
-
-    /*
-     * The sections that contain "symbol pointers" and "routine stubs" have
-     * indexes and (implied counts based on the size of the section and fixed
-     * size of the entry) into the "indirect symbol" table for each pointer
-     * and stub.  For every section of these two types the index into the
-     * indirect symbol table is stored in the section header in the field
-     * reserved1.  An indirect symbol table entry is simply a 32bit index into
-     * the symbol table to the symbol that the pointer or stub is referring to.
-     * The indirect symbol table is ordered to match the entries in the section.
-     */
-    uint32_t indirectsymoff; /* file offset to the indirect symbol table */
-    uint32_t nindirectsyms;  /* number of indirect symbol table entries */
-
-    /*
-     * To support relocating an individual module in a library file quickly the
-     * external relocation entries for each module in the library need to be
-     * accessed efficiently.  Since the relocation entries can't be accessed
-     * through the section headers for a library file they are separated into
-     * groups of local and external entries further grouped by module.  In this
-     * case the presents of this load command who's extreloff, nextrel,
-     * locreloff and nlocrel fields are non-zero indicates that the relocation
-     * entries of non-merged sections are not referenced through the section
-     * structures (and the reloff and nreloc fields in the section headers are
-     * set to zero).
-     *
-     * Since the relocation entries are not accessed through the section headers
-     * this requires the r_address field to be something other than a section
-     * offset to identify the item to be relocated.  In this case r_address is
-     * set to the offset from the vmaddr of the first LC_SEGMENT command.
-     * For MH_SPLIT_SEGS images r_address is set to the the offset from the
-     * vmaddr of the first read-write LC_SEGMENT command.
-     *
-     * The relocation entries are grouped by module and the module table
-     * entries have indexes and counts into them for the group of external
-     * relocation entries for that the module.
-     *
-     * For sections that are merged across modules there must not be any
-     * remaining external relocation entries for them (for merged sections
-     * remaining relocation entries must be local).
-     */
-    uint32_t extreloff;	/* offset to external relocation entries */
-    uint32_t nextrel;	/* number of external relocation entries */
-
-    /*
-     * All the local relocation entries are grouped together (they are not
-     * grouped by their module since they are only used if the object is moved
-     * from it staticly link edited address).
-     */
-    uint32_t locreloff;	/* offset to local relocation entries */
-    uint32_t nlocrel;	/* number of local relocation entries */
-
-};	
-
-/*
- * An indirect symbol table entry is simply a 32bit index into the symbol table 
- * to the symbol that the pointer or stub is refering to.  Unless it is for a
- * non-lazy symbol pointer section for a defined symbol which strip(1) as 
- * removed.  In which case it has the value INDIRECT_SYMBOL_LOCAL.  If the
- * symbol was also absolute INDIRECT_SYMBOL_ABS is or'ed with that.
- */
-#define INDIRECT_SYMBOL_LOCAL	0x80000000
-#define INDIRECT_SYMBOL_ABS	0x40000000
-
-
-/* a table of contents entry */
-struct dylib_table_of_contents {
-    uint32_t symbol_index;	/* the defined external symbol
-				   (index into the symbol table) */
-    uint32_t module_index;	/* index into the module table this symbol
-				   is defined in */
-};	
-
-/* a module table entry */
-struct dylib_module {
-    uint32_t module_name;	/* the module name (index into string table) */
-
-    uint32_t iextdefsym;	/* index into externally defined symbols */
-    uint32_t nextdefsym;	/* number of externally defined symbols */
-    uint32_t irefsym;		/* index into reference symbol table */
-    uint32_t nrefsym;		/* number of reference symbol table entries */
-    uint32_t ilocalsym;		/* index into symbols for local symbols */
-    uint32_t nlocalsym;		/* number of local symbols */
-
-    uint32_t iextrel;		/* index into external relocation entries */
-    uint32_t nextrel;		/* number of external relocation entries */
-
-    uint32_t iinit_iterm;	/* low 16 bits are the index into the init
-				   section, high 16 bits are the index into
-			           the term section */
-    uint32_t ninit_nterm;	/* low 16 bits are the number of init section
-				   entries, high 16 bits are the number of
-				   term section entries */
-
-    uint32_t			/* for this module address of the start of */
-	objc_module_info_addr;  /*  the (__OBJC,__module_info) section */
-    uint32_t			/* for this module size of */
-	objc_module_info_size;	/*  the (__OBJC,__module_info) section */
-};	
-
-/* a 64-bit module table entry */
-struct dylib_module_64 {
-    uint32_t module_name;	/* the module name (index into string table) */
-
-    uint32_t iextdefsym;	/* index into externally defined symbols */
-    uint32_t nextdefsym;	/* number of externally defined symbols */
-    uint32_t irefsym;		/* index into reference symbol table */
-    uint32_t nrefsym;		/* number of reference symbol table entries */
-    uint32_t ilocalsym;		/* index into symbols for local symbols */
-    uint32_t nlocalsym;		/* number of local symbols */
-
-    uint32_t iextrel;		/* index into external relocation entries */
-    uint32_t nextrel;		/* number of external relocation entries */
-
-    uint32_t iinit_iterm;	/* low 16 bits are the index into the init
-				   section, high 16 bits are the index into
-				   the term section */
-    uint32_t ninit_nterm;      /* low 16 bits are the number of init section
-				  entries, high 16 bits are the number of
-				  term section entries */
-
-    uint32_t			/* for this module size of */
-        objc_module_info_size;	/*  the (__OBJC,__module_info) section */
-    uint64_t			/* for this module address of the start of */
-        objc_module_info_addr;	/*  the (__OBJC,__module_info) section */
-};
-
-/* 
- * The entries in the reference symbol table are used when loading the module
- * (both by the static and dynamic link editors) and if the module is unloaded
- * or replaced.  Therefore all external symbols (defined and undefined) are
- * listed in the module's reference table.  The flags describe the type of
- * reference that is being made.  The constants for the flags are defined in
- * <mach-o/nlist.h> as they are also used for symbol table entries.
- */
-struct dylib_reference {
-    uint32_t isym:24,		/* index into the symbol table */
-    		  flags:8;	/* flags to indicate the type of reference */
-};
-
-/*
- * The twolevel_hints_command contains the offset and number of hints in the
- * two-level namespace lookup hints table.
- */
-struct twolevel_hints_command {
-    uint32_t cmd;	/* LC_TWOLEVEL_HINTS */
-    uint32_t cmdsize;	/* sizeof(struct twolevel_hints_command) */
-    uint32_t offset;	/* offset to the hint table */
-    uint32_t nhints;	/* number of hints in the hint table */
-};
-
-/*
- * The entries in the two-level namespace lookup hints table are twolevel_hint
- * structs.  These provide hints to the dynamic link editor where to start
- * looking for an undefined symbol in a two-level namespace image.  The
- * isub_image field is an index into the sub-images (sub-frameworks and
- * sub-umbrellas list) that made up the two-level image that the undefined
- * symbol was found in when it was built by the static link editor.  If
- * isub-image is 0 the the symbol is expected to be defined in library and not
- * in the sub-images.  If isub-image is non-zero it is an index into the array
- * of sub-images for the umbrella with the first index in the sub-images being
- * 1. The array of sub-images is the ordered list of sub-images of the umbrella
- * that would be searched for a symbol that has the umbrella recorded as its
- * primary library.  The table of contents index is an index into the
- * library's table of contents.  This is used as the starting point of the
- * binary search or a directed linear search.
- */
-struct twolevel_hint {
-    uint32_t 
-	isub_image:8,	/* index into the sub images */
-	itoc:24;	/* index into the table of contents */
-};
-
-/*
- * The prebind_cksum_command contains the value of the original check sum for
- * prebound files or zero.  When a prebound file is first created or modified
- * for other than updating its prebinding information the value of the check sum
- * is set to zero.  When the file has it prebinding re-done and if the value of
- * the check sum is zero the original check sum is calculated and stored in
- * cksum field of this load command in the output file.  If when the prebinding
- * is re-done and the cksum field is non-zero it is left unchanged from the
- * input file.
- */
-struct prebind_cksum_command {
-    uint32_t cmd;	/* LC_PREBIND_CKSUM */
-    uint32_t cmdsize;	/* sizeof(struct prebind_cksum_command) */
-    uint32_t cksum;	/* the check sum or zero */
-};
-
-/*
- * The uuid load command contains a single 128-bit unique random number that
- * identifies an object produced by the static link editor.
- */
-struct uuid_command {
-    uint32_t	cmd;		/* LC_UUID */
-    uint32_t	cmdsize;	/* sizeof(struct uuid_command) */
-    uint8_t	uuid[16];	/* the 128-bit uuid */
-};
-
-/*
- * The rpath_command contains a path which at runtime should be added to
- * the current run path used to find @rpath prefixed dylibs.
- */
-struct rpath_command {
-    uint32_t	 cmd;		/* LC_RPATH */
-    uint32_t	 cmdsize;	/* includes string */
-    union lc_str path;		/* path to add to run path */
-};
-
-/*
- * The linkedit_data_command contains the offsets and sizes of a blob
- * of data in the __LINKEDIT segment.  
- */
-struct linkedit_data_command {
-    uint32_t	cmd;		/* LC_CODE_SIGNATURE, LC_SEGMENT_SPLIT_INFO,
-				   LC_FUNCTION_STARTS, LC_DATA_IN_CODE,
-				   LC_DYLIB_CODE_SIGN_DRS,
-				   LC_LINKER_OPTIMIZATION_HINT,
-				   LC_DYLD_EXPORTS_TRIE, or
-				   LC_DYLD_CHAINED_FIXUPS. */
-    uint32_t	cmdsize;	/* sizeof(struct linkedit_data_command) */
-    uint32_t	dataoff;	/* file offset of data in __LINKEDIT segment */
-    uint32_t	datasize;	/* file size of data in __LINKEDIT segment  */
-};
-
-/*
- * The encryption_info_command contains the file offset and size of an
- * of an encrypted segment.
- */
-struct encryption_info_command {
-   uint32_t	cmd;		/* LC_ENCRYPTION_INFO */
-   uint32_t	cmdsize;	/* sizeof(struct encryption_info_command) */
-   uint32_t	cryptoff;	/* file offset of encrypted range */
-   uint32_t	cryptsize;	/* file size of encrypted range */
-   uint32_t	cryptid;	/* which enryption system,
-				   0 means not-encrypted yet */
-};
-
-/*
- * The encryption_info_command_64 contains the file offset and size of an
- * of an encrypted segment (for use in x86_64 targets).
- */
-struct encryption_info_command_64 {
-   uint32_t	cmd;		/* LC_ENCRYPTION_INFO_64 */
-   uint32_t	cmdsize;	/* sizeof(struct encryption_info_command_64) */
-   uint32_t	cryptoff;	/* file offset of encrypted range */
-   uint32_t	cryptsize;	/* file size of encrypted range */
-   uint32_t	cryptid;	/* which enryption system,
-				   0 means not-encrypted yet */
-   uint32_t	pad;		/* padding to make this struct's size a multiple
-				   of 8 bytes */
-};
-
-/*
- * The version_min_command contains the min OS version on which this 
- * binary was built to run.
- */
-struct version_min_command {
-    uint32_t	cmd;		/* LC_VERSION_MIN_MACOSX or
-				   LC_VERSION_MIN_IPHONEOS or
-				   LC_VERSION_MIN_WATCHOS or
-				   LC_VERSION_MIN_TVOS */
-    uint32_t	cmdsize;	/* sizeof(struct min_version_command) */
-    uint32_t	version;	/* X.Y.Z is encoded in nibbles xxxx.yy.zz */
-    uint32_t	sdk;		/* X.Y.Z is encoded in nibbles xxxx.yy.zz */
-};
-
-/*
- * The build_version_command contains the min OS version on which this 
- * binary was built to run for its platform.  The list of known platforms and
- * tool values following it.
- */
-struct build_version_command {
-    uint32_t	cmd;		/* LC_BUILD_VERSION */
-    uint32_t	cmdsize;	/* sizeof(struct build_version_command) plus */
-				/* ntools * sizeof(struct build_tool_version) */
-    uint32_t	platform;	/* platform */
-    uint32_t	minos;		/* X.Y.Z is encoded in nibbles xxxx.yy.zz */
-    uint32_t	sdk;		/* X.Y.Z is encoded in nibbles xxxx.yy.zz */
-    uint32_t	ntools;		/* number of tool entries following this */
-};
-
-struct build_tool_version {
-    uint32_t	tool;		/* enum for the tool */
-    uint32_t	version;	/* version number of the tool */
-};
-
-/* Known values for the platform field above. */
-#define PLATFORM_MACOS 1
-#define PLATFORM_IOS 2
-#define PLATFORM_TVOS 3
-#define PLATFORM_WATCHOS 4
-#define PLATFORM_BRIDGEOS 5
-#define PLATFORM_MACCATALYST 6
-#if (!defined(PLATFORM_MACCATALYST))
-#define PLATFORM_MACCATALYST 6
-#endif
-#define PLATFORM_IOSSIMULATOR 7
-#define PLATFORM_TVOSSIMULATOR 8
-#define PLATFORM_WATCHOSSIMULATOR 9
-#define PLATFORM_DRIVERKIT 10
-
-/* Known values for the tool field above. */
-#define TOOL_CLANG 1
-#define TOOL_SWIFT 2
-#define TOOL_LD	3
-
-/*
- * The dyld_info_command contains the file offsets and sizes of 
- * the new compressed form of the information dyld needs to 
- * load the image.  This information is used by dyld on Mac OS X
- * 10.6 and later.  All information pointed to by this command
- * is encoded using byte streams, so no endian swapping is needed
- * to interpret it. 
- */
-struct dyld_info_command {
-   uint32_t   cmd;		/* LC_DYLD_INFO or LC_DYLD_INFO_ONLY */
-   uint32_t   cmdsize;		/* sizeof(struct dyld_info_command) */
-
-    /*
-     * Dyld rebases an image whenever dyld loads it at an address different
-     * from its preferred address.  The rebase information is a stream
-     * of byte sized opcodes whose symbolic names start with REBASE_OPCODE_.
-     * Conceptually the rebase information is a table of tuples:
-     *    <seg-index, seg-offset, type>
-     * The opcodes are a compressed way to encode the table by only
-     * encoding when a column changes.  In addition simple patterns
-     * like "every n'th offset for m times" can be encoded in a few
-     * bytes.
-     */
-    uint32_t   rebase_off;	/* file offset to rebase info  */
-    uint32_t   rebase_size;	/* size of rebase info   */
-    
-    /*
-     * Dyld binds an image during the loading process, if the image
-     * requires any pointers to be initialized to symbols in other images.  
-     * The bind information is a stream of byte sized 
-     * opcodes whose symbolic names start with BIND_OPCODE_.
-     * Conceptually the bind information is a table of tuples:
-     *    <seg-index, seg-offset, type, symbol-library-ordinal, symbol-name, addend>
-     * The opcodes are a compressed way to encode the table by only
-     * encoding when a column changes.  In addition simple patterns
-     * like for runs of pointers initialzed to the same value can be 
-     * encoded in a few bytes.
-     */
-    uint32_t   bind_off;	/* file offset to binding info   */
-    uint32_t   bind_size;	/* size of binding info  */
-        
-    /*
-     * Some C++ programs require dyld to unique symbols so that all
-     * images in the process use the same copy of some code/data.
-     * This step is done after binding. The content of the weak_bind
-     * info is an opcode stream like the bind_info.  But it is sorted
-     * alphabetically by symbol name.  This enable dyld to walk 
-     * all images with weak binding information in order and look
-     * for collisions.  If there are no collisions, dyld does
-     * no updating.  That means that some fixups are also encoded
-     * in the bind_info.  For instance, all calls to "operator new"
-     * are first bound to libstdc++.dylib using the information
-     * in bind_info.  Then if some image overrides operator new
-     * that is detected when the weak_bind information is processed
-     * and the call to operator new is then rebound.
-     */
-    uint32_t   weak_bind_off;	/* file offset to weak binding info   */
-    uint32_t   weak_bind_size;  /* size of weak binding info  */
-    
-    /*
-     * Some uses of external symbols do not need to be bound immediately.
-     * Instead they can be lazily bound on first use.  The lazy_bind
-     * are contains a stream of BIND opcodes to bind all lazy symbols.
-     * Normal use is that dyld ignores the lazy_bind section when
-     * loading an image.  Instead the static linker arranged for the
-     * lazy pointer to initially point to a helper function which 
-     * pushes the offset into the lazy_bind area for the symbol
-     * needing to be bound, then jumps to dyld which simply adds
-     * the offset to lazy_bind_off to get the information on what 
-     * to bind.  
-     */
-    uint32_t   lazy_bind_off;	/* file offset to lazy binding info */
-    uint32_t   lazy_bind_size;  /* size of lazy binding infs */
-    
-    /*
-     * The symbols exported by a dylib are encoded in a trie.  This
-     * is a compact representation that factors out common prefixes.
-     * It also reduces LINKEDIT pages in RAM because it encodes all  
-     * information (name, address, flags) in one small, contiguous range.
-     * The export area is a stream of nodes.  The first node sequentially
-     * is the start node for the trie.  
-     *
-     * Nodes for a symbol start with a uleb128 that is the length of
-     * the exported symbol information for the string so far.
-     * If there is no exported symbol, the node starts with a zero byte. 
-     * If there is exported info, it follows the length.  
-     *
-     * First is a uleb128 containing flags. Normally, it is followed by
-     * a uleb128 encoded offset which is location of the content named
-     * by the symbol from the mach_header for the image.  If the flags
-     * is EXPORT_SYMBOL_FLAGS_REEXPORT, then following the flags is
-     * a uleb128 encoded library ordinal, then a zero terminated
-     * UTF8 string.  If the string is zero length, then the symbol
-     * is re-export from the specified dylib with the same name.
-     * If the flags is EXPORT_SYMBOL_FLAGS_STUB_AND_RESOLVER, then following
-     * the flags is two uleb128s: the stub offset and the resolver offset.
-     * The stub is used by non-lazy pointers.  The resolver is used
-     * by lazy pointers and must be called to get the actual address to use.
-     *
-     * After the optional exported symbol information is a byte of
-     * how many edges (0-255) that this node has leaving it, 
-     * followed by each edge.
-     * Each edge is a zero terminated UTF8 of the addition chars
-     * in the symbol, followed by a uleb128 offset for the node that
-     * edge points to.
-     *  
-     */
-    uint32_t   export_off;	/* file offset to lazy binding info */
-    uint32_t   export_size;	/* size of lazy binding infs */
-};
-
-/*
- * The following are used to encode rebasing information
- */
-#define REBASE_TYPE_POINTER					1
-#define REBASE_TYPE_TEXT_ABSOLUTE32				2
-#define REBASE_TYPE_TEXT_PCREL32				3
-
-#define REBASE_OPCODE_MASK					0xF0
-#define REBASE_IMMEDIATE_MASK					0x0F
-#define REBASE_OPCODE_DONE					0x00
-#define REBASE_OPCODE_SET_TYPE_IMM				0x10
-#define REBASE_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB		0x20
-#define REBASE_OPCODE_ADD_ADDR_ULEB				0x30
-#define REBASE_OPCODE_ADD_ADDR_IMM_SCALED			0x40
-#define REBASE_OPCODE_DO_REBASE_IMM_TIMES			0x50
-#define REBASE_OPCODE_DO_REBASE_ULEB_TIMES			0x60
-#define REBASE_OPCODE_DO_REBASE_ADD_ADDR_ULEB			0x70
-#define REBASE_OPCODE_DO_REBASE_ULEB_TIMES_SKIPPING_ULEB	0x80
-
-
-/*
- * The following are used to encode binding information
- */
-#define BIND_TYPE_POINTER					1
-#define BIND_TYPE_TEXT_ABSOLUTE32				2
-#define BIND_TYPE_TEXT_PCREL32					3
-
-#define BIND_SPECIAL_DYLIB_SELF					 0
-#define BIND_SPECIAL_DYLIB_MAIN_EXECUTABLE			-1
-#define BIND_SPECIAL_DYLIB_FLAT_LOOKUP				-2
-#define BIND_SPECIAL_DYLIB_WEAK_LOOKUP				-3
-
-#define BIND_SYMBOL_FLAGS_WEAK_IMPORT				0x1
-#define BIND_SYMBOL_FLAGS_NON_WEAK_DEFINITION			0x8
-
-#define BIND_OPCODE_MASK					0xF0
-#define BIND_IMMEDIATE_MASK					0x0F
-#define BIND_OPCODE_DONE					0x00
-#define BIND_OPCODE_SET_DYLIB_ORDINAL_IMM			0x10
-#define BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB			0x20
-#define BIND_OPCODE_SET_DYLIB_SPECIAL_IMM			0x30
-#define BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM		0x40
-#define BIND_OPCODE_SET_TYPE_IMM				0x50
-#define BIND_OPCODE_SET_ADDEND_SLEB				0x60
-#define BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB			0x70
-#define BIND_OPCODE_ADD_ADDR_ULEB				0x80
-#define BIND_OPCODE_DO_BIND					0x90
-#define BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB			0xA0
-#define BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED			0xB0
-#define BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB		0xC0
-#define	BIND_OPCODE_THREADED					0xD0
-#define	BIND_SUBOPCODE_THREADED_SET_BIND_ORDINAL_TABLE_SIZE_ULEB 0x00
-#define	BIND_SUBOPCODE_THREADED_APPLY				 0x01
-
-
-/*
- * The following are used on the flags byte of a terminal node
- * in the export information.
- */
-#define EXPORT_SYMBOL_FLAGS_KIND_MASK				0x03
-#define EXPORT_SYMBOL_FLAGS_KIND_REGULAR			0x00
-#define EXPORT_SYMBOL_FLAGS_KIND_THREAD_LOCAL			0x01
-#define EXPORT_SYMBOL_FLAGS_KIND_ABSOLUTE			0x02
-#define EXPORT_SYMBOL_FLAGS_WEAK_DEFINITION			0x04
-#define EXPORT_SYMBOL_FLAGS_REEXPORT				0x08
-#define EXPORT_SYMBOL_FLAGS_STUB_AND_RESOLVER			0x10
-
-/*
- * The linker_option_command contains linker options embedded in object files.
- */
-struct linker_option_command {
-    uint32_t  cmd;	/* LC_LINKER_OPTION only used in MH_OBJECT filetypes */
-    uint32_t  cmdsize;
-    uint32_t  count;	/* number of strings */
-    /* concatenation of zero terminated UTF8 strings.
-       Zero filled at end to align */
-};
-
-/*
- * The symseg_command contains the offset and size of the GNU style
- * symbol table information as described in the header file <symseg.h>.
- * The symbol roots of the symbol segments must also be aligned properly
- * in the file.  So the requirement of keeping the offsets aligned to a
- * multiple of a 4 bytes translates to the length field of the symbol
- * roots also being a multiple of a long.  Also the padding must again be
- * zeroed. (THIS IS OBSOLETE and no longer supported).
- */
-struct symseg_command {
-	uint32_t	cmd;		/* LC_SYMSEG */
-	uint32_t	cmdsize;	/* sizeof(struct symseg_command) */
-	uint32_t	offset;		/* symbol segment offset */
-	uint32_t	size;		/* symbol segment size in bytes */
-};
-
-/*
- * The ident_command contains a free format string table following the
- * ident_command structure.  The strings are null terminated and the size of
- * the command is padded out with zero bytes to a multiple of 4 bytes/
- * (THIS IS OBSOLETE and no longer supported).
- */
-struct ident_command {
-	uint32_t cmd;		/* LC_IDENT */
-	uint32_t cmdsize;	/* strings that follow this command */
-};
-
-/*
- * The fvmfile_command contains a reference to a file to be loaded at the
- * specified virtual address.  (Presently, this command is reserved for
- * internal use.  The kernel ignores this command when loading a program into
- * memory).
- */
-struct fvmfile_command {
-	uint32_t cmd;			/* LC_FVMFILE */
-	uint32_t cmdsize;		/* includes pathname string */
-	union lc_str	name;		/* files pathname */
-	uint32_t	header_addr;	/* files virtual address */
-};
-
-
-/*
- * The entry_point_command is a replacement for thread_command.
- * It is used for main executables to specify the location (file offset)
- * of main().  If -stack_size was used at link time, the stacksize
- * field will contain the stack size need for the main thread.
- */
-struct entry_point_command {
-    uint32_t  cmd;	/* LC_MAIN only used in MH_EXECUTE filetypes */
-    uint32_t  cmdsize;	/* 24 */
-    uint64_t  entryoff;	/* file (__TEXT) offset of main() */
-    uint64_t  stacksize;/* if not zero, initial stack size */
-};
-
-
-/*
- * The source_version_command is an optional load command containing
- * the version of the sources used to build the binary.
- */
-struct source_version_command {
-    uint32_t  cmd;	/* LC_SOURCE_VERSION */
-    uint32_t  cmdsize;	/* 16 */
-    uint64_t  version;	/* A.B.C.D.E packed as a24.b10.c10.d10.e10 */
-};
-
-
-/*
- * The LC_DATA_IN_CODE load commands uses a linkedit_data_command 
- * to point to an array of data_in_code_entry entries. Each entry
- * describes a range of data in a code section.
- */
-struct data_in_code_entry {
-    uint32_t	offset;  /* from mach_header to start of data range*/
-    uint16_t	length;  /* number of bytes in data range */
-    uint16_t	kind;    /* a DICE_KIND_* value  */
-};
-#define DICE_KIND_DATA              0x0001
-#define DICE_KIND_JUMP_TABLE8       0x0002
-#define DICE_KIND_JUMP_TABLE16      0x0003
-#define DICE_KIND_JUMP_TABLE32      0x0004
-#define DICE_KIND_ABS_JUMP_TABLE32  0x0005
-
-
-
-/*
- * Sections of type S_THREAD_LOCAL_VARIABLES contain an array 
- * of tlv_descriptor structures.
- */
-struct tlv_descriptor
-{
-	void*		(*thunk)(struct tlv_descriptor*);
-	unsigned long	key;
-	unsigned long	offset;
-};
-
-/*
- * LC_NOTE commands describe a region of arbitrary data included in a Mach-O
- * file.  Its initial use is to record extra data in MH_CORE files.
- */
-struct note_command {
-    uint32_t	cmd;		/* LC_NOTE */
-    uint32_t	cmdsize;	/* sizeof(struct note_command) */
-    char	data_owner[16];	/* owner name for this LC_NOTE */
-    uint64_t	offset;		/* file offset of this data */
-    uint64_t	size;		/* length of data region */
-};
-
-#endif /* _MACHO_LOADER_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/mach/exception_types.h b/lib/libc/include/x86_64-macos-gnu/mach/exception_types.h
deleted file mode 100644
index a0026b9ce2..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/mach/exception_types.h
+++ /dev/null
@@ -1,204 +0,0 @@
-/*
- * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-/*
- * @OSF_COPYRIGHT@
- */
-/*
- * Mach Operating System
- * Copyright (c) 1991,1990,1989,1988,1987 Carnegie Mellon University
- * All Rights Reserved.
- *
- * Permission to use, copy, modify and distribute this software and its
- * documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
- * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie Mellon
- * the rights to redistribute these changes.
- */
-/*
- */
-
-#ifndef _MACH_EXCEPTION_TYPES_H_
-#define _MACH_EXCEPTION_TYPES_H_
-
-#include <mach/machine/exception.h>
-
-/*
- *	Machine-independent exception definitions.
- */
-
-#define EXC_BAD_ACCESS          1       /* Could not access memory */
-/* Code contains kern_return_t describing error. */
-/* Subcode contains bad memory address. */
-
-#define EXC_BAD_INSTRUCTION     2       /* Instruction failed */
-/* Illegal or undefined instruction or operand */
-
-#define EXC_ARITHMETIC          3       /* Arithmetic exception */
-/* Exact nature of exception is in code field */
-
-#define EXC_EMULATION           4       /* Emulation instruction */
-/* Emulation support instruction encountered */
-/* Details in code and subcode fields	*/
-
-#define EXC_SOFTWARE            5       /* Software generated exception */
-/* Exact exception is in code field. */
-/* Codes 0 - 0xFFFF reserved to hardware */
-/* Codes 0x10000 - 0x1FFFF reserved for OS emulation (Unix) */
-
-#define EXC_BREAKPOINT          6       /* Trace, breakpoint, etc. */
-/* Details in code field. */
-
-#define EXC_SYSCALL             7       /* System calls. */
-
-#define EXC_MACH_SYSCALL        8       /* Mach system calls. */
-
-#define EXC_RPC_ALERT           9       /* RPC alert */
-
-#define EXC_CRASH               10      /* Abnormal process exit */
-
-#define EXC_RESOURCE            11      /* Hit resource consumption limit */
-/* Exact resource is in code field. */
-
-#define EXC_GUARD               12      /* Violated guarded resource protections */
-
-#define EXC_CORPSE_NOTIFY       13      /* Abnormal process exited to corpse state */
-
-#define EXC_CORPSE_VARIANT_BIT  0x100  /* bit set for EXC_*_CORPSE variants of EXC_* */
-
-
-/*
- *	Machine-independent exception behaviors
- */
-
-# define EXCEPTION_DEFAULT              1
-/*	Send a catch_exception_raise message including the identity.
- */
-
-# define EXCEPTION_STATE                2
-/*	Send a catch_exception_raise_state message including the
- *	thread state.
- */
-
-# define EXCEPTION_STATE_IDENTITY       3
-/*	Send a catch_exception_raise_state_identity message including
- *	the thread identity and state.
- */
-
-#define MACH_EXCEPTION_ERRORS           0x40000000
-/*	include additional exception specific errors, not used yet.  */
-
-#define MACH_EXCEPTION_CODES            0x80000000
-/*	Send 64-bit code and subcode in the exception header */
-
-#define MACH_EXCEPTION_MASK             (MACH_EXCEPTION_CODES | MACH_EXCEPTION_ERRORS)
-/*
- * Masks for exception definitions, above
- * bit zero is unused, therefore 1 word = 31 exception types
- */
-
-#define EXC_MASK_BAD_ACCESS             (1 << EXC_BAD_ACCESS)
-#define EXC_MASK_BAD_INSTRUCTION        (1 << EXC_BAD_INSTRUCTION)
-#define EXC_MASK_ARITHMETIC             (1 << EXC_ARITHMETIC)
-#define EXC_MASK_EMULATION              (1 << EXC_EMULATION)
-#define EXC_MASK_SOFTWARE               (1 << EXC_SOFTWARE)
-#define EXC_MASK_BREAKPOINT             (1 << EXC_BREAKPOINT)
-#define EXC_MASK_SYSCALL                (1 << EXC_SYSCALL)
-#define EXC_MASK_MACH_SYSCALL           (1 << EXC_MACH_SYSCALL)
-#define EXC_MASK_RPC_ALERT              (1 << EXC_RPC_ALERT)
-#define EXC_MASK_CRASH                  (1 << EXC_CRASH)
-#define EXC_MASK_RESOURCE               (1 << EXC_RESOURCE)
-#define EXC_MASK_GUARD                  (1 << EXC_GUARD)
-#define EXC_MASK_CORPSE_NOTIFY          (1 << EXC_CORPSE_NOTIFY)
-
-#define EXC_MASK_ALL    (EXC_MASK_BAD_ACCESS |                  \
-	                 EXC_MASK_BAD_INSTRUCTION |             \
-	                 EXC_MASK_ARITHMETIC |                  \
-	                 EXC_MASK_EMULATION |                   \
-	                 EXC_MASK_SOFTWARE |                    \
-	                 EXC_MASK_BREAKPOINT |                  \
-	                 EXC_MASK_SYSCALL |                     \
-	                 EXC_MASK_MACH_SYSCALL |                \
-	                 EXC_MASK_RPC_ALERT |                   \
-	                 EXC_MASK_RESOURCE |                    \
-	                 EXC_MASK_GUARD |                       \
-	                 EXC_MASK_MACHINE)
-
-
-#define FIRST_EXCEPTION         1       /* ZERO is illegal */
-
-/*
- * Machine independent codes for EXC_SOFTWARE
- * Codes 0x10000 - 0x1FFFF reserved for OS emulation (Unix)
- * 0x10000 - 0x10002 in use for unix signals
- * 0x20000 - 0x2FFFF reserved for MACF
- */
-#define EXC_SOFT_SIGNAL         0x10003 /* Unix signal exceptions */
-
-#define EXC_MACF_MIN            0x20000 /* MACF exceptions */
-#define EXC_MACF_MAX            0x2FFFF
-
-#ifndef ASSEMBLER
-
-#include <mach/port.h>
-#include <mach/thread_status.h>
-#include <mach/machine/vm_types.h>
-/*
- * Exported types
- */
-
-typedef int                             exception_type_t;
-typedef integer_t                       exception_data_type_t;
-typedef int64_t                         mach_exception_data_type_t;
-typedef int                             exception_behavior_t;
-typedef exception_data_type_t           *exception_data_t;
-typedef mach_exception_data_type_t      *mach_exception_data_t;
-typedef unsigned int                    exception_mask_t;
-typedef exception_mask_t                *exception_mask_array_t;
-typedef exception_behavior_t            *exception_behavior_array_t;
-typedef thread_state_flavor_t           *exception_flavor_array_t;
-typedef mach_port_t                     *exception_port_array_t;
-typedef mach_exception_data_type_t      mach_exception_code_t;
-typedef mach_exception_data_type_t      mach_exception_subcode_t;
-
-#endif  /* ASSEMBLER */
-
-#endif  /* _MACH_EXCEPTION_TYPES_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/mach/host_special_ports.h b/lib/libc/include/x86_64-macos-gnu/mach/host_special_ports.h
deleted file mode 100644
index 8d4cdbefce..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/mach/host_special_ports.h
+++ /dev/null
@@ -1,281 +0,0 @@
-/*
- * Copyright (c) 2003 Apple Computer, Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-/*
- * @OSF_COPYRIGHT@
- */
-/*
- * Mach Operating System
- * Copyright (c) 1991 Carnegie Mellon University
- * All Rights Reserved.
- *
- * Permission to use, copy, modify and distribute this software and its
- * documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
- * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie Mellon
- * the rights to redistribute these changes.
- */
-/*
- */
-/*
- *	File:	mach/host_special_ports.h
- *
- *	Defines codes for access to host-wide special ports.
- */
-
-#ifndef _MACH_HOST_SPECIAL_PORTS_H_
-#define _MACH_HOST_SPECIAL_PORTS_H_
-
-/*
- * Cannot be set or gotten from user space
- */
-#define HOST_SECURITY_PORT               0
-
-#define HOST_MIN_SPECIAL_PORT            HOST_SECURITY_PORT
-
-/*
- * Always provided by kernel (cannot be set from user-space).
- */
-#define HOST_PORT                        1
-#define HOST_PRIV_PORT                   2
-#define HOST_IO_MASTER_PORT              3
-#define HOST_MAX_SPECIAL_KERNEL_PORT     7 /* room to grow */
-
-#define HOST_LAST_SPECIAL_KERNEL_PORT    HOST_IO_MASTER_PORT
-
-/*
- * Not provided by kernel
- */
-#define HOST_DYNAMIC_PAGER_PORT         (1 + HOST_MAX_SPECIAL_KERNEL_PORT)
-#define HOST_AUDIT_CONTROL_PORT         (2 + HOST_MAX_SPECIAL_KERNEL_PORT)
-#define HOST_USER_NOTIFICATION_PORT     (3 + HOST_MAX_SPECIAL_KERNEL_PORT)
-#define HOST_AUTOMOUNTD_PORT            (4 + HOST_MAX_SPECIAL_KERNEL_PORT)
-#define HOST_LOCKD_PORT                 (5 + HOST_MAX_SPECIAL_KERNEL_PORT)
-#define HOST_KTRACE_BACKGROUND_PORT     (6 + HOST_MAX_SPECIAL_KERNEL_PORT)
-#define HOST_SEATBELT_PORT              (7 + HOST_MAX_SPECIAL_KERNEL_PORT)
-#define HOST_KEXTD_PORT                 (8 + HOST_MAX_SPECIAL_KERNEL_PORT)
-#define HOST_LAUNCHCTL_PORT             (9 + HOST_MAX_SPECIAL_KERNEL_PORT)
-#define HOST_UNFREED_PORT               (10 + HOST_MAX_SPECIAL_KERNEL_PORT)
-#define HOST_AMFID_PORT                 (11 + HOST_MAX_SPECIAL_KERNEL_PORT)
-#define HOST_GSSD_PORT                  (12 + HOST_MAX_SPECIAL_KERNEL_PORT)
-#define HOST_TELEMETRY_PORT             (13 + HOST_MAX_SPECIAL_KERNEL_PORT)
-#define HOST_ATM_NOTIFICATION_PORT      (14 + HOST_MAX_SPECIAL_KERNEL_PORT)
-#define HOST_COALITION_PORT             (15 + HOST_MAX_SPECIAL_KERNEL_PORT)
-#define HOST_SYSDIAGNOSE_PORT           (16 + HOST_MAX_SPECIAL_KERNEL_PORT)
-#define HOST_XPC_EXCEPTION_PORT         (17 + HOST_MAX_SPECIAL_KERNEL_PORT)
-#define HOST_CONTAINERD_PORT            (18 + HOST_MAX_SPECIAL_KERNEL_PORT)
-#define HOST_NODE_PORT                  (19 + HOST_MAX_SPECIAL_KERNEL_PORT)
-#define HOST_RESOURCE_NOTIFY_PORT       (20 + HOST_MAX_SPECIAL_KERNEL_PORT)
-#define HOST_CLOSURED_PORT              (21 + HOST_MAX_SPECIAL_KERNEL_PORT)
-#define HOST_SYSPOLICYD_PORT            (22 + HOST_MAX_SPECIAL_KERNEL_PORT)
-#define HOST_FILECOORDINATIOND_PORT     (23 + HOST_MAX_SPECIAL_KERNEL_PORT)
-#define HOST_FAIRPLAYD_PORT             (24 + HOST_MAX_SPECIAL_KERNEL_PORT)
-
-#define HOST_MAX_SPECIAL_PORT           HOST_FAIRPLAYD_PORT
-/* MAX = last since rdar://35861175 */
-
-/* obsolete name */
-#define HOST_CHUD_PORT HOST_LAUNCHCTL_PORT
-
-/*
- * Special node identifier to always represent the local node.
- */
-#define HOST_LOCAL_NODE                  -1
-
-/*
- * Definitions for ease of use.
- *
- * In the get call, the host parameter can be any host, but will generally
- * be the local node host port. In the set call, the host must the per-node
- * host port for the node being affected.
- */
-#define host_get_host_port(host, port)  \
-	(host_get_special_port((host),  \
-	HOST_LOCAL_NODE, HOST_PORT, (port)))
-#define host_set_host_port(host, port) (KERN_INVALID_ARGUMENT)
-
-#define host_get_host_priv_port(host, port)     \
-	(host_get_special_port((host),          \
-	HOST_LOCAL_NODE, HOST_PRIV_PORT, (port)))
-#define host_set_host_priv_port(host, port) (KERN_INVALID_ARGUMENT)
-
-#define host_get_io_master_port(host, port)     \
-	(host_get_special_port((host),          \
-	HOST_LOCAL_NODE, HOST_IO_MASTER_PORT, (port)))
-#define host_set_io_master_port(host, port) (KERN_INVALID_ARGUMENT)
-
-/*
- * User-settable special ports.
- */
-#define host_get_dynamic_pager_port(host, port) \
-	(host_get_special_port((host),                  \
-	HOST_LOCAL_NODE, HOST_DYNAMIC_PAGER_PORT, (port)))
-#define host_set_dynamic_pager_port(host, port) \
-	(host_set_special_port((host), HOST_DYNAMIC_PAGER_PORT, (port)))
-
-#define host_get_audit_control_port(host, port) \
-	(host_get_special_port((host),          \
-	HOST_LOCAL_NODE, HOST_AUDIT_CONTROL_PORT, (port)))
-#define host_set_audit_control_port(host, port) \
-	(host_set_special_port((host), HOST_AUDIT_CONTROL_PORT, (port)))
-
-#define host_get_user_notification_port(host, port)     \
-	(host_get_special_port((host),                  \
-	HOST_LOCAL_NODE, HOST_USER_NOTIFICATION_PORT, (port)))
-#define host_set_user_notification_port(host, port)     \
-	(host_set_special_port((host), HOST_USER_NOTIFICATION_PORT, (port)))
-
-#define host_get_automountd_port(host, port)    \
-	(host_get_special_port((host),          \
-	HOST_LOCAL_NODE, HOST_AUTOMOUNTD_PORT, (port)))
-#define host_set_automountd_port(host, port)    \
-	(host_set_special_port((host), HOST_AUTOMOUNTD_PORT, (port)))
-
-#define host_get_lockd_port(host, port) \
-	(host_get_special_port((host),                  \
-	HOST_LOCAL_NODE, HOST_LOCKD_PORT, (port)))
-#define host_set_lockd_port(host, port) \
-	(host_set_special_port((host), HOST_LOCKD_PORT, (port)))
-
-#define host_get_ktrace_background_port(host, port)     \
-	(host_get_special_port((host),                  \
-	HOST_LOCAL_NODE, HOST_KTRACE_BACKGROUND_PORT, (port)))
-#define host_set_ktrace_background_port(host, port)     \
-	(host_set_special_port((host), HOST_KTRACE_BACKGROUND_PORT, (port)))
-
-#define host_get_kextd_port(host, port) \
-	(host_get_special_port((host),                  \
-	HOST_LOCAL_NODE, HOST_KEXTD_PORT, (port)))
-#define host_set_kextd_port(host, port) \
-	(host_set_special_port((host), HOST_KEXTD_PORT, (port)))
-
-#define host_get_launchctl_port(host, port) \
-	(host_get_special_port((host), HOST_LOCAL_NODE, HOST_LAUNCHCTL_PORT, \
-	(port)))
-#define host_set_launchctl_port(host, port) \
-	(host_set_special_port((host), HOST_LAUNCHCTL_PORT, (port)))
-
-#define host_get_chud_port(host, port) host_get_launchctl_port(host, port)
-#define host_set_chud_port(host, port) host_set_launchctl_port(host, port)
-
-#define host_get_unfreed_port(host, port)       \
-	(host_get_special_port((host),                  \
-	HOST_LOCAL_NODE, HOST_UNFREED_PORT, (port)))
-#define host_set_unfreed_port(host, port)       \
-	(host_set_special_port((host), HOST_UNFREED_PORT, (port)))
-
-#define host_get_amfid_port(host, port) \
-	(host_get_special_port((host),                  \
-	HOST_LOCAL_NODE, HOST_AMFID_PORT, (port)))
-#define host_set_amfid_port(host, port) \
-	(host_set_special_port((host), HOST_AMFID_PORT, (port)))
-
-#define host_get_gssd_port(host, port)  \
-	(host_get_special_port((host),                  \
-	HOST_LOCAL_NODE, HOST_GSSD_PORT, (port)))
-#define host_set_gssd_port(host, port)  \
-	(host_set_special_port((host), HOST_GSSD_PORT, (port)))
-
-#define host_get_telemetry_port(host, port)     \
-	(host_get_special_port((host),                  \
-	HOST_LOCAL_NODE, HOST_TELEMETRY_PORT, (port)))
-#define host_set_telemetry_port(host, port)     \
-	(host_set_special_port((host), HOST_TELEMETRY_PORT, (port)))
-
-#define host_get_atm_notification_port(host, port)      \
-	(host_get_special_port((host),                  \
-	HOST_LOCAL_NODE, HOST_ATM_NOTIFICATION_PORT, (port)))
-#define host_set_atm_notification_port(host, port)      \
-	(host_set_special_port((host), HOST_ATM_NOTIFICATION_PORT, (port)))
-
-#define host_get_coalition_port(host, port)     \
-	(host_get_special_port((host),                  \
-	HOST_LOCAL_NODE, HOST_COALITION_PORT, (port)))
-#define host_set_coalition_port(host, port)     \
-	(host_set_special_port((host), HOST_COALITION_PORT, (port)))
-
-#define host_get_sysdiagnose_port(host, port)   \
-	(host_get_special_port((host),                  \
-	HOST_LOCAL_NODE, HOST_SYSDIAGNOSE_PORT, (port)))
-#define host_set_sysdiagnose_port(host, port)   \
-	(host_set_special_port((host), HOST_SYSDIAGNOSE_PORT, (port)))
-
-#define host_get_container_port(host, port)     \
-	(host_get_special_port((host),                  \
-	HOST_LOCAL_NODE, HOST_CONTAINERD_PORT, (port)))
-#define host_set_container_port(host, port)     \
-	(host_set_special_port((host), HOST_CONTAINERD_PORT, (port)))
-
-#define host_get_node_port(host, port)  \
-	(host_get_special_port((host),                  \
-	HOST_LOCAL_NODE, HOST_NODE_PORT, (port)))
-#define host_set_node_port(host, port)  \
-	(host_set_special_port((host), HOST_NODE_PORT, (port)))
-
-#define host_get_closured_port(host, port)      \
-	(host_get_special_port((host),                  \
-	HOST_LOCAL_NODE, HOST_CLOSURED_PORT, (port)))
-#define host_set_closured_port(host, port)      \
-	(host_set_special_port((host), HOST_CLOSURED_PORT, (port)))
-
-#define host_get_syspolicyd_port(host, port)    \
-	(host_get_special_port((host),                          \
-	HOST_LOCAL_NODE, HOST_SYSPOLICYD_PORT, (port)))
-#define host_set_syspolicyd_port(host, port)    \
-	(host_set_special_port((host), HOST_SYSPOLICYD_PORT, (port)))
-
-#define host_get_filecoordinationd_port(host, port)     \
-	(host_get_special_port((host),                  \
-	HOST_LOCAL_NODE, HOST_FILECOORDINATIOND_PORT, (port)))
-#define host_set_filecoordinationd_port(host, port)     \
-	(host_set_special_port((host), HOST_FILECOORDINATIOND_PORT, (port)))
-
-#define host_get_fairplayd_port(host, port)     \
-	(host_get_special_port((host),                  \
-	HOST_LOCAL_NODE, HOST_FAIRPLAYD_PORT, (port)))
-#define host_set_fairplayd_port(host, port)     \
-	(host_set_special_port((host), HOST_FAIRPLAYD_PORT, (port)))
-
-/* HOST_RESOURCE_NOTIFY_PORT doesn't #defines these conveniences.
- *  All lookups go through send_resource_violation()
- */
-
-#endif  /* _MACH_HOST_SPECIAL_PORTS_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/mach/i386/_structs.h b/lib/libc/include/x86_64-macos-gnu/mach/i386/_structs.h
index f041af9f3f..248653b4f8 100644
--- a/lib/libc/include/x86_64-macos-gnu/mach/i386/_structs.h
+++ b/lib/libc/include/x86_64-macos-gnu/mach/i386/_structs.h
@@ -603,7 +603,48 @@ _STRUCT_X86_DEBUG_STATE32
 	unsigned int	__dr6;
 	unsigned int	__dr7;
 };
+
+#define _STRUCT_X86_INSTRUCTION_STATE	struct __x86_instruction_state
+_STRUCT_X86_INSTRUCTION_STATE
+{
+        int		__insn_stream_valid_bytes;
+        int		__insn_offset;
+	int		__out_of_synch;	/*
+					 * non-zero when the cacheline that includes the insn_offset
+					 * is replaced in the insn_bytes array due to a mismatch
+					 * detected when comparing it with the same cacheline in memory
+					 */
+#define _X86_INSTRUCTION_STATE_MAX_INSN_BYTES    (2448 - 64 - 4)
+        __uint8_t	__insn_bytes[_X86_INSTRUCTION_STATE_MAX_INSN_BYTES];
+#define _X86_INSTRUCTION_STATE_CACHELINE_SIZE	64
+	__uint8_t	__insn_cacheline[_X86_INSTRUCTION_STATE_CACHELINE_SIZE];
+};
+
+#define _STRUCT_LAST_BRANCH_RECORD	struct __last_branch_record
+_STRUCT_LAST_BRANCH_RECORD
+{
+	__uint64_t	__from_ip;
+	__uint64_t	__to_ip;
+	__uint32_t	__mispredict : 1,
+			__tsx_abort  : 1,
+			__in_tsx     : 1,
+			__cycle_count: 16,
+			__reserved   : 13;
+};
+
+#define _STRUCT_LAST_BRANCH_STATE	struct __last_branch_state
+_STRUCT_LAST_BRANCH_STATE
+{
+        int				__lbr_count;
+	__uint32_t			__lbr_supported_tsx : 1,
+					__lbr_supported_cycle_count : 1,
+					__reserved : 30;
+#define	__LASTBRANCH_MAX	32
+	_STRUCT_LAST_BRANCH_RECORD	__lbrs[__LASTBRANCH_MAX];
+};
+
 #else /* !__DARWIN_UNIX03 */
+
 #define _STRUCT_X86_DEBUG_STATE32	struct x86_debug_state32
 _STRUCT_X86_DEBUG_STATE32
 {
@@ -616,6 +657,45 @@ _STRUCT_X86_DEBUG_STATE32
 	unsigned int	dr6;
 	unsigned int	dr7;
 };
+
+#define _STRUCT_X86_INSTRUCTION_STATE	struct __x86_instruction_state
+_STRUCT_X86_INSTRUCTION_STATE
+{
+        int		insn_stream_valid_bytes;
+        int		insn_offset;
+	int		out_of_synch;	/*
+					 * non-zero when the cacheline that includes the insn_offset
+					 * is replaced in the insn_bytes array due to a mismatch
+					 * detected when comparing it with the same cacheline in memory
+					 */
+#define x86_INSTRUCTION_STATE_MAX_INSN_BYTES    (2448 - 64 - 4)
+        __uint8_t	insn_bytes[x86_INSTRUCTION_STATE_MAX_INSN_BYTES];
+#define x86_INSTRUCTION_STATE_CACHELINE_SIZE	64
+	__uint8_t	insn_cacheline[x86_INSTRUCTION_STATE_CACHELINE_SIZE];
+};
+
+#define _STRUCT_LAST_BRANCH_RECORD	struct __last_branch_record
+_STRUCT_LAST_BRANCH_RECORD
+{
+	__uint64_t	from_ip;
+	__uint64_t	to_ip;
+	__uint32_t	mispredict : 1,
+			tsx_abort  : 1,
+			in_tsx     : 1,
+			cycle_count: 16,
+			reserved   : 13;
+};
+
+#define _STRUCT_LAST_BRANCH_STATE	struct __last_branch_state
+_STRUCT_LAST_BRANCH_STATE
+{
+        int				lbr_count;
+	__uint32_t			lbr_supported_tsx : 1,
+					lbr_supported_cycle_count : 1,
+					reserved : 30;
+#define	__LASTBRANCH_MAX	32
+	_STRUCT_LAST_BRANCH_RECORD	lbrs[__LASTBRANCH_MAX];
+};
 #endif /* !__DARWIN_UNIX03 */
 
 #define	_STRUCT_X86_PAGEIN_STATE	struct __x86_pagein_state
diff --git a/lib/libc/include/x86_64-macos-gnu/mach/i386/thread_state.h b/lib/libc/include/x86_64-macos-gnu/mach/i386/thread_state.h
index 78595255a3..4d9825be70 100644
--- a/lib/libc/include/x86_64-macos-gnu/mach/i386/thread_state.h
+++ b/lib/libc/include/x86_64-macos-gnu/mach/i386/thread_state.h
@@ -32,7 +32,7 @@
 #ifndef _MACH_I386_THREAD_STATE_H_
 #define _MACH_I386_THREAD_STATE_H_
 
-/* Size of maximum exported thread state in words */
+/* Size of maximum exported thread state in 32-bit words */
 #define I386_THREAD_STATE_MAX   (614)    /* Size of biggest state possible */
 
 #if defined (__i386__) || defined(__x86_64__)
diff --git a/lib/libc/include/x86_64-macos-gnu/mach/i386/thread_status.h b/lib/libc/include/x86_64-macos-gnu/mach/i386/thread_status.h
index 233e0f22a6..24de7ae76c 100644
--- a/lib/libc/include/x86_64-macos-gnu/mach/i386/thread_status.h
+++ b/lib/libc/include/x86_64-macos-gnu/mach/i386/thread_status.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2000-2006 Apple Computer, Inc. All rights reserved.
+ * Copyright (c) 2000-2020 Apple Computer, Inc. All rights reserved.
  *
  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
  *
@@ -121,6 +121,8 @@
 #define x86_AVX512_STATE                (x86_AVX512_STATE32 + 2)
 #define x86_PAGEIN_STATE                22
 #define x86_THREAD_FULL_STATE64         23
+#define x86_INSTRUCTION_STATE           24
+#define x86_LAST_BRANCH_STATE           25
 
 /*
  * Largest state on this machine:
@@ -155,6 +157,8 @@
 	  (x == x86_AVX512_STATE64)		|| \
 	  (x == x86_AVX512_STATE)		|| \
 	  (x == x86_PAGEIN_STATE)		|| \
+	  (x == x86_INSTRUCTION_STATE)		|| \
+	  (x == x86_LAST_BRANCH_STATE)		|| \
 	  (x == THREAD_STATE_NONE))
 
 struct x86_state_hdr {
@@ -259,6 +263,19 @@ typedef _STRUCT_X86_PAGEIN_STATE x86_pagein_state_t;
 
 #define X86_PAGEIN_STATE_COUNT x86_PAGEIN_STATE_COUNT
 
+typedef _STRUCT_X86_INSTRUCTION_STATE x86_instruction_state_t;
+#define x86_INSTRUCTION_STATE_COUNT \
+    ((mach_msg_type_number_t)(sizeof(x86_instruction_state_t) / sizeof(int)))
+
+#define X86_INSTRUCTION_STATE_COUNT x86_INSTRUCTION_STATE_COUNT
+
+typedef _STRUCT_LAST_BRANCH_STATE last_branch_state_t;
+#define x86_LAST_BRANCH_STATE_COUNT \
+    ((mach_msg_type_number_t)(sizeof(last_branch_state_t) / sizeof(int)))
+
+#define X86_LAST_BRANCH_STATE_COUNT x86_LAST_BRANCH_STATE_COUNT
+
+
 /*
  * Combined thread, float and exception states
  */
diff --git a/lib/libc/include/x86_64-macos-gnu/mach/i386/vm_param.h b/lib/libc/include/x86_64-macos-gnu/mach/i386/vm_param.h
index a85ee924b7..fa27fffa2f 100644
--- a/lib/libc/include/x86_64-macos-gnu/mach/i386/vm_param.h
+++ b/lib/libc/include/x86_64-macos-gnu/mach/i386/vm_param.h
@@ -90,47 +90,34 @@
 #ifndef _MACH_I386_VM_PARAM_H_
 #define _MACH_I386_VM_PARAM_H_
 
+#if !defined(KERNEL) && !defined(__ASSEMBLER__)
+
+#include <mach/vm_page_size.h>
+#endif
+
 #define BYTE_SIZE               8               /* byte size in bits */
 
 #define I386_PGBYTES            4096            /* bytes per 80386 page */
 #define I386_PGSHIFT            12              /* bitshift for pages */
 
-#define PAGE_SIZE               I386_PGBYTES
+
+#if !defined(__MAC_OS_X_VERSION_MIN_REQUIRED) || (__MAC_OS_X_VERSION_MIN_REQUIRED < 101600)
 #define PAGE_SHIFT              I386_PGSHIFT
-#define PAGE_MASK               (PAGE_SIZE - 1)
+#define PAGE_SIZE               I386_PGBYTES
+#define PAGE_MASK               (PAGE_SIZE-1)
+#else /* !defined(__MAC_OS_X_VERSION_MIN_REQUIRED) || (__MAC_OS_X_VERSION_MIN_REQUIRED < 101600) */
+#define PAGE_SHIFT              vm_page_shift
+#define PAGE_SIZE               vm_page_size
+#define PAGE_MASK               vm_page_mask
+#endif /* !defined(__MAC_OS_X_VERSION_MIN_REQUIRED) || (__MAC_OS_X_VERSION_MIN_REQUIRED < 101600) */
 
-#define PAGE_MAX_SHIFT          PAGE_SHIFT
-#define PAGE_MAX_SIZE           PAGE_SIZE
-#define PAGE_MAX_MASK           PAGE_MASK
-
-#define PAGE_MIN_SHIFT          PAGE_SHIFT
-#define PAGE_MIN_SIZE           PAGE_SIZE
-#define PAGE_MIN_MASK           PAGE_MASK
-
-#define I386_LPGBYTES           2*1024*1024     /* bytes per large page */
-#define I386_LPGSHIFT           21              /* bitshift for large pages */
-#define I386_LPGMASK            (I386_LPGBYTES-1)
-
-/*
- *	Convert bytes to pages and convert pages to bytes.
- *	No rounding is used.
- */
-
-#define i386_btop(x)            ((ppnum_t)((x) >> I386_PGSHIFT))
-#define machine_btop(x)         i386_btop(x)
-#define i386_ptob(x)            (((pmap_paddr_t)(x)) << I386_PGSHIFT)
-#define machine_ptob(x)         i386_ptob(x)
-
-/*
- *	Round off or truncate to the nearest page.  These will work
- *	for either addresses or counts.  (i.e. 1 byte rounds to 1 page
- *	bytes.
- */
-
-#define i386_round_page(x)      ((((pmap_paddr_t)(x)) + I386_PGBYTES - 1) & \
-	                                ~(I386_PGBYTES-1))
-#define i386_trunc_page(x)      (((pmap_paddr_t)(x)) & ~(I386_PGBYTES-1))
+#define PAGE_MAX_SHIFT          14
+#define PAGE_MAX_SIZE           (1 << PAGE_MAX_SHIFT)
+#define PAGE_MAX_MASK           (PAGE_MAX_SIZE-1)
 
+#define PAGE_MIN_SHIFT          12
+#define PAGE_MIN_SIZE           (1 << PAGE_MIN_SHIFT)
+#define PAGE_MIN_MASK           (PAGE_MIN_SIZE-1)
 
 
 #define VM_MIN_ADDRESS64        ((user_addr_t) 0x0000000000000000ULL)
diff --git a/lib/libc/include/x86_64-macos-gnu/mach/i386/vm_types.h b/lib/libc/include/x86_64-macos-gnu/mach/i386/vm_types.h
index 8a95db53ee..57bc28af88 100644
--- a/lib/libc/include/x86_64-macos-gnu/mach/i386/vm_types.h
+++ b/lib/libc/include/x86_64-macos-gnu/mach/i386/vm_types.h
@@ -70,7 +70,6 @@
 #ifndef ASSEMBLER
 
 #include <i386/_types.h>
-#include <mach/i386/vm_param.h>
 #include <stdint.h>
 
 /*
diff --git a/lib/libc/include/x86_64-macos-gnu/mach/kern_return.h b/lib/libc/include/x86_64-macos-gnu/mach/kern_return.h
deleted file mode 100644
index 62d6415f52..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/mach/kern_return.h
+++ /dev/null
@@ -1,330 +0,0 @@
-/*
- * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-/*
- * @OSF_COPYRIGHT@
- */
-/*
- * Mach Operating System
- * Copyright (c) 1991,1990,1989,1988,1987 Carnegie Mellon University
- * All Rights Reserved.
- *
- * Permission to use, copy, modify and distribute this software and its
- * documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
- * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie Mellon
- * the rights to redistribute these changes.
- */
-/*
- */
-/*
- *	File:	h/kern_return.h
- *	Author:	Avadis Tevanian, Jr.
- *	Date:	1985
- *
- *	Kernel return codes.
- *
- */
-
-#ifndef _MACH_KERN_RETURN_H_
-#define _MACH_KERN_RETURN_H_
-
-#include <mach/machine/kern_return.h>
-
-#define KERN_SUCCESS                    0
-
-#define KERN_INVALID_ADDRESS            1
-/* Specified address is not currently valid.
- */
-
-#define KERN_PROTECTION_FAILURE         2
-/* Specified memory is valid, but does not permit the
- * required forms of access.
- */
-
-#define KERN_NO_SPACE                   3
-/* The address range specified is already in use, or
- * no address range of the size specified could be
- * found.
- */
-
-#define KERN_INVALID_ARGUMENT           4
-/* The function requested was not applicable to this
- * type of argument, or an argument is invalid
- */
-
-#define KERN_FAILURE                    5
-/* The function could not be performed.  A catch-all.
- */
-
-#define KERN_RESOURCE_SHORTAGE          6
-/* A system resource could not be allocated to fulfill
- * this request.  This failure may not be permanent.
- */
-
-#define KERN_NOT_RECEIVER               7
-/* The task in question does not hold receive rights
- * for the port argument.
- */
-
-#define KERN_NO_ACCESS                  8
-/* Bogus access restriction.
- */
-
-#define KERN_MEMORY_FAILURE             9
-/* During a page fault, the target address refers to a
- * memory object that has been destroyed.  This
- * failure is permanent.
- */
-
-#define KERN_MEMORY_ERROR               10
-/* During a page fault, the memory object indicated
- * that the data could not be returned.  This failure
- * may be temporary; future attempts to access this
- * same data may succeed, as defined by the memory
- * object.
- */
-
-#define KERN_ALREADY_IN_SET             11
-/* The receive right is already a member of the portset.
- */
-
-#define KERN_NOT_IN_SET                 12
-/* The receive right is not a member of a port set.
- */
-
-#define KERN_NAME_EXISTS                13
-/* The name already denotes a right in the task.
- */
-
-#define KERN_ABORTED                    14
-/* The operation was aborted.  Ipc code will
- * catch this and reflect it as a message error.
- */
-
-#define KERN_INVALID_NAME               15
-/* The name doesn't denote a right in the task.
- */
-
-#define KERN_INVALID_TASK               16
-/* Target task isn't an active task.
- */
-
-#define KERN_INVALID_RIGHT              17
-/* The name denotes a right, but not an appropriate right.
- */
-
-#define KERN_INVALID_VALUE              18
-/* A blatant range error.
- */
-
-#define KERN_UREFS_OVERFLOW             19
-/* Operation would overflow limit on user-references.
- */
-
-#define KERN_INVALID_CAPABILITY         20
-/* The supplied (port) capability is improper.
- */
-
-#define KERN_RIGHT_EXISTS               21
-/* The task already has send or receive rights
- * for the port under another name.
- */
-
-#define KERN_INVALID_HOST               22
-/* Target host isn't actually a host.
- */
-
-#define KERN_MEMORY_PRESENT             23
-/* An attempt was made to supply "precious" data
- * for memory that is already present in a
- * memory object.
- */
-
-#define KERN_MEMORY_DATA_MOVED          24
-/* A page was requested of a memory manager via
- * memory_object_data_request for an object using
- * a MEMORY_OBJECT_COPY_CALL strategy, with the
- * VM_PROT_WANTS_COPY flag being used to specify
- * that the page desired is for a copy of the
- * object, and the memory manager has detected
- * the page was pushed into a copy of the object
- * while the kernel was walking the shadow chain
- * from the copy to the object. This error code
- * is delivered via memory_object_data_error
- * and is handled by the kernel (it forces the
- * kernel to restart the fault). It will not be
- * seen by users.
- */
-
-#define KERN_MEMORY_RESTART_COPY        25
-/* A strategic copy was attempted of an object
- * upon which a quicker copy is now possible.
- * The caller should retry the copy using
- * vm_object_copy_quickly. This error code
- * is seen only by the kernel.
- */
-
-#define KERN_INVALID_PROCESSOR_SET      26
-/* An argument applied to assert processor set privilege
- * was not a processor set control port.
- */
-
-#define KERN_POLICY_LIMIT               27
-/* The specified scheduling attributes exceed the thread's
- * limits.
- */
-
-#define KERN_INVALID_POLICY             28
-/* The specified scheduling policy is not currently
- * enabled for the processor set.
- */
-
-#define KERN_INVALID_OBJECT             29
-/* The external memory manager failed to initialize the
- * memory object.
- */
-
-#define KERN_ALREADY_WAITING            30
-/* A thread is attempting to wait for an event for which
- * there is already a waiting thread.
- */
-
-#define KERN_DEFAULT_SET                31
-/* An attempt was made to destroy the default processor
- * set.
- */
-
-#define KERN_EXCEPTION_PROTECTED        32
-/* An attempt was made to fetch an exception port that is
- * protected, or to abort a thread while processing a
- * protected exception.
- */
-
-#define KERN_INVALID_LEDGER             33
-/* A ledger was required but not supplied.
- */
-
-#define KERN_INVALID_MEMORY_CONTROL     34
-/* The port was not a memory cache control port.
- */
-
-#define KERN_INVALID_SECURITY           35
-/* An argument supplied to assert security privilege
- * was not a host security port.
- */
-
-#define KERN_NOT_DEPRESSED              36
-/* thread_depress_abort was called on a thread which
- * was not currently depressed.
- */
-
-#define KERN_TERMINATED                 37
-/* Object has been terminated and is no longer available
- */
-
-#define KERN_LOCK_SET_DESTROYED         38
-/* Lock set has been destroyed and is no longer available.
- */
-
-#define KERN_LOCK_UNSTABLE              39
-/* The thread holding the lock terminated before releasing
- * the lock
- */
-
-#define KERN_LOCK_OWNED                 40
-/* The lock is already owned by another thread
- */
-
-#define KERN_LOCK_OWNED_SELF            41
-/* The lock is already owned by the calling thread
- */
-
-#define KERN_SEMAPHORE_DESTROYED        42
-/* Semaphore has been destroyed and is no longer available.
- */
-
-#define KERN_RPC_SERVER_TERMINATED      43
-/* Return from RPC indicating the target server was
- * terminated before it successfully replied
- */
-
-#define KERN_RPC_TERMINATE_ORPHAN       44
-/* Terminate an orphaned activation.
- */
-
-#define KERN_RPC_CONTINUE_ORPHAN        45
-/* Allow an orphaned activation to continue executing.
- */
-
-#define KERN_NOT_SUPPORTED              46
-/* Empty thread activation (No thread linked to it)
- */
-
-#define KERN_NODE_DOWN                  47
-/* Remote node down or inaccessible.
- */
-
-#define KERN_NOT_WAITING                48
-/* A signalled thread was not actually waiting. */
-
-#define KERN_OPERATION_TIMED_OUT        49
-/* Some thread-oriented operation (semaphore_wait) timed out
- */
-
-#define KERN_CODESIGN_ERROR             50
-/* During a page fault, indicates that the page was rejected
- * as a result of a signature check.
- */
-
-#define KERN_POLICY_STATIC              51
-/* The requested property cannot be changed at this time.
- */
-
-#define KERN_INSUFFICIENT_BUFFER_SIZE   52
-/* The provided buffer is of insufficient size for the requested data.
- */
-
-#define KERN_RETURN_MAX                 0x100
-/* Maximum return value allowable
- */
-
-#endif  /* _MACH_KERN_RETURN_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/mach/mach_init.h b/lib/libc/include/x86_64-macos-gnu/mach/mach_init.h
deleted file mode 100644
index d61d6e90b5..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/mach/mach_init.h
+++ /dev/null
@@ -1,110 +0,0 @@
-/*
- * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-/*
- * Mach Operating System
- * Copyright (c) 1991,1990,1989,1988,1987,1986 Carnegie Mellon University
- * All Rights Reserved.
- *
- * Permission to use, copy, modify and distribute this software and its
- * documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
- * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie Mellon
- * the rights to redistribute these changes.
- */
-
-/*
- *	Items provided by the Mach environment initialization.
- */
-
-#ifndef _MACH_INIT_
-#define _MACH_INIT_     1
-
-#include <mach/mach_types.h>
-#include <mach/vm_page_size.h>
-#include <stdarg.h>
-
-#include <sys/cdefs.h>
-
-/*
- *	Kernel-related ports; how a task/thread controls itself
- */
-
-__BEGIN_DECLS
-extern mach_port_t mach_host_self(void);
-extern mach_port_t mach_thread_self(void);
-extern kern_return_t host_page_size(host_t, vm_size_t *);
-
-extern mach_port_t      mach_task_self_;
-#define mach_task_self() mach_task_self_
-#define current_task()  mach_task_self()
-
-__END_DECLS
-#include <mach/mach_traps.h>
-__BEGIN_DECLS
-
-/*
- *	Other important ports in the Mach user environment
- */
-
-extern  mach_port_t     bootstrap_port;
-
-/*
- *	Where these ports occur in the "mach_ports_register"
- *	collection... only servers or the runtime library need know.
- */
-
-#define NAME_SERVER_SLOT        0
-#define ENVIRONMENT_SLOT        1
-#define SERVICE_SLOT            2
-
-#define MACH_PORTS_SLOTS_USED   3
-
-/*
- *	fprintf_stderr uses vprintf_stderr_func to produce
- *	error messages, this can be overridden by a user
- *	application to point to a user-specified output function
- */
-extern int (*vprintf_stderr_func)(const char *format, va_list ap);
-
-__END_DECLS
-
-#endif  /* _MACH_INIT_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/mach/mach_port.h b/lib/libc/include/x86_64-macos-gnu/mach/mach_port.h
deleted file mode 100644
index fcec114ccf..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/mach/mach_port.h
+++ /dev/null
@@ -1,1808 +0,0 @@
-#ifndef	_mach_port_user_
-#define	_mach_port_user_
-
-/* Module mach_port */
-
-#include <string.h>
-#include <mach/ndr.h>
-#include <mach/boolean.h>
-#include <mach/kern_return.h>
-#include <mach/notify.h>
-#include <mach/mach_types.h>
-#include <mach/message.h>
-#include <mach/mig_errors.h>
-#include <mach/port.h>
-	
-/* BEGIN MIG_STRNCPY_ZEROFILL CODE */
-
-#if defined(__has_include)
-#if __has_include(<mach/mig_strncpy_zerofill_support.h>)
-#ifndef USING_MIG_STRNCPY_ZEROFILL
-#define USING_MIG_STRNCPY_ZEROFILL
-#endif
-#ifndef __MIG_STRNCPY_ZEROFILL_FORWARD_TYPE_DECLS__
-#define __MIG_STRNCPY_ZEROFILL_FORWARD_TYPE_DECLS__
-#ifdef __cplusplus
-extern "C" {
-#endif
-	extern int mig_strncpy_zerofill(char *dest, const char *src, int len) __attribute__((weak_import));
-#ifdef __cplusplus
-}
-#endif
-#endif /* __MIG_STRNCPY_ZEROFILL_FORWARD_TYPE_DECLS__ */
-#endif /* __has_include(<mach/mig_strncpy_zerofill_support.h>) */
-#endif /* __has_include */
-	
-/* END MIG_STRNCPY_ZEROFILL CODE */
-
-
-#ifdef AUTOTEST
-#ifndef FUNCTION_PTR_T
-#define FUNCTION_PTR_T
-typedef void (*function_ptr_t)(mach_port_t, char *, mach_msg_type_number_t);
-typedef struct {
-        char            *name;
-        function_ptr_t  function;
-} function_table_entry;
-typedef function_table_entry   *function_table_t;
-#endif /* FUNCTION_PTR_T */
-#endif /* AUTOTEST */
-
-#ifndef	mach_port_MSG_COUNT
-#define	mach_port_MSG_COUNT	40
-#endif	/* mach_port_MSG_COUNT */
-
-#include <mach/std_types.h>
-#include <mach/mig.h>
-#include <mach/mig.h>
-#include <mach/mach_types.h>
-#include <mach_debug/mach_debug_types.h>
-
-#ifdef __BeforeMigUserHeader
-__BeforeMigUserHeader
-#endif /* __BeforeMigUserHeader */
-
-#include <sys/cdefs.h>
-__BEGIN_DECLS
-
-
-/* Routine mach_port_names */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t mach_port_names
-(
-	ipc_space_t task,
-	mach_port_name_array_t *names,
-	mach_msg_type_number_t *namesCnt,
-	mach_port_type_array_t *types,
-	mach_msg_type_number_t *typesCnt
-);
-
-/* Routine mach_port_type */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t mach_port_type
-(
-	ipc_space_t task,
-	mach_port_name_t name,
-	mach_port_type_t *ptype
-);
-
-/* Routine mach_port_rename */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t mach_port_rename
-(
-	ipc_space_t task,
-	mach_port_name_t old_name,
-	mach_port_name_t new_name
-);
-
-/* Routine mach_port_allocate_name */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-__WATCHOS_PROHIBITED
-__TVOS_PROHIBITED
-kern_return_t mach_port_allocate_name
-(
-	ipc_space_t task,
-	mach_port_right_t right,
-	mach_port_name_t name
-);
-
-/* Routine mach_port_allocate */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t mach_port_allocate
-(
-	ipc_space_t task,
-	mach_port_right_t right,
-	mach_port_name_t *name
-);
-
-/* Routine mach_port_destroy */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t mach_port_destroy
-(
-	ipc_space_t task,
-	mach_port_name_t name
-);
-
-/* Routine mach_port_deallocate */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t mach_port_deallocate
-(
-	ipc_space_t task,
-	mach_port_name_t name
-);
-
-/* Routine mach_port_get_refs */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t mach_port_get_refs
-(
-	ipc_space_t task,
-	mach_port_name_t name,
-	mach_port_right_t right,
-	mach_port_urefs_t *refs
-);
-
-/* Routine mach_port_mod_refs */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t mach_port_mod_refs
-(
-	ipc_space_t task,
-	mach_port_name_t name,
-	mach_port_right_t right,
-	mach_port_delta_t delta
-);
-
-/* Routine mach_port_peek */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t mach_port_peek
-(
-	ipc_space_t task,
-	mach_port_name_t name,
-	mach_msg_trailer_type_t trailer_type,
-	mach_port_seqno_t *request_seqnop,
-	mach_msg_size_t *msg_sizep,
-	mach_msg_id_t *msg_idp,
-	mach_msg_trailer_info_t trailer_infop,
-	mach_msg_type_number_t *trailer_infopCnt
-);
-
-/* Routine mach_port_set_mscount */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t mach_port_set_mscount
-(
-	ipc_space_t task,
-	mach_port_name_t name,
-	mach_port_mscount_t mscount
-);
-
-/* Routine mach_port_get_set_status */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t mach_port_get_set_status
-(
-	ipc_space_inspect_t task,
-	mach_port_name_t name,
-	mach_port_name_array_t *members,
-	mach_msg_type_number_t *membersCnt
-);
-
-/* Routine mach_port_move_member */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t mach_port_move_member
-(
-	ipc_space_t task,
-	mach_port_name_t member,
-	mach_port_name_t after
-);
-
-/* Routine mach_port_request_notification */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t mach_port_request_notification
-(
-	ipc_space_t task,
-	mach_port_name_t name,
-	mach_msg_id_t msgid,
-	mach_port_mscount_t sync,
-	mach_port_t notify,
-	mach_msg_type_name_t notifyPoly,
-	mach_port_t *previous
-);
-
-/* Routine mach_port_insert_right */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t mach_port_insert_right
-(
-	ipc_space_t task,
-	mach_port_name_t name,
-	mach_port_t poly,
-	mach_msg_type_name_t polyPoly
-);
-
-/* Routine mach_port_extract_right */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t mach_port_extract_right
-(
-	ipc_space_t task,
-	mach_port_name_t name,
-	mach_msg_type_name_t msgt_name,
-	mach_port_t *poly,
-	mach_msg_type_name_t *polyPoly
-);
-
-/* Routine mach_port_set_seqno */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t mach_port_set_seqno
-(
-	ipc_space_t task,
-	mach_port_name_t name,
-	mach_port_seqno_t seqno
-);
-
-/* Routine mach_port_get_attributes */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t mach_port_get_attributes
-(
-	ipc_space_inspect_t task,
-	mach_port_name_t name,
-	mach_port_flavor_t flavor,
-	mach_port_info_t port_info_out,
-	mach_msg_type_number_t *port_info_outCnt
-);
-
-/* Routine mach_port_set_attributes */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t mach_port_set_attributes
-(
-	ipc_space_t task,
-	mach_port_name_t name,
-	mach_port_flavor_t flavor,
-	mach_port_info_t port_info,
-	mach_msg_type_number_t port_infoCnt
-);
-
-/* Routine mach_port_allocate_qos */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t mach_port_allocate_qos
-(
-	ipc_space_t task,
-	mach_port_right_t right,
-	mach_port_qos_t *qos,
-	mach_port_name_t *name
-);
-
-/* Routine mach_port_allocate_full */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t mach_port_allocate_full
-(
-	ipc_space_t task,
-	mach_port_right_t right,
-	mach_port_t proto,
-	mach_port_qos_t *qos,
-	mach_port_name_t *name
-);
-
-/* Routine task_set_port_space */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-__WATCHOS_PROHIBITED
-__TVOS_PROHIBITED
-kern_return_t task_set_port_space
-(
-	ipc_space_t task,
-	int table_entries
-);
-
-/* Routine mach_port_get_srights */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t mach_port_get_srights
-(
-	ipc_space_t task,
-	mach_port_name_t name,
-	mach_port_rights_t *srights
-);
-
-/* Routine mach_port_space_info */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t mach_port_space_info
-(
-	ipc_space_inspect_t task,
-	ipc_info_space_t *space_info,
-	ipc_info_name_array_t *table_info,
-	mach_msg_type_number_t *table_infoCnt,
-	ipc_info_tree_name_array_t *tree_info,
-	mach_msg_type_number_t *tree_infoCnt
-);
-
-/* Routine mach_port_dnrequest_info */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t mach_port_dnrequest_info
-(
-	ipc_space_t task,
-	mach_port_name_t name,
-	unsigned *dnr_total,
-	unsigned *dnr_used
-);
-
-/* Routine mach_port_kernel_object */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t mach_port_kernel_object
-(
-	ipc_space_inspect_t task,
-	mach_port_name_t name,
-	unsigned *object_type,
-	unsigned *object_addr
-);
-
-/* Routine mach_port_insert_member */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t mach_port_insert_member
-(
-	ipc_space_t task,
-	mach_port_name_t name,
-	mach_port_name_t pset
-);
-
-/* Routine mach_port_extract_member */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t mach_port_extract_member
-(
-	ipc_space_t task,
-	mach_port_name_t name,
-	mach_port_name_t pset
-);
-
-/* Routine mach_port_get_context */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t mach_port_get_context
-(
-	ipc_space_inspect_t task,
-	mach_port_name_t name,
-	mach_port_context_t *context
-);
-
-/* Routine mach_port_set_context */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t mach_port_set_context
-(
-	ipc_space_t task,
-	mach_port_name_t name,
-	mach_port_context_t context
-);
-
-/* Routine mach_port_kobject */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t mach_port_kobject
-(
-	ipc_space_inspect_t task,
-	mach_port_name_t name,
-	natural_t *object_type,
-	mach_vm_address_t *object_addr
-);
-
-/* Routine mach_port_construct */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t mach_port_construct
-(
-	ipc_space_t task,
-	mach_port_options_ptr_t options,
-	mach_port_context_t context,
-	mach_port_name_t *name
-);
-
-/* Routine mach_port_destruct */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t mach_port_destruct
-(
-	ipc_space_t task,
-	mach_port_name_t name,
-	mach_port_delta_t srdelta,
-	mach_port_context_t guard
-);
-
-/* Routine mach_port_guard */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t mach_port_guard
-(
-	ipc_space_t task,
-	mach_port_name_t name,
-	mach_port_context_t guard,
-	boolean_t strict
-);
-
-/* Routine mach_port_unguard */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t mach_port_unguard
-(
-	ipc_space_t task,
-	mach_port_name_t name,
-	mach_port_context_t guard
-);
-
-/* Routine mach_port_space_basic_info */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t mach_port_space_basic_info
-(
-	ipc_space_inspect_t task,
-	ipc_info_space_basic_t *basic_info
-);
-
-/* Routine mach_port_guard_with_flags */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t mach_port_guard_with_flags
-(
-	ipc_space_t task,
-	mach_port_name_t name,
-	mach_port_context_t guard,
-	uint64_t flags
-);
-
-/* Routine mach_port_swap_guard */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t mach_port_swap_guard
-(
-	ipc_space_t task,
-	mach_port_name_t name,
-	mach_port_context_t old_guard,
-	mach_port_context_t new_guard
-);
-
-/* Routine mach_port_kobject_description */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t mach_port_kobject_description
-(
-	ipc_space_inspect_t task,
-	mach_port_name_t name,
-	natural_t *object_type,
-	mach_vm_address_t *object_addr,
-	kobject_description_t description
-);
-
-__END_DECLS
-
-/********************** Caution **************************/
-/* The following data types should be used to calculate  */
-/* maximum message sizes only. The actual message may be */
-/* smaller, and the position of the arguments within the */
-/* message layout may vary from what is presented here.  */
-/* For example, if any of the arguments are variable-    */
-/* sized, and less than the maximum is sent, the data    */
-/* will be packed tight in the actual message to reduce  */
-/* the presence of holes.                                */
-/********************** Caution **************************/
-
-/* typedefs for all requests */
-
-#ifndef __Request__mach_port_subsystem__defined
-#define __Request__mach_port_subsystem__defined
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-	} __Request__mach_port_names_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		mach_port_name_t name;
-	} __Request__mach_port_type_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		mach_port_name_t old_name;
-		mach_port_name_t new_name;
-	} __Request__mach_port_rename_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		mach_port_right_t right;
-		mach_port_name_t name;
-	} __Request__mach_port_allocate_name_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		mach_port_right_t right;
-	} __Request__mach_port_allocate_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		mach_port_name_t name;
-	} __Request__mach_port_destroy_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		mach_port_name_t name;
-	} __Request__mach_port_deallocate_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		mach_port_name_t name;
-		mach_port_right_t right;
-	} __Request__mach_port_get_refs_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		mach_port_name_t name;
-		mach_port_right_t right;
-		mach_port_delta_t delta;
-	} __Request__mach_port_mod_refs_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		mach_port_name_t name;
-		mach_msg_trailer_type_t trailer_type;
-		mach_port_seqno_t request_seqnop;
-		mach_msg_type_number_t trailer_infopCnt;
-	} __Request__mach_port_peek_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		mach_port_name_t name;
-		mach_port_mscount_t mscount;
-	} __Request__mach_port_set_mscount_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		mach_port_name_t name;
-	} __Request__mach_port_get_set_status_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		mach_port_name_t member;
-		mach_port_name_t after;
-	} __Request__mach_port_move_member_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		/* start of the kernel processed data */
-		mach_msg_body_t msgh_body;
-		mach_msg_port_descriptor_t notify;
-		/* end of the kernel processed data */
-		NDR_record_t NDR;
-		mach_port_name_t name;
-		mach_msg_id_t msgid;
-		mach_port_mscount_t sync;
-	} __Request__mach_port_request_notification_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		/* start of the kernel processed data */
-		mach_msg_body_t msgh_body;
-		mach_msg_port_descriptor_t poly;
-		/* end of the kernel processed data */
-		NDR_record_t NDR;
-		mach_port_name_t name;
-	} __Request__mach_port_insert_right_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		mach_port_name_t name;
-		mach_msg_type_name_t msgt_name;
-	} __Request__mach_port_extract_right_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		mach_port_name_t name;
-		mach_port_seqno_t seqno;
-	} __Request__mach_port_set_seqno_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		mach_port_name_t name;
-		mach_port_flavor_t flavor;
-		mach_msg_type_number_t port_info_outCnt;
-	} __Request__mach_port_get_attributes_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		mach_port_name_t name;
-		mach_port_flavor_t flavor;
-		mach_msg_type_number_t port_infoCnt;
-		integer_t port_info[17];
-	} __Request__mach_port_set_attributes_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		mach_port_right_t right;
-		mach_port_qos_t qos;
-	} __Request__mach_port_allocate_qos_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		/* start of the kernel processed data */
-		mach_msg_body_t msgh_body;
-		mach_msg_port_descriptor_t proto;
-		/* end of the kernel processed data */
-		NDR_record_t NDR;
-		mach_port_right_t right;
-		mach_port_qos_t qos;
-		mach_port_name_t name;
-	} __Request__mach_port_allocate_full_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		int table_entries;
-	} __Request__task_set_port_space_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		mach_port_name_t name;
-	} __Request__mach_port_get_srights_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-	} __Request__mach_port_space_info_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		mach_port_name_t name;
-	} __Request__mach_port_dnrequest_info_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		mach_port_name_t name;
-	} __Request__mach_port_kernel_object_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		mach_port_name_t name;
-		mach_port_name_t pset;
-	} __Request__mach_port_insert_member_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		mach_port_name_t name;
-		mach_port_name_t pset;
-	} __Request__mach_port_extract_member_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		mach_port_name_t name;
-	} __Request__mach_port_get_context_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		mach_port_name_t name;
-		mach_port_context_t context;
-	} __Request__mach_port_set_context_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		mach_port_name_t name;
-	} __Request__mach_port_kobject_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		/* start of the kernel processed data */
-		mach_msg_body_t msgh_body;
-		mach_msg_ool_descriptor_t options;
-		/* end of the kernel processed data */
-		NDR_record_t NDR;
-		mach_port_context_t context;
-	} __Request__mach_port_construct_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		mach_port_name_t name;
-		mach_port_delta_t srdelta;
-		mach_port_context_t guard;
-	} __Request__mach_port_destruct_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		mach_port_name_t name;
-		mach_port_context_t guard;
-		boolean_t strict;
-	} __Request__mach_port_guard_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		mach_port_name_t name;
-		mach_port_context_t guard;
-	} __Request__mach_port_unguard_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-	} __Request__mach_port_space_basic_info_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		mach_port_name_t name;
-		mach_port_context_t guard;
-		uint64_t flags;
-	} __Request__mach_port_guard_with_flags_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		mach_port_name_t name;
-		mach_port_context_t old_guard;
-		mach_port_context_t new_guard;
-	} __Request__mach_port_swap_guard_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		mach_port_name_t name;
-	} __Request__mach_port_kobject_description_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-#endif /* !__Request__mach_port_subsystem__defined */
-
-/* union of all requests */
-
-#ifndef __RequestUnion__mach_port_subsystem__defined
-#define __RequestUnion__mach_port_subsystem__defined
-union __RequestUnion__mach_port_subsystem {
-	__Request__mach_port_names_t Request_mach_port_names;
-	__Request__mach_port_type_t Request_mach_port_type;
-	__Request__mach_port_rename_t Request_mach_port_rename;
-	__Request__mach_port_allocate_name_t Request_mach_port_allocate_name;
-	__Request__mach_port_allocate_t Request_mach_port_allocate;
-	__Request__mach_port_destroy_t Request_mach_port_destroy;
-	__Request__mach_port_deallocate_t Request_mach_port_deallocate;
-	__Request__mach_port_get_refs_t Request_mach_port_get_refs;
-	__Request__mach_port_mod_refs_t Request_mach_port_mod_refs;
-	__Request__mach_port_peek_t Request_mach_port_peek;
-	__Request__mach_port_set_mscount_t Request_mach_port_set_mscount;
-	__Request__mach_port_get_set_status_t Request_mach_port_get_set_status;
-	__Request__mach_port_move_member_t Request_mach_port_move_member;
-	__Request__mach_port_request_notification_t Request_mach_port_request_notification;
-	__Request__mach_port_insert_right_t Request_mach_port_insert_right;
-	__Request__mach_port_extract_right_t Request_mach_port_extract_right;
-	__Request__mach_port_set_seqno_t Request_mach_port_set_seqno;
-	__Request__mach_port_get_attributes_t Request_mach_port_get_attributes;
-	__Request__mach_port_set_attributes_t Request_mach_port_set_attributes;
-	__Request__mach_port_allocate_qos_t Request_mach_port_allocate_qos;
-	__Request__mach_port_allocate_full_t Request_mach_port_allocate_full;
-	__Request__task_set_port_space_t Request_task_set_port_space;
-	__Request__mach_port_get_srights_t Request_mach_port_get_srights;
-	__Request__mach_port_space_info_t Request_mach_port_space_info;
-	__Request__mach_port_dnrequest_info_t Request_mach_port_dnrequest_info;
-	__Request__mach_port_kernel_object_t Request_mach_port_kernel_object;
-	__Request__mach_port_insert_member_t Request_mach_port_insert_member;
-	__Request__mach_port_extract_member_t Request_mach_port_extract_member;
-	__Request__mach_port_get_context_t Request_mach_port_get_context;
-	__Request__mach_port_set_context_t Request_mach_port_set_context;
-	__Request__mach_port_kobject_t Request_mach_port_kobject;
-	__Request__mach_port_construct_t Request_mach_port_construct;
-	__Request__mach_port_destruct_t Request_mach_port_destruct;
-	__Request__mach_port_guard_t Request_mach_port_guard;
-	__Request__mach_port_unguard_t Request_mach_port_unguard;
-	__Request__mach_port_space_basic_info_t Request_mach_port_space_basic_info;
-	__Request__mach_port_guard_with_flags_t Request_mach_port_guard_with_flags;
-	__Request__mach_port_swap_guard_t Request_mach_port_swap_guard;
-	__Request__mach_port_kobject_description_t Request_mach_port_kobject_description;
-};
-#endif /* !__RequestUnion__mach_port_subsystem__defined */
-/* typedefs for all replies */
-
-#ifndef __Reply__mach_port_subsystem__defined
-#define __Reply__mach_port_subsystem__defined
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		/* start of the kernel processed data */
-		mach_msg_body_t msgh_body;
-		mach_msg_ool_descriptor_t names;
-		mach_msg_ool_descriptor_t types;
-		/* end of the kernel processed data */
-		NDR_record_t NDR;
-		mach_msg_type_number_t namesCnt;
-		mach_msg_type_number_t typesCnt;
-	} __Reply__mach_port_names_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-		mach_port_type_t ptype;
-	} __Reply__mach_port_type_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-	} __Reply__mach_port_rename_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-	} __Reply__mach_port_allocate_name_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-		mach_port_name_t name;
-	} __Reply__mach_port_allocate_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-	} __Reply__mach_port_destroy_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-	} __Reply__mach_port_deallocate_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-		mach_port_urefs_t refs;
-	} __Reply__mach_port_get_refs_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-	} __Reply__mach_port_mod_refs_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-		mach_port_seqno_t request_seqnop;
-		mach_msg_size_t msg_sizep;
-		mach_msg_id_t msg_idp;
-		mach_msg_type_number_t trailer_infopCnt;
-		char trailer_infop[68];
-	} __Reply__mach_port_peek_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-	} __Reply__mach_port_set_mscount_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		/* start of the kernel processed data */
-		mach_msg_body_t msgh_body;
-		mach_msg_ool_descriptor_t members;
-		/* end of the kernel processed data */
-		NDR_record_t NDR;
-		mach_msg_type_number_t membersCnt;
-	} __Reply__mach_port_get_set_status_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-	} __Reply__mach_port_move_member_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		/* start of the kernel processed data */
-		mach_msg_body_t msgh_body;
-		mach_msg_port_descriptor_t previous;
-		/* end of the kernel processed data */
-	} __Reply__mach_port_request_notification_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-	} __Reply__mach_port_insert_right_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		/* start of the kernel processed data */
-		mach_msg_body_t msgh_body;
-		mach_msg_port_descriptor_t poly;
-		/* end of the kernel processed data */
-	} __Reply__mach_port_extract_right_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-	} __Reply__mach_port_set_seqno_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-		mach_msg_type_number_t port_info_outCnt;
-		integer_t port_info_out[17];
-	} __Reply__mach_port_get_attributes_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-	} __Reply__mach_port_set_attributes_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-		mach_port_qos_t qos;
-		mach_port_name_t name;
-	} __Reply__mach_port_allocate_qos_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-		mach_port_qos_t qos;
-		mach_port_name_t name;
-	} __Reply__mach_port_allocate_full_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-	} __Reply__task_set_port_space_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-		mach_port_rights_t srights;
-	} __Reply__mach_port_get_srights_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		/* start of the kernel processed data */
-		mach_msg_body_t msgh_body;
-		mach_msg_ool_descriptor_t table_info;
-		mach_msg_ool_descriptor_t tree_info;
-		/* end of the kernel processed data */
-		NDR_record_t NDR;
-		ipc_info_space_t space_info;
-		mach_msg_type_number_t table_infoCnt;
-		mach_msg_type_number_t tree_infoCnt;
-	} __Reply__mach_port_space_info_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-		unsigned dnr_total;
-		unsigned dnr_used;
-	} __Reply__mach_port_dnrequest_info_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-		unsigned object_type;
-		unsigned object_addr;
-	} __Reply__mach_port_kernel_object_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-	} __Reply__mach_port_insert_member_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-	} __Reply__mach_port_extract_member_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-		mach_port_context_t context;
-	} __Reply__mach_port_get_context_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-	} __Reply__mach_port_set_context_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-		natural_t object_type;
-		mach_vm_address_t object_addr;
-	} __Reply__mach_port_kobject_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-		mach_port_name_t name;
-	} __Reply__mach_port_construct_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-	} __Reply__mach_port_destruct_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-	} __Reply__mach_port_guard_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-	} __Reply__mach_port_unguard_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-		ipc_info_space_basic_t basic_info;
-	} __Reply__mach_port_space_basic_info_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-	} __Reply__mach_port_guard_with_flags_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-	} __Reply__mach_port_swap_guard_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-		natural_t object_type;
-		mach_vm_address_t object_addr;
-		mach_msg_type_number_t descriptionOffset; /* MiG doesn't use it */
-		mach_msg_type_number_t descriptionCnt;
-		char description[512];
-	} __Reply__mach_port_kobject_description_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-#endif /* !__Reply__mach_port_subsystem__defined */
-
-/* union of all replies */
-
-#ifndef __ReplyUnion__mach_port_subsystem__defined
-#define __ReplyUnion__mach_port_subsystem__defined
-union __ReplyUnion__mach_port_subsystem {
-	__Reply__mach_port_names_t Reply_mach_port_names;
-	__Reply__mach_port_type_t Reply_mach_port_type;
-	__Reply__mach_port_rename_t Reply_mach_port_rename;
-	__Reply__mach_port_allocate_name_t Reply_mach_port_allocate_name;
-	__Reply__mach_port_allocate_t Reply_mach_port_allocate;
-	__Reply__mach_port_destroy_t Reply_mach_port_destroy;
-	__Reply__mach_port_deallocate_t Reply_mach_port_deallocate;
-	__Reply__mach_port_get_refs_t Reply_mach_port_get_refs;
-	__Reply__mach_port_mod_refs_t Reply_mach_port_mod_refs;
-	__Reply__mach_port_peek_t Reply_mach_port_peek;
-	__Reply__mach_port_set_mscount_t Reply_mach_port_set_mscount;
-	__Reply__mach_port_get_set_status_t Reply_mach_port_get_set_status;
-	__Reply__mach_port_move_member_t Reply_mach_port_move_member;
-	__Reply__mach_port_request_notification_t Reply_mach_port_request_notification;
-	__Reply__mach_port_insert_right_t Reply_mach_port_insert_right;
-	__Reply__mach_port_extract_right_t Reply_mach_port_extract_right;
-	__Reply__mach_port_set_seqno_t Reply_mach_port_set_seqno;
-	__Reply__mach_port_get_attributes_t Reply_mach_port_get_attributes;
-	__Reply__mach_port_set_attributes_t Reply_mach_port_set_attributes;
-	__Reply__mach_port_allocate_qos_t Reply_mach_port_allocate_qos;
-	__Reply__mach_port_allocate_full_t Reply_mach_port_allocate_full;
-	__Reply__task_set_port_space_t Reply_task_set_port_space;
-	__Reply__mach_port_get_srights_t Reply_mach_port_get_srights;
-	__Reply__mach_port_space_info_t Reply_mach_port_space_info;
-	__Reply__mach_port_dnrequest_info_t Reply_mach_port_dnrequest_info;
-	__Reply__mach_port_kernel_object_t Reply_mach_port_kernel_object;
-	__Reply__mach_port_insert_member_t Reply_mach_port_insert_member;
-	__Reply__mach_port_extract_member_t Reply_mach_port_extract_member;
-	__Reply__mach_port_get_context_t Reply_mach_port_get_context;
-	__Reply__mach_port_set_context_t Reply_mach_port_set_context;
-	__Reply__mach_port_kobject_t Reply_mach_port_kobject;
-	__Reply__mach_port_construct_t Reply_mach_port_construct;
-	__Reply__mach_port_destruct_t Reply_mach_port_destruct;
-	__Reply__mach_port_guard_t Reply_mach_port_guard;
-	__Reply__mach_port_unguard_t Reply_mach_port_unguard;
-	__Reply__mach_port_space_basic_info_t Reply_mach_port_space_basic_info;
-	__Reply__mach_port_guard_with_flags_t Reply_mach_port_guard_with_flags;
-	__Reply__mach_port_swap_guard_t Reply_mach_port_swap_guard;
-	__Reply__mach_port_kobject_description_t Reply_mach_port_kobject_description;
-};
-#endif /* !__RequestUnion__mach_port_subsystem__defined */
-
-#ifndef subsystem_to_name_map_mach_port
-#define subsystem_to_name_map_mach_port \
-    { "mach_port_names", 3200 },\
-    { "mach_port_type", 3201 },\
-    { "mach_port_rename", 3202 },\
-    { "mach_port_allocate_name", 3203 },\
-    { "mach_port_allocate", 3204 },\
-    { "mach_port_destroy", 3205 },\
-    { "mach_port_deallocate", 3206 },\
-    { "mach_port_get_refs", 3207 },\
-    { "mach_port_mod_refs", 3208 },\
-    { "mach_port_peek", 3209 },\
-    { "mach_port_set_mscount", 3210 },\
-    { "mach_port_get_set_status", 3211 },\
-    { "mach_port_move_member", 3212 },\
-    { "mach_port_request_notification", 3213 },\
-    { "mach_port_insert_right", 3214 },\
-    { "mach_port_extract_right", 3215 },\
-    { "mach_port_set_seqno", 3216 },\
-    { "mach_port_get_attributes", 3217 },\
-    { "mach_port_set_attributes", 3218 },\
-    { "mach_port_allocate_qos", 3219 },\
-    { "mach_port_allocate_full", 3220 },\
-    { "task_set_port_space", 3221 },\
-    { "mach_port_get_srights", 3222 },\
-    { "mach_port_space_info", 3223 },\
-    { "mach_port_dnrequest_info", 3224 },\
-    { "mach_port_kernel_object", 3225 },\
-    { "mach_port_insert_member", 3226 },\
-    { "mach_port_extract_member", 3227 },\
-    { "mach_port_get_context", 3228 },\
-    { "mach_port_set_context", 3229 },\
-    { "mach_port_kobject", 3230 },\
-    { "mach_port_construct", 3231 },\
-    { "mach_port_destruct", 3232 },\
-    { "mach_port_guard", 3233 },\
-    { "mach_port_unguard", 3234 },\
-    { "mach_port_space_basic_info", 3235 },\
-    { "mach_port_guard_with_flags", 3237 },\
-    { "mach_port_swap_guard", 3238 },\
-    { "mach_port_kobject_description", 3239 }
-#endif
-
-#ifdef __AfterMigUserHeader
-__AfterMigUserHeader
-#endif /* __AfterMigUserHeader */
-
-#endif	 /* _mach_port_user_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/mach/mach_traps.h b/lib/libc/include/x86_64-macos-gnu/mach/mach_traps.h
deleted file mode 100644
index d3aaf577ed..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/mach/mach_traps.h
+++ /dev/null
@@ -1,303 +0,0 @@
-/*
- * Copyright (c) 2000-2019 Apple Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-/*
- * @OSF_COPYRIGHT@
- */
-/*
- * Mach Operating System
- * Copyright (c) 1991,1990,1989,1988,1987 Carnegie Mellon University
- * All Rights Reserved.
- *
- * Permission to use, copy, modify and distribute this software and its
- * documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
- * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie Mellon
- * the rights to redistribute these changes.
- */
-/*
- */
-/*
- *	Definitions of general Mach system traps.
- *
- *	These are the definitions as seen from user-space.
- *	The kernel definitions are in <mach/syscall_sw.h>.
- *	Kernel RPC functions are defined in <mach/mach_interface.h>.
- */
-
-#ifndef _MACH_MACH_TRAPS_H_
-#define _MACH_MACH_TRAPS_H_
-
-#include <stdint.h>
-
-#include <mach/std_types.h>
-#include <mach/mach_types.h>
-#include <mach/kern_return.h>
-#include <mach/port.h>
-#include <mach/vm_types.h>
-#include <mach/clock_types.h>
-
-#include <machine/endian.h>
-
-#include <sys/cdefs.h>
-
-__BEGIN_DECLS
-
-
-
-extern kern_return_t clock_sleep_trap(
-	mach_port_name_t clock_name,
-	sleep_type_t sleep_type,
-	int sleep_sec,
-	int sleep_nsec,
-	mach_timespec_t *wakeup_time);
-
-extern kern_return_t _kernelrpc_mach_vm_allocate_trap(
-	mach_port_name_t target,
-	mach_vm_offset_t *addr,
-	mach_vm_size_t size,
-	int flags);
-
-extern kern_return_t _kernelrpc_mach_vm_deallocate_trap(
-	mach_port_name_t target,
-	mach_vm_address_t address,
-	mach_vm_size_t size
-	);
-
-extern kern_return_t _kernelrpc_mach_vm_protect_trap(
-	mach_port_name_t target,
-	mach_vm_address_t address,
-	mach_vm_size_t size,
-	boolean_t set_maximum,
-	vm_prot_t new_protection
-	);
-
-extern kern_return_t _kernelrpc_mach_vm_map_trap(
-	mach_port_name_t target,
-	mach_vm_offset_t *address,
-	mach_vm_size_t size,
-	mach_vm_offset_t mask,
-	int flags,
-	vm_prot_t cur_protection
-	);
-
-extern kern_return_t _kernelrpc_mach_vm_purgable_control_trap(
-	mach_port_name_t target,
-	mach_vm_offset_t address,
-	vm_purgable_t control,
-	int *state);
-
-extern kern_return_t _kernelrpc_mach_port_allocate_trap(
-	mach_port_name_t target,
-	mach_port_right_t right,
-	mach_port_name_t *name
-	);
-
-
-extern kern_return_t _kernelrpc_mach_port_destroy_trap(
-	mach_port_name_t target,
-	mach_port_name_t name
-	);
-
-extern kern_return_t _kernelrpc_mach_port_deallocate_trap(
-	mach_port_name_t target,
-	mach_port_name_t name
-	);
-
-extern kern_return_t _kernelrpc_mach_port_mod_refs_trap(
-	mach_port_name_t target,
-	mach_port_name_t name,
-	mach_port_right_t right,
-	mach_port_delta_t delta
-	);
-
-extern kern_return_t _kernelrpc_mach_port_move_member_trap(
-	mach_port_name_t target,
-	mach_port_name_t member,
-	mach_port_name_t after
-	);
-
-extern kern_return_t _kernelrpc_mach_port_insert_right_trap(
-	mach_port_name_t target,
-	mach_port_name_t name,
-	mach_port_name_t poly,
-	mach_msg_type_name_t polyPoly
-	);
-
-extern kern_return_t _kernelrpc_mach_port_get_attributes_trap(
-	mach_port_name_t target,
-	mach_port_name_t name,
-	mach_port_flavor_t flavor,
-	mach_port_info_t port_info_out,
-	mach_msg_type_number_t *port_info_outCnt
-	);
-
-extern kern_return_t _kernelrpc_mach_port_insert_member_trap(
-	mach_port_name_t target,
-	mach_port_name_t name,
-	mach_port_name_t pset
-	);
-
-extern kern_return_t _kernelrpc_mach_port_extract_member_trap(
-	mach_port_name_t target,
-	mach_port_name_t name,
-	mach_port_name_t pset
-	);
-
-extern kern_return_t _kernelrpc_mach_port_construct_trap(
-	mach_port_name_t target,
-	mach_port_options_t *options,
-	uint64_t context,
-	mach_port_name_t *name
-	);
-
-extern kern_return_t _kernelrpc_mach_port_destruct_trap(
-	mach_port_name_t target,
-	mach_port_name_t name,
-	mach_port_delta_t srdelta,
-	uint64_t guard
-	);
-
-extern kern_return_t _kernelrpc_mach_port_guard_trap(
-	mach_port_name_t target,
-	mach_port_name_t name,
-	uint64_t guard,
-	boolean_t strict
-	);
-
-extern kern_return_t _kernelrpc_mach_port_unguard_trap(
-	mach_port_name_t target,
-	mach_port_name_t name,
-	uint64_t guard
-	);
-
-extern kern_return_t mach_generate_activity_id(
-	mach_port_name_t target,
-	int count,
-	uint64_t *activity_id
-	);
-
-extern kern_return_t macx_swapon(
-	uint64_t filename,
-	int flags,
-	int size,
-	int priority);
-
-extern kern_return_t macx_swapoff(
-	uint64_t filename,
-	int flags);
-
-extern kern_return_t macx_triggers(
-	int hi_water,
-	int low_water,
-	int flags,
-	mach_port_t alert_port);
-
-extern kern_return_t macx_backing_store_suspend(
-	boolean_t suspend);
-
-extern kern_return_t macx_backing_store_recovery(
-	int pid);
-
-extern boolean_t swtch_pri(int pri);
-
-extern boolean_t swtch(void);
-
-extern kern_return_t thread_switch(
-	mach_port_name_t thread_name,
-	int option,
-	mach_msg_timeout_t option_time);
-
-extern mach_port_name_t task_self_trap(void);
-
-extern kern_return_t host_create_mach_voucher_trap(
-	mach_port_name_t host,
-	mach_voucher_attr_raw_recipe_array_t recipes,
-	int recipes_size,
-	mach_port_name_t *voucher);
-
-extern kern_return_t mach_voucher_extract_attr_recipe_trap(
-	mach_port_name_t voucher_name,
-	mach_voucher_attr_key_t key,
-	mach_voucher_attr_raw_recipe_t recipe,
-	mach_msg_type_number_t *recipe_size);
-
-extern kern_return_t _kernelrpc_mach_port_type_trap(
-	ipc_space_t task,
-	mach_port_name_t name,
-	mach_port_type_t *ptype);
-
-extern kern_return_t _kernelrpc_mach_port_request_notification_trap(
-	ipc_space_t task,
-	mach_port_name_t name,
-	mach_msg_id_t msgid,
-	mach_port_mscount_t sync,
-	mach_port_name_t notify,
-	mach_msg_type_name_t notifyPoly,
-	mach_port_name_t *previous);
-
-/*
- *	Obsolete interfaces.
- */
-
-extern kern_return_t task_for_pid(
-	mach_port_name_t target_tport,
-	int pid,
-	mach_port_name_t *t);
-
-extern kern_return_t task_name_for_pid(
-	mach_port_name_t target_tport,
-	int pid,
-	mach_port_name_t *tn);
-
-extern kern_return_t pid_for_task(
-	mach_port_name_t t,
-	int *x);
-
-extern kern_return_t debug_control_port_for_pid(
-	mach_port_name_t target_tport,
-	int pid,
-	mach_port_name_t *t);
-
-
-__END_DECLS
-
-#endif  /* _MACH_MACH_TRAPS_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/mach/mach_types.h b/lib/libc/include/x86_64-macos-gnu/mach/mach_types.h
deleted file mode 100644
index 0c35705acf..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/mach/mach_types.h
+++ /dev/null
@@ -1,254 +0,0 @@
-/*
- * Copyright (c) 2000-2018 Apple Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-/*
- * @OSF_COPYRIGHT@
- */
-/*
- * Mach Operating System
- * Copyright (c) 1991,1990,1989,1988 Carnegie Mellon University
- * All Rights Reserved.
- *
- * Permission to use, copy, modify and distribute this software and its
- * documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
- * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie Mellon
- * the rights to redistribute these changes.
- */
-/*
- */
-/*
- * NOTICE: This file was modified by SPARTA, Inc. in 2005 to introduce
- * support for mandatory and extensible security protections.  This notice
- * is included in support of clause 2.2 (b) of the Apple Public License,
- * Version 2.0.
- */
-/*
- *	File:	mach/mach_types.h
- *	Author:	Avadis Tevanian, Jr., Michael Wayne Young
- *	Date:	1986
- *
- *	Mach external interface definitions.
- *
- */
-
-#ifndef _MACH_MACH_TYPES_H_
-#define _MACH_MACH_TYPES_H_
-
-#include <stdint.h>
-
-#include <sys/cdefs.h>
-
-#include <mach/host_info.h>
-#include <mach/host_notify.h>
-#include <mach/host_special_ports.h>
-#include <mach/machine.h>
-#include <mach/machine/vm_types.h>
-#include <mach/memory_object_types.h>
-#include <mach/message.h>
-#include <mach/exception_types.h>
-#include <mach/port.h>
-#include <mach/mach_voucher_types.h>
-#include <mach/processor_info.h>
-#include <mach/task_info.h>
-#include <mach/task_inspect.h>
-#include <mach/task_policy.h>
-#include <mach/task_special_ports.h>
-#include <mach/thread_info.h>
-#include <mach/thread_policy.h>
-#include <mach/thread_special_ports.h>
-#include <mach/thread_status.h>
-#include <mach/time_value.h>
-#include <mach/clock_types.h>
-#include <mach/vm_attributes.h>
-#include <mach/vm_inherit.h>
-#include <mach/vm_purgable.h>
-#include <mach/vm_behavior.h>
-#include <mach/vm_prot.h>
-#include <mach/vm_statistics.h>
-#include <mach/vm_sync.h>
-#include <mach/vm_types.h>
-#include <mach/vm_region.h>
-#include <mach/kmod.h>
-#include <mach/dyld_kernel.h>
-
-
-/*
- * If we are not in the kernel, then these will all be represented by
- * ports at user-space.
- */
-typedef mach_port_t             task_t;
-typedef mach_port_t             task_name_t;
-typedef mach_port_t             task_inspect_t;
-typedef mach_port_t             task_suspension_token_t;
-typedef mach_port_t             thread_t;
-typedef mach_port_t             thread_act_t;
-typedef mach_port_t             thread_inspect_t;
-typedef mach_port_t             ipc_space_t;
-typedef mach_port_t             ipc_space_inspect_t;
-typedef mach_port_t             coalition_t;
-typedef mach_port_t             host_t;
-typedef mach_port_t             host_priv_t;
-typedef mach_port_t             host_security_t;
-typedef mach_port_t             processor_t;
-typedef mach_port_t             processor_set_t;
-typedef mach_port_t             processor_set_control_t;
-typedef mach_port_t             semaphore_t;
-typedef mach_port_t             lock_set_t;
-typedef mach_port_t             ledger_t;
-typedef mach_port_t             alarm_t;
-typedef mach_port_t             clock_serv_t;
-typedef mach_port_t             clock_ctrl_t;
-typedef mach_port_t             arcade_register_t;
-typedef mach_port_t             suid_cred_t;
-
-
-/*
- * These aren't really unique types.  They are just called
- * out as unique types at one point in history.  So we list
- * them here for compatibility.
- */
-typedef processor_set_t         processor_set_name_t;
-
-/*
- * These types are just hard-coded as ports
- */
-typedef mach_port_t             clock_reply_t;
-typedef mach_port_t             bootstrap_t;
-typedef mach_port_t             mem_entry_name_port_t;
-typedef mach_port_t             exception_handler_t;
-typedef exception_handler_t     *exception_handler_array_t;
-typedef mach_port_t             vm_task_entry_t;
-typedef mach_port_t             io_master_t;
-typedef mach_port_t             UNDServerRef;
-
-/*
- * Mig doesn't translate the components of an array.
- * For example, Mig won't use the thread_t translations
- * to translate a thread_array_t argument.  So, these definitions
- * are not completely accurate at the moment for other kernel
- * components.
- */
-typedef task_t                  *task_array_t;
-typedef thread_t                *thread_array_t;
-typedef processor_set_t         *processor_set_array_t;
-typedef processor_set_t         *processor_set_name_array_t;
-typedef processor_t             *processor_array_t;
-typedef thread_act_t            *thread_act_array_t;
-typedef ledger_t                *ledger_array_t;
-
-/*
- * However the real mach_types got declared, we also have to declare
- * types with "port" in the name for compatability with the way OSF
- * had declared the user interfaces at one point.  Someday these should
- * go away.
- */
-typedef task_t                  task_port_t;
-typedef task_array_t            task_port_array_t;
-typedef thread_t                thread_port_t;
-typedef thread_array_t          thread_port_array_t;
-typedef ipc_space_t             ipc_space_port_t;
-typedef host_t                  host_name_t;
-typedef host_t                  host_name_port_t;
-typedef processor_set_t         processor_set_port_t;
-typedef processor_set_t         processor_set_name_port_t;
-typedef processor_set_array_t   processor_set_name_port_array_t;
-typedef processor_set_t         processor_set_control_port_t;
-typedef processor_t             processor_port_t;
-typedef processor_array_t       processor_port_array_t;
-typedef thread_act_t            thread_act_port_t;
-typedef thread_act_array_t      thread_act_port_array_t;
-typedef semaphore_t             semaphore_port_t;
-typedef lock_set_t              lock_set_port_t;
-typedef ledger_t                ledger_port_t;
-typedef ledger_array_t          ledger_port_array_t;
-typedef alarm_t                 alarm_port_t;
-typedef clock_serv_t            clock_serv_port_t;
-typedef clock_ctrl_t            clock_ctrl_port_t;
-typedef exception_handler_t     exception_port_t;
-typedef exception_handler_array_t exception_port_arrary_t;
-typedef char vfs_path_t[4096];
-typedef char nspace_path_t[1024]; /* 1024 == PATH_MAX */
-typedef char suid_cred_path_t[1024];
-typedef uint32_t suid_cred_uid_t;
-
-#define TASK_NULL               ((task_t) 0)
-#define TASK_NAME_NULL          ((task_name_t) 0)
-#define TASK_INSPECT_NULL               ((task_inspect_t) 0)
-#define THREAD_NULL             ((thread_t) 0)
-#define THREAD_INSPECT_NULL     ((thread_inspect_t) 0)
-#define TID_NULL                ((uint64_t) 0)
-#define THR_ACT_NULL            ((thread_act_t) 0)
-#define IPC_SPACE_NULL          ((ipc_space_t) 0)
-#define IPC_SPACE_INSPECT_NULL  ((ipc_space_inspect_t) 0)
-#define COALITION_NULL          ((coalition_t) 0)
-#define HOST_NULL               ((host_t) 0)
-#define HOST_PRIV_NULL          ((host_priv_t) 0)
-#define HOST_SECURITY_NULL      ((host_security_t) 0)
-#define PROCESSOR_SET_NULL      ((processor_set_t) 0)
-#define PROCESSOR_NULL          ((processor_t) 0)
-#define SEMAPHORE_NULL          ((semaphore_t) 0)
-#define LOCK_SET_NULL           ((lock_set_t) 0)
-#define LEDGER_NULL             ((ledger_t) 0)
-#define ALARM_NULL              ((alarm_t) 0)
-#define CLOCK_NULL              ((clock_t) 0)
-#define UND_SERVER_NULL         ((UNDServerRef) 0)
-#define ARCADE_REG_NULL         ((arcade_register_t) 0)
-#define SUID_CRED_NULL         ((suid_cred_t) 0)
-
-/* DEPRECATED */
-typedef natural_t       ledger_item_t;
-#define LEDGER_ITEM_INFINITY    ((ledger_item_t) (~0))
-
-typedef int64_t                 ledger_amount_t;
-#define LEDGER_LIMIT_INFINITY   ((ledger_amount_t)((1ULL << 63) - 1))
-
-typedef mach_vm_offset_t        *emulation_vector_t;
-typedef char                    *user_subsystem_t;
-
-typedef char                    *labelstr_t;
-/*
- *	Backwards compatibility, for those programs written
- *	before mach/{std,mach}_types.{defs,h} were set up.
- */
-#include <mach/std_types.h>
-
-#endif  /* _MACH_MACH_TYPES_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/mach/machine.h b/lib/libc/include/x86_64-macos-gnu/mach/machine.h
deleted file mode 100644
index 30aafcc812..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/mach/machine.h
+++ /dev/null
@@ -1,395 +0,0 @@
-/*
- * Copyright (c) 2007-2016 Apple, Inc. All rights reserved.
- * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-/*
- * Mach Operating System
- * Copyright (c) 1991,1990,1989,1988,1987 Carnegie Mellon University
- * All Rights Reserved.
- *
- * Permission to use, copy, modify and distribute this software and its
- * documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
- * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie Mellon
- * the rights to redistribute these changes.
- */
-/*	File:	machine.h
- *	Author:	Avadis Tevanian, Jr.
- *	Date:	1986
- *
- *	Machine independent machine abstraction.
- */
-
-#ifndef _MACH_MACHINE_H_
-#define _MACH_MACHINE_H_
-
-#ifndef __ASSEMBLER__
-
-#include <stdint.h>
-#include <mach/machine/vm_types.h>
-#include <mach/boolean.h>
-
-typedef integer_t       cpu_type_t;
-typedef integer_t       cpu_subtype_t;
-typedef integer_t       cpu_threadtype_t;
-
-#define CPU_STATE_MAX           4
-
-#define CPU_STATE_USER          0
-#define CPU_STATE_SYSTEM        1
-#define CPU_STATE_IDLE          2
-#define CPU_STATE_NICE          3
-
-
-
-/*
- * Capability bits used in the definition of cpu_type.
- */
-#define CPU_ARCH_MASK           0xff000000      /* mask for architecture bits */
-#define CPU_ARCH_ABI64          0x01000000      /* 64 bit ABI */
-#define CPU_ARCH_ABI64_32       0x02000000      /* ABI for 64-bit hardware with 32-bit types; LP32 */
-
-/*
- *	Machine types known by all.
- */
-
-#define CPU_TYPE_ANY            ((cpu_type_t) -1)
-
-#define CPU_TYPE_VAX            ((cpu_type_t) 1)
-/* skip				((cpu_type_t) 2)	*/
-/* skip				((cpu_type_t) 3)	*/
-/* skip				((cpu_type_t) 4)	*/
-/* skip				((cpu_type_t) 5)	*/
-#define CPU_TYPE_MC680x0        ((cpu_type_t) 6)
-#define CPU_TYPE_X86            ((cpu_type_t) 7)
-#define CPU_TYPE_I386           CPU_TYPE_X86            /* compatibility */
-#define CPU_TYPE_X86_64         (CPU_TYPE_X86 | CPU_ARCH_ABI64)
-
-/* skip CPU_TYPE_MIPS		((cpu_type_t) 8)	*/
-/* skip                         ((cpu_type_t) 9)	*/
-#define CPU_TYPE_MC98000        ((cpu_type_t) 10)
-#define CPU_TYPE_HPPA           ((cpu_type_t) 11)
-#define CPU_TYPE_ARM            ((cpu_type_t) 12)
-#define CPU_TYPE_ARM64          (CPU_TYPE_ARM | CPU_ARCH_ABI64)
-#define CPU_TYPE_ARM64_32       (CPU_TYPE_ARM | CPU_ARCH_ABI64_32)
-#define CPU_TYPE_MC88000        ((cpu_type_t) 13)
-#define CPU_TYPE_SPARC          ((cpu_type_t) 14)
-#define CPU_TYPE_I860           ((cpu_type_t) 15)
-/* skip	CPU_TYPE_ALPHA		((cpu_type_t) 16)	*/
-/* skip				((cpu_type_t) 17)	*/
-#define CPU_TYPE_POWERPC                ((cpu_type_t) 18)
-#define CPU_TYPE_POWERPC64              (CPU_TYPE_POWERPC | CPU_ARCH_ABI64)
-/* skip				((cpu_type_t) 19)	*/
-
-/*
- *	Machine subtypes (these are defined here, instead of in a machine
- *	dependent directory, so that any program can get all definitions
- *	regardless of where is it compiled).
- */
-
-/*
- * Capability bits used in the definition of cpu_subtype.
- */
-#define CPU_SUBTYPE_MASK        0xff000000      /* mask for feature flags */
-#define CPU_SUBTYPE_LIB64       0x80000000      /* 64 bit libraries */
-
-
-/*
- *	Object files that are hand-crafted to run on any
- *	implementation of an architecture are tagged with
- *	CPU_SUBTYPE_MULTIPLE.  This functions essentially the same as
- *	the "ALL" subtype of an architecture except that it allows us
- *	to easily find object files that may need to be modified
- *	whenever a new implementation of an architecture comes out.
- *
- *	It is the responsibility of the implementor to make sure the
- *	software handles unsupported implementations elegantly.
- */
-#define CPU_SUBTYPE_MULTIPLE            ((cpu_subtype_t) -1)
-#define CPU_SUBTYPE_LITTLE_ENDIAN       ((cpu_subtype_t) 0)
-#define CPU_SUBTYPE_BIG_ENDIAN          ((cpu_subtype_t) 1)
-
-/*
- *     Machine threadtypes.
- *     This is none - not defined - for most machine types/subtypes.
- */
-#define CPU_THREADTYPE_NONE             ((cpu_threadtype_t) 0)
-
-/*
- *	VAX subtypes (these do *not* necessary conform to the actual cpu
- *	ID assigned by DEC available via the SID register).
- */
-
-#define CPU_SUBTYPE_VAX_ALL     ((cpu_subtype_t) 0)
-#define CPU_SUBTYPE_VAX780      ((cpu_subtype_t) 1)
-#define CPU_SUBTYPE_VAX785      ((cpu_subtype_t) 2)
-#define CPU_SUBTYPE_VAX750      ((cpu_subtype_t) 3)
-#define CPU_SUBTYPE_VAX730      ((cpu_subtype_t) 4)
-#define CPU_SUBTYPE_UVAXI       ((cpu_subtype_t) 5)
-#define CPU_SUBTYPE_UVAXII      ((cpu_subtype_t) 6)
-#define CPU_SUBTYPE_VAX8200     ((cpu_subtype_t) 7)
-#define CPU_SUBTYPE_VAX8500     ((cpu_subtype_t) 8)
-#define CPU_SUBTYPE_VAX8600     ((cpu_subtype_t) 9)
-#define CPU_SUBTYPE_VAX8650     ((cpu_subtype_t) 10)
-#define CPU_SUBTYPE_VAX8800     ((cpu_subtype_t) 11)
-#define CPU_SUBTYPE_UVAXIII     ((cpu_subtype_t) 12)
-
-/*
- *      680x0 subtypes
- *
- * The subtype definitions here are unusual for historical reasons.
- * NeXT used to consider 68030 code as generic 68000 code.  For
- * backwards compatability:
- *
- *	CPU_SUBTYPE_MC68030 symbol has been preserved for source code
- *	compatability.
- *
- *	CPU_SUBTYPE_MC680x0_ALL has been defined to be the same
- *	subtype as CPU_SUBTYPE_MC68030 for binary comatability.
- *
- *	CPU_SUBTYPE_MC68030_ONLY has been added to allow new object
- *	files to be tagged as containing 68030-specific instructions.
- */
-
-#define CPU_SUBTYPE_MC680x0_ALL         ((cpu_subtype_t) 1)
-#define CPU_SUBTYPE_MC68030             ((cpu_subtype_t) 1) /* compat */
-#define CPU_SUBTYPE_MC68040             ((cpu_subtype_t) 2)
-#define CPU_SUBTYPE_MC68030_ONLY        ((cpu_subtype_t) 3)
-
-/*
- *	I386 subtypes
- */
-
-#define CPU_SUBTYPE_INTEL(f, m) ((cpu_subtype_t) (f) + ((m) << 4))
-
-#define CPU_SUBTYPE_I386_ALL                    CPU_SUBTYPE_INTEL(3, 0)
-#define CPU_SUBTYPE_386                                 CPU_SUBTYPE_INTEL(3, 0)
-#define CPU_SUBTYPE_486                                 CPU_SUBTYPE_INTEL(4, 0)
-#define CPU_SUBTYPE_486SX                               CPU_SUBTYPE_INTEL(4, 8) // 8 << 4 = 128
-#define CPU_SUBTYPE_586                                 CPU_SUBTYPE_INTEL(5, 0)
-#define CPU_SUBTYPE_PENT        CPU_SUBTYPE_INTEL(5, 0)
-#define CPU_SUBTYPE_PENTPRO     CPU_SUBTYPE_INTEL(6, 1)
-#define CPU_SUBTYPE_PENTII_M3   CPU_SUBTYPE_INTEL(6, 3)
-#define CPU_SUBTYPE_PENTII_M5   CPU_SUBTYPE_INTEL(6, 5)
-#define CPU_SUBTYPE_CELERON                             CPU_SUBTYPE_INTEL(7, 6)
-#define CPU_SUBTYPE_CELERON_MOBILE              CPU_SUBTYPE_INTEL(7, 7)
-#define CPU_SUBTYPE_PENTIUM_3                   CPU_SUBTYPE_INTEL(8, 0)
-#define CPU_SUBTYPE_PENTIUM_3_M                 CPU_SUBTYPE_INTEL(8, 1)
-#define CPU_SUBTYPE_PENTIUM_3_XEON              CPU_SUBTYPE_INTEL(8, 2)
-#define CPU_SUBTYPE_PENTIUM_M                   CPU_SUBTYPE_INTEL(9, 0)
-#define CPU_SUBTYPE_PENTIUM_4                   CPU_SUBTYPE_INTEL(10, 0)
-#define CPU_SUBTYPE_PENTIUM_4_M                 CPU_SUBTYPE_INTEL(10, 1)
-#define CPU_SUBTYPE_ITANIUM                             CPU_SUBTYPE_INTEL(11, 0)
-#define CPU_SUBTYPE_ITANIUM_2                   CPU_SUBTYPE_INTEL(11, 1)
-#define CPU_SUBTYPE_XEON                                CPU_SUBTYPE_INTEL(12, 0)
-#define CPU_SUBTYPE_XEON_MP                             CPU_SUBTYPE_INTEL(12, 1)
-
-#define CPU_SUBTYPE_INTEL_FAMILY(x)     ((x) & 15)
-#define CPU_SUBTYPE_INTEL_FAMILY_MAX    15
-
-#define CPU_SUBTYPE_INTEL_MODEL(x)      ((x) >> 4)
-#define CPU_SUBTYPE_INTEL_MODEL_ALL     0
-
-/*
- *	X86 subtypes.
- */
-
-#define CPU_SUBTYPE_X86_ALL             ((cpu_subtype_t)3)
-#define CPU_SUBTYPE_X86_64_ALL          ((cpu_subtype_t)3)
-#define CPU_SUBTYPE_X86_ARCH1           ((cpu_subtype_t)4)
-#define CPU_SUBTYPE_X86_64_H            ((cpu_subtype_t)8)      /* Haswell feature subset */
-
-
-#define CPU_THREADTYPE_INTEL_HTT        ((cpu_threadtype_t) 1)
-
-/*
- *	Mips subtypes.
- */
-
-#define CPU_SUBTYPE_MIPS_ALL    ((cpu_subtype_t) 0)
-#define CPU_SUBTYPE_MIPS_R2300  ((cpu_subtype_t) 1)
-#define CPU_SUBTYPE_MIPS_R2600  ((cpu_subtype_t) 2)
-#define CPU_SUBTYPE_MIPS_R2800  ((cpu_subtype_t) 3)
-#define CPU_SUBTYPE_MIPS_R2000a ((cpu_subtype_t) 4)     /* pmax */
-#define CPU_SUBTYPE_MIPS_R2000  ((cpu_subtype_t) 5)
-#define CPU_SUBTYPE_MIPS_R3000a ((cpu_subtype_t) 6)     /* 3max */
-#define CPU_SUBTYPE_MIPS_R3000  ((cpu_subtype_t) 7)
-
-/*
- *	MC98000 (PowerPC) subtypes
- */
-#define CPU_SUBTYPE_MC98000_ALL ((cpu_subtype_t) 0)
-#define CPU_SUBTYPE_MC98601     ((cpu_subtype_t) 1)
-
-/*
- *	HPPA subtypes for Hewlett-Packard HP-PA family of
- *	risc processors. Port by NeXT to 700 series.
- */
-
-#define CPU_SUBTYPE_HPPA_ALL            ((cpu_subtype_t) 0)
-#define CPU_SUBTYPE_HPPA_7100           ((cpu_subtype_t) 0) /* compat */
-#define CPU_SUBTYPE_HPPA_7100LC         ((cpu_subtype_t) 1)
-
-/*
- *	MC88000 subtypes.
- */
-#define CPU_SUBTYPE_MC88000_ALL ((cpu_subtype_t) 0)
-#define CPU_SUBTYPE_MC88100     ((cpu_subtype_t) 1)
-#define CPU_SUBTYPE_MC88110     ((cpu_subtype_t) 2)
-
-/*
- *	SPARC subtypes
- */
-#define CPU_SUBTYPE_SPARC_ALL           ((cpu_subtype_t) 0)
-
-/*
- *	I860 subtypes
- */
-#define CPU_SUBTYPE_I860_ALL    ((cpu_subtype_t) 0)
-#define CPU_SUBTYPE_I860_860    ((cpu_subtype_t) 1)
-
-/*
- *	PowerPC subtypes
- */
-#define CPU_SUBTYPE_POWERPC_ALL         ((cpu_subtype_t) 0)
-#define CPU_SUBTYPE_POWERPC_601         ((cpu_subtype_t) 1)
-#define CPU_SUBTYPE_POWERPC_602         ((cpu_subtype_t) 2)
-#define CPU_SUBTYPE_POWERPC_603         ((cpu_subtype_t) 3)
-#define CPU_SUBTYPE_POWERPC_603e        ((cpu_subtype_t) 4)
-#define CPU_SUBTYPE_POWERPC_603ev       ((cpu_subtype_t) 5)
-#define CPU_SUBTYPE_POWERPC_604         ((cpu_subtype_t) 6)
-#define CPU_SUBTYPE_POWERPC_604e        ((cpu_subtype_t) 7)
-#define CPU_SUBTYPE_POWERPC_620         ((cpu_subtype_t) 8)
-#define CPU_SUBTYPE_POWERPC_750         ((cpu_subtype_t) 9)
-#define CPU_SUBTYPE_POWERPC_7400        ((cpu_subtype_t) 10)
-#define CPU_SUBTYPE_POWERPC_7450        ((cpu_subtype_t) 11)
-#define CPU_SUBTYPE_POWERPC_970         ((cpu_subtype_t) 100)
-
-/*
- *	ARM subtypes
- */
-#define CPU_SUBTYPE_ARM_ALL             ((cpu_subtype_t) 0)
-#define CPU_SUBTYPE_ARM_V4T             ((cpu_subtype_t) 5)
-#define CPU_SUBTYPE_ARM_V6              ((cpu_subtype_t) 6)
-#define CPU_SUBTYPE_ARM_V5TEJ           ((cpu_subtype_t) 7)
-#define CPU_SUBTYPE_ARM_XSCALE          ((cpu_subtype_t) 8)
-#define CPU_SUBTYPE_ARM_V7              ((cpu_subtype_t) 9)  /* ARMv7-A and ARMv7-R */
-#define CPU_SUBTYPE_ARM_V7F             ((cpu_subtype_t) 10) /* Cortex A9 */
-#define CPU_SUBTYPE_ARM_V7S             ((cpu_subtype_t) 11) /* Swift */
-#define CPU_SUBTYPE_ARM_V7K             ((cpu_subtype_t) 12)
-#define CPU_SUBTYPE_ARM_V8              ((cpu_subtype_t) 13)
-#define CPU_SUBTYPE_ARM_V6M             ((cpu_subtype_t) 14) /* Not meant to be run under xnu */
-#define CPU_SUBTYPE_ARM_V7M             ((cpu_subtype_t) 15) /* Not meant to be run under xnu */
-#define CPU_SUBTYPE_ARM_V7EM            ((cpu_subtype_t) 16) /* Not meant to be run under xnu */
-#define CPU_SUBTYPE_ARM_V8M             ((cpu_subtype_t) 17) /* Not meant to be run under xnu */
-
-/*
- *  ARM64 subtypes
- */
-#define CPU_SUBTYPE_ARM64_ALL           ((cpu_subtype_t) 0)
-#define CPU_SUBTYPE_ARM64_V8            ((cpu_subtype_t) 1)
-#define CPU_SUBTYPE_ARM64E              ((cpu_subtype_t) 2)
-
-/* CPU subtype feature flags for ptrauth on arm64e platforms */
-#define CPU_SUBTYPE_ARM64_PTR_AUTH_MASK 0x0f000000
-#define CPU_SUBTYPE_ARM64_PTR_AUTH_VERSION(x) (((x) & CPU_SUBTYPE_ARM64_PTR_AUTH_MASK) >> 24)
-
-/*
- *  ARM64_32 subtypes
- */
-#define CPU_SUBTYPE_ARM64_32_ALL        ((cpu_subtype_t) 0)
-#define CPU_SUBTYPE_ARM64_32_V8 ((cpu_subtype_t) 1)
-
-#endif /* !__ASSEMBLER__ */
-
-/*
- *	CPU families (sysctl hw.cpufamily)
- *
- * These are meant to identify the CPU's marketing name - an
- * application can map these to (possibly) localized strings.
- * NB: the encodings of the CPU families are intentionally arbitrary.
- * There is no ordering, and you should never try to deduce whether
- * or not some feature is available based on the family.
- * Use feature flags (eg, hw.optional.altivec) to test for optional
- * functionality.
- */
-#define CPUFAMILY_UNKNOWN               0
-#define CPUFAMILY_POWERPC_G3            0xcee41549
-#define CPUFAMILY_POWERPC_G4            0x77c184ae
-#define CPUFAMILY_POWERPC_G5            0xed76d8aa
-#define CPUFAMILY_INTEL_6_13            0xaa33392b
-#define CPUFAMILY_INTEL_PENRYN          0x78ea4fbc
-#define CPUFAMILY_INTEL_NEHALEM         0x6b5a4cd2
-#define CPUFAMILY_INTEL_WESTMERE        0x573b5eec
-#define CPUFAMILY_INTEL_SANDYBRIDGE     0x5490b78c
-#define CPUFAMILY_INTEL_IVYBRIDGE       0x1f65e835
-#define CPUFAMILY_INTEL_HASWELL         0x10b282dc
-#define CPUFAMILY_INTEL_BROADWELL       0x582ed09c
-#define CPUFAMILY_INTEL_SKYLAKE         0x37fc219f
-#define CPUFAMILY_INTEL_KABYLAKE        0x0f817246
-#if !defined(RC_HIDE_XNU_ICELAKE)
-#define CPUFAMILY_INTEL_ICELAKE         0x38435547
-#endif /* not RC_HIDE_XNU_ICELAKE */
-#if !defined(RC_HIDE_XNU_COMETLAKE)
-#define CPUFAMILY_INTEL_COMETLAKE       0x1cf8a03e
-#endif /* not RC_HIDE_XNU_COMETLAKE */
-#define CPUFAMILY_ARM_9                 0xe73283ae
-#define CPUFAMILY_ARM_11                0x8ff620d8
-#define CPUFAMILY_ARM_XSCALE            0x53b005f5
-#define CPUFAMILY_ARM_12                0xbd1b0ae9
-#define CPUFAMILY_ARM_13                0x0cc90e64
-#define CPUFAMILY_ARM_14                0x96077ef1
-#define CPUFAMILY_ARM_15                0xa8511bca
-#define CPUFAMILY_ARM_SWIFT             0x1e2d6381
-#define CPUFAMILY_ARM_CYCLONE           0x37a09642
-#define CPUFAMILY_ARM_TYPHOON           0x2c91a47e
-#define CPUFAMILY_ARM_TWISTER           0x92fb37c8
-#define CPUFAMILY_ARM_HURRICANE         0x67ceee93
-#define CPUFAMILY_ARM_MONSOON_MISTRAL   0xe81e7ef6
-#define CPUFAMILY_ARM_VORTEX_TEMPEST    0x07d34b9f
-#define CPUFAMILY_ARM_LIGHTNING_THUNDER 0x462504d2
-
-/* The following synonyms are deprecated: */
-#define CPUFAMILY_INTEL_6_23    CPUFAMILY_INTEL_PENRYN
-#define CPUFAMILY_INTEL_6_26    CPUFAMILY_INTEL_NEHALEM
-
-
-#endif  /* _MACH_MACHINE_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/mach/machine/_structs.h b/lib/libc/include/x86_64-macos-gnu/mach/machine/_structs.h
deleted file mode 100644
index 0a61125417..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/mach/machine/_structs.h
+++ /dev/null
@@ -1,38 +0,0 @@
-/*
- * Copyright (c) 2017 Apple Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-
-#ifndef _MACH_MACHINE__STRUCTS_H_
-#define _MACH_MACHINE__STRUCTS_H_
-
-#if defined (__i386__) || defined(__x86_64__)
-#include "mach/i386/_structs.h"
-#else
-#error architecture not supported
-#endif
-
-#endif /* _MACH_MACHINE__STRUCTS_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/mach/machine/boolean.h b/lib/libc/include/x86_64-macos-gnu/mach/machine/boolean.h
deleted file mode 100644
index d373913b40..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/mach/machine/boolean.h
+++ /dev/null
@@ -1,38 +0,0 @@
-/*
- * Copyright (c) 2000-2007 Apple Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-
-#ifndef _MACH_MACHINE_BOOLEAN_H_
-#define _MACH_MACHINE_BOOLEAN_H_
-
-#if defined (__i386__) || defined(__x86_64__)
-#include "mach/i386/boolean.h"
-#else
-#error architecture not supported
-#endif
-
-#endif /* _MACH_MACHINE_BOOLEAN_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/mach/machine/exception.h b/lib/libc/include/x86_64-macos-gnu/mach/machine/exception.h
deleted file mode 100644
index f3e960d436..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/mach/machine/exception.h
+++ /dev/null
@@ -1,38 +0,0 @@
-/*
- * Copyright (c) 2000-2007 Apple Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-
-#ifndef _MACH_MACHINE_EXCEPTION_H_
-#define _MACH_MACHINE_EXCEPTION_H_
-
-#if defined (__i386__) || defined(__x86_64__)
-#include "mach/i386/exception.h"
-#else
-#error architecture not supported
-#endif
-
-#endif /* _MACH_MACHINE_EXCEPTION_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/mach/machine/kern_return.h b/lib/libc/include/x86_64-macos-gnu/mach/machine/kern_return.h
deleted file mode 100644
index b764492d29..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/mach/machine/kern_return.h
+++ /dev/null
@@ -1,38 +0,0 @@
-/*
- * Copyright (c) 2000-2007 Apple Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-
-#ifndef _MACH_MACHINE_KERN_RETURN_H_
-#define _MACH_MACHINE_KERN_RETURN_H_
-
-#if defined (__i386__) || defined(__x86_64__)
-#include "mach/i386/kern_return.h"
-#else
-#error architecture not supported
-#endif
-
-#endif /* _MACH_MACHINE_KERN_RETURN_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/mach/machine/processor_info.h b/lib/libc/include/x86_64-macos-gnu/mach/machine/processor_info.h
deleted file mode 100644
index 4e5028d24d..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/mach/machine/processor_info.h
+++ /dev/null
@@ -1,38 +0,0 @@
-/*
- * Copyright (c) 2000-2007 Apple Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-
-#ifndef _MACH_MACHINE_PROCESSOR_INFO_H_
-#define _MACH_MACHINE_PROCESSOR_INFO_H_
-
-#if defined (__i386__) || defined(__x86_64__)
-#include "mach/i386/processor_info.h"
-#else
-#error architecture not supported
-#endif
-
-#endif /* _MACH_MACHINE_PROCESSOR_INFO_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/mach/machine/rpc.h b/lib/libc/include/x86_64-macos-gnu/mach/machine/rpc.h
deleted file mode 100644
index 7d6ccee5f8..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/mach/machine/rpc.h
+++ /dev/null
@@ -1,38 +0,0 @@
-/*
- * Copyright (c) 2000-2007 Apple Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-
-#ifndef _MACH_MACHINE_RPC_H_
-#define _MACH_MACHINE_RPC_H_
-
-#if defined (__i386__) || defined(__x86_64__)
-#include "mach/i386/rpc.h"
-#else
-#error architecture not supported
-#endif
-
-#endif  /* _MACH_MACHINE_RPC_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/mach/machine/thread_state.h b/lib/libc/include/x86_64-macos-gnu/mach/machine/thread_state.h
deleted file mode 100644
index 91daad8671..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/mach/machine/thread_state.h
+++ /dev/null
@@ -1,38 +0,0 @@
-/*
- * Copyright (c) 2000-2007 Apple Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-
-#ifndef _MACH_MACHINE_THREAD_STATE_H_
-#define _MACH_MACHINE_THREAD_STATE_H_
-
-#if defined (__i386__) || defined(__x86_64__)
-#include "mach/i386/thread_state.h"
-#else
-#error architecture not supported
-#endif
-
-#endif /* _MACH_MACHINE_THREAD_STATE_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/mach/machine/thread_status.h b/lib/libc/include/x86_64-macos-gnu/mach/machine/thread_status.h
deleted file mode 100644
index 7e65df246e..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/mach/machine/thread_status.h
+++ /dev/null
@@ -1,38 +0,0 @@
-/*
- * Copyright (c) 2000-2007 Apple Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-
-#ifndef _MACH_MACHINE_THREAD_STATUS_H_
-#define _MACH_MACHINE_THREAD_STATUS_H_
-
-#if defined (__i386__) || defined(__x86_64__)
-#include "mach/i386/thread_status.h"
-#else
-#error architecture not supported
-#endif
-
-#endif /* _MACH_MACHINE_THREAD_STATUS_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/mach/machine/vm_param.h b/lib/libc/include/x86_64-macos-gnu/mach/machine/vm_param.h
deleted file mode 100644
index 7f272f5b70..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/mach/machine/vm_param.h
+++ /dev/null
@@ -1,38 +0,0 @@
-/*
- * Copyright (c) 2000-2007 Apple Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-
-#ifndef _MACH_MACHINE_VM_PARAM_H_
-#define _MACH_MACHINE_VM_PARAM_H_
-
-#if defined (__i386__) || defined(__x86_64__)
-#include "mach/i386/vm_param.h"
-#else
-#error architecture not supported
-#endif
-
-#endif /* _MACH_MACHINE_VM_PARAM_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/mach/machine/vm_types.h b/lib/libc/include/x86_64-macos-gnu/mach/machine/vm_types.h
deleted file mode 100644
index 5d16a871ea..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/mach/machine/vm_types.h
+++ /dev/null
@@ -1,38 +0,0 @@
-/*
- * Copyright (c) 2000-2007 Apple Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-
-#ifndef _MACH_MACHINE_VM_TYPES_H_
-#define _MACH_MACHINE_VM_TYPES_H_
-
-#if defined (__i386__) || defined(__x86_64__)
-#include "mach/i386/vm_types.h"
-#else
-#error architecture not supported
-#endif
-
-#endif /* _MACH_MACHINE_VM_TYPES_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/mach/memory_object_types.h b/lib/libc/include/x86_64-macos-gnu/mach/memory_object_types.h
deleted file mode 100644
index fec6e53593..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/mach/memory_object_types.h
+++ /dev/null
@@ -1,299 +0,0 @@
-/*
- * Copyright (c) 2000-2016 Apple Computer, Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-/*
- * @OSF_COPYRIGHT@
- */
-/*
- * Mach Operating System
- * Copyright (c) 1991,1990,1989,1988 Carnegie Mellon University
- * All Rights Reserved.
- *
- * Permission to use, copy, modify and distribute this software and its
- * documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
- * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie Mellon
- * the rights to redistribute these changes.
- */
-/*
- */
-/*
- *	File:	memory_object.h
- *	Author:	Michael Wayne Young
- *
- *	External memory management interface definition.
- */
-
-#ifndef _MACH_MEMORY_OBJECT_TYPES_H_
-#define _MACH_MEMORY_OBJECT_TYPES_H_
-
-/*
- *	User-visible types used in the external memory
- *	management interface:
- */
-
-#include <mach/port.h>
-#include <mach/message.h>
-#include <mach/vm_prot.h>
-#include <mach/vm_sync.h>
-#include <mach/vm_types.h>
-#include <mach/machine/vm_types.h>
-
-#include <sys/cdefs.h>
-
-#define VM_64_BIT_DATA_OBJECTS
-
-typedef unsigned long long      memory_object_offset_t;
-typedef unsigned long long      memory_object_size_t;
-typedef natural_t               memory_object_cluster_size_t;
-typedef natural_t *             memory_object_fault_info_t;
-
-typedef unsigned long long      vm_object_id_t;
-
-
-/*
- * Temporary until real EMMI version gets re-implemented
- */
-
-
-typedef mach_port_t     memory_object_t;
-typedef mach_port_t     memory_object_control_t;
-
-
-typedef memory_object_t *memory_object_array_t;
-/* A memory object ... */
-/*  Used by the kernel to retrieve */
-/*  or store data */
-
-typedef mach_port_t     memory_object_name_t;
-/* Used to describe the memory ... */
-/*  object in vm_regions() calls */
-
-typedef mach_port_t     memory_object_default_t;
-/* Registered with the host ... */
-/*  for creating new internal objects */
-
-#define MEMORY_OBJECT_NULL              ((memory_object_t) 0)
-#define MEMORY_OBJECT_CONTROL_NULL      ((memory_object_control_t) 0)
-#define MEMORY_OBJECT_NAME_NULL         ((memory_object_name_t) 0)
-#define MEMORY_OBJECT_DEFAULT_NULL      ((memory_object_default_t) 0)
-
-
-typedef int             memory_object_copy_strategy_t;
-/* How memory manager handles copy: */
-#define         MEMORY_OBJECT_COPY_NONE         0
-/* ... No special support */
-#define         MEMORY_OBJECT_COPY_CALL         1
-/* ... Make call on memory manager */
-#define         MEMORY_OBJECT_COPY_DELAY        2
-/* ... Memory manager doesn't
- *     change data externally.
- */
-#define         MEMORY_OBJECT_COPY_TEMPORARY    3
-/* ... Memory manager doesn't
- *     change data externally, and
- *     doesn't need to see changes.
- */
-#define         MEMORY_OBJECT_COPY_SYMMETRIC    4
-/* ... Memory manager doesn't
- *     change data externally,
- *     doesn't need to see changes,
- *     and object will not be
- *     multiply mapped.
- *
- *     XXX
- *     Not yet safe for non-kernel use.
- */
-
-#define         MEMORY_OBJECT_COPY_INVALID      5
-/* ...	An invalid copy strategy,
- *	for external objects which
- *	have not been initialized.
- *	Allows copy_strategy to be
- *	examined without also
- *	examining pager_ready and
- *	internal.
- */
-
-typedef int             memory_object_return_t;
-/* Which pages to return to manager
- *  this time (lock_request) */
-#define         MEMORY_OBJECT_RETURN_NONE       0
-/* ... don't return any. */
-#define         MEMORY_OBJECT_RETURN_DIRTY      1
-/* ... only dirty pages. */
-#define         MEMORY_OBJECT_RETURN_ALL        2
-/* ... dirty and precious pages. */
-#define         MEMORY_OBJECT_RETURN_ANYTHING   3
-/* ... any resident page. */
-
-/*
- *	Data lock request flags
- */
-
-#define         MEMORY_OBJECT_DATA_FLUSH        0x1
-#define         MEMORY_OBJECT_DATA_NO_CHANGE    0x2
-#define         MEMORY_OBJECT_DATA_PURGE        0x4
-#define         MEMORY_OBJECT_COPY_SYNC         0x8
-#define         MEMORY_OBJECT_DATA_SYNC         0x10
-#define         MEMORY_OBJECT_IO_SYNC           0x20
-#define         MEMORY_OBJECT_DATA_FLUSH_ALL    0x40
-
-/*
- *	Types for the memory object flavor interfaces
- */
-
-#define MEMORY_OBJECT_INFO_MAX      (1024)
-typedef int     *memory_object_info_t;
-typedef int      memory_object_flavor_t;
-typedef int      memory_object_info_data_t[MEMORY_OBJECT_INFO_MAX];
-
-
-#define MEMORY_OBJECT_PERFORMANCE_INFO  11
-#define MEMORY_OBJECT_ATTRIBUTE_INFO    14
-#define MEMORY_OBJECT_BEHAVIOR_INFO     15
-
-
-struct memory_object_perf_info {
-	memory_object_cluster_size_t    cluster_size;
-	boolean_t                       may_cache;
-};
-
-struct memory_object_attr_info {
-	memory_object_copy_strategy_t   copy_strategy;
-	memory_object_cluster_size_t    cluster_size;
-	boolean_t                       may_cache_object;
-	boolean_t                       temporary;
-};
-
-struct memory_object_behave_info {
-	memory_object_copy_strategy_t   copy_strategy;
-	boolean_t                       temporary;
-	boolean_t                       invalidate;
-	boolean_t                       silent_overwrite;
-	boolean_t                       advisory_pageout;
-};
-
-
-typedef struct memory_object_behave_info *memory_object_behave_info_t;
-typedef struct memory_object_behave_info memory_object_behave_info_data_t;
-
-typedef struct memory_object_perf_info  *memory_object_perf_info_t;
-typedef struct memory_object_perf_info  memory_object_perf_info_data_t;
-
-typedef struct memory_object_attr_info  *memory_object_attr_info_t;
-typedef struct memory_object_attr_info  memory_object_attr_info_data_t;
-
-#define MEMORY_OBJECT_BEHAVE_INFO_COUNT ((mach_msg_type_number_t)       \
-	        (sizeof(memory_object_behave_info_data_t)/sizeof(int)))
-#define MEMORY_OBJECT_PERF_INFO_COUNT   ((mach_msg_type_number_t)       \
-	        (sizeof(memory_object_perf_info_data_t)/sizeof(int)))
-#define MEMORY_OBJECT_ATTR_INFO_COUNT   ((mach_msg_type_number_t)       \
-	        (sizeof(memory_object_attr_info_data_t)/sizeof(int)))
-
-#define invalid_memory_object_flavor(f)                                 \
-	(f != MEMORY_OBJECT_ATTRIBUTE_INFO &&                           \
-	 f != MEMORY_OBJECT_PERFORMANCE_INFO &&                         \
-	 f != OLD_MEMORY_OBJECT_BEHAVIOR_INFO &&                        \
-	 f != MEMORY_OBJECT_BEHAVIOR_INFO &&                            \
-	 f != OLD_MEMORY_OBJECT_ATTRIBUTE_INFO)
-
-
-/*
- * Used to support options on memory_object_release_name call
- */
-#define MEMORY_OBJECT_TERMINATE_IDLE    0x1
-#define MEMORY_OBJECT_RESPECT_CACHE     0x2
-#define MEMORY_OBJECT_RELEASE_NO_OP     0x4
-
-
-/* named entry processor mapping options */
-/* enumerated */
-#define MAP_MEM_NOOP                      0
-#define MAP_MEM_COPYBACK                  1
-#define MAP_MEM_IO                        2
-#define MAP_MEM_WTHRU                     3
-#define MAP_MEM_WCOMB                     4       /* Write combining mode */
-                                                  /* aka store gather     */
-#define MAP_MEM_INNERWBACK                5
-#define MAP_MEM_POSTED                    6
-#define MAP_MEM_RT                        7
-#define MAP_MEM_POSTED_REORDERED          8
-#define MAP_MEM_POSTED_COMBINED_REORDERED 9
-
-#define GET_MAP_MEM(flags)      \
-	((((unsigned int)(flags)) >> 24) & 0xFF)
-
-#define SET_MAP_MEM(caching, flags)     \
-	((flags) = ((((unsigned int)(caching)) << 24) \
-	                & 0xFF000000) | ((flags) & 0xFFFFFF));
-
-/* leave room for vm_prot bits (0xFF ?) */
-#define MAP_MEM_LEDGER_TAGGED        0x002000 /* object owned by a specific task and ledger */
-#define MAP_MEM_PURGABLE_KERNEL_ONLY 0x004000 /* volatility controlled by kernel */
-#define MAP_MEM_GRAB_SECLUDED   0x008000 /* can grab secluded pages */
-#define MAP_MEM_ONLY            0x010000 /* change processor caching  */
-#define MAP_MEM_NAMED_CREATE    0x020000 /* create extant object      */
-#define MAP_MEM_PURGABLE        0x040000 /* create a purgable VM object */
-#define MAP_MEM_NAMED_REUSE     0x080000 /* reuse provided entry if identical */
-#define MAP_MEM_USE_DATA_ADDR   0x100000 /* preserve address of data, rather than base of page */
-#define MAP_MEM_VM_COPY         0x200000 /* make a copy of a VM range */
-#define MAP_MEM_VM_SHARE        0x400000 /* extract a VM range for remap */
-#define MAP_MEM_4K_DATA_ADDR    0x800000 /* preserve 4K aligned address of data */
-
-#define MAP_MEM_FLAGS_MASK 0x00FFFF00
-#define MAP_MEM_FLAGS_USER (                               \
-	MAP_MEM_PURGABLE_KERNEL_ONLY |                     \
-	MAP_MEM_GRAB_SECLUDED |                            \
-	MAP_MEM_ONLY |                                     \
-	MAP_MEM_NAMED_CREATE |                             \
-	MAP_MEM_PURGABLE |                                 \
-	MAP_MEM_NAMED_REUSE |                              \
-	MAP_MEM_USE_DATA_ADDR |                            \
-	MAP_MEM_VM_COPY |                                  \
-	MAP_MEM_VM_SHARE |                                 \
-	MAP_MEM_LEDGER_TAGGED |                            \
-	MAP_MEM_4K_DATA_ADDR)
-#define MAP_MEM_FLAGS_ALL (                     \
-	MAP_MEM_FLAGS_USER)
-
-
-#endif  /* _MACH_MEMORY_OBJECT_TYPES_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/mach/message.h b/lib/libc/include/x86_64-macos-gnu/mach/message.h
deleted file mode 100644
index 3f9f9a0605..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/mach/message.h
+++ /dev/null
@@ -1,902 +0,0 @@
-/*
- * Copyright (c) 2000-2005 Apple Computer, Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-/*
- * @OSF_COPYRIGHT@
- */
-/*
- * Mach Operating System
- * Copyright (c) 1991,1990,1989,1988,1987 Carnegie Mellon University
- * All Rights Reserved.
- *
- * Permission to use, copy, modify and distribute this software and its
- * documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
- * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie Mellon
- * the rights to redistribute these changes.
- */
-/*
- * NOTICE: This file was modified by McAfee Research in 2004 to introduce
- * support for mandatory and extensible security protections.  This notice
- * is included in support of clause 2.2 (b) of the Apple Public License,
- * Version 2.0.
- * Copyright (c) 2005 SPARTA, Inc.
- */
-/*
- */
-/*
- *	File:	mach/message.h
- *
- *	Mach IPC message and primitive function definitions.
- */
-
-#ifndef _MACH_MESSAGE_H_
-#define _MACH_MESSAGE_H_
-
-#include <stdint.h>
-#include <mach/port.h>
-#include <mach/boolean.h>
-#include <mach/kern_return.h>
-#include <mach/machine/vm_types.h>
-
-#include <sys/cdefs.h>
-#include <sys/appleapiopts.h>
-#include <Availability.h>
-
-/*
- *  The timeout mechanism uses mach_msg_timeout_t values,
- *  passed by value.  The timeout units are milliseconds.
- *  It is controlled with the MACH_SEND_TIMEOUT
- *  and MACH_RCV_TIMEOUT options.
- */
-
-typedef natural_t mach_msg_timeout_t;
-
-/*
- *  The value to be used when there is no timeout.
- *  (No MACH_SEND_TIMEOUT/MACH_RCV_TIMEOUT option.)
- */
-
-#define MACH_MSG_TIMEOUT_NONE           ((mach_msg_timeout_t) 0)
-
-/*
- *  The kernel uses MACH_MSGH_BITS_COMPLEX as a hint.  If it isn't on, it
- *  assumes the body of the message doesn't contain port rights or OOL
- *  data.  The field is set in received messages.  A user task must
- *  use caution in interpreting the body of a message if the bit isn't
- *  on, because the mach_msg_type's in the body might "lie" about the
- *  contents.  If the bit isn't on, but the mach_msg_types
- *  in the body specify rights or OOL data, the behavior is undefined.
- *  (Ie, an error may or may not be produced.)
- *
- *  The value of MACH_MSGH_BITS_REMOTE determines the interpretation
- *  of the msgh_remote_port field.  It is handled like a msgt_name,
- *  but must result in a send or send-once type right.
- *
- *  The value of MACH_MSGH_BITS_LOCAL determines the interpretation
- *  of the msgh_local_port field.  It is handled like a msgt_name,
- *  and also must result in a send or send-once type right.
- *
- *  The value of MACH_MSGH_BITS_VOUCHER determines the interpretation
- *  of the msgh_voucher_port field.  It is handled like a msgt_name,
- *  but must result in a send right (and the msgh_voucher_port field
- *  must be the name of a send right to a Mach voucher kernel object.
- *
- *  MACH_MSGH_BITS() combines two MACH_MSG_TYPE_* values, for the remote
- *  and local fields, into a single value suitable for msgh_bits.
- *
- *  MACH_MSGH_BITS_CIRCULAR should be zero; is is used internally.
- *
- *  The unused bits should be zero and are reserved for the kernel
- *  or for future interface expansion.
- */
-
-#define MACH_MSGH_BITS_ZERO             0x00000000
-
-#define MACH_MSGH_BITS_REMOTE_MASK      0x0000001f
-#define MACH_MSGH_BITS_LOCAL_MASK       0x00001f00
-#define MACH_MSGH_BITS_VOUCHER_MASK     0x001f0000
-
-#define MACH_MSGH_BITS_PORTS_MASK               \
-	        (MACH_MSGH_BITS_REMOTE_MASK |   \
-	         MACH_MSGH_BITS_LOCAL_MASK |    \
-	         MACH_MSGH_BITS_VOUCHER_MASK)
-
-#define MACH_MSGH_BITS_COMPLEX          0x80000000U     /* message is complex */
-
-#define MACH_MSGH_BITS_USER             0x801f1f1fU     /* allowed bits user->kernel */
-
-#define MACH_MSGH_BITS_RAISEIMP         0x20000000U     /* importance raised due to msg */
-#define MACH_MSGH_BITS_DENAP            MACH_MSGH_BITS_RAISEIMP
-
-#define MACH_MSGH_BITS_IMPHOLDASRT      0x10000000U     /* assertion help, userland private */
-#define MACH_MSGH_BITS_DENAPHOLDASRT    MACH_MSGH_BITS_IMPHOLDASRT
-
-#define MACH_MSGH_BITS_CIRCULAR         0x10000000U     /* message circular, kernel private */
-
-#define MACH_MSGH_BITS_USED             0xb01f1f1fU
-
-/* setter macros for the bits */
-#define MACH_MSGH_BITS(remote, local)  /* legacy */             \
-	        ((remote) | ((local) << 8))
-#define MACH_MSGH_BITS_SET_PORTS(remote, local, voucher)        \
-	(((remote) & MACH_MSGH_BITS_REMOTE_MASK) |              \
-	 (((local) << 8) & MACH_MSGH_BITS_LOCAL_MASK) |         \
-	 (((voucher) << 16) & MACH_MSGH_BITS_VOUCHER_MASK))
-#define MACH_MSGH_BITS_SET(remote, local, voucher, other)       \
-	(MACH_MSGH_BITS_SET_PORTS((remote), (local), (voucher)) \
-	 | ((other) &~ MACH_MSGH_BITS_PORTS_MASK))
-
-/* getter macros for pulling values out of the bits field */
-#define MACH_MSGH_BITS_REMOTE(bits)                             \
-	        ((bits) & MACH_MSGH_BITS_REMOTE_MASK)
-#define MACH_MSGH_BITS_LOCAL(bits)                              \
-	        (((bits) & MACH_MSGH_BITS_LOCAL_MASK) >> 8)
-#define MACH_MSGH_BITS_VOUCHER(bits)                            \
-	        (((bits) & MACH_MSGH_BITS_VOUCHER_MASK) >> 16)
-#define MACH_MSGH_BITS_PORTS(bits)                              \
-	((bits) & MACH_MSGH_BITS_PORTS_MASK)
-#define MACH_MSGH_BITS_OTHER(bits)                              \
-	        ((bits) &~ MACH_MSGH_BITS_PORTS_MASK)
-
-/* checking macros */
-#define MACH_MSGH_BITS_HAS_REMOTE(bits)                         \
-	(MACH_MSGH_BITS_REMOTE(bits) != MACH_MSGH_BITS_ZERO)
-#define MACH_MSGH_BITS_HAS_LOCAL(bits)                          \
-	(MACH_MSGH_BITS_LOCAL(bits) != MACH_MSGH_BITS_ZERO)
-#define MACH_MSGH_BITS_HAS_VOUCHER(bits)                        \
-	(MACH_MSGH_BITS_VOUCHER(bits) != MACH_MSGH_BITS_ZERO)
-#define MACH_MSGH_BITS_IS_COMPLEX(bits)                         \
-	(((bits) & MACH_MSGH_BITS_COMPLEX) != MACH_MSGH_BITS_ZERO)
-
-/* importance checking macros */
-#define MACH_MSGH_BITS_RAISED_IMPORTANCE(bits)                  \
-	(((bits) & MACH_MSGH_BITS_RAISEIMP) != MACH_MSGH_BITS_ZERO)
-#define MACH_MSGH_BITS_HOLDS_IMPORTANCE_ASSERTION(bits)         \
-	(((bits) & MACH_MSGH_BITS_IMPHOLDASRT) != MACH_MSGH_BITS_ZERO)
-
-/*
- *  Every message starts with a message header.
- *  Following the message header, if the message is complex, are a count
- *  of type descriptors and the type descriptors themselves
- *  (mach_msg_descriptor_t). The size of the message must be specified in
- *  bytes, and includes the message header, descriptor count, descriptors,
- *  and inline data.
- *
- *  The msgh_remote_port field specifies the destination of the message.
- *  It must specify a valid send or send-once right for a port.
- *
- *  The msgh_local_port field specifies a "reply port".  Normally,
- *  This field carries a send-once right that the receiver will use
- *  to reply to the message.  It may carry the values MACH_PORT_NULL,
- *  MACH_PORT_DEAD, a send-once right, or a send right.
- *
- *  The msgh_voucher_port field specifies a Mach voucher port. Only
- *  send rights to kernel-implemented Mach Voucher kernel objects in
- *  addition to MACH_PORT_NULL or MACH_PORT_DEAD may be passed.
- *
- *  The msgh_id field is uninterpreted by the message primitives.
- *  It normally carries information specifying the format
- *  or meaning of the message.
- */
-
-typedef unsigned int mach_msg_bits_t;
-typedef natural_t mach_msg_size_t;
-typedef integer_t mach_msg_id_t;
-
-#define MACH_MSG_SIZE_NULL (mach_msg_size_t *) 0
-
-typedef unsigned int mach_msg_priority_t;
-
-#define MACH_MSG_PRIORITY_UNSPECIFIED (mach_msg_priority_t) 0
-
-typedef unsigned int mach_msg_type_name_t;
-
-#define MACH_MSG_TYPE_MOVE_RECEIVE      16      /* Must hold receive right */
-#define MACH_MSG_TYPE_MOVE_SEND         17      /* Must hold send right(s) */
-#define MACH_MSG_TYPE_MOVE_SEND_ONCE    18      /* Must hold sendonce right */
-#define MACH_MSG_TYPE_COPY_SEND         19      /* Must hold send right(s) */
-#define MACH_MSG_TYPE_MAKE_SEND         20      /* Must hold receive right */
-#define MACH_MSG_TYPE_MAKE_SEND_ONCE    21      /* Must hold receive right */
-#define MACH_MSG_TYPE_COPY_RECEIVE      22      /* NOT VALID */
-#define MACH_MSG_TYPE_DISPOSE_RECEIVE   24      /* must hold receive right */
-#define MACH_MSG_TYPE_DISPOSE_SEND      25      /* must hold send right(s) */
-#define MACH_MSG_TYPE_DISPOSE_SEND_ONCE 26      /* must hold sendonce right */
-
-typedef unsigned int mach_msg_copy_options_t;
-
-#define MACH_MSG_PHYSICAL_COPY          0
-#define MACH_MSG_VIRTUAL_COPY           1
-#define MACH_MSG_ALLOCATE               2
-#define MACH_MSG_OVERWRITE              3       /* deprecated */
-#ifdef  MACH_KERNEL
-#define MACH_MSG_KALLOC_COPY_T          4
-#endif  /* MACH_KERNEL */
-
-#define MACH_MSG_GUARD_FLAGS_NONE                   0x0000
-#define MACH_MSG_GUARD_FLAGS_IMMOVABLE_RECEIVE      0x0001    /* Move the receive right and mark it as immovable */
-#define MACH_MSG_GUARD_FLAGS_UNGUARDED_ON_SEND      0x0002    /* Verify that the port is unguarded */
-#define MACH_MSG_GUARD_FLAGS_MASK                   0x0003    /* Valid flag bits */
-typedef unsigned int mach_msg_guard_flags_t;
-
-/*
- * In a complex mach message, the mach_msg_header_t is followed by
- * a descriptor count, then an array of that number of descriptors
- * (mach_msg_*_descriptor_t). The type field of mach_msg_type_descriptor_t
- * (which any descriptor can be cast to) indicates the flavor of the
- * descriptor.
- *
- * Note that in LP64, the various types of descriptors are no longer all
- * the same size as mach_msg_descriptor_t, so the array cannot be indexed
- * as expected.
- */
-
-typedef unsigned int mach_msg_descriptor_type_t;
-
-#define MACH_MSG_PORT_DESCRIPTOR                0
-#define MACH_MSG_OOL_DESCRIPTOR                 1
-#define MACH_MSG_OOL_PORTS_DESCRIPTOR           2
-#define MACH_MSG_OOL_VOLATILE_DESCRIPTOR        3
-#define MACH_MSG_GUARDED_PORT_DESCRIPTOR        4
-
-#pragma pack(push, 4)
-
-typedef struct{
-	natural_t                     pad1;
-	mach_msg_size_t               pad2;
-	unsigned int                  pad3 : 24;
-	mach_msg_descriptor_type_t    type : 8;
-} mach_msg_type_descriptor_t;
-
-typedef struct{
-	mach_port_t                   name;
-// Pad to 8 bytes everywhere except the K64 kernel where mach_port_t is 8 bytes
-	mach_msg_size_t               pad1;
-	unsigned int                  pad2 : 16;
-	mach_msg_type_name_t          disposition : 8;
-	mach_msg_descriptor_type_t    type : 8;
-} mach_msg_port_descriptor_t;
-
-typedef struct{
-	uint32_t                      address;
-	mach_msg_size_t               size;
-	boolean_t                     deallocate: 8;
-	mach_msg_copy_options_t       copy: 8;
-	unsigned int                  pad1: 8;
-	mach_msg_descriptor_type_t    type: 8;
-} mach_msg_ool_descriptor32_t;
-
-typedef struct{
-	uint64_t                      address;
-	boolean_t                     deallocate: 8;
-	mach_msg_copy_options_t       copy: 8;
-	unsigned int                  pad1: 8;
-	mach_msg_descriptor_type_t    type: 8;
-	mach_msg_size_t               size;
-} mach_msg_ool_descriptor64_t;
-
-typedef struct{
-	void*                         address;
-#if !defined(__LP64__)
-	mach_msg_size_t               size;
-#endif
-	boolean_t                     deallocate: 8;
-	mach_msg_copy_options_t       copy: 8;
-	unsigned int                  pad1: 8;
-	mach_msg_descriptor_type_t    type: 8;
-#if defined(__LP64__)
-	mach_msg_size_t               size;
-#endif
-} mach_msg_ool_descriptor_t;
-
-typedef struct{
-	uint32_t                      address;
-	mach_msg_size_t               count;
-	boolean_t                     deallocate: 8;
-	mach_msg_copy_options_t       copy: 8;
-	mach_msg_type_name_t          disposition : 8;
-	mach_msg_descriptor_type_t    type : 8;
-} mach_msg_ool_ports_descriptor32_t;
-
-typedef struct{
-	uint64_t                      address;
-	boolean_t                     deallocate: 8;
-	mach_msg_copy_options_t       copy: 8;
-	mach_msg_type_name_t          disposition : 8;
-	mach_msg_descriptor_type_t    type : 8;
-	mach_msg_size_t               count;
-} mach_msg_ool_ports_descriptor64_t;
-
-typedef struct{
-	void*                         address;
-#if !defined(__LP64__)
-	mach_msg_size_t               count;
-#endif
-	boolean_t                     deallocate: 8;
-	mach_msg_copy_options_t       copy: 8;
-	mach_msg_type_name_t          disposition : 8;
-	mach_msg_descriptor_type_t    type : 8;
-#if defined(__LP64__)
-	mach_msg_size_t               count;
-#endif
-} mach_msg_ool_ports_descriptor_t;
-
-typedef struct{
-	uint32_t                      context;
-	mach_port_name_t              name;
-	mach_msg_guard_flags_t        flags : 16;
-	mach_msg_type_name_t          disposition : 8;
-	mach_msg_descriptor_type_t    type : 8;
-} mach_msg_guarded_port_descriptor32_t;
-
-typedef struct{
-	uint64_t                      context;
-	mach_msg_guard_flags_t        flags : 16;
-	mach_msg_type_name_t          disposition : 8;
-	mach_msg_descriptor_type_t    type : 8;
-	mach_port_name_t              name;
-} mach_msg_guarded_port_descriptor64_t;
-
-typedef struct{
-	mach_port_context_t           context;
-#if !defined(__LP64__)
-	mach_port_name_t              name;
-#endif
-	mach_msg_guard_flags_t        flags : 16;
-	mach_msg_type_name_t          disposition : 8;
-	mach_msg_descriptor_type_t    type : 8;
-#if defined(__LP64__)
-	mach_port_name_t              name;
-#endif /* defined(__LP64__) */
-} mach_msg_guarded_port_descriptor_t;
-
-/*
- * LP64support - This union definition is not really
- * appropriate in LP64 mode because not all descriptors
- * are of the same size in that environment.
- */
-typedef union{
-	mach_msg_port_descriptor_t            port;
-	mach_msg_ool_descriptor_t             out_of_line;
-	mach_msg_ool_ports_descriptor_t       ool_ports;
-	mach_msg_type_descriptor_t            type;
-	mach_msg_guarded_port_descriptor_t    guarded_port;
-} mach_msg_descriptor_t;
-
-typedef struct{
-	mach_msg_size_t msgh_descriptor_count;
-} mach_msg_body_t;
-
-#define MACH_MSG_BODY_NULL (mach_msg_body_t *) 0
-#define MACH_MSG_DESCRIPTOR_NULL (mach_msg_descriptor_t *) 0
-
-typedef struct{
-	mach_msg_bits_t       msgh_bits;
-	mach_msg_size_t       msgh_size;
-	mach_port_t           msgh_remote_port;
-	mach_port_t           msgh_local_port;
-	mach_port_name_t      msgh_voucher_port;
-	mach_msg_id_t         msgh_id;
-} mach_msg_header_t;
-
-#define msgh_reserved           msgh_voucher_port
-#define MACH_MSG_NULL   (mach_msg_header_t *) 0
-
-typedef struct{
-	mach_msg_header_t       header;
-	mach_msg_body_t         body;
-} mach_msg_base_t;
-
-typedef unsigned int mach_msg_trailer_type_t;
-
-#define MACH_MSG_TRAILER_FORMAT_0       0
-
-typedef unsigned int mach_msg_trailer_size_t;
-typedef char *mach_msg_trailer_info_t;
-
-typedef struct{
-	mach_msg_trailer_type_t       msgh_trailer_type;
-	mach_msg_trailer_size_t       msgh_trailer_size;
-} mach_msg_trailer_t;
-
-/*
- *  The msgh_seqno field carries a sequence number
- *  associated with the received-from port.  A port's
- *  sequence number is incremented every time a message
- *  is received from it and included in the received
- *  trailer to help put messages back in sequence if
- *  multiple threads receive and/or process received
- *  messages.
- */
-typedef struct{
-	mach_msg_trailer_type_t       msgh_trailer_type;
-	mach_msg_trailer_size_t       msgh_trailer_size;
-	mach_port_seqno_t             msgh_seqno;
-} mach_msg_seqno_trailer_t;
-
-typedef struct{
-	unsigned int                  val[2];
-} security_token_t;
-
-typedef struct{
-	mach_msg_trailer_type_t       msgh_trailer_type;
-	mach_msg_trailer_size_t       msgh_trailer_size;
-	mach_port_seqno_t             msgh_seqno;
-	security_token_t              msgh_sender;
-} mach_msg_security_trailer_t;
-
-/*
- * The audit token is an opaque token which identifies
- * Mach tasks and senders of Mach messages as subjects
- * to the BSM audit system.  Only the appropriate BSM
- * library routines should be used to interpret the
- * contents of the audit token as the representation
- * of the subject identity within the token may change
- * over time.
- */
-typedef struct{
-	unsigned int                  val[8];
-} audit_token_t;
-
-typedef struct{
-	mach_msg_trailer_type_t       msgh_trailer_type;
-	mach_msg_trailer_size_t       msgh_trailer_size;
-	mach_port_seqno_t             msgh_seqno;
-	security_token_t              msgh_sender;
-	audit_token_t                 msgh_audit;
-} mach_msg_audit_trailer_t;
-
-typedef struct{
-	mach_msg_trailer_type_t       msgh_trailer_type;
-	mach_msg_trailer_size_t       msgh_trailer_size;
-	mach_port_seqno_t             msgh_seqno;
-	security_token_t              msgh_sender;
-	audit_token_t                 msgh_audit;
-	mach_port_context_t           msgh_context;
-} mach_msg_context_trailer_t;
-
-
-
-typedef struct{
-	mach_port_name_t sender;
-} msg_labels_t;
-
-/*
- *  Trailer type to pass MAC policy label info as a mach message trailer.
- *
- */
-
-typedef struct{
-	mach_msg_trailer_type_t       msgh_trailer_type;
-	mach_msg_trailer_size_t       msgh_trailer_size;
-	mach_port_seqno_t             msgh_seqno;
-	security_token_t              msgh_sender;
-	audit_token_t                 msgh_audit;
-	mach_port_context_t           msgh_context;
-	int                           msgh_ad;
-	msg_labels_t                  msgh_labels;
-} mach_msg_mac_trailer_t;
-
-
-#define MACH_MSG_TRAILER_MINIMUM_SIZE  sizeof(mach_msg_trailer_t)
-
-/*
- * These values can change from release to release - but clearly
- * code cannot request additional trailer elements one was not
- * compiled to understand.  Therefore, it is safe to use this
- * constant when the same module specified the receive options.
- * Otherwise, you run the risk that the options requested by
- * another module may exceed the local modules notion of
- * MAX_TRAILER_SIZE.
- */
-
-typedef mach_msg_mac_trailer_t mach_msg_max_trailer_t;
-#define MAX_TRAILER_SIZE ((mach_msg_size_t)sizeof(mach_msg_max_trailer_t))
-
-/*
- * Legacy requirements keep us from ever updating these defines (even
- * when the format_0 trailers gain new option data fields in the future).
- * Therefore, they shouldn't be used going forward.  Instead, the sizes
- * should be compared against the specific element size requested using
- * REQUESTED_TRAILER_SIZE.
- */
-typedef mach_msg_security_trailer_t mach_msg_format_0_trailer_t;
-
-/*typedef mach_msg_mac_trailer_t mach_msg_format_0_trailer_t;
- */
-
-#define MACH_MSG_TRAILER_FORMAT_0_SIZE sizeof(mach_msg_format_0_trailer_t)
-
-#define   KERNEL_SECURITY_TOKEN_VALUE  { {0, 1} }
-extern const security_token_t KERNEL_SECURITY_TOKEN;
-
-#define   KERNEL_AUDIT_TOKEN_VALUE  { {0, 0, 0, 0, 0, 0, 0, 0} }
-extern const audit_token_t KERNEL_AUDIT_TOKEN;
-
-typedef integer_t mach_msg_options_t;
-
-typedef struct{
-	mach_msg_header_t     header;
-} mach_msg_empty_send_t;
-
-typedef struct{
-	mach_msg_header_t     header;
-	mach_msg_trailer_t    trailer;
-} mach_msg_empty_rcv_t;
-
-typedef union{
-	mach_msg_empty_send_t send;
-	mach_msg_empty_rcv_t  rcv;
-} mach_msg_empty_t;
-
-#pragma pack(pop)
-
-/* utility to round the message size - will become machine dependent */
-#define round_msg(x)    (((mach_msg_size_t)(x) + sizeof (natural_t) - 1) & \
-	                        ~(sizeof (natural_t) - 1))
-
-
-/*
- *  There is no fixed upper bound to the size of Mach messages.
- */
-#define MACH_MSG_SIZE_MAX       ((mach_msg_size_t) ~0)
-
-#if defined(__APPLE_API_PRIVATE)
-/*
- *  But architectural limits of a given implementation, or
- *  temporal conditions may cause unpredictable send failures
- *  for messages larger than MACH_MSG_SIZE_RELIABLE.
- *
- *  In either case, waiting for memory is [currently] outside
- *  the scope of send timeout values provided to IPC.
- */
-#define MACH_MSG_SIZE_RELIABLE  ((mach_msg_size_t) 256 * 1024)
-#endif
-/*
- *  Compatibility definitions, for code written
- *  when there was a msgh_kind instead of msgh_seqno.
- */
-#define MACH_MSGH_KIND_NORMAL           0x00000000
-#define MACH_MSGH_KIND_NOTIFICATION     0x00000001
-#define msgh_kind                       msgh_seqno
-#define mach_msg_kind_t                 mach_port_seqno_t
-
-typedef natural_t mach_msg_type_size_t;
-typedef natural_t mach_msg_type_number_t;
-
-/*
- *  Values received/carried in messages.  Tells the receiver what
- *  sort of port right he now has.
- *
- *  MACH_MSG_TYPE_PORT_NAME is used to transfer a port name
- *  which should remain uninterpreted by the kernel.  (Port rights
- *  are not transferred, just the port name.)
- */
-
-#define MACH_MSG_TYPE_PORT_NONE         0
-
-#define MACH_MSG_TYPE_PORT_NAME         15
-#define MACH_MSG_TYPE_PORT_RECEIVE      MACH_MSG_TYPE_MOVE_RECEIVE
-#define MACH_MSG_TYPE_PORT_SEND         MACH_MSG_TYPE_MOVE_SEND
-#define MACH_MSG_TYPE_PORT_SEND_ONCE    MACH_MSG_TYPE_MOVE_SEND_ONCE
-
-#define MACH_MSG_TYPE_LAST              22              /* Last assigned */
-
-/*
- *  A dummy value.  Mostly used to indicate that the actual value
- *  will be filled in later, dynamically.
- */
-
-#define MACH_MSG_TYPE_POLYMORPHIC       ((mach_msg_type_name_t) -1)
-
-/*
- *	Is a given item a port type?
- */
-
-#define MACH_MSG_TYPE_PORT_ANY(x)                       \
-	(((x) >= MACH_MSG_TYPE_MOVE_RECEIVE) &&         \
-	 ((x) <= MACH_MSG_TYPE_MAKE_SEND_ONCE))
-
-#define MACH_MSG_TYPE_PORT_ANY_SEND(x)                  \
-	(((x) >= MACH_MSG_TYPE_MOVE_SEND) &&            \
-	 ((x) <= MACH_MSG_TYPE_MAKE_SEND_ONCE))
-
-#define MACH_MSG_TYPE_PORT_ANY_RIGHT(x)                 \
-	(((x) >= MACH_MSG_TYPE_MOVE_RECEIVE) &&         \
-	 ((x) <= MACH_MSG_TYPE_MOVE_SEND_ONCE))
-
-typedef integer_t mach_msg_option_t;
-
-#define MACH_MSG_OPTION_NONE    0x00000000
-
-#define MACH_SEND_MSG           0x00000001
-#define MACH_RCV_MSG            0x00000002
-
-#define MACH_RCV_LARGE          0x00000004      /* report large message sizes */
-#define MACH_RCV_LARGE_IDENTITY 0x00000008      /* identify source of large messages */
-
-#define MACH_SEND_TIMEOUT       0x00000010      /* timeout value applies to send */
-#define MACH_SEND_OVERRIDE      0x00000020      /* priority override for send */
-#define MACH_SEND_INTERRUPT     0x00000040      /* don't restart interrupted sends */
-#define MACH_SEND_NOTIFY        0x00000080      /* arm send-possible notify */
-#define MACH_SEND_ALWAYS        0x00010000      /* ignore qlimits - kernel only */
-#define MACH_SEND_TRAILER       0x00020000      /* sender-provided trailer */
-#define MACH_SEND_NOIMPORTANCE  0x00040000      /* msg won't carry importance */
-#define MACH_SEND_NODENAP       MACH_SEND_NOIMPORTANCE
-#define MACH_SEND_IMPORTANCE    0x00080000      /* msg carries importance - kernel only */
-#define MACH_SEND_SYNC_OVERRIDE 0x00100000      /* msg should do sync ipc override */
-#define MACH_SEND_PROPAGATE_QOS 0x00200000      /* IPC should propagate the caller's QoS */
-#define MACH_SEND_SYNC_USE_THRPRI       MACH_SEND_PROPAGATE_QOS /* obsolete name */
-#define MACH_SEND_KERNEL        0x00400000      /* full send from kernel space - kernel only */
-#define MACH_SEND_SYNC_BOOTSTRAP_CHECKIN  0x00800000      /* special reply port should boost thread doing sync bootstrap checkin */
-
-#define MACH_RCV_TIMEOUT        0x00000100      /* timeout value applies to receive */
-#define MACH_RCV_NOTIFY         0x00000000      /* legacy name (value was: 0x00000200) */
-#define MACH_RCV_INTERRUPT      0x00000400      /* don't restart interrupted receive */
-#define MACH_RCV_VOUCHER        0x00000800      /* willing to receive voucher port */
-#define MACH_RCV_OVERWRITE      0x00000000      /* scatter receive (deprecated) */
-#define MACH_RCV_GUARDED_DESC   0x00001000      /* Can receive new guarded descriptor */
-#define MACH_RCV_SYNC_WAIT      0x00004000      /* sync waiter waiting for rcv */
-#define MACH_RCV_SYNC_PEEK      0x00008000      /* sync waiter waiting to peek */
-
-#define MACH_MSG_STRICT_REPLY   0x00000200      /* Enforce specific properties about the reply port, and
-	                                         * the context in which a thread replies to a message.
-	                                         * This flag must be passed on both the SEND and RCV */
-
-
-/*
- * NOTE: a 0x00------ RCV mask implies to ask for
- * a MACH_MSG_TRAILER_FORMAT_0 with 0 Elements,
- * which is equivalent to a mach_msg_trailer_t.
- *
- * XXXMAC: unlike the rest of the MACH_RCV_* flags, MACH_RCV_TRAILER_LABELS
- * needs its own private bit since we only calculate its fields when absolutely
- * required.
- */
-#define MACH_RCV_TRAILER_NULL   0
-#define MACH_RCV_TRAILER_SEQNO  1
-#define MACH_RCV_TRAILER_SENDER 2
-#define MACH_RCV_TRAILER_AUDIT  3
-#define MACH_RCV_TRAILER_CTX    4
-#define MACH_RCV_TRAILER_AV     7
-#define MACH_RCV_TRAILER_LABELS 8
-
-#define MACH_RCV_TRAILER_TYPE(x)     (((x) & 0xf) << 28)
-#define MACH_RCV_TRAILER_ELEMENTS(x) (((x) & 0xf) << 24)
-#define MACH_RCV_TRAILER_MASK        ((0xf << 24))
-
-#define GET_RCV_ELEMENTS(y) (((y) >> 24) & 0xf)
-
-
-/*
- * XXXMAC: note that in the case of MACH_RCV_TRAILER_LABELS,
- * we just fall through to mach_msg_max_trailer_t.
- * This is correct behavior since mach_msg_max_trailer_t is defined as
- * mac_msg_mac_trailer_t which is used for the LABELS trailer.
- * It also makes things work properly if MACH_RCV_TRAILER_LABELS is ORed
- * with one of the other options.
- */
-
-#define REQUESTED_TRAILER_SIZE_NATIVE(y)                        \
-	((mach_msg_trailer_size_t)                              \
-	 ((GET_RCV_ELEMENTS(y) == MACH_RCV_TRAILER_NULL) ?      \
-	  sizeof(mach_msg_trailer_t) :                          \
-	  ((GET_RCV_ELEMENTS(y) == MACH_RCV_TRAILER_SEQNO) ?    \
-	   sizeof(mach_msg_seqno_trailer_t) :                   \
-	  ((GET_RCV_ELEMENTS(y) == MACH_RCV_TRAILER_SENDER) ?   \
-	   sizeof(mach_msg_security_trailer_t) :                \
-	   ((GET_RCV_ELEMENTS(y) == MACH_RCV_TRAILER_AUDIT) ?   \
-	    sizeof(mach_msg_audit_trailer_t) :                  \
-	    ((GET_RCV_ELEMENTS(y) == MACH_RCV_TRAILER_CTX) ?    \
-	     sizeof(mach_msg_context_trailer_t) :               \
-	     ((GET_RCV_ELEMENTS(y) == MACH_RCV_TRAILER_AV) ?    \
-	      sizeof(mach_msg_mac_trailer_t) :                  \
-	     sizeof(mach_msg_max_trailer_t))))))))
-
-
-#define REQUESTED_TRAILER_SIZE(y) REQUESTED_TRAILER_SIZE_NATIVE(y)
-
-/*
- *  Much code assumes that mach_msg_return_t == kern_return_t.
- *  This definition is useful for descriptive purposes.
- *
- *  See <mach/error.h> for the format of error codes.
- *  IPC errors are system 4.  Send errors are subsystem 0;
- *  receive errors are subsystem 1.  The code field is always non-zero.
- *  The high bits of the code field communicate extra information
- *  for some error codes.  MACH_MSG_MASK masks off these special bits.
- */
-
-typedef kern_return_t mach_msg_return_t;
-
-#define MACH_MSG_SUCCESS                0x00000000
-
-
-#define MACH_MSG_MASK                   0x00003e00
-/* All special error code bits defined below. */
-#define MACH_MSG_IPC_SPACE              0x00002000
-/* No room in IPC name space for another capability name. */
-#define MACH_MSG_VM_SPACE               0x00001000
-/* No room in VM address space for out-of-line memory. */
-#define MACH_MSG_IPC_KERNEL             0x00000800
-/* Kernel resource shortage handling an IPC capability. */
-#define MACH_MSG_VM_KERNEL              0x00000400
-/* Kernel resource shortage handling out-of-line memory. */
-
-#define MACH_SEND_IN_PROGRESS           0x10000001
-/* Thread is waiting to send.  (Internal use only.) */
-#define MACH_SEND_INVALID_DATA          0x10000002
-/* Bogus in-line data. */
-#define MACH_SEND_INVALID_DEST          0x10000003
-/* Bogus destination port. */
-#define MACH_SEND_TIMED_OUT             0x10000004
-/* Message not sent before timeout expired. */
-#define MACH_SEND_INVALID_VOUCHER       0x10000005
-/* Bogus voucher port. */
-#define MACH_SEND_INTERRUPTED           0x10000007
-/* Software interrupt. */
-#define MACH_SEND_MSG_TOO_SMALL         0x10000008
-/* Data doesn't contain a complete message. */
-#define MACH_SEND_INVALID_REPLY         0x10000009
-/* Bogus reply port. */
-#define MACH_SEND_INVALID_RIGHT         0x1000000a
-/* Bogus port rights in the message body. */
-#define MACH_SEND_INVALID_NOTIFY        0x1000000b
-/* Bogus notify port argument. */
-#define MACH_SEND_INVALID_MEMORY        0x1000000c
-/* Invalid out-of-line memory pointer. */
-#define MACH_SEND_NO_BUFFER             0x1000000d
-/* No message buffer is available. */
-#define MACH_SEND_TOO_LARGE             0x1000000e
-/* Send is too large for port */
-#define MACH_SEND_INVALID_TYPE          0x1000000f
-/* Invalid msg-type specification. */
-#define MACH_SEND_INVALID_HEADER        0x10000010
-/* A field in the header had a bad value. */
-#define MACH_SEND_INVALID_TRAILER       0x10000011
-/* The trailer to be sent does not match kernel format. */
-#define MACH_SEND_INVALID_CONTEXT       0x10000012
-/* The sending thread context did not match the context on the dest port */
-#define MACH_SEND_INVALID_RT_OOL_SIZE   0x10000015
-/* compatibility: no longer a returned error */
-#define MACH_SEND_NO_GRANT_DEST         0x10000016
-/* The destination port doesn't accept ports in body */
-
-#define MACH_RCV_IN_PROGRESS            0x10004001
-/* Thread is waiting for receive.  (Internal use only.) */
-#define MACH_RCV_INVALID_NAME           0x10004002
-/* Bogus name for receive port/port-set. */
-#define MACH_RCV_TIMED_OUT              0x10004003
-/* Didn't get a message within the timeout value. */
-#define MACH_RCV_TOO_LARGE              0x10004004
-/* Message buffer is not large enough for inline data. */
-#define MACH_RCV_INTERRUPTED            0x10004005
-/* Software interrupt. */
-#define MACH_RCV_PORT_CHANGED           0x10004006
-/* compatibility: no longer a returned error */
-#define MACH_RCV_INVALID_NOTIFY         0x10004007
-/* Bogus notify port argument. */
-#define MACH_RCV_INVALID_DATA           0x10004008
-/* Bogus message buffer for inline data. */
-#define MACH_RCV_PORT_DIED              0x10004009
-/* Port/set was sent away/died during receive. */
-#define MACH_RCV_IN_SET                 0x1000400a
-/* compatibility: no longer a returned error */
-#define MACH_RCV_HEADER_ERROR           0x1000400b
-/* Error receiving message header.  See special bits. */
-#define MACH_RCV_BODY_ERROR             0x1000400c
-/* Error receiving message body.  See special bits. */
-#define MACH_RCV_INVALID_TYPE           0x1000400d
-/* Invalid msg-type specification in scatter list. */
-#define MACH_RCV_SCATTER_SMALL          0x1000400e
-/* Out-of-line overwrite region is not large enough */
-#define MACH_RCV_INVALID_TRAILER        0x1000400f
-/* trailer type or number of trailer elements not supported */
-#define MACH_RCV_IN_PROGRESS_TIMED      0x10004011
-/* Waiting for receive with timeout. (Internal use only.) */
-#define MACH_RCV_INVALID_REPLY          0x10004012
-/* invalid reply port used in a STRICT_REPLY message */
-
-
-
-__BEGIN_DECLS
-
-/*
- *	Routine:	mach_msg_overwrite
- *	Purpose:
- *		Send and/or receive a message.  If the message operation
- *		is interrupted, and the user did not request an indication
- *		of that fact, then restart the appropriate parts of the
- *		operation silently (trap version does not restart).
- *
- *		Distinct send and receive buffers may be specified.  If
- *		no separate receive buffer is specified, the msg parameter
- *		will be used for both send and receive operations.
- *
- *		In addition to a distinct receive buffer, that buffer may
- *		already contain scatter control information to direct the
- *		receiving of the message.
- */
-__WATCHOS_PROHIBITED __TVOS_PROHIBITED
-extern mach_msg_return_t        mach_msg_overwrite(
-	mach_msg_header_t *msg,
-	mach_msg_option_t option,
-	mach_msg_size_t send_size,
-	mach_msg_size_t rcv_size,
-	mach_port_name_t rcv_name,
-	mach_msg_timeout_t timeout,
-	mach_port_name_t notify,
-	mach_msg_header_t *rcv_msg,
-	mach_msg_size_t rcv_limit);
-
-
-/*
- *	Routine:	mach_msg
- *	Purpose:
- *		Send and/or receive a message.  If the message operation
- *		is interrupted, and the user did not request an indication
- *		of that fact, then restart the appropriate parts of the
- *		operation silently (trap version does not restart).
- */
-__WATCHOS_PROHIBITED __TVOS_PROHIBITED
-extern mach_msg_return_t        mach_msg(
-	mach_msg_header_t *msg,
-	mach_msg_option_t option,
-	mach_msg_size_t send_size,
-	mach_msg_size_t rcv_size,
-	mach_port_name_t rcv_name,
-	mach_msg_timeout_t timeout,
-	mach_port_name_t notify);
-
-/*
- *	Routine:	mach_voucher_deallocate
- *	Purpose:
- *		Deallocate a mach voucher created or received in a message.  Drops
- *		one (send right) reference to the voucher.
- */
-__WATCHOS_PROHIBITED __TVOS_PROHIBITED
-extern kern_return_t            mach_voucher_deallocate(
-	mach_port_name_t voucher);
-
-
-__END_DECLS
-
-#endif  /* _MACH_MESSAGE_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/mach/port.h b/lib/libc/include/x86_64-macos-gnu/mach/port.h
deleted file mode 100644
index 3547576e80..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/mach/port.h
+++ /dev/null
@@ -1,422 +0,0 @@
-/*
- * Copyright (c) 2000-2006 Apple Computer, Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-/*
- * @OSF_COPYRIGHT@
- */
-/*
- * Mach Operating System
- * Copyright (c) 1991,1990,1989,1988,1987 Carnegie Mellon University
- * All Rights Reserved.
- *
- * Permission to use, copy, modify and distribute this software and its
- * documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
- * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie Mellon
- * the rights to redistribute these changes.
- */
-/*
- * NOTICE: This file was modified by McAfee Research in 2004 to introduce
- * support for mandatory and extensible security protections.  This notice
- * is included in support of clause 2.2 (b) of the Apple Public License,
- * Version 2.0.
- */
-/*
- */
-/*
- *	File:	mach/port.h
- *
- *	Definition of a Mach port
- *
- *	Mach ports are the endpoints to Mach-implemented communications
- *	channels (usually uni-directional message queues, but other types
- *	also exist).
- *
- *	Unique collections of these endpoints are maintained for each
- *	Mach task.  Each Mach port in the task's collection is given a
- *	[task-local] name to identify it - and the the various "rights"
- *	held by the task for that specific endpoint.
- *
- *	This header defines the types used to identify these Mach ports
- *	and the various rights associated with them.  For more info see:
- *
- *	<mach/mach_port.h> - manipulation of port rights in a given space
- *	<mach/message.h> - message queue [and port right passing] mechanism
- *
- */
-
-#ifndef _MACH_PORT_H_
-#define _MACH_PORT_H_
-
-#include <sys/cdefs.h>
-#include <stdint.h>
-#include <mach/boolean.h>
-#include <mach/machine/vm_types.h>
-
-/*
- *	mach_port_name_t - the local identity for a Mach port
- *
- *	The name is Mach port namespace specific.  It is used to
- *	identify the rights held for that port by the task whose
- *	namespace is implied [or specifically provided].
- *
- *	Use of this type usually implies just a name - no rights.
- *	See mach_port_t for a type that implies a "named right."
- *
- */
-
-typedef natural_t mach_port_name_t;
-typedef mach_port_name_t *mach_port_name_array_t;
-
-
-/*
- *	mach_port_t - a named port right
- *
- *	In user-space, "rights" are represented by the name of the
- *	right in the Mach port namespace.  Even so, this type is
- *	presented as a unique one to more clearly denote the presence
- *	of a right coming along with the name.
- *
- *	Often, various rights for a port held in a single name space
- *	will coalesce and are, therefore, be identified by a single name
- *	[this is the case for send and receive rights].  But not
- *	always [send-once rights currently get a unique name for
- *	each right].
- *
- */
-
-#include <sys/_types.h>
-#include <sys/_types/_mach_port_t.h>
-
-
-typedef mach_port_t                     *mach_port_array_t;
-
-/*
- *  MACH_PORT_NULL is a legal value that can be carried in messages.
- *  It indicates the absence of any port or port rights.  (A port
- *  argument keeps the message from being "simple", even if the
- *  value is MACH_PORT_NULL.)  The value MACH_PORT_DEAD is also a legal
- *  value that can be carried in messages.  It indicates
- *  that a port right was present, but it died.
- */
-
-#define MACH_PORT_NULL          0  /* intentional loose typing */
-#define MACH_PORT_DEAD          ((mach_port_name_t) ~0)
-#define MACH_PORT_VALID(name)                           \
-	        (((name) != MACH_PORT_NULL) &&          \
-	         ((name) != MACH_PORT_DEAD))
-
-
-/*
- *	For kernel-selected [assigned] port names, the name is
- *	comprised of two parts: a generation number and an index.
- *	This approach keeps the exact same name from being generated
- *	and reused too quickly [to catch right/reference counting bugs].
- *	The dividing line between the constituent parts is exposed so
- *	that efficient "mach_port_name_t to data structure pointer"
- *	conversion implementation can be made.  But it is possible
- *	for user-level code to assign their own names to Mach ports.
- *	These are not required to participate in this algorithm.  So
- *	care should be taken before "assuming" this model.
- *
- */
-
-#ifndef NO_PORT_GEN
-
-#define MACH_PORT_INDEX(name)           ((name) >> 8)
-#define MACH_PORT_GEN(name)             (((name) & 0xff) << 24)
-#define MACH_PORT_MAKE(index, gen)      \
-	        (((index) << 8) | (gen) >> 24)
-
-#else   /* NO_PORT_GEN */
-
-#define MACH_PORT_INDEX(name)           (name)
-#define MACH_PORT_GEN(name)             (0)
-#define MACH_PORT_MAKE(index, gen)      (index)
-
-#endif  /* NO_PORT_GEN */
-
-
-/*
- *  These are the different rights a task may have for a port.
- *  The MACH_PORT_RIGHT_* definitions are used as arguments
- *  to mach_port_allocate, mach_port_get_refs, etc, to specify
- *  a particular right to act upon.  The mach_port_names and
- *  mach_port_type calls return bitmasks using the MACH_PORT_TYPE_*
- *  definitions.  This is because a single name may denote
- *  multiple rights.
- */
-
-typedef natural_t mach_port_right_t;
-
-#define MACH_PORT_RIGHT_SEND            ((mach_port_right_t) 0)
-#define MACH_PORT_RIGHT_RECEIVE         ((mach_port_right_t) 1)
-#define MACH_PORT_RIGHT_SEND_ONCE       ((mach_port_right_t) 2)
-#define MACH_PORT_RIGHT_PORT_SET        ((mach_port_right_t) 3)
-#define MACH_PORT_RIGHT_DEAD_NAME       ((mach_port_right_t) 4)
-#define MACH_PORT_RIGHT_LABELH          ((mach_port_right_t) 5) /* obsolete right */
-#define MACH_PORT_RIGHT_NUMBER          ((mach_port_right_t) 6) /* right not implemented */
-
-
-typedef natural_t mach_port_type_t;
-typedef mach_port_type_t *mach_port_type_array_t;
-
-#define MACH_PORT_TYPE(right)                                           \
-	        ((mach_port_type_t)(((mach_port_type_t) 1)              \
-	        << ((right) + ((mach_port_right_t) 16))))
-#define MACH_PORT_TYPE_NONE         ((mach_port_type_t) 0L)
-#define MACH_PORT_TYPE_SEND         MACH_PORT_TYPE(MACH_PORT_RIGHT_SEND)
-#define MACH_PORT_TYPE_RECEIVE      MACH_PORT_TYPE(MACH_PORT_RIGHT_RECEIVE)
-#define MACH_PORT_TYPE_SEND_ONCE    MACH_PORT_TYPE(MACH_PORT_RIGHT_SEND_ONCE)
-#define MACH_PORT_TYPE_PORT_SET     MACH_PORT_TYPE(MACH_PORT_RIGHT_PORT_SET)
-#define MACH_PORT_TYPE_DEAD_NAME    MACH_PORT_TYPE(MACH_PORT_RIGHT_DEAD_NAME)
-#define MACH_PORT_TYPE_LABELH       MACH_PORT_TYPE(MACH_PORT_RIGHT_LABELH) /* obsolete */
-
-
-
-/* Convenient combinations. */
-
-#define MACH_PORT_TYPE_SEND_RECEIVE                                     \
-	        (MACH_PORT_TYPE_SEND|MACH_PORT_TYPE_RECEIVE)
-#define MACH_PORT_TYPE_SEND_RIGHTS                                      \
-	        (MACH_PORT_TYPE_SEND|MACH_PORT_TYPE_SEND_ONCE)
-#define MACH_PORT_TYPE_PORT_RIGHTS                                      \
-	        (MACH_PORT_TYPE_SEND_RIGHTS|MACH_PORT_TYPE_RECEIVE)
-#define MACH_PORT_TYPE_PORT_OR_DEAD                                     \
-	        (MACH_PORT_TYPE_PORT_RIGHTS|MACH_PORT_TYPE_DEAD_NAME)
-#define MACH_PORT_TYPE_ALL_RIGHTS                                       \
-	        (MACH_PORT_TYPE_PORT_OR_DEAD|MACH_PORT_TYPE_PORT_SET)
-
-/* Dummy type bits that mach_port_type/mach_port_names can return. */
-
-#define MACH_PORT_TYPE_DNREQUEST                0x80000000
-#define MACH_PORT_TYPE_SPREQUEST                0x40000000
-#define MACH_PORT_TYPE_SPREQUEST_DELAYED        0x20000000
-
-/* User-references for capabilities. */
-
-typedef natural_t mach_port_urefs_t;
-typedef integer_t mach_port_delta_t;                    /* change in urefs */
-
-/* Attributes of ports.  (See mach_port_get_receive_status.) */
-
-typedef natural_t mach_port_seqno_t;            /* sequence number */
-typedef natural_t mach_port_mscount_t;          /* make-send count */
-typedef natural_t mach_port_msgcount_t;         /* number of msgs */
-typedef natural_t mach_port_rights_t;           /* number of rights */
-
-/*
- *	Are there outstanding send rights for a given port?
- */
-#define MACH_PORT_SRIGHTS_NONE          0               /* no srights */
-#define MACH_PORT_SRIGHTS_PRESENT       1               /* srights */
-typedef unsigned int mach_port_srights_t;       /* status of send rights */
-
-typedef struct mach_port_status {
-	mach_port_rights_t      mps_pset;       /* count of containing port sets */
-	mach_port_seqno_t       mps_seqno;      /* sequence number */
-	mach_port_mscount_t     mps_mscount;    /* make-send count */
-	mach_port_msgcount_t    mps_qlimit;     /* queue limit */
-	mach_port_msgcount_t    mps_msgcount;   /* number in the queue */
-	mach_port_rights_t      mps_sorights;   /* how many send-once rights */
-	boolean_t               mps_srights;    /* do send rights exist? */
-	boolean_t               mps_pdrequest;  /* port-deleted requested? */
-	boolean_t               mps_nsrequest;  /* no-senders requested? */
-	natural_t               mps_flags;              /* port flags */
-} mach_port_status_t;
-
-/* System-wide values for setting queue limits on a port */
-#define MACH_PORT_QLIMIT_ZERO           (0)
-#define MACH_PORT_QLIMIT_BASIC          (5)
-#define MACH_PORT_QLIMIT_SMALL          (16)
-#define MACH_PORT_QLIMIT_LARGE          (1024)
-#define MACH_PORT_QLIMIT_KERNEL         (65534)
-#define MACH_PORT_QLIMIT_MIN            MACH_PORT_QLIMIT_ZERO
-#define MACH_PORT_QLIMIT_DEFAULT        MACH_PORT_QLIMIT_BASIC
-#define MACH_PORT_QLIMIT_MAX            MACH_PORT_QLIMIT_LARGE
-
-typedef struct mach_port_limits {
-	mach_port_msgcount_t    mpl_qlimit;     /* number of msgs */
-} mach_port_limits_t;
-
-/* Possible values for mps_flags (part of mach_port_status_t) */
-#define MACH_PORT_STATUS_FLAG_TEMPOWNER         0x01
-#define MACH_PORT_STATUS_FLAG_GUARDED           0x02
-#define MACH_PORT_STATUS_FLAG_STRICT_GUARD      0x04
-#define MACH_PORT_STATUS_FLAG_IMP_DONATION      0x08
-#define MACH_PORT_STATUS_FLAG_REVIVE            0x10
-#define MACH_PORT_STATUS_FLAG_TASKPTR           0x20
-#define MACH_PORT_STATUS_FLAG_GUARD_IMMOVABLE_RECEIVE 0x40
-#define MACH_PORT_STATUS_FLAG_NO_GRANT          0x80
-
-typedef struct mach_port_info_ext {
-	mach_port_status_t      mpie_status;
-	mach_port_msgcount_t    mpie_boost_cnt;
-	uint32_t                reserved[6];
-} mach_port_info_ext_t;
-
-typedef integer_t *mach_port_info_t;            /* varying array of natural_t */
-
-/* Flavors for mach_port_get/set_attributes() */
-typedef int     mach_port_flavor_t;
-#define MACH_PORT_LIMITS_INFO           1       /* uses mach_port_limits_t */
-#define MACH_PORT_RECEIVE_STATUS        2       /* uses mach_port_status_t */
-#define MACH_PORT_DNREQUESTS_SIZE       3       /* info is int */
-#define MACH_PORT_TEMPOWNER             4       /* indicates receive right will be reassigned to another task */
-#define MACH_PORT_IMPORTANCE_RECEIVER   5       /* indicates recieve right accepts priority donation */
-#define MACH_PORT_DENAP_RECEIVER        6       /* indicates receive right accepts de-nap donation */
-#define MACH_PORT_INFO_EXT              7       /* uses mach_port_info_ext_t */
-
-#define MACH_PORT_LIMITS_INFO_COUNT     ((natural_t) \
-	(sizeof(mach_port_limits_t)/sizeof(natural_t)))
-#define MACH_PORT_RECEIVE_STATUS_COUNT  ((natural_t) \
-	(sizeof(mach_port_status_t)/sizeof(natural_t)))
-#define MACH_PORT_DNREQUESTS_SIZE_COUNT 1
-#define MACH_PORT_INFO_EXT_COUNT        ((natural_t) \
-	(sizeof(mach_port_info_ext_t)/sizeof(natural_t)))
-/*
- * Structure used to pass information about port allocation requests.
- * Must be padded to 64-bits total length.
- */
-typedef struct mach_port_qos {
-	unsigned int            name:1;         /* name given */
-	unsigned int            prealloc:1;     /* prealloced message */
-	boolean_t               pad1:30;
-	natural_t               len;
-} mach_port_qos_t;
-
-/* Mach Port Guarding definitions */
-
-/*
- * Flags for mach_port_options (used for
- * invocation of mach_port_construct).
- * Indicates attributes to be set for the newly
- * allocated port.
- */
-#define MPO_CONTEXT_AS_GUARD    0x01    /* Add guard to the port */
-#define MPO_QLIMIT              0x02    /* Set qlimit for the port msg queue */
-#define MPO_TEMPOWNER           0x04    /* Set the tempowner bit of the port */
-#define MPO_IMPORTANCE_RECEIVER 0x08    /* Mark the port as importance receiver */
-#define MPO_INSERT_SEND_RIGHT   0x10    /* Insert a send right for the port */
-#define MPO_STRICT              0x20    /* Apply strict guarding for port */
-#define MPO_DENAP_RECEIVER      0x40    /* Mark the port as App de-nap receiver */
-#define MPO_IMMOVABLE_RECEIVE   0x80    /* Mark the port as immovable; protected by the guard context */
-/*
- * Structure to define optional attributes for a newly
- * constructed port.
- */
-typedef struct mach_port_options {
-	uint32_t                flags;          /* Flags defining attributes for port */
-	mach_port_limits_t      mpl;            /* Message queue limit for port */
-	uint64_t                reserved[2];    /* Reserved */
-}mach_port_options_t;
-
-typedef mach_port_options_t *mach_port_options_ptr_t;
-
-/*
- * EXC_GUARD represents a guard violation for both
- * mach ports and file descriptors. GUARD_TYPE_ is used
- * to differentiate among them.
- */
-#define GUARD_TYPE_MACH_PORT    0x1
-
-/* Reasons for exception for a guarded mach port */
-enum mach_port_guard_exception_codes {
-	kGUARD_EXC_DESTROY                       = 1u << 0,
-	kGUARD_EXC_MOD_REFS                      = 1u << 1,
-	kGUARD_EXC_SET_CONTEXT               = 1u << 2,
-	kGUARD_EXC_UNGUARDED                 = 1u << 3,
-	kGUARD_EXC_INCORRECT_GUARD           = 1u << 4,
-	kGUARD_EXC_IMMOVABLE                 = 1u << 5,
-	kGUARD_EXC_STRICT_REPLY              = 1u << 6,
-	/* start of [optionally] non-fatal guards */
-	kGUARD_EXC_INVALID_RIGHT         = 1u << 8,
-	kGUARD_EXC_INVALID_NAME          = 1u << 9,
-	kGUARD_EXC_INVALID_VALUE         = 1u << 10,
-	kGUARD_EXC_INVALID_ARGUMENT      = 1u << 11,
-	kGUARD_EXC_RIGHT_EXISTS          = 1u << 12,
-	kGUARD_EXC_KERN_NO_SPACE         = 1u << 13,
-	kGUARD_EXC_KERN_FAILURE          = 1u << 14,
-	kGUARD_EXC_KERN_RESOURCE         = 1u << 15,
-	kGUARD_EXC_SEND_INVALID_REPLY    = 1u << 16,
-	kGUARD_EXC_SEND_INVALID_VOUCHER  = 1u << 17,
-	kGUARD_EXC_SEND_INVALID_RIGHT    = 1u << 18,
-	kGUARD_EXC_RCV_INVALID_NAME      = 1u << 19,
-	kGUARD_EXC_RCV_GUARDED_DESC      = 1u << 20, /* should never be fatal; for development only */
-};
-
-#define MAX_FATAL_kGUARD_EXC_CODE (1u << 6)
-
-/*
- * These flags are used as bits in the subcode of kGUARD_EXC_STRICT_REPLY exceptions.
- */
-#define MPG_FLAGS_STRICT_REPLY_INVALID_REPLY_DISP  (0x01ull << 56)
-#define MPG_FLAGS_STRICT_REPLY_INVALID_REPLY_PORT  (0x02ull << 56)
-#define MPG_FLAGS_STRICT_REPLY_INVALID_VOUCHER     (0x04ull << 56)
-#define MPG_FLAGS_STRICT_REPLY_NO_BANK_ATTR        (0x08ull << 56)
-#define MPG_FLAGS_STRICT_REPLY_MISMATCHED_PERSONA  (0x10ull << 56)
-#define MPG_FLAGS_STRICT_REPLY_MASK                (0xffull << 56)
-
-/*
- * Flags for mach_port_guard_with_flags. These flags extend
- * the attributes associated with a guarded port.
- */
-#define MPG_STRICT              0x01    /* Apply strict guarding for a port */
-#define MPG_IMMOVABLE_RECEIVE   0x02    /* Receive right cannot be moved out of the space */
-
-#if     !__DARWIN_UNIX03 && !defined(_NO_PORT_T_FROM_MACH)
-/*
- *  Mach 3.0 renamed everything to have mach_ in front of it.
- *  These types and macros are provided for backward compatibility
- *	but are deprecated.
- */
-typedef mach_port_t             port_t;
-typedef mach_port_name_t        port_name_t;
-typedef mach_port_name_t        *port_name_array_t;
-
-#define PORT_NULL               ((port_t) 0)
-#define PORT_DEAD               ((port_t) ~0)
-#define PORT_VALID(name) \
-	        ((port_t)(name) != PORT_NULL && (port_t)(name) != PORT_DEAD)
-
-#endif  /* !__DARWIN_UNIX03 && !_NO_PORT_T_FROM_MACH */
-
-#endif  /* _MACH_PORT_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/mach/processor_set.h b/lib/libc/include/x86_64-macos-gnu/mach/processor_set.h
deleted file mode 100644
index c7637d1f19..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/mach/processor_set.h
+++ /dev/null
@@ -1,540 +0,0 @@
-#ifndef	_processor_set_user_
-#define	_processor_set_user_
-
-/* Module processor_set */
-
-#include <string.h>
-#include <mach/ndr.h>
-#include <mach/boolean.h>
-#include <mach/kern_return.h>
-#include <mach/notify.h>
-#include <mach/mach_types.h>
-#include <mach/message.h>
-#include <mach/mig_errors.h>
-#include <mach/port.h>
-	
-/* BEGIN MIG_STRNCPY_ZEROFILL CODE */
-
-#if defined(__has_include)
-#if __has_include(<mach/mig_strncpy_zerofill_support.h>)
-#ifndef USING_MIG_STRNCPY_ZEROFILL
-#define USING_MIG_STRNCPY_ZEROFILL
-#endif
-#ifndef __MIG_STRNCPY_ZEROFILL_FORWARD_TYPE_DECLS__
-#define __MIG_STRNCPY_ZEROFILL_FORWARD_TYPE_DECLS__
-#ifdef __cplusplus
-extern "C" {
-#endif
-	extern int mig_strncpy_zerofill(char *dest, const char *src, int len) __attribute__((weak_import));
-#ifdef __cplusplus
-}
-#endif
-#endif /* __MIG_STRNCPY_ZEROFILL_FORWARD_TYPE_DECLS__ */
-#endif /* __has_include(<mach/mig_strncpy_zerofill_support.h>) */
-#endif /* __has_include */
-	
-/* END MIG_STRNCPY_ZEROFILL CODE */
-
-
-#ifdef AUTOTEST
-#ifndef FUNCTION_PTR_T
-#define FUNCTION_PTR_T
-typedef void (*function_ptr_t)(mach_port_t, char *, mach_msg_type_number_t);
-typedef struct {
-        char            *name;
-        function_ptr_t  function;
-} function_table_entry;
-typedef function_table_entry   *function_table_t;
-#endif /* FUNCTION_PTR_T */
-#endif /* AUTOTEST */
-
-#ifndef	processor_set_MSG_COUNT
-#define	processor_set_MSG_COUNT	10
-#endif	/* processor_set_MSG_COUNT */
-
-#include <mach/std_types.h>
-#include <mach/mig.h>
-#include <mach/mig.h>
-#include <mach/mach_types.h>
-
-#ifdef __BeforeMigUserHeader
-__BeforeMigUserHeader
-#endif /* __BeforeMigUserHeader */
-
-#include <sys/cdefs.h>
-__BEGIN_DECLS
-
-
-/* Routine processor_set_statistics */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t processor_set_statistics
-(
-	processor_set_name_t pset,
-	processor_set_flavor_t flavor,
-	processor_set_info_t info_out,
-	mach_msg_type_number_t *info_outCnt
-);
-
-/* Routine processor_set_destroy */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t processor_set_destroy
-(
-	processor_set_t set
-);
-
-/* Routine processor_set_max_priority */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t processor_set_max_priority
-(
-	processor_set_t processor_set,
-	int max_priority,
-	boolean_t change_threads
-);
-
-/* Routine processor_set_policy_enable */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t processor_set_policy_enable
-(
-	processor_set_t processor_set,
-	int policy
-);
-
-/* Routine processor_set_policy_disable */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t processor_set_policy_disable
-(
-	processor_set_t processor_set,
-	int policy,
-	boolean_t change_threads
-);
-
-/* Routine processor_set_tasks */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t processor_set_tasks
-(
-	processor_set_t processor_set,
-	task_array_t *task_list,
-	mach_msg_type_number_t *task_listCnt
-);
-
-/* Routine processor_set_threads */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t processor_set_threads
-(
-	processor_set_t processor_set,
-	thread_act_array_t *thread_list,
-	mach_msg_type_number_t *thread_listCnt
-);
-
-/* Routine processor_set_policy_control */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t processor_set_policy_control
-(
-	processor_set_t pset,
-	processor_set_flavor_t flavor,
-	processor_set_info_t policy_info,
-	mach_msg_type_number_t policy_infoCnt,
-	boolean_t change
-);
-
-/* Routine processor_set_stack_usage */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t processor_set_stack_usage
-(
-	processor_set_t pset,
-	unsigned *ltotal,
-	vm_size_t *space,
-	vm_size_t *resident,
-	vm_size_t *maxusage,
-	vm_offset_t *maxstack
-);
-
-/* Routine processor_set_info */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t processor_set_info
-(
-	processor_set_name_t set_name,
-	int flavor,
-	host_t *host,
-	processor_set_info_t info_out,
-	mach_msg_type_number_t *info_outCnt
-);
-
-__END_DECLS
-
-/********************** Caution **************************/
-/* The following data types should be used to calculate  */
-/* maximum message sizes only. The actual message may be */
-/* smaller, and the position of the arguments within the */
-/* message layout may vary from what is presented here.  */
-/* For example, if any of the arguments are variable-    */
-/* sized, and less than the maximum is sent, the data    */
-/* will be packed tight in the actual message to reduce  */
-/* the presence of holes.                                */
-/********************** Caution **************************/
-
-/* typedefs for all requests */
-
-#ifndef __Request__processor_set_subsystem__defined
-#define __Request__processor_set_subsystem__defined
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		processor_set_flavor_t flavor;
-		mach_msg_type_number_t info_outCnt;
-	} __Request__processor_set_statistics_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-	} __Request__processor_set_destroy_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		int max_priority;
-		boolean_t change_threads;
-	} __Request__processor_set_max_priority_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		int policy;
-	} __Request__processor_set_policy_enable_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		int policy;
-		boolean_t change_threads;
-	} __Request__processor_set_policy_disable_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-	} __Request__processor_set_tasks_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-	} __Request__processor_set_threads_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		processor_set_flavor_t flavor;
-		mach_msg_type_number_t policy_infoCnt;
-		integer_t policy_info[5];
-		boolean_t change;
-	} __Request__processor_set_policy_control_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-	} __Request__processor_set_stack_usage_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		int flavor;
-		mach_msg_type_number_t info_outCnt;
-	} __Request__processor_set_info_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-#endif /* !__Request__processor_set_subsystem__defined */
-
-/* union of all requests */
-
-#ifndef __RequestUnion__processor_set_subsystem__defined
-#define __RequestUnion__processor_set_subsystem__defined
-union __RequestUnion__processor_set_subsystem {
-	__Request__processor_set_statistics_t Request_processor_set_statistics;
-	__Request__processor_set_destroy_t Request_processor_set_destroy;
-	__Request__processor_set_max_priority_t Request_processor_set_max_priority;
-	__Request__processor_set_policy_enable_t Request_processor_set_policy_enable;
-	__Request__processor_set_policy_disable_t Request_processor_set_policy_disable;
-	__Request__processor_set_tasks_t Request_processor_set_tasks;
-	__Request__processor_set_threads_t Request_processor_set_threads;
-	__Request__processor_set_policy_control_t Request_processor_set_policy_control;
-	__Request__processor_set_stack_usage_t Request_processor_set_stack_usage;
-	__Request__processor_set_info_t Request_processor_set_info;
-};
-#endif /* !__RequestUnion__processor_set_subsystem__defined */
-/* typedefs for all replies */
-
-#ifndef __Reply__processor_set_subsystem__defined
-#define __Reply__processor_set_subsystem__defined
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-		mach_msg_type_number_t info_outCnt;
-		integer_t info_out[5];
-	} __Reply__processor_set_statistics_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-	} __Reply__processor_set_destroy_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-	} __Reply__processor_set_max_priority_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-	} __Reply__processor_set_policy_enable_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-	} __Reply__processor_set_policy_disable_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		/* start of the kernel processed data */
-		mach_msg_body_t msgh_body;
-		mach_msg_ool_ports_descriptor_t task_list;
-		/* end of the kernel processed data */
-		NDR_record_t NDR;
-		mach_msg_type_number_t task_listCnt;
-	} __Reply__processor_set_tasks_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		/* start of the kernel processed data */
-		mach_msg_body_t msgh_body;
-		mach_msg_ool_ports_descriptor_t thread_list;
-		/* end of the kernel processed data */
-		NDR_record_t NDR;
-		mach_msg_type_number_t thread_listCnt;
-	} __Reply__processor_set_threads_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-	} __Reply__processor_set_policy_control_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-		unsigned ltotal;
-		vm_size_t space;
-		vm_size_t resident;
-		vm_size_t maxusage;
-		vm_offset_t maxstack;
-	} __Reply__processor_set_stack_usage_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		/* start of the kernel processed data */
-		mach_msg_body_t msgh_body;
-		mach_msg_port_descriptor_t host;
-		/* end of the kernel processed data */
-		NDR_record_t NDR;
-		mach_msg_type_number_t info_outCnt;
-		integer_t info_out[5];
-	} __Reply__processor_set_info_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-#endif /* !__Reply__processor_set_subsystem__defined */
-
-/* union of all replies */
-
-#ifndef __ReplyUnion__processor_set_subsystem__defined
-#define __ReplyUnion__processor_set_subsystem__defined
-union __ReplyUnion__processor_set_subsystem {
-	__Reply__processor_set_statistics_t Reply_processor_set_statistics;
-	__Reply__processor_set_destroy_t Reply_processor_set_destroy;
-	__Reply__processor_set_max_priority_t Reply_processor_set_max_priority;
-	__Reply__processor_set_policy_enable_t Reply_processor_set_policy_enable;
-	__Reply__processor_set_policy_disable_t Reply_processor_set_policy_disable;
-	__Reply__processor_set_tasks_t Reply_processor_set_tasks;
-	__Reply__processor_set_threads_t Reply_processor_set_threads;
-	__Reply__processor_set_policy_control_t Reply_processor_set_policy_control;
-	__Reply__processor_set_stack_usage_t Reply_processor_set_stack_usage;
-	__Reply__processor_set_info_t Reply_processor_set_info;
-};
-#endif /* !__RequestUnion__processor_set_subsystem__defined */
-
-#ifndef subsystem_to_name_map_processor_set
-#define subsystem_to_name_map_processor_set \
-    { "processor_set_statistics", 4000 },\
-    { "processor_set_destroy", 4001 },\
-    { "processor_set_max_priority", 4002 },\
-    { "processor_set_policy_enable", 4003 },\
-    { "processor_set_policy_disable", 4004 },\
-    { "processor_set_tasks", 4005 },\
-    { "processor_set_threads", 4006 },\
-    { "processor_set_policy_control", 4007 },\
-    { "processor_set_stack_usage", 4008 },\
-    { "processor_set_info", 4009 }
-#endif
-
-#ifdef __AfterMigUserHeader
-__AfterMigUserHeader
-#endif /* __AfterMigUserHeader */
-
-#endif	 /* _processor_set_user_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/mach/task.h b/lib/libc/include/x86_64-macos-gnu/mach/task.h
deleted file mode 100644
index 5f0de2dcd5..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/mach/task.h
+++ /dev/null
@@ -1,2523 +0,0 @@
-#ifndef	_task_user_
-#define	_task_user_
-
-/* Module task */
-
-#include <string.h>
-#include <mach/ndr.h>
-#include <mach/boolean.h>
-#include <mach/kern_return.h>
-#include <mach/notify.h>
-#include <mach/mach_types.h>
-#include <mach/message.h>
-#include <mach/mig_errors.h>
-#include <mach/port.h>
-	
-/* BEGIN MIG_STRNCPY_ZEROFILL CODE */
-
-#if defined(__has_include)
-#if __has_include(<mach/mig_strncpy_zerofill_support.h>)
-#ifndef USING_MIG_STRNCPY_ZEROFILL
-#define USING_MIG_STRNCPY_ZEROFILL
-#endif
-#ifndef __MIG_STRNCPY_ZEROFILL_FORWARD_TYPE_DECLS__
-#define __MIG_STRNCPY_ZEROFILL_FORWARD_TYPE_DECLS__
-#ifdef __cplusplus
-extern "C" {
-#endif
-	extern int mig_strncpy_zerofill(char *dest, const char *src, int len) __attribute__((weak_import));
-#ifdef __cplusplus
-}
-#endif
-#endif /* __MIG_STRNCPY_ZEROFILL_FORWARD_TYPE_DECLS__ */
-#endif /* __has_include(<mach/mig_strncpy_zerofill_support.h>) */
-#endif /* __has_include */
-	
-/* END MIG_STRNCPY_ZEROFILL CODE */
-
-
-#ifdef AUTOTEST
-#ifndef FUNCTION_PTR_T
-#define FUNCTION_PTR_T
-typedef void (*function_ptr_t)(mach_port_t, char *, mach_msg_type_number_t);
-typedef struct {
-        char            *name;
-        function_ptr_t  function;
-} function_table_entry;
-typedef function_table_entry   *function_table_t;
-#endif /* FUNCTION_PTR_T */
-#endif /* AUTOTEST */
-
-#ifndef	task_MSG_COUNT
-#define	task_MSG_COUNT	55
-#endif	/* task_MSG_COUNT */
-
-#include <mach/std_types.h>
-#include <mach/mig.h>
-#include <mach/mig.h>
-#include <mach/mach_types.h>
-#include <mach_debug/mach_debug_types.h>
-
-#ifdef __BeforeMigUserHeader
-__BeforeMigUserHeader
-#endif /* __BeforeMigUserHeader */
-
-#include <sys/cdefs.h>
-__BEGIN_DECLS
-
-
-/* Routine task_create */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t task_create
-(
-	task_t target_task,
-	ledger_array_t ledgers,
-	mach_msg_type_number_t ledgersCnt,
-	boolean_t inherit_memory,
-	task_t *child_task
-);
-
-/* Routine task_terminate */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t task_terminate
-(
-	task_t target_task
-);
-
-/* Routine task_threads */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t task_threads
-(
-	task_inspect_t target_task,
-	thread_act_array_t *act_list,
-	mach_msg_type_number_t *act_listCnt
-);
-
-/* Routine mach_ports_register */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-__WATCHOS_PROHIBITED
-__TVOS_PROHIBITED
-kern_return_t mach_ports_register
-(
-	task_t target_task,
-	mach_port_array_t init_port_set,
-	mach_msg_type_number_t init_port_setCnt
-);
-
-/* Routine mach_ports_lookup */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-__WATCHOS_PROHIBITED
-__TVOS_PROHIBITED
-kern_return_t mach_ports_lookup
-(
-	task_t target_task,
-	mach_port_array_t *init_port_set,
-	mach_msg_type_number_t *init_port_setCnt
-);
-
-/* Routine task_info */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t task_info
-(
-	task_name_t target_task,
-	task_flavor_t flavor,
-	task_info_t task_info_out,
-	mach_msg_type_number_t *task_info_outCnt
-);
-
-/* Routine task_set_info */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-__WATCHOS_PROHIBITED
-__TVOS_PROHIBITED
-kern_return_t task_set_info
-(
-	task_t target_task,
-	task_flavor_t flavor,
-	task_info_t task_info_in,
-	mach_msg_type_number_t task_info_inCnt
-);
-
-/* Routine task_suspend */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-__WATCHOS_PROHIBITED
-__TVOS_PROHIBITED
-kern_return_t task_suspend
-(
-	task_t target_task
-);
-
-/* Routine task_resume */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-__WATCHOS_PROHIBITED
-__TVOS_PROHIBITED
-kern_return_t task_resume
-(
-	task_t target_task
-);
-
-/* Routine task_get_special_port */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-__WATCHOS_PROHIBITED
-__TVOS_PROHIBITED
-kern_return_t task_get_special_port
-(
-	task_inspect_t task,
-	int which_port,
-	mach_port_t *special_port
-);
-
-/* Routine task_set_special_port */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-__WATCHOS_PROHIBITED
-__TVOS_PROHIBITED
-kern_return_t task_set_special_port
-(
-	task_t task,
-	int which_port,
-	mach_port_t special_port
-);
-
-/* Routine thread_create */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-__WATCHOS_PROHIBITED
-__TVOS_PROHIBITED
-kern_return_t thread_create
-(
-	task_t parent_task,
-	thread_act_t *child_act
-);
-
-/* Routine thread_create_running */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-__WATCHOS_PROHIBITED
-__TVOS_PROHIBITED
-kern_return_t thread_create_running
-(
-	task_t parent_task,
-	thread_state_flavor_t flavor,
-	thread_state_t new_state,
-	mach_msg_type_number_t new_stateCnt,
-	thread_act_t *child_act
-);
-
-/* Routine task_set_exception_ports */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-__WATCHOS_PROHIBITED
-__TVOS_PROHIBITED
-kern_return_t task_set_exception_ports
-(
-	task_t task,
-	exception_mask_t exception_mask,
-	mach_port_t new_port,
-	exception_behavior_t behavior,
-	thread_state_flavor_t new_flavor
-);
-
-/* Routine task_get_exception_ports */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-__WATCHOS_PROHIBITED
-__TVOS_PROHIBITED
-kern_return_t task_get_exception_ports
-(
-	task_inspect_t task,
-	exception_mask_t exception_mask,
-	exception_mask_array_t masks,
-	mach_msg_type_number_t *masksCnt,
-	exception_handler_array_t old_handlers,
-	exception_behavior_array_t old_behaviors,
-	exception_flavor_array_t old_flavors
-);
-
-/* Routine task_swap_exception_ports */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-__WATCHOS_PROHIBITED
-__TVOS_PROHIBITED
-kern_return_t task_swap_exception_ports
-(
-	task_t task,
-	exception_mask_t exception_mask,
-	mach_port_t new_port,
-	exception_behavior_t behavior,
-	thread_state_flavor_t new_flavor,
-	exception_mask_array_t masks,
-	mach_msg_type_number_t *masksCnt,
-	exception_handler_array_t old_handlerss,
-	exception_behavior_array_t old_behaviors,
-	exception_flavor_array_t old_flavors
-);
-
-/* Routine lock_set_create */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t lock_set_create
-(
-	task_t task,
-	lock_set_t *new_lock_set,
-	int n_ulocks,
-	int policy
-);
-
-/* Routine lock_set_destroy */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t lock_set_destroy
-(
-	task_t task,
-	lock_set_t lock_set
-);
-
-/* Routine semaphore_create */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t semaphore_create
-(
-	task_t task,
-	semaphore_t *semaphore,
-	int policy,
-	int value
-);
-
-/* Routine semaphore_destroy */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t semaphore_destroy
-(
-	task_t task,
-	semaphore_t semaphore
-);
-
-/* Routine task_policy_set */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-__WATCHOS_PROHIBITED
-__TVOS_PROHIBITED
-kern_return_t task_policy_set
-(
-	task_t task,
-	task_policy_flavor_t flavor,
-	task_policy_t policy_info,
-	mach_msg_type_number_t policy_infoCnt
-);
-
-/* Routine task_policy_get */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-__WATCHOS_PROHIBITED
-__TVOS_PROHIBITED
-kern_return_t task_policy_get
-(
-	task_t task,
-	task_policy_flavor_t flavor,
-	task_policy_t policy_info,
-	mach_msg_type_number_t *policy_infoCnt,
-	boolean_t *get_default
-);
-
-/* Routine task_sample */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t task_sample
-(
-	task_t task,
-	mach_port_t reply
-);
-
-/* Routine task_policy */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t task_policy
-(
-	task_t task,
-	policy_t policy,
-	policy_base_t base,
-	mach_msg_type_number_t baseCnt,
-	boolean_t set_limit,
-	boolean_t change
-);
-
-/* Routine task_set_emulation */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t task_set_emulation
-(
-	task_t target_port,
-	vm_address_t routine_entry_pt,
-	int routine_number
-);
-
-/* Routine task_get_emulation_vector */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t task_get_emulation_vector
-(
-	task_t task,
-	int *vector_start,
-	emulation_vector_t *emulation_vector,
-	mach_msg_type_number_t *emulation_vectorCnt
-);
-
-/* Routine task_set_emulation_vector */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t task_set_emulation_vector
-(
-	task_t task,
-	int vector_start,
-	emulation_vector_t emulation_vector,
-	mach_msg_type_number_t emulation_vectorCnt
-);
-
-/* Routine task_set_ras_pc */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t task_set_ras_pc
-(
-	task_t target_task,
-	vm_address_t basepc,
-	vm_address_t boundspc
-);
-
-/* Routine task_zone_info */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-__WATCHOS_PROHIBITED
-__TVOS_PROHIBITED
-kern_return_t task_zone_info
-(
-	task_t target_task,
-	mach_zone_name_array_t *names,
-	mach_msg_type_number_t *namesCnt,
-	task_zone_info_array_t *info,
-	mach_msg_type_number_t *infoCnt
-);
-
-/* Routine task_assign */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t task_assign
-(
-	task_t task,
-	processor_set_t new_set,
-	boolean_t assign_threads
-);
-
-/* Routine task_assign_default */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t task_assign_default
-(
-	task_t task,
-	boolean_t assign_threads
-);
-
-/* Routine task_get_assignment */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t task_get_assignment
-(
-	task_t task,
-	processor_set_name_t *assigned_set
-);
-
-/* Routine task_set_policy */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t task_set_policy
-(
-	task_t task,
-	processor_set_t pset,
-	policy_t policy,
-	policy_base_t base,
-	mach_msg_type_number_t baseCnt,
-	policy_limit_t limit,
-	mach_msg_type_number_t limitCnt,
-	boolean_t change
-);
-
-/* Routine task_get_state */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-__WATCHOS_PROHIBITED
-__TVOS_PROHIBITED
-kern_return_t task_get_state
-(
-	task_t task,
-	thread_state_flavor_t flavor,
-	thread_state_t old_state,
-	mach_msg_type_number_t *old_stateCnt
-);
-
-/* Routine task_set_state */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-__WATCHOS_PROHIBITED
-__TVOS_PROHIBITED
-kern_return_t task_set_state
-(
-	task_t task,
-	thread_state_flavor_t flavor,
-	thread_state_t new_state,
-	mach_msg_type_number_t new_stateCnt
-);
-
-/* Routine task_set_phys_footprint_limit */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-__WATCHOS_PROHIBITED
-__TVOS_PROHIBITED
-kern_return_t task_set_phys_footprint_limit
-(
-	task_t task,
-	int new_limit,
-	int *old_limit
-);
-
-/* Routine task_suspend2 */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-__WATCHOS_PROHIBITED
-__TVOS_PROHIBITED
-kern_return_t task_suspend2
-(
-	task_t target_task,
-	task_suspension_token_t *suspend_token
-);
-
-/* Routine task_resume2 */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-__WATCHOS_PROHIBITED
-__TVOS_PROHIBITED
-kern_return_t task_resume2
-(
-	task_suspension_token_t suspend_token
-);
-
-/* Routine task_purgable_info */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t task_purgable_info
-(
-	task_t task,
-	task_purgable_info_t *stats
-);
-
-/* Routine task_get_mach_voucher */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-__WATCHOS_PROHIBITED
-__TVOS_PROHIBITED
-kern_return_t task_get_mach_voucher
-(
-	task_t task,
-	mach_voucher_selector_t which,
-	ipc_voucher_t *voucher
-);
-
-/* Routine task_set_mach_voucher */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-__WATCHOS_PROHIBITED
-__TVOS_PROHIBITED
-kern_return_t task_set_mach_voucher
-(
-	task_t task,
-	ipc_voucher_t voucher
-);
-
-/* Routine task_swap_mach_voucher */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-__WATCHOS_PROHIBITED
-__TVOS_PROHIBITED
-kern_return_t task_swap_mach_voucher
-(
-	task_t task,
-	ipc_voucher_t new_voucher,
-	ipc_voucher_t *old_voucher
-);
-
-/* Routine task_generate_corpse */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t task_generate_corpse
-(
-	task_t task,
-	mach_port_t *corpse_task_port
-);
-
-/* Routine task_map_corpse_info */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t task_map_corpse_info
-(
-	task_t task,
-	task_t corspe_task,
-	vm_address_t *kcd_addr_begin,
-	uint32_t *kcd_size
-);
-
-/* Routine task_register_dyld_image_infos */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t task_register_dyld_image_infos
-(
-	task_t task,
-	dyld_kernel_image_info_array_t dyld_images,
-	mach_msg_type_number_t dyld_imagesCnt
-);
-
-/* Routine task_unregister_dyld_image_infos */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t task_unregister_dyld_image_infos
-(
-	task_t task,
-	dyld_kernel_image_info_array_t dyld_images,
-	mach_msg_type_number_t dyld_imagesCnt
-);
-
-/* Routine task_get_dyld_image_infos */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t task_get_dyld_image_infos
-(
-	task_inspect_t task,
-	dyld_kernel_image_info_array_t *dyld_images,
-	mach_msg_type_number_t *dyld_imagesCnt
-);
-
-/* Routine task_register_dyld_shared_cache_image_info */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t task_register_dyld_shared_cache_image_info
-(
-	task_t task,
-	dyld_kernel_image_info_t dyld_cache_image,
-	boolean_t no_cache,
-	boolean_t private_cache
-);
-
-/* Routine task_register_dyld_set_dyld_state */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t task_register_dyld_set_dyld_state
-(
-	task_t task,
-	uint8_t dyld_state
-);
-
-/* Routine task_register_dyld_get_process_state */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t task_register_dyld_get_process_state
-(
-	task_t task,
-	dyld_kernel_process_info_t *dyld_process_state
-);
-
-/* Routine task_map_corpse_info_64 */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t task_map_corpse_info_64
-(
-	task_t task,
-	task_t corspe_task,
-	mach_vm_address_t *kcd_addr_begin,
-	mach_vm_size_t *kcd_size
-);
-
-/* Routine task_inspect */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t task_inspect
-(
-	task_inspect_t task,
-	task_inspect_flavor_t flavor,
-	task_inspect_info_t info_out,
-	mach_msg_type_number_t *info_outCnt
-);
-
-/* Routine task_get_exc_guard_behavior */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t task_get_exc_guard_behavior
-(
-	task_inspect_t task,
-	task_exc_guard_behavior_t *behavior
-);
-
-/* Routine task_set_exc_guard_behavior */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t task_set_exc_guard_behavior
-(
-	task_t task,
-	task_exc_guard_behavior_t behavior
-);
-
-/* Routine task_create_suid_cred */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t task_create_suid_cred
-(
-	task_t task,
-	suid_cred_path_t path,
-	suid_cred_uid_t uid,
-	suid_cred_t *delegation
-);
-
-__END_DECLS
-
-/********************** Caution **************************/
-/* The following data types should be used to calculate  */
-/* maximum message sizes only. The actual message may be */
-/* smaller, and the position of the arguments within the */
-/* message layout may vary from what is presented here.  */
-/* For example, if any of the arguments are variable-    */
-/* sized, and less than the maximum is sent, the data    */
-/* will be packed tight in the actual message to reduce  */
-/* the presence of holes.                                */
-/********************** Caution **************************/
-
-/* typedefs for all requests */
-
-#ifndef __Request__task_subsystem__defined
-#define __Request__task_subsystem__defined
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		/* start of the kernel processed data */
-		mach_msg_body_t msgh_body;
-		mach_msg_ool_ports_descriptor_t ledgers;
-		/* end of the kernel processed data */
-		NDR_record_t NDR;
-		mach_msg_type_number_t ledgersCnt;
-		boolean_t inherit_memory;
-	} __Request__task_create_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-	} __Request__task_terminate_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-	} __Request__task_threads_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		/* start of the kernel processed data */
-		mach_msg_body_t msgh_body;
-		mach_msg_ool_ports_descriptor_t init_port_set;
-		/* end of the kernel processed data */
-		NDR_record_t NDR;
-		mach_msg_type_number_t init_port_setCnt;
-	} __Request__mach_ports_register_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-	} __Request__mach_ports_lookup_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		task_flavor_t flavor;
-		mach_msg_type_number_t task_info_outCnt;
-	} __Request__task_info_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		task_flavor_t flavor;
-		mach_msg_type_number_t task_info_inCnt;
-		integer_t task_info_in[87];
-	} __Request__task_set_info_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-	} __Request__task_suspend_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-	} __Request__task_resume_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		int which_port;
-	} __Request__task_get_special_port_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		/* start of the kernel processed data */
-		mach_msg_body_t msgh_body;
-		mach_msg_port_descriptor_t special_port;
-		/* end of the kernel processed data */
-		NDR_record_t NDR;
-		int which_port;
-	} __Request__task_set_special_port_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-	} __Request__thread_create_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		thread_state_flavor_t flavor;
-		mach_msg_type_number_t new_stateCnt;
-		natural_t new_state[614];
-	} __Request__thread_create_running_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		/* start of the kernel processed data */
-		mach_msg_body_t msgh_body;
-		mach_msg_port_descriptor_t new_port;
-		/* end of the kernel processed data */
-		NDR_record_t NDR;
-		exception_mask_t exception_mask;
-		exception_behavior_t behavior;
-		thread_state_flavor_t new_flavor;
-	} __Request__task_set_exception_ports_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		exception_mask_t exception_mask;
-	} __Request__task_get_exception_ports_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		/* start of the kernel processed data */
-		mach_msg_body_t msgh_body;
-		mach_msg_port_descriptor_t new_port;
-		/* end of the kernel processed data */
-		NDR_record_t NDR;
-		exception_mask_t exception_mask;
-		exception_behavior_t behavior;
-		thread_state_flavor_t new_flavor;
-	} __Request__task_swap_exception_ports_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		int n_ulocks;
-		int policy;
-	} __Request__lock_set_create_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		/* start of the kernel processed data */
-		mach_msg_body_t msgh_body;
-		mach_msg_port_descriptor_t lock_set;
-		/* end of the kernel processed data */
-	} __Request__lock_set_destroy_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		int policy;
-		int value;
-	} __Request__semaphore_create_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		/* start of the kernel processed data */
-		mach_msg_body_t msgh_body;
-		mach_msg_port_descriptor_t semaphore;
-		/* end of the kernel processed data */
-	} __Request__semaphore_destroy_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		task_policy_flavor_t flavor;
-		mach_msg_type_number_t policy_infoCnt;
-		integer_t policy_info[16];
-	} __Request__task_policy_set_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		task_policy_flavor_t flavor;
-		mach_msg_type_number_t policy_infoCnt;
-		boolean_t get_default;
-	} __Request__task_policy_get_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		/* start of the kernel processed data */
-		mach_msg_body_t msgh_body;
-		mach_msg_port_descriptor_t reply;
-		/* end of the kernel processed data */
-	} __Request__task_sample_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		policy_t policy;
-		mach_msg_type_number_t baseCnt;
-		integer_t base[5];
-		boolean_t set_limit;
-		boolean_t change;
-	} __Request__task_policy_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		vm_address_t routine_entry_pt;
-		int routine_number;
-	} __Request__task_set_emulation_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-	} __Request__task_get_emulation_vector_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		/* start of the kernel processed data */
-		mach_msg_body_t msgh_body;
-		mach_msg_ool_descriptor_t emulation_vector;
-		/* end of the kernel processed data */
-		NDR_record_t NDR;
-		int vector_start;
-		mach_msg_type_number_t emulation_vectorCnt;
-	} __Request__task_set_emulation_vector_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		vm_address_t basepc;
-		vm_address_t boundspc;
-	} __Request__task_set_ras_pc_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-	} __Request__task_zone_info_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		/* start of the kernel processed data */
-		mach_msg_body_t msgh_body;
-		mach_msg_port_descriptor_t new_set;
-		/* end of the kernel processed data */
-		NDR_record_t NDR;
-		boolean_t assign_threads;
-	} __Request__task_assign_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		boolean_t assign_threads;
-	} __Request__task_assign_default_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-	} __Request__task_get_assignment_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		/* start of the kernel processed data */
-		mach_msg_body_t msgh_body;
-		mach_msg_port_descriptor_t pset;
-		/* end of the kernel processed data */
-		NDR_record_t NDR;
-		policy_t policy;
-		mach_msg_type_number_t baseCnt;
-		integer_t base[5];
-		mach_msg_type_number_t limitCnt;
-		integer_t limit[1];
-		boolean_t change;
-	} __Request__task_set_policy_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		thread_state_flavor_t flavor;
-		mach_msg_type_number_t old_stateCnt;
-	} __Request__task_get_state_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		thread_state_flavor_t flavor;
-		mach_msg_type_number_t new_stateCnt;
-		natural_t new_state[614];
-	} __Request__task_set_state_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		int new_limit;
-	} __Request__task_set_phys_footprint_limit_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-	} __Request__task_suspend2_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-	} __Request__task_resume2_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-	} __Request__task_purgable_info_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		mach_voucher_selector_t which;
-	} __Request__task_get_mach_voucher_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		/* start of the kernel processed data */
-		mach_msg_body_t msgh_body;
-		mach_msg_port_descriptor_t voucher;
-		/* end of the kernel processed data */
-	} __Request__task_set_mach_voucher_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		/* start of the kernel processed data */
-		mach_msg_body_t msgh_body;
-		mach_msg_port_descriptor_t new_voucher;
-		mach_msg_port_descriptor_t old_voucher;
-		/* end of the kernel processed data */
-	} __Request__task_swap_mach_voucher_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-	} __Request__task_generate_corpse_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		/* start of the kernel processed data */
-		mach_msg_body_t msgh_body;
-		mach_msg_port_descriptor_t corspe_task;
-		/* end of the kernel processed data */
-	} __Request__task_map_corpse_info_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		/* start of the kernel processed data */
-		mach_msg_body_t msgh_body;
-		mach_msg_ool_descriptor_t dyld_images;
-		/* end of the kernel processed data */
-		NDR_record_t NDR;
-		mach_msg_type_number_t dyld_imagesCnt;
-	} __Request__task_register_dyld_image_infos_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		/* start of the kernel processed data */
-		mach_msg_body_t msgh_body;
-		mach_msg_ool_descriptor_t dyld_images;
-		/* end of the kernel processed data */
-		NDR_record_t NDR;
-		mach_msg_type_number_t dyld_imagesCnt;
-	} __Request__task_unregister_dyld_image_infos_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-	} __Request__task_get_dyld_image_infos_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		dyld_kernel_image_info_t dyld_cache_image;
-		boolean_t no_cache;
-		boolean_t private_cache;
-	} __Request__task_register_dyld_shared_cache_image_info_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		uint8_t dyld_state;
-		char dyld_statePad[3];
-	} __Request__task_register_dyld_set_dyld_state_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-	} __Request__task_register_dyld_get_process_state_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		/* start of the kernel processed data */
-		mach_msg_body_t msgh_body;
-		mach_msg_port_descriptor_t corspe_task;
-		/* end of the kernel processed data */
-	} __Request__task_map_corpse_info_64_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		task_inspect_flavor_t flavor;
-		mach_msg_type_number_t info_outCnt;
-	} __Request__task_inspect_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-	} __Request__task_get_exc_guard_behavior_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		task_exc_guard_behavior_t behavior;
-	} __Request__task_set_exc_guard_behavior_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		mach_msg_type_number_t pathOffset; /* MiG doesn't use it */
-		mach_msg_type_number_t pathCnt;
-		char path[1024];
-		suid_cred_uid_t uid;
-	} __Request__task_create_suid_cred_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-#endif /* !__Request__task_subsystem__defined */
-
-/* union of all requests */
-
-#ifndef __RequestUnion__task_subsystem__defined
-#define __RequestUnion__task_subsystem__defined
-union __RequestUnion__task_subsystem {
-	__Request__task_create_t Request_task_create;
-	__Request__task_terminate_t Request_task_terminate;
-	__Request__task_threads_t Request_task_threads;
-	__Request__mach_ports_register_t Request_mach_ports_register;
-	__Request__mach_ports_lookup_t Request_mach_ports_lookup;
-	__Request__task_info_t Request_task_info;
-	__Request__task_set_info_t Request_task_set_info;
-	__Request__task_suspend_t Request_task_suspend;
-	__Request__task_resume_t Request_task_resume;
-	__Request__task_get_special_port_t Request_task_get_special_port;
-	__Request__task_set_special_port_t Request_task_set_special_port;
-	__Request__thread_create_t Request_thread_create;
-	__Request__thread_create_running_t Request_thread_create_running;
-	__Request__task_set_exception_ports_t Request_task_set_exception_ports;
-	__Request__task_get_exception_ports_t Request_task_get_exception_ports;
-	__Request__task_swap_exception_ports_t Request_task_swap_exception_ports;
-	__Request__lock_set_create_t Request_lock_set_create;
-	__Request__lock_set_destroy_t Request_lock_set_destroy;
-	__Request__semaphore_create_t Request_semaphore_create;
-	__Request__semaphore_destroy_t Request_semaphore_destroy;
-	__Request__task_policy_set_t Request_task_policy_set;
-	__Request__task_policy_get_t Request_task_policy_get;
-	__Request__task_sample_t Request_task_sample;
-	__Request__task_policy_t Request_task_policy;
-	__Request__task_set_emulation_t Request_task_set_emulation;
-	__Request__task_get_emulation_vector_t Request_task_get_emulation_vector;
-	__Request__task_set_emulation_vector_t Request_task_set_emulation_vector;
-	__Request__task_set_ras_pc_t Request_task_set_ras_pc;
-	__Request__task_zone_info_t Request_task_zone_info;
-	__Request__task_assign_t Request_task_assign;
-	__Request__task_assign_default_t Request_task_assign_default;
-	__Request__task_get_assignment_t Request_task_get_assignment;
-	__Request__task_set_policy_t Request_task_set_policy;
-	__Request__task_get_state_t Request_task_get_state;
-	__Request__task_set_state_t Request_task_set_state;
-	__Request__task_set_phys_footprint_limit_t Request_task_set_phys_footprint_limit;
-	__Request__task_suspend2_t Request_task_suspend2;
-	__Request__task_resume2_t Request_task_resume2;
-	__Request__task_purgable_info_t Request_task_purgable_info;
-	__Request__task_get_mach_voucher_t Request_task_get_mach_voucher;
-	__Request__task_set_mach_voucher_t Request_task_set_mach_voucher;
-	__Request__task_swap_mach_voucher_t Request_task_swap_mach_voucher;
-	__Request__task_generate_corpse_t Request_task_generate_corpse;
-	__Request__task_map_corpse_info_t Request_task_map_corpse_info;
-	__Request__task_register_dyld_image_infos_t Request_task_register_dyld_image_infos;
-	__Request__task_unregister_dyld_image_infos_t Request_task_unregister_dyld_image_infos;
-	__Request__task_get_dyld_image_infos_t Request_task_get_dyld_image_infos;
-	__Request__task_register_dyld_shared_cache_image_info_t Request_task_register_dyld_shared_cache_image_info;
-	__Request__task_register_dyld_set_dyld_state_t Request_task_register_dyld_set_dyld_state;
-	__Request__task_register_dyld_get_process_state_t Request_task_register_dyld_get_process_state;
-	__Request__task_map_corpse_info_64_t Request_task_map_corpse_info_64;
-	__Request__task_inspect_t Request_task_inspect;
-	__Request__task_get_exc_guard_behavior_t Request_task_get_exc_guard_behavior;
-	__Request__task_set_exc_guard_behavior_t Request_task_set_exc_guard_behavior;
-	__Request__task_create_suid_cred_t Request_task_create_suid_cred;
-};
-#endif /* !__RequestUnion__task_subsystem__defined */
-/* typedefs for all replies */
-
-#ifndef __Reply__task_subsystem__defined
-#define __Reply__task_subsystem__defined
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		/* start of the kernel processed data */
-		mach_msg_body_t msgh_body;
-		mach_msg_port_descriptor_t child_task;
-		/* end of the kernel processed data */
-	} __Reply__task_create_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-	} __Reply__task_terminate_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		/* start of the kernel processed data */
-		mach_msg_body_t msgh_body;
-		mach_msg_ool_ports_descriptor_t act_list;
-		/* end of the kernel processed data */
-		NDR_record_t NDR;
-		mach_msg_type_number_t act_listCnt;
-	} __Reply__task_threads_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-	} __Reply__mach_ports_register_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		/* start of the kernel processed data */
-		mach_msg_body_t msgh_body;
-		mach_msg_ool_ports_descriptor_t init_port_set;
-		/* end of the kernel processed data */
-		NDR_record_t NDR;
-		mach_msg_type_number_t init_port_setCnt;
-	} __Reply__mach_ports_lookup_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-		mach_msg_type_number_t task_info_outCnt;
-		integer_t task_info_out[87];
-	} __Reply__task_info_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-	} __Reply__task_set_info_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-	} __Reply__task_suspend_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-	} __Reply__task_resume_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		/* start of the kernel processed data */
-		mach_msg_body_t msgh_body;
-		mach_msg_port_descriptor_t special_port;
-		/* end of the kernel processed data */
-	} __Reply__task_get_special_port_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-	} __Reply__task_set_special_port_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		/* start of the kernel processed data */
-		mach_msg_body_t msgh_body;
-		mach_msg_port_descriptor_t child_act;
-		/* end of the kernel processed data */
-	} __Reply__thread_create_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		/* start of the kernel processed data */
-		mach_msg_body_t msgh_body;
-		mach_msg_port_descriptor_t child_act;
-		/* end of the kernel processed data */
-	} __Reply__thread_create_running_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-	} __Reply__task_set_exception_ports_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		/* start of the kernel processed data */
-		mach_msg_body_t msgh_body;
-		mach_msg_port_descriptor_t old_handlers[32];
-		/* end of the kernel processed data */
-		NDR_record_t NDR;
-		mach_msg_type_number_t masksCnt;
-		exception_mask_t masks[32];
-		exception_behavior_t old_behaviors[32];
-		thread_state_flavor_t old_flavors[32];
-	} __Reply__task_get_exception_ports_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		/* start of the kernel processed data */
-		mach_msg_body_t msgh_body;
-		mach_msg_port_descriptor_t old_handlerss[32];
-		/* end of the kernel processed data */
-		NDR_record_t NDR;
-		mach_msg_type_number_t masksCnt;
-		exception_mask_t masks[32];
-		exception_behavior_t old_behaviors[32];
-		thread_state_flavor_t old_flavors[32];
-	} __Reply__task_swap_exception_ports_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		/* start of the kernel processed data */
-		mach_msg_body_t msgh_body;
-		mach_msg_port_descriptor_t new_lock_set;
-		/* end of the kernel processed data */
-	} __Reply__lock_set_create_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-	} __Reply__lock_set_destroy_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		/* start of the kernel processed data */
-		mach_msg_body_t msgh_body;
-		mach_msg_port_descriptor_t semaphore;
-		/* end of the kernel processed data */
-	} __Reply__semaphore_create_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-	} __Reply__semaphore_destroy_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-	} __Reply__task_policy_set_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-		mach_msg_type_number_t policy_infoCnt;
-		integer_t policy_info[16];
-		boolean_t get_default;
-	} __Reply__task_policy_get_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-	} __Reply__task_sample_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-	} __Reply__task_policy_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-	} __Reply__task_set_emulation_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		/* start of the kernel processed data */
-		mach_msg_body_t msgh_body;
-		mach_msg_ool_descriptor_t emulation_vector;
-		/* end of the kernel processed data */
-		NDR_record_t NDR;
-		int vector_start;
-		mach_msg_type_number_t emulation_vectorCnt;
-	} __Reply__task_get_emulation_vector_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-	} __Reply__task_set_emulation_vector_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-	} __Reply__task_set_ras_pc_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		/* start of the kernel processed data */
-		mach_msg_body_t msgh_body;
-		mach_msg_ool_descriptor_t names;
-		mach_msg_ool_descriptor_t info;
-		/* end of the kernel processed data */
-		NDR_record_t NDR;
-		mach_msg_type_number_t namesCnt;
-		mach_msg_type_number_t infoCnt;
-	} __Reply__task_zone_info_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-	} __Reply__task_assign_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-	} __Reply__task_assign_default_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		/* start of the kernel processed data */
-		mach_msg_body_t msgh_body;
-		mach_msg_port_descriptor_t assigned_set;
-		/* end of the kernel processed data */
-	} __Reply__task_get_assignment_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-	} __Reply__task_set_policy_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-		mach_msg_type_number_t old_stateCnt;
-		natural_t old_state[614];
-	} __Reply__task_get_state_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-	} __Reply__task_set_state_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-		int old_limit;
-	} __Reply__task_set_phys_footprint_limit_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		/* start of the kernel processed data */
-		mach_msg_body_t msgh_body;
-		mach_msg_port_descriptor_t suspend_token;
-		/* end of the kernel processed data */
-	} __Reply__task_suspend2_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-	} __Reply__task_resume2_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-		task_purgable_info_t stats;
-	} __Reply__task_purgable_info_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		/* start of the kernel processed data */
-		mach_msg_body_t msgh_body;
-		mach_msg_port_descriptor_t voucher;
-		/* end of the kernel processed data */
-	} __Reply__task_get_mach_voucher_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-	} __Reply__task_set_mach_voucher_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		/* start of the kernel processed data */
-		mach_msg_body_t msgh_body;
-		mach_msg_port_descriptor_t old_voucher;
-		/* end of the kernel processed data */
-	} __Reply__task_swap_mach_voucher_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		/* start of the kernel processed data */
-		mach_msg_body_t msgh_body;
-		mach_msg_port_descriptor_t corpse_task_port;
-		/* end of the kernel processed data */
-	} __Reply__task_generate_corpse_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-		vm_address_t kcd_addr_begin;
-		uint32_t kcd_size;
-	} __Reply__task_map_corpse_info_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-	} __Reply__task_register_dyld_image_infos_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-	} __Reply__task_unregister_dyld_image_infos_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		/* start of the kernel processed data */
-		mach_msg_body_t msgh_body;
-		mach_msg_ool_descriptor_t dyld_images;
-		/* end of the kernel processed data */
-		NDR_record_t NDR;
-		mach_msg_type_number_t dyld_imagesCnt;
-	} __Reply__task_get_dyld_image_infos_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-	} __Reply__task_register_dyld_shared_cache_image_info_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-	} __Reply__task_register_dyld_set_dyld_state_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-		dyld_kernel_process_info_t dyld_process_state;
-	} __Reply__task_register_dyld_get_process_state_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-		mach_vm_address_t kcd_addr_begin;
-		mach_vm_size_t kcd_size;
-	} __Reply__task_map_corpse_info_64_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-		mach_msg_type_number_t info_outCnt;
-		integer_t info_out[4];
-	} __Reply__task_inspect_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-		task_exc_guard_behavior_t behavior;
-	} __Reply__task_get_exc_guard_behavior_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-	} __Reply__task_set_exc_guard_behavior_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		/* start of the kernel processed data */
-		mach_msg_body_t msgh_body;
-		mach_msg_port_descriptor_t delegation;
-		/* end of the kernel processed data */
-	} __Reply__task_create_suid_cred_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-#endif /* !__Reply__task_subsystem__defined */
-
-/* union of all replies */
-
-#ifndef __ReplyUnion__task_subsystem__defined
-#define __ReplyUnion__task_subsystem__defined
-union __ReplyUnion__task_subsystem {
-	__Reply__task_create_t Reply_task_create;
-	__Reply__task_terminate_t Reply_task_terminate;
-	__Reply__task_threads_t Reply_task_threads;
-	__Reply__mach_ports_register_t Reply_mach_ports_register;
-	__Reply__mach_ports_lookup_t Reply_mach_ports_lookup;
-	__Reply__task_info_t Reply_task_info;
-	__Reply__task_set_info_t Reply_task_set_info;
-	__Reply__task_suspend_t Reply_task_suspend;
-	__Reply__task_resume_t Reply_task_resume;
-	__Reply__task_get_special_port_t Reply_task_get_special_port;
-	__Reply__task_set_special_port_t Reply_task_set_special_port;
-	__Reply__thread_create_t Reply_thread_create;
-	__Reply__thread_create_running_t Reply_thread_create_running;
-	__Reply__task_set_exception_ports_t Reply_task_set_exception_ports;
-	__Reply__task_get_exception_ports_t Reply_task_get_exception_ports;
-	__Reply__task_swap_exception_ports_t Reply_task_swap_exception_ports;
-	__Reply__lock_set_create_t Reply_lock_set_create;
-	__Reply__lock_set_destroy_t Reply_lock_set_destroy;
-	__Reply__semaphore_create_t Reply_semaphore_create;
-	__Reply__semaphore_destroy_t Reply_semaphore_destroy;
-	__Reply__task_policy_set_t Reply_task_policy_set;
-	__Reply__task_policy_get_t Reply_task_policy_get;
-	__Reply__task_sample_t Reply_task_sample;
-	__Reply__task_policy_t Reply_task_policy;
-	__Reply__task_set_emulation_t Reply_task_set_emulation;
-	__Reply__task_get_emulation_vector_t Reply_task_get_emulation_vector;
-	__Reply__task_set_emulation_vector_t Reply_task_set_emulation_vector;
-	__Reply__task_set_ras_pc_t Reply_task_set_ras_pc;
-	__Reply__task_zone_info_t Reply_task_zone_info;
-	__Reply__task_assign_t Reply_task_assign;
-	__Reply__task_assign_default_t Reply_task_assign_default;
-	__Reply__task_get_assignment_t Reply_task_get_assignment;
-	__Reply__task_set_policy_t Reply_task_set_policy;
-	__Reply__task_get_state_t Reply_task_get_state;
-	__Reply__task_set_state_t Reply_task_set_state;
-	__Reply__task_set_phys_footprint_limit_t Reply_task_set_phys_footprint_limit;
-	__Reply__task_suspend2_t Reply_task_suspend2;
-	__Reply__task_resume2_t Reply_task_resume2;
-	__Reply__task_purgable_info_t Reply_task_purgable_info;
-	__Reply__task_get_mach_voucher_t Reply_task_get_mach_voucher;
-	__Reply__task_set_mach_voucher_t Reply_task_set_mach_voucher;
-	__Reply__task_swap_mach_voucher_t Reply_task_swap_mach_voucher;
-	__Reply__task_generate_corpse_t Reply_task_generate_corpse;
-	__Reply__task_map_corpse_info_t Reply_task_map_corpse_info;
-	__Reply__task_register_dyld_image_infos_t Reply_task_register_dyld_image_infos;
-	__Reply__task_unregister_dyld_image_infos_t Reply_task_unregister_dyld_image_infos;
-	__Reply__task_get_dyld_image_infos_t Reply_task_get_dyld_image_infos;
-	__Reply__task_register_dyld_shared_cache_image_info_t Reply_task_register_dyld_shared_cache_image_info;
-	__Reply__task_register_dyld_set_dyld_state_t Reply_task_register_dyld_set_dyld_state;
-	__Reply__task_register_dyld_get_process_state_t Reply_task_register_dyld_get_process_state;
-	__Reply__task_map_corpse_info_64_t Reply_task_map_corpse_info_64;
-	__Reply__task_inspect_t Reply_task_inspect;
-	__Reply__task_get_exc_guard_behavior_t Reply_task_get_exc_guard_behavior;
-	__Reply__task_set_exc_guard_behavior_t Reply_task_set_exc_guard_behavior;
-	__Reply__task_create_suid_cred_t Reply_task_create_suid_cred;
-};
-#endif /* !__RequestUnion__task_subsystem__defined */
-
-#ifndef subsystem_to_name_map_task
-#define subsystem_to_name_map_task \
-    { "task_create", 3400 },\
-    { "task_terminate", 3401 },\
-    { "task_threads", 3402 },\
-    { "mach_ports_register", 3403 },\
-    { "mach_ports_lookup", 3404 },\
-    { "task_info", 3405 },\
-    { "task_set_info", 3406 },\
-    { "task_suspend", 3407 },\
-    { "task_resume", 3408 },\
-    { "task_get_special_port", 3409 },\
-    { "task_set_special_port", 3410 },\
-    { "thread_create", 3411 },\
-    { "thread_create_running", 3412 },\
-    { "task_set_exception_ports", 3413 },\
-    { "task_get_exception_ports", 3414 },\
-    { "task_swap_exception_ports", 3415 },\
-    { "lock_set_create", 3416 },\
-    { "lock_set_destroy", 3417 },\
-    { "semaphore_create", 3418 },\
-    { "semaphore_destroy", 3419 },\
-    { "task_policy_set", 3420 },\
-    { "task_policy_get", 3421 },\
-    { "task_sample", 3422 },\
-    { "task_policy", 3423 },\
-    { "task_set_emulation", 3424 },\
-    { "task_get_emulation_vector", 3425 },\
-    { "task_set_emulation_vector", 3426 },\
-    { "task_set_ras_pc", 3427 },\
-    { "task_zone_info", 3428 },\
-    { "task_assign", 3429 },\
-    { "task_assign_default", 3430 },\
-    { "task_get_assignment", 3431 },\
-    { "task_set_policy", 3432 },\
-    { "task_get_state", 3433 },\
-    { "task_set_state", 3434 },\
-    { "task_set_phys_footprint_limit", 3435 },\
-    { "task_suspend2", 3436 },\
-    { "task_resume2", 3437 },\
-    { "task_purgable_info", 3438 },\
-    { "task_get_mach_voucher", 3439 },\
-    { "task_set_mach_voucher", 3440 },\
-    { "task_swap_mach_voucher", 3441 },\
-    { "task_generate_corpse", 3442 },\
-    { "task_map_corpse_info", 3443 },\
-    { "task_register_dyld_image_infos", 3444 },\
-    { "task_unregister_dyld_image_infos", 3445 },\
-    { "task_get_dyld_image_infos", 3446 },\
-    { "task_register_dyld_shared_cache_image_info", 3447 },\
-    { "task_register_dyld_set_dyld_state", 3448 },\
-    { "task_register_dyld_get_process_state", 3449 },\
-    { "task_map_corpse_info_64", 3450 },\
-    { "task_inspect", 3451 },\
-    { "task_get_exc_guard_behavior", 3452 },\
-    { "task_set_exc_guard_behavior", 3453 },\
-    { "task_create_suid_cred", 3454 }
-#endif
-
-#ifdef __AfterMigUserHeader
-__AfterMigUserHeader
-#endif /* __AfterMigUserHeader */
-
-#endif	 /* _task_user_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/mach/task_info.h b/lib/libc/include/x86_64-macos-gnu/mach/task_info.h
deleted file mode 100644
index 5b2046a700..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/mach/task_info.h
+++ /dev/null
@@ -1,478 +0,0 @@
-/*
- * Copyright (c) 2000-2007, 2015 Apple Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-/*
- * @OSF_COPYRIGHT@
- */
-/*
- * Mach Operating System
- * Copyright (c) 1991,1990,1989,1988,1987 Carnegie Mellon University
- * All Rights Reserved.
- *
- * Permission to use, copy, modify and distribute this software and its
- * documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
- * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie Mellon
- * the rights to redistribute these changes.
- */
-/*
- *	Machine-independent task information structures and definitions.
- *
- *	The definitions in this file are exported to the user.  The kernel
- *	will translate its internal data structures to these structures
- *	as appropriate.
- *
- */
-
-#ifndef _MACH_TASK_INFO_H_
-#define _MACH_TASK_INFO_H_
-
-#include <mach/message.h>
-#include <mach/machine/vm_types.h>
-#include <mach/time_value.h>
-#include <mach/policy.h>
-#include <mach/vm_statistics.h> /* for vm_extmod_statistics_data_t */
-#include <Availability.h>
-
-#include <sys/cdefs.h>
-
-/*
- *	Generic information structure to allow for expansion.
- */
-typedef natural_t       task_flavor_t;
-typedef integer_t       *task_info_t;           /* varying array of int */
-
-/* Deprecated, use per structure _data_t's instead */
-#define TASK_INFO_MAX   (1024)          /* maximum array size */
-typedef integer_t       task_info_data_t[TASK_INFO_MAX];
-
-/*
- *	Currently defined information structures.
- */
-
-#pragma pack(push, 4)
-
-/* Don't use this, use MACH_TASK_BASIC_INFO instead */
-#define TASK_BASIC_INFO_32      4       /* basic information */
-#define TASK_BASIC2_INFO_32      6
-
-struct task_basic_info_32 {
-	integer_t       suspend_count;  /* suspend count for task */
-	natural_t       virtual_size;   /* virtual memory size (bytes) */
-	natural_t       resident_size;  /* resident memory size (bytes) */
-	time_value_t    user_time;      /* total user run time for
-	                                 *  terminated threads */
-	time_value_t    system_time;    /* total system run time for
-	                                 *  terminated threads */
-	policy_t        policy;         /* default policy for new threads */
-};
-typedef struct task_basic_info_32       task_basic_info_32_data_t;
-typedef struct task_basic_info_32       *task_basic_info_32_t;
-#define TASK_BASIC_INFO_32_COUNT   \
-	        (sizeof(task_basic_info_32_data_t) / sizeof(natural_t))
-
-/* Don't use this, use MACH_TASK_BASIC_INFO instead */
-struct task_basic_info_64 {
-	integer_t       suspend_count;  /* suspend count for task */
-	mach_vm_size_t  virtual_size;   /* virtual memory size (bytes) */
-	mach_vm_size_t  resident_size;  /* resident memory size (bytes) */
-	time_value_t    user_time;      /* total user run time for
-	                                 *  terminated threads */
-	time_value_t    system_time;    /* total system run time for
-	                                 *  terminated threads */
-	policy_t        policy;         /* default policy for new threads */
-};
-typedef struct task_basic_info_64       task_basic_info_64_data_t;
-typedef struct task_basic_info_64       *task_basic_info_64_t;
-
-#define TASK_BASIC_INFO_64      5       /* 64-bit capable basic info */
-#define TASK_BASIC_INFO_64_COUNT   \
-	        (sizeof(task_basic_info_64_data_t) / sizeof(natural_t))
-
-
-/* localized structure - cannot be safely passed between tasks of differing sizes */
-/* Don't use this, use MACH_TASK_BASIC_INFO instead */
-struct task_basic_info {
-	integer_t       suspend_count;  /* suspend count for task */
-	vm_size_t       virtual_size;   /* virtual memory size (bytes) */
-	vm_size_t       resident_size;  /* resident memory size (bytes) */
-	time_value_t    user_time;      /* total user run time for
-	                                 *  terminated threads */
-	time_value_t    system_time;    /* total system run time for
-	                                 *  terminated threads */
-	policy_t        policy;         /* default policy for new threads */
-};
-
-typedef struct task_basic_info          task_basic_info_data_t;
-typedef struct task_basic_info          *task_basic_info_t;
-#define TASK_BASIC_INFO_COUNT   \
-	        (sizeof(task_basic_info_data_t) / sizeof(natural_t))
-#if !defined(__LP64__)
-#define TASK_BASIC_INFO TASK_BASIC_INFO_32
-#else
-#define TASK_BASIC_INFO TASK_BASIC_INFO_64
-#endif
-
-
-
-#define TASK_EVENTS_INFO        2       /* various event counts */
-
-struct task_events_info {
-	integer_t       faults;         /* number of page faults */
-	integer_t       pageins;        /* number of actual pageins */
-	integer_t       cow_faults;     /* number of copy-on-write faults */
-	integer_t       messages_sent;  /* number of messages sent */
-	integer_t       messages_received; /* number of messages received */
-	integer_t       syscalls_mach;  /* number of mach system calls */
-	integer_t       syscalls_unix;  /* number of unix system calls */
-	integer_t       csw;            /* number of context switches */
-};
-typedef struct task_events_info         task_events_info_data_t;
-typedef struct task_events_info         *task_events_info_t;
-#define TASK_EVENTS_INFO_COUNT          ((mach_msg_type_number_t) \
-	        (sizeof(task_events_info_data_t) / sizeof(natural_t)))
-
-#define TASK_THREAD_TIMES_INFO  3       /* total times for live threads -
-	                                 *  only accurate if suspended */
-
-struct task_thread_times_info {
-	time_value_t    user_time;      /* total user run time for
-	                                 *  live threads */
-	time_value_t    system_time;    /* total system run time for
-	                                 *  live threads */
-};
-
-typedef struct task_thread_times_info   task_thread_times_info_data_t;
-typedef struct task_thread_times_info   *task_thread_times_info_t;
-#define TASK_THREAD_TIMES_INFO_COUNT    ((mach_msg_type_number_t) \
-	        (sizeof(task_thread_times_info_data_t) / sizeof(natural_t)))
-
-#define TASK_ABSOLUTETIME_INFO  1
-
-struct task_absolutetime_info {
-	uint64_t                total_user;
-	uint64_t                total_system;
-	uint64_t                threads_user;   /* existing threads only */
-	uint64_t                threads_system;
-};
-
-typedef struct task_absolutetime_info   task_absolutetime_info_data_t;
-typedef struct task_absolutetime_info   *task_absolutetime_info_t;
-#define TASK_ABSOLUTETIME_INFO_COUNT    ((mach_msg_type_number_t) \
-	        (sizeof (task_absolutetime_info_data_t) / sizeof (natural_t)))
-
-#define TASK_KERNELMEMORY_INFO  7
-
-struct task_kernelmemory_info {
-	uint64_t                total_palloc;   /* private kernel mem alloc'ed */
-	uint64_t                total_pfree;    /* private kernel mem freed */
-	uint64_t                total_salloc;   /* shared kernel mem alloc'ed */
-	uint64_t                total_sfree;    /* shared kernel mem freed */
-};
-
-typedef struct task_kernelmemory_info   task_kernelmemory_info_data_t;
-typedef struct task_kernelmemory_info   *task_kernelmemory_info_t;
-#define TASK_KERNELMEMORY_INFO_COUNT    ((mach_msg_type_number_t) \
-	        (sizeof (task_kernelmemory_info_data_t) / sizeof (natural_t)))
-
-#define TASK_SECURITY_TOKEN             13
-#define TASK_SECURITY_TOKEN_COUNT       ((mach_msg_type_number_t) \
-	        (sizeof(security_token_t) / sizeof(natural_t)))
-
-#define TASK_AUDIT_TOKEN                15
-#define TASK_AUDIT_TOKEN_COUNT  \
-	        (sizeof(audit_token_t) / sizeof(natural_t))
-
-
-#define TASK_AFFINITY_TAG_INFO          16      /* This is experimental. */
-
-struct task_affinity_tag_info {
-	integer_t               set_count;
-	integer_t               min;
-	integer_t               max;
-	integer_t               task_count;
-};
-typedef struct task_affinity_tag_info   task_affinity_tag_info_data_t;
-typedef struct task_affinity_tag_info   *task_affinity_tag_info_t;
-#define TASK_AFFINITY_TAG_INFO_COUNT    \
-	        (sizeof(task_affinity_tag_info_data_t) / sizeof(natural_t))
-
-#define TASK_DYLD_INFO                  17
-
-struct task_dyld_info {
-	mach_vm_address_t       all_image_info_addr;
-	mach_vm_size_t          all_image_info_size;
-	integer_t               all_image_info_format;
-};
-typedef struct task_dyld_info   task_dyld_info_data_t;
-typedef struct task_dyld_info   *task_dyld_info_t;
-#define TASK_DYLD_INFO_COUNT    \
-	        (sizeof(task_dyld_info_data_t) / sizeof(natural_t))
-#define TASK_DYLD_ALL_IMAGE_INFO_32     0       /* format value */
-#define TASK_DYLD_ALL_IMAGE_INFO_64     1       /* format value */
-
-
-#define TASK_EXTMOD_INFO                        19
-
-struct task_extmod_info {
-	unsigned char   task_uuid[16];
-	vm_extmod_statistics_data_t             extmod_statistics;
-};
-typedef struct task_extmod_info task_extmod_info_data_t;
-typedef struct task_extmod_info *task_extmod_info_t;
-#define TASK_EXTMOD_INFO_COUNT  \
-	        (sizeof(task_extmod_info_data_t) / sizeof(natural_t))
-
-
-#define MACH_TASK_BASIC_INFO     20         /* always 64-bit basic info */
-struct mach_task_basic_info {
-	mach_vm_size_t  virtual_size;       /* virtual memory size (bytes) */
-	mach_vm_size_t  resident_size;      /* resident memory size (bytes) */
-	mach_vm_size_t  resident_size_max;  /* maximum resident memory size (bytes) */
-	time_value_t    user_time;          /* total user run time for
-	                                     *  terminated threads */
-	time_value_t    system_time;        /* total system run time for
-	                                     *  terminated threads */
-	policy_t        policy;             /* default policy for new threads */
-	integer_t       suspend_count;      /* suspend count for task */
-};
-typedef struct mach_task_basic_info       mach_task_basic_info_data_t;
-typedef struct mach_task_basic_info       *mach_task_basic_info_t;
-#define MACH_TASK_BASIC_INFO_COUNT   \
-	        (sizeof(mach_task_basic_info_data_t) / sizeof(natural_t))
-
-
-#define TASK_POWER_INFO 21
-
-struct task_power_info {
-	uint64_t                total_user;
-	uint64_t                total_system;
-	uint64_t                task_interrupt_wakeups;
-	uint64_t                task_platform_idle_wakeups;
-	uint64_t                task_timer_wakeups_bin_1;
-	uint64_t                task_timer_wakeups_bin_2;
-};
-
-typedef struct task_power_info  task_power_info_data_t;
-typedef struct task_power_info  *task_power_info_t;
-#define TASK_POWER_INFO_COUNT   ((mach_msg_type_number_t) \
-	        (sizeof (task_power_info_data_t) / sizeof (natural_t)))
-
-
-
-#define TASK_VM_INFO            22
-#define TASK_VM_INFO_PURGEABLE  23
-struct task_vm_info {
-	mach_vm_size_t  virtual_size;       /* virtual memory size (bytes) */
-	integer_t       region_count;       /* number of memory regions */
-	integer_t       page_size;
-	mach_vm_size_t  resident_size;      /* resident memory size (bytes) */
-	mach_vm_size_t  resident_size_peak; /* peak resident size (bytes) */
-
-	mach_vm_size_t  device;
-	mach_vm_size_t  device_peak;
-	mach_vm_size_t  internal;
-	mach_vm_size_t  internal_peak;
-	mach_vm_size_t  external;
-	mach_vm_size_t  external_peak;
-	mach_vm_size_t  reusable;
-	mach_vm_size_t  reusable_peak;
-	mach_vm_size_t  purgeable_volatile_pmap;
-	mach_vm_size_t  purgeable_volatile_resident;
-	mach_vm_size_t  purgeable_volatile_virtual;
-	mach_vm_size_t  compressed;
-	mach_vm_size_t  compressed_peak;
-	mach_vm_size_t  compressed_lifetime;
-
-	/* added for rev1 */
-	mach_vm_size_t  phys_footprint;
-
-	/* added for rev2 */
-	mach_vm_address_t       min_address;
-	mach_vm_address_t       max_address;
-
-	/* added for rev3 */
-	int64_t ledger_phys_footprint_peak;
-	int64_t ledger_purgeable_nonvolatile;
-	int64_t ledger_purgeable_novolatile_compressed;
-	int64_t ledger_purgeable_volatile;
-	int64_t ledger_purgeable_volatile_compressed;
-	int64_t ledger_tag_network_nonvolatile;
-	int64_t ledger_tag_network_nonvolatile_compressed;
-	int64_t ledger_tag_network_volatile;
-	int64_t ledger_tag_network_volatile_compressed;
-	int64_t ledger_tag_media_footprint;
-	int64_t ledger_tag_media_footprint_compressed;
-	int64_t ledger_tag_media_nofootprint;
-	int64_t ledger_tag_media_nofootprint_compressed;
-	int64_t ledger_tag_graphics_footprint;
-	int64_t ledger_tag_graphics_footprint_compressed;
-	int64_t ledger_tag_graphics_nofootprint;
-	int64_t ledger_tag_graphics_nofootprint_compressed;
-	int64_t ledger_tag_neural_footprint;
-	int64_t ledger_tag_neural_footprint_compressed;
-	int64_t ledger_tag_neural_nofootprint;
-	int64_t ledger_tag_neural_nofootprint_compressed;
-
-	/* added for rev4 */
-	uint64_t limit_bytes_remaining;
-
-	/* added for rev5 */
-	integer_t decompressions;
-};
-typedef struct task_vm_info     task_vm_info_data_t;
-typedef struct task_vm_info     *task_vm_info_t;
-#define TASK_VM_INFO_COUNT      ((mach_msg_type_number_t) \
-	        (sizeof (task_vm_info_data_t) / sizeof (natural_t)))
-#define TASK_VM_INFO_REV5_COUNT TASK_VM_INFO_COUNT
-#define TASK_VM_INFO_REV4_COUNT /* doesn't include decompressions */ \
-	((mach_msg_type_number_t) (TASK_VM_INFO_REV5_COUNT - 1))
-#define TASK_VM_INFO_REV3_COUNT /* doesn't include limit bytes */ \
-	((mach_msg_type_number_t) (TASK_VM_INFO_REV4_COUNT - 2))
-#define TASK_VM_INFO_REV2_COUNT /* doesn't include extra ledgers info */ \
-	((mach_msg_type_number_t) (TASK_VM_INFO_REV3_COUNT - 42))
-#define TASK_VM_INFO_REV1_COUNT /* doesn't include min and max address */ \
-	((mach_msg_type_number_t) (TASK_VM_INFO_REV2_COUNT - 4))
-#define TASK_VM_INFO_REV0_COUNT /* doesn't include phys_footprint */ \
-	((mach_msg_type_number_t) (TASK_VM_INFO_REV1_COUNT - 2))
-
-typedef struct vm_purgeable_info        task_purgable_info_t;
-
-
-#define TASK_TRACE_MEMORY_INFO  24
-struct task_trace_memory_info {
-	uint64_t  user_memory_address;  /* address of start of trace memory buffer */
-	uint64_t  buffer_size;                  /* size of buffer in bytes */
-	uint64_t  mailbox_array_size;   /* size of mailbox area in bytes */
-};
-typedef struct task_trace_memory_info task_trace_memory_info_data_t;
-typedef struct task_trace_memory_info * task_trace_memory_info_t;
-#define TASK_TRACE_MEMORY_INFO_COUNT  ((mach_msg_type_number_t) \
-	        (sizeof(task_trace_memory_info_data_t) / sizeof(natural_t)))
-
-#define TASK_WAIT_STATE_INFO  25    /* deprecated. */
-struct task_wait_state_info {
-	uint64_t  total_wait_state_time;        /* Time that all threads past and present have been in a wait state */
-	uint64_t  total_wait_sfi_state_time;    /* Time that threads have been in SFI wait (should be a subset of total wait state time */
-	uint32_t  _reserved[4];
-};
-typedef struct task_wait_state_info task_wait_state_info_data_t;
-typedef struct task_wait_state_info * task_wait_state_info_t;
-#define TASK_WAIT_STATE_INFO_COUNT  ((mach_msg_type_number_t) \
-	        (sizeof(task_wait_state_info_data_t) / sizeof(natural_t)))
-
-#define TASK_POWER_INFO_V2      26
-
-typedef struct {
-	uint64_t                task_gpu_utilisation;
-	uint64_t                task_gpu_stat_reserved0;
-	uint64_t                task_gpu_stat_reserved1;
-	uint64_t                task_gpu_stat_reserved2;
-} gpu_energy_data;
-
-typedef gpu_energy_data *gpu_energy_data_t;
-struct task_power_info_v2 {
-	task_power_info_data_t  cpu_energy;
-	gpu_energy_data gpu_energy;
-	uint64_t                task_ptime;
-	uint64_t                task_pset_switches;
-};
-
-typedef struct task_power_info_v2       task_power_info_v2_data_t;
-typedef struct task_power_info_v2       *task_power_info_v2_t;
-#define TASK_POWER_INFO_V2_COUNT_OLD    \
-	        ((mach_msg_type_number_t) (sizeof (task_power_info_v2_data_t) - sizeof(uint64_t)*2) / sizeof (natural_t))
-#define TASK_POWER_INFO_V2_COUNT        \
-	        ((mach_msg_type_number_t) (sizeof (task_power_info_v2_data_t) / sizeof (natural_t)))
-
-#define TASK_VM_INFO_PURGEABLE_ACCOUNT 27 /* Used for xnu purgeable vm unit tests */
-
-
-#define TASK_FLAGS_INFO  28                     /* return t_flags field */
-struct task_flags_info {
-	uint32_t        flags;                          /* task flags */
-};
-typedef struct task_flags_info task_flags_info_data_t;
-typedef struct task_flags_info * task_flags_info_t;
-#define TASK_FLAGS_INFO_COUNT  ((mach_msg_type_number_t) \
-	        (sizeof(task_flags_info_data_t) / sizeof (natural_t)))
-
-#define TF_LP64         0x00000001 /* task has 64-bit addressing */
-#define TF_64B_DATA     0x00000002 /* task has 64-bit data registers */
-
-#define TASK_DEBUG_INFO_INTERNAL    29 /* Used for kernel internal development tests. */
-
-
-/*
- * Type to control EXC_GUARD delivery options for a task
- * via task_get/set_exc_guard_behavior interface(s).
- */
-typedef uint32_t task_exc_guard_behavior_t;
-
-/* EXC_GUARD optional delivery settings on a per-task basis */
-#define TASK_EXC_GUARD_VM_DELIVER            0x01 /* Deliver virtual memory EXC_GUARD exceptions */
-#define TASK_EXC_GUARD_VM_ONCE               0x02 /* Deliver them only once */
-#define TASK_EXC_GUARD_VM_CORPSE             0x04 /* Deliver them via a forked corpse */
-#define TASK_EXC_GUARD_VM_FATAL              0x08 /* Virtual Memory EXC_GUARD delivery is fatal */
-#define TASK_EXC_GUARD_VM_ALL                0x0f
-
-#define TASK_EXC_GUARD_MP_DELIVER            0x10 /* Deliver mach port EXC_GUARD exceptions */
-#define TASK_EXC_GUARD_MP_ONCE               0x20 /* Deliver them only once */
-#define TASK_EXC_GUARD_MP_CORPSE             0x40 /* Deliver them via a forked corpse */
-#define TASK_EXC_GUARD_MP_FATAL              0x80 /* mach port EXC_GUARD delivery is fatal */
-#define TASK_EXC_GUARD_MP_ALL                0xf0
-
-#define TASK_EXC_GUARD_ALL                   0xff /* All optional deliver settings */
-
-
-/*
- * Obsolete interfaces.
- */
-
-#define TASK_SCHED_TIMESHARE_INFO       10
-#define TASK_SCHED_RR_INFO              11
-#define TASK_SCHED_FIFO_INFO            12
-
-#define TASK_SCHED_INFO                 14
-
-#pragma pack(pop)
-
-#endif  /* _MACH_TASK_INFO_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/mach/task_policy.h b/lib/libc/include/x86_64-macos-gnu/mach/task_policy.h
deleted file mode 100644
index 4b6d3f9449..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/mach/task_policy.h
+++ /dev/null
@@ -1,189 +0,0 @@
-/*
- * Copyright (c) 2000-2005 Apple Computer, Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-
-#ifndef _MACH_TASK_POLICY_H_
-#define _MACH_TASK_POLICY_H_
-
-#include <mach/mach_types.h>
-
-/*
- * These are the calls for accessing the policy parameters
- * of a particular task.
- *
- * The extra 'get_default' parameter to the second call is
- * IN/OUT as follows:
- * 1) if asserted on the way in it indicates that the default
- * values should be returned, not the ones currently set, in
- * this case 'get_default' will always be asserted on return;
- * 2) if unasserted on the way in, the current settings are
- * desired and if still unasserted on return, then the info
- * returned reflects the current settings, otherwise if
- * 'get_default' returns asserted, it means that there are no
- * current settings due to other parameters taking precedence,
- * and the default ones are being returned instead.
- */
-
-typedef natural_t       task_policy_flavor_t;
-typedef integer_t       *task_policy_t;
-
-/*
- *  kern_return_t	task_policy_set(
- *                                       task_t					task,
- *                                       task_policy_flavor_t	flavor,
- *                                       task_policy_t			policy_info,
- *                                       mach_msg_type_number_t	count);
- *
- *  kern_return_t	task_policy_get(
- *                                       task_t					task,
- *                                       task_policy_flavor_t	flavor,
- *                                       task_policy_t			policy_info,
- *                                       mach_msg_type_number_t	*count,
- *                                       boolean_t				*get_default);
- */
-
-/*
- * Defined flavors.
- */
-/*
- * TASK_CATEGORY_POLICY:
- *
- * This provides information to the kernel about the role
- * of the task in the system.
- *
- * Parameters:
- *
- * role: Enumerated as follows:
- *
- * TASK_UNSPECIFIED is the default, since the role is not
- * inherited from the parent.
- *
- * TASK_FOREGROUND_APPLICATION should be assigned when the
- * task is a normal UI application in the foreground from
- * the HI point of view.
- * **N.B. There may be more than one of these at a given time.
- *
- * TASK_BACKGROUND_APPLICATION should be assigned when the
- * task is a normal UI application in the background from
- * the HI point of view.
- *
- * TASK_CONTROL_APPLICATION should be assigned to the unique
- * UI application which implements the pop-up application dialog.
- * There can only be one task at a time with this designation,
- * which is assigned FCFS.
- *
- * TASK_GRAPHICS_SERVER should be assigned to the graphics
- * management (window) server.  There can only be one task at
- * a time with this designation, which is assigned FCFS.
- */
-
-#define TASK_CATEGORY_POLICY            1
-
-#define TASK_SUPPRESSION_POLICY         3
-#define TASK_POLICY_STATE               4
-#define TASK_BASE_QOS_POLICY            8
-#define TASK_OVERRIDE_QOS_POLICY        9
-#define TASK_BASE_LATENCY_QOS_POLICY    10
-#define TASK_BASE_THROUGHPUT_QOS_POLICY 11
-
-
-enum task_role {
-	TASK_RENICED                    = -1,
-	TASK_UNSPECIFIED                = 0,
-	TASK_FOREGROUND_APPLICATION     = 1,
-	TASK_BACKGROUND_APPLICATION     = 2,
-	TASK_CONTROL_APPLICATION        = 3,
-	TASK_GRAPHICS_SERVER            = 4,
-	TASK_THROTTLE_APPLICATION       = 5,
-	TASK_NONUI_APPLICATION          = 6,
-	TASK_DEFAULT_APPLICATION        = 7,
-	TASK_DARWINBG_APPLICATION       = 8,
-};
-
-typedef integer_t       task_role_t;
-
-struct task_category_policy {
-	task_role_t             role;
-};
-
-typedef struct task_category_policy             task_category_policy_data_t;
-typedef struct task_category_policy             *task_category_policy_t;
-
-#define TASK_CATEGORY_POLICY_COUNT      ((mach_msg_type_number_t) \
-	(sizeof (task_category_policy_data_t) / sizeof (integer_t)))
-
-
-enum task_latency_qos {
-	LATENCY_QOS_TIER_UNSPECIFIED = 0x0,
-	LATENCY_QOS_TIER_0 = ((0xFF << 16) | 1),
-	LATENCY_QOS_TIER_1 = ((0xFF << 16) | 2),
-	LATENCY_QOS_TIER_2 = ((0xFF << 16) | 3),
-	LATENCY_QOS_TIER_3 = ((0xFF << 16) | 4),
-	LATENCY_QOS_TIER_4 = ((0xFF << 16) | 5),
-	LATENCY_QOS_TIER_5 = ((0xFF << 16) | 6)
-};
-typedef integer_t       task_latency_qos_t;
-enum task_throughput_qos {
-	THROUGHPUT_QOS_TIER_UNSPECIFIED = 0x0,
-	THROUGHPUT_QOS_TIER_0 = ((0xFE << 16) | 1),
-	THROUGHPUT_QOS_TIER_1 = ((0xFE << 16) | 2),
-	THROUGHPUT_QOS_TIER_2 = ((0xFE << 16) | 3),
-	THROUGHPUT_QOS_TIER_3 = ((0xFE << 16) | 4),
-	THROUGHPUT_QOS_TIER_4 = ((0xFE << 16) | 5),
-	THROUGHPUT_QOS_TIER_5 = ((0xFE << 16) | 6),
-};
-
-#define LATENCY_QOS_LAUNCH_DEFAULT_TIER LATENCY_QOS_TIER_3
-#define THROUGHPUT_QOS_LAUNCH_DEFAULT_TIER THROUGHPUT_QOS_TIER_3
-
-typedef integer_t       task_throughput_qos_t;
-
-struct task_qos_policy {
-	task_latency_qos_t task_latency_qos_tier;
-	task_throughput_qos_t task_throughput_qos_tier;
-};
-
-typedef struct task_qos_policy *task_qos_policy_t;
-#define TASK_QOS_POLICY_COUNT   ((mach_msg_type_number_t) \
-	(sizeof (struct task_qos_policy) / sizeof (integer_t)))
-
-/* These should be removed - they belong in proc_info.h */
-#define PROC_FLAG_DARWINBG           0x8000    /* process in darwin background */
-#define PROC_FLAG_EXT_DARWINBG           0x10000   /* process in darwin background - external enforcement */
-#define PROC_FLAG_IOS_APPLEDAEMON    0x20000   /* process is apple ios daemon */
-#define PROC_FLAG_IOS_IMPPROMOTION   0x80000   /* process is apple ios daemon */
-#define PROC_FLAG_ADAPTIVE           0x100000  /* Process is adaptive */
-#define PROC_FLAG_ADAPTIVE_IMPORTANT 0x200000  /* Process is adaptive, and is currently important */
-#define PROC_FLAG_IMPORTANCE_DONOR   0x400000  /* Process is marked as an importance donor */
-#define PROC_FLAG_SUPPRESSED         0x800000  /* Process is suppressed */
-#define PROC_FLAG_APPLICATION        0x1000000 /* Process is an application */
-#define PROC_FLAG_IOS_APPLICATION PROC_FLAG_APPLICATION /* Process is an application */
-
-
-
-
-#endif  /* _MACH_TASK_POLICY_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/mach/task_special_ports.h b/lib/libc/include/x86_64-macos-gnu/mach/task_special_ports.h
deleted file mode 100644
index f8ee7c2bbf..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/mach/task_special_ports.h
+++ /dev/null
@@ -1,132 +0,0 @@
-/*
- * Copyright (c) 2000-2010 Apple Computer, Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-/*
- * @OSF_COPYRIGHT@
- */
-/*
- * Mach Operating System
- * Copyright (c) 1991,1990,1989,1988,1987 Carnegie Mellon University
- * All Rights Reserved.
- *
- * Permission to use, copy, modify and distribute this software and its
- * documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
- * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie Mellon
- * the rights to redistribute these changes.
- */
-/*
- */
-/*
- *	File:	mach/task_special_ports.h
- *
- *	Defines codes for special_purpose task ports.  These are NOT
- *	port identifiers - they are only used for the task_get_special_port
- *	and task_set_special_port routines.
- *
- */
-
-#ifndef _MACH_TASK_SPECIAL_PORTS_H_
-#define _MACH_TASK_SPECIAL_PORTS_H_
-
-typedef int     task_special_port_t;
-
-#define TASK_KERNEL_PORT        1       /* Represents task to the outside
-	                                 *  world.*/
-
-#define TASK_HOST_PORT          2       /* The host (priv) port for task.  */
-
-#define TASK_NAME_PORT          3       /* the name (unpriv) port for task */
-
-#define TASK_BOOTSTRAP_PORT     4       /* Bootstrap environment for task. */
-
-/*
- * Evolving and likely to change.
- */
-
-#define TASK_SEATBELT_PORT      7       /* Seatbelt compiler/DEM port for task. */
-
-/* PORT 8 was the GSSD TASK PORT which transformed to a host port */
-
-#define TASK_ACCESS_PORT        9       /* Permission check for task_for_pid. */
-
-#define TASK_DEBUG_CONTROL_PORT 10      /* debug control port */
-
-#define TASK_RESOURCE_NOTIFY_PORT   11  /* overrides host special RN port */
-
-#define TASK_MAX_SPECIAL_PORT TASK_RESOURCE_NOTIFY_PORT
-
-/*
- *	Definitions for ease of use
- */
-
-#define task_get_kernel_port(task, port)        \
-	        (task_get_special_port((task), TASK_KERNEL_PORT, (port)))
-
-#define task_set_kernel_port(task, port)        \
-	        (task_set_special_port((task), TASK_KERNEL_PORT, (port)))
-
-#define task_get_host_port(task, port)          \
-	        (task_get_special_port((task), TASK_HOST_PORT, (port)))
-
-#define task_set_host_port(task, port)  \
-	        (task_set_special_port((task), TASK_HOST_PORT, (port)))
-
-#define task_get_bootstrap_port(task, port)     \
-	        (task_get_special_port((task), TASK_BOOTSTRAP_PORT, (port)))
-
-#define task_get_debug_control_port(task, port) \
-	        (task_get_special_port((task), TASK_DEBUG_CONTROL_PORT, (port)))
-
-#define task_set_bootstrap_port(task, port)     \
-	        (task_set_special_port((task), TASK_BOOTSTRAP_PORT, (port)))
-
-#define task_get_task_access_port(task, port)   \
-	        (task_get_special_port((task), TASK_ACCESS_PORT, (port)))
-
-#define task_set_task_access_port(task, port)   \
-	        (task_set_special_port((task), TASK_ACCESS_PORT, (port)))
-
-#define task_set_task_debug_control_port(task, port) \
-	        (task_set_special_port((task), TASK_DEBUG_CONTROL_PORT, (port)))
-
-
-#endif  /* _MACH_TASK_SPECIAL_PORTS_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/mach/thread_act.h b/lib/libc/include/x86_64-macos-gnu/mach/thread_act.h
deleted file mode 100644
index 88561082cd..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/mach/thread_act.h
+++ /dev/null
@@ -1,1336 +0,0 @@
-#ifndef	_thread_act_user_
-#define	_thread_act_user_
-
-/* Module thread_act */
-
-#include <string.h>
-#include <mach/ndr.h>
-#include <mach/boolean.h>
-#include <mach/kern_return.h>
-#include <mach/notify.h>
-#include <mach/mach_types.h>
-#include <mach/message.h>
-#include <mach/mig_errors.h>
-#include <mach/port.h>
-	
-/* BEGIN MIG_STRNCPY_ZEROFILL CODE */
-
-#if defined(__has_include)
-#if __has_include(<mach/mig_strncpy_zerofill_support.h>)
-#ifndef USING_MIG_STRNCPY_ZEROFILL
-#define USING_MIG_STRNCPY_ZEROFILL
-#endif
-#ifndef __MIG_STRNCPY_ZEROFILL_FORWARD_TYPE_DECLS__
-#define __MIG_STRNCPY_ZEROFILL_FORWARD_TYPE_DECLS__
-#ifdef __cplusplus
-extern "C" {
-#endif
-	extern int mig_strncpy_zerofill(char *dest, const char *src, int len) __attribute__((weak_import));
-#ifdef __cplusplus
-}
-#endif
-#endif /* __MIG_STRNCPY_ZEROFILL_FORWARD_TYPE_DECLS__ */
-#endif /* __has_include(<mach/mig_strncpy_zerofill_support.h>) */
-#endif /* __has_include */
-	
-/* END MIG_STRNCPY_ZEROFILL CODE */
-
-
-#ifdef AUTOTEST
-#ifndef FUNCTION_PTR_T
-#define FUNCTION_PTR_T
-typedef void (*function_ptr_t)(mach_port_t, char *, mach_msg_type_number_t);
-typedef struct {
-        char            *name;
-        function_ptr_t  function;
-} function_table_entry;
-typedef function_table_entry   *function_table_t;
-#endif /* FUNCTION_PTR_T */
-#endif /* AUTOTEST */
-
-#ifndef	thread_act_MSG_COUNT
-#define	thread_act_MSG_COUNT	28
-#endif	/* thread_act_MSG_COUNT */
-
-#include <mach/std_types.h>
-#include <mach/mig.h>
-#include <mach/mig.h>
-#include <mach/mach_types.h>
-
-#ifdef __BeforeMigUserHeader
-__BeforeMigUserHeader
-#endif /* __BeforeMigUserHeader */
-
-#include <sys/cdefs.h>
-__BEGIN_DECLS
-
-
-/* Routine thread_terminate */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-__WATCHOS_PROHIBITED
-__TVOS_PROHIBITED
-kern_return_t thread_terminate
-(
-	thread_act_t target_act
-);
-
-/* Routine act_get_state */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-__WATCHOS_PROHIBITED
-__TVOS_PROHIBITED
-kern_return_t act_get_state
-(
-	thread_act_t target_act,
-	int flavor,
-	thread_state_t old_state,
-	mach_msg_type_number_t *old_stateCnt
-);
-
-/* Routine act_set_state */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-__WATCHOS_PROHIBITED
-__TVOS_PROHIBITED
-kern_return_t act_set_state
-(
-	thread_act_t target_act,
-	int flavor,
-	thread_state_t new_state,
-	mach_msg_type_number_t new_stateCnt
-);
-
-/* Routine thread_get_state */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-__WATCHOS_PROHIBITED
-kern_return_t thread_get_state
-(
-	thread_act_t target_act,
-	thread_state_flavor_t flavor,
-	thread_state_t old_state,
-	mach_msg_type_number_t *old_stateCnt
-);
-
-/* Routine thread_set_state */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-__WATCHOS_PROHIBITED
-kern_return_t thread_set_state
-(
-	thread_act_t target_act,
-	thread_state_flavor_t flavor,
-	thread_state_t new_state,
-	mach_msg_type_number_t new_stateCnt
-);
-
-/* Routine thread_suspend */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-__WATCHOS_PROHIBITED
-kern_return_t thread_suspend
-(
-	thread_act_t target_act
-);
-
-/* Routine thread_resume */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-__WATCHOS_PROHIBITED
-kern_return_t thread_resume
-(
-	thread_act_t target_act
-);
-
-/* Routine thread_abort */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-__WATCHOS_PROHIBITED
-kern_return_t thread_abort
-(
-	thread_act_t target_act
-);
-
-/* Routine thread_abort_safely */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-__WATCHOS_PROHIBITED
-kern_return_t thread_abort_safely
-(
-	thread_act_t target_act
-);
-
-/* Routine thread_depress_abort */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-__WATCHOS_PROHIBITED
-__TVOS_PROHIBITED
-kern_return_t thread_depress_abort
-(
-	thread_act_t thread
-);
-
-/* Routine thread_get_special_port */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-__WATCHOS_PROHIBITED
-__TVOS_PROHIBITED
-kern_return_t thread_get_special_port
-(
-	thread_act_t thr_act,
-	int which_port,
-	mach_port_t *special_port
-);
-
-/* Routine thread_set_special_port */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-__WATCHOS_PROHIBITED
-__TVOS_PROHIBITED
-kern_return_t thread_set_special_port
-(
-	thread_act_t thr_act,
-	int which_port,
-	mach_port_t special_port
-);
-
-/* Routine thread_info */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t thread_info
-(
-	thread_inspect_t target_act,
-	thread_flavor_t flavor,
-	thread_info_t thread_info_out,
-	mach_msg_type_number_t *thread_info_outCnt
-);
-
-/* Routine thread_set_exception_ports */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-__WATCHOS_PROHIBITED
-__TVOS_PROHIBITED
-kern_return_t thread_set_exception_ports
-(
-	thread_act_t thread,
-	exception_mask_t exception_mask,
-	mach_port_t new_port,
-	exception_behavior_t behavior,
-	thread_state_flavor_t new_flavor
-);
-
-/* Routine thread_get_exception_ports */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-__WATCHOS_PROHIBITED
-__TVOS_PROHIBITED
-kern_return_t thread_get_exception_ports
-(
-	thread_inspect_t thread,
-	exception_mask_t exception_mask,
-	exception_mask_array_t masks,
-	mach_msg_type_number_t *masksCnt,
-	exception_handler_array_t old_handlers,
-	exception_behavior_array_t old_behaviors,
-	exception_flavor_array_t old_flavors
-);
-
-/* Routine thread_swap_exception_ports */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-__WATCHOS_PROHIBITED
-__TVOS_PROHIBITED
-kern_return_t thread_swap_exception_ports
-(
-	thread_act_t thread,
-	exception_mask_t exception_mask,
-	mach_port_t new_port,
-	exception_behavior_t behavior,
-	thread_state_flavor_t new_flavor,
-	exception_mask_array_t masks,
-	mach_msg_type_number_t *masksCnt,
-	exception_handler_array_t old_handlers,
-	exception_behavior_array_t old_behaviors,
-	exception_flavor_array_t old_flavors
-);
-
-/* Routine thread_policy */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t thread_policy
-(
-	thread_act_t thr_act,
-	policy_t policy,
-	policy_base_t base,
-	mach_msg_type_number_t baseCnt,
-	boolean_t set_limit
-);
-
-/* Routine thread_policy_set */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t thread_policy_set
-(
-	thread_act_t thread,
-	thread_policy_flavor_t flavor,
-	thread_policy_t policy_info,
-	mach_msg_type_number_t policy_infoCnt
-);
-
-/* Routine thread_policy_get */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t thread_policy_get
-(
-	thread_inspect_t thread,
-	thread_policy_flavor_t flavor,
-	thread_policy_t policy_info,
-	mach_msg_type_number_t *policy_infoCnt,
-	boolean_t *get_default
-);
-
-/* Routine thread_sample */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t thread_sample
-(
-	thread_act_t thread,
-	mach_port_t reply
-);
-
-/* Routine etap_trace_thread */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t etap_trace_thread
-(
-	thread_act_t target_act,
-	boolean_t trace_status
-);
-
-/* Routine thread_assign */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t thread_assign
-(
-	thread_act_t thread,
-	processor_set_t new_set
-);
-
-/* Routine thread_assign_default */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t thread_assign_default
-(
-	thread_act_t thread
-);
-
-/* Routine thread_get_assignment */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t thread_get_assignment
-(
-	thread_act_t thread,
-	processor_set_name_t *assigned_set
-);
-
-/* Routine thread_set_policy */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t thread_set_policy
-(
-	thread_act_t thr_act,
-	processor_set_t pset,
-	policy_t policy,
-	policy_base_t base,
-	mach_msg_type_number_t baseCnt,
-	policy_limit_t limit,
-	mach_msg_type_number_t limitCnt
-);
-
-/* Routine thread_get_mach_voucher */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-__WATCHOS_PROHIBITED
-__TVOS_PROHIBITED
-kern_return_t thread_get_mach_voucher
-(
-	thread_act_t thr_act,
-	mach_voucher_selector_t which,
-	ipc_voucher_t *voucher
-);
-
-/* Routine thread_set_mach_voucher */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-__WATCHOS_PROHIBITED
-__TVOS_PROHIBITED
-kern_return_t thread_set_mach_voucher
-(
-	thread_act_t thr_act,
-	ipc_voucher_t voucher
-);
-
-/* Routine thread_swap_mach_voucher */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-__WATCHOS_PROHIBITED
-__TVOS_PROHIBITED
-kern_return_t thread_swap_mach_voucher
-(
-	thread_act_t thr_act,
-	ipc_voucher_t new_voucher,
-	ipc_voucher_t *old_voucher
-);
-
-__END_DECLS
-
-/********************** Caution **************************/
-/* The following data types should be used to calculate  */
-/* maximum message sizes only. The actual message may be */
-/* smaller, and the position of the arguments within the */
-/* message layout may vary from what is presented here.  */
-/* For example, if any of the arguments are variable-    */
-/* sized, and less than the maximum is sent, the data    */
-/* will be packed tight in the actual message to reduce  */
-/* the presence of holes.                                */
-/********************** Caution **************************/
-
-/* typedefs for all requests */
-
-#ifndef __Request__thread_act_subsystem__defined
-#define __Request__thread_act_subsystem__defined
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-	} __Request__thread_terminate_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		int flavor;
-		mach_msg_type_number_t old_stateCnt;
-	} __Request__act_get_state_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		int flavor;
-		mach_msg_type_number_t new_stateCnt;
-		natural_t new_state[614];
-	} __Request__act_set_state_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		thread_state_flavor_t flavor;
-		mach_msg_type_number_t old_stateCnt;
-	} __Request__thread_get_state_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		thread_state_flavor_t flavor;
-		mach_msg_type_number_t new_stateCnt;
-		natural_t new_state[614];
-	} __Request__thread_set_state_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-	} __Request__thread_suspend_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-	} __Request__thread_resume_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-	} __Request__thread_abort_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-	} __Request__thread_abort_safely_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-	} __Request__thread_depress_abort_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		int which_port;
-	} __Request__thread_get_special_port_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		/* start of the kernel processed data */
-		mach_msg_body_t msgh_body;
-		mach_msg_port_descriptor_t special_port;
-		/* end of the kernel processed data */
-		NDR_record_t NDR;
-		int which_port;
-	} __Request__thread_set_special_port_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		thread_flavor_t flavor;
-		mach_msg_type_number_t thread_info_outCnt;
-	} __Request__thread_info_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		/* start of the kernel processed data */
-		mach_msg_body_t msgh_body;
-		mach_msg_port_descriptor_t new_port;
-		/* end of the kernel processed data */
-		NDR_record_t NDR;
-		exception_mask_t exception_mask;
-		exception_behavior_t behavior;
-		thread_state_flavor_t new_flavor;
-	} __Request__thread_set_exception_ports_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		exception_mask_t exception_mask;
-	} __Request__thread_get_exception_ports_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		/* start of the kernel processed data */
-		mach_msg_body_t msgh_body;
-		mach_msg_port_descriptor_t new_port;
-		/* end of the kernel processed data */
-		NDR_record_t NDR;
-		exception_mask_t exception_mask;
-		exception_behavior_t behavior;
-		thread_state_flavor_t new_flavor;
-	} __Request__thread_swap_exception_ports_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		policy_t policy;
-		mach_msg_type_number_t baseCnt;
-		integer_t base[5];
-		boolean_t set_limit;
-	} __Request__thread_policy_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		thread_policy_flavor_t flavor;
-		mach_msg_type_number_t policy_infoCnt;
-		integer_t policy_info[16];
-	} __Request__thread_policy_set_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		thread_policy_flavor_t flavor;
-		mach_msg_type_number_t policy_infoCnt;
-		boolean_t get_default;
-	} __Request__thread_policy_get_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		/* start of the kernel processed data */
-		mach_msg_body_t msgh_body;
-		mach_msg_port_descriptor_t reply;
-		/* end of the kernel processed data */
-	} __Request__thread_sample_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		boolean_t trace_status;
-	} __Request__etap_trace_thread_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		/* start of the kernel processed data */
-		mach_msg_body_t msgh_body;
-		mach_msg_port_descriptor_t new_set;
-		/* end of the kernel processed data */
-	} __Request__thread_assign_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-	} __Request__thread_assign_default_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-	} __Request__thread_get_assignment_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		/* start of the kernel processed data */
-		mach_msg_body_t msgh_body;
-		mach_msg_port_descriptor_t pset;
-		/* end of the kernel processed data */
-		NDR_record_t NDR;
-		policy_t policy;
-		mach_msg_type_number_t baseCnt;
-		integer_t base[5];
-		mach_msg_type_number_t limitCnt;
-		integer_t limit[1];
-	} __Request__thread_set_policy_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		mach_voucher_selector_t which;
-	} __Request__thread_get_mach_voucher_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		/* start of the kernel processed data */
-		mach_msg_body_t msgh_body;
-		mach_msg_port_descriptor_t voucher;
-		/* end of the kernel processed data */
-	} __Request__thread_set_mach_voucher_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		/* start of the kernel processed data */
-		mach_msg_body_t msgh_body;
-		mach_msg_port_descriptor_t new_voucher;
-		mach_msg_port_descriptor_t old_voucher;
-		/* end of the kernel processed data */
-	} __Request__thread_swap_mach_voucher_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-#endif /* !__Request__thread_act_subsystem__defined */
-
-/* union of all requests */
-
-#ifndef __RequestUnion__thread_act_subsystem__defined
-#define __RequestUnion__thread_act_subsystem__defined
-union __RequestUnion__thread_act_subsystem {
-	__Request__thread_terminate_t Request_thread_terminate;
-	__Request__act_get_state_t Request_act_get_state;
-	__Request__act_set_state_t Request_act_set_state;
-	__Request__thread_get_state_t Request_thread_get_state;
-	__Request__thread_set_state_t Request_thread_set_state;
-	__Request__thread_suspend_t Request_thread_suspend;
-	__Request__thread_resume_t Request_thread_resume;
-	__Request__thread_abort_t Request_thread_abort;
-	__Request__thread_abort_safely_t Request_thread_abort_safely;
-	__Request__thread_depress_abort_t Request_thread_depress_abort;
-	__Request__thread_get_special_port_t Request_thread_get_special_port;
-	__Request__thread_set_special_port_t Request_thread_set_special_port;
-	__Request__thread_info_t Request_thread_info;
-	__Request__thread_set_exception_ports_t Request_thread_set_exception_ports;
-	__Request__thread_get_exception_ports_t Request_thread_get_exception_ports;
-	__Request__thread_swap_exception_ports_t Request_thread_swap_exception_ports;
-	__Request__thread_policy_t Request_thread_policy;
-	__Request__thread_policy_set_t Request_thread_policy_set;
-	__Request__thread_policy_get_t Request_thread_policy_get;
-	__Request__thread_sample_t Request_thread_sample;
-	__Request__etap_trace_thread_t Request_etap_trace_thread;
-	__Request__thread_assign_t Request_thread_assign;
-	__Request__thread_assign_default_t Request_thread_assign_default;
-	__Request__thread_get_assignment_t Request_thread_get_assignment;
-	__Request__thread_set_policy_t Request_thread_set_policy;
-	__Request__thread_get_mach_voucher_t Request_thread_get_mach_voucher;
-	__Request__thread_set_mach_voucher_t Request_thread_set_mach_voucher;
-	__Request__thread_swap_mach_voucher_t Request_thread_swap_mach_voucher;
-};
-#endif /* !__RequestUnion__thread_act_subsystem__defined */
-/* typedefs for all replies */
-
-#ifndef __Reply__thread_act_subsystem__defined
-#define __Reply__thread_act_subsystem__defined
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-	} __Reply__thread_terminate_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-		mach_msg_type_number_t old_stateCnt;
-		natural_t old_state[614];
-	} __Reply__act_get_state_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-	} __Reply__act_set_state_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-		mach_msg_type_number_t old_stateCnt;
-		natural_t old_state[614];
-	} __Reply__thread_get_state_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-	} __Reply__thread_set_state_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-	} __Reply__thread_suspend_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-	} __Reply__thread_resume_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-	} __Reply__thread_abort_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-	} __Reply__thread_abort_safely_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-	} __Reply__thread_depress_abort_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		/* start of the kernel processed data */
-		mach_msg_body_t msgh_body;
-		mach_msg_port_descriptor_t special_port;
-		/* end of the kernel processed data */
-	} __Reply__thread_get_special_port_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-	} __Reply__thread_set_special_port_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-		mach_msg_type_number_t thread_info_outCnt;
-		integer_t thread_info_out[32];
-	} __Reply__thread_info_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-	} __Reply__thread_set_exception_ports_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		/* start of the kernel processed data */
-		mach_msg_body_t msgh_body;
-		mach_msg_port_descriptor_t old_handlers[32];
-		/* end of the kernel processed data */
-		NDR_record_t NDR;
-		mach_msg_type_number_t masksCnt;
-		exception_mask_t masks[32];
-		exception_behavior_t old_behaviors[32];
-		thread_state_flavor_t old_flavors[32];
-	} __Reply__thread_get_exception_ports_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		/* start of the kernel processed data */
-		mach_msg_body_t msgh_body;
-		mach_msg_port_descriptor_t old_handlers[32];
-		/* end of the kernel processed data */
-		NDR_record_t NDR;
-		mach_msg_type_number_t masksCnt;
-		exception_mask_t masks[32];
-		exception_behavior_t old_behaviors[32];
-		thread_state_flavor_t old_flavors[32];
-	} __Reply__thread_swap_exception_ports_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-	} __Reply__thread_policy_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-	} __Reply__thread_policy_set_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-		mach_msg_type_number_t policy_infoCnt;
-		integer_t policy_info[16];
-		boolean_t get_default;
-	} __Reply__thread_policy_get_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-	} __Reply__thread_sample_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-	} __Reply__etap_trace_thread_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-	} __Reply__thread_assign_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-	} __Reply__thread_assign_default_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		/* start of the kernel processed data */
-		mach_msg_body_t msgh_body;
-		mach_msg_port_descriptor_t assigned_set;
-		/* end of the kernel processed data */
-	} __Reply__thread_get_assignment_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-	} __Reply__thread_set_policy_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		/* start of the kernel processed data */
-		mach_msg_body_t msgh_body;
-		mach_msg_port_descriptor_t voucher;
-		/* end of the kernel processed data */
-	} __Reply__thread_get_mach_voucher_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-	} __Reply__thread_set_mach_voucher_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		/* start of the kernel processed data */
-		mach_msg_body_t msgh_body;
-		mach_msg_port_descriptor_t old_voucher;
-		/* end of the kernel processed data */
-	} __Reply__thread_swap_mach_voucher_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-#endif /* !__Reply__thread_act_subsystem__defined */
-
-/* union of all replies */
-
-#ifndef __ReplyUnion__thread_act_subsystem__defined
-#define __ReplyUnion__thread_act_subsystem__defined
-union __ReplyUnion__thread_act_subsystem {
-	__Reply__thread_terminate_t Reply_thread_terminate;
-	__Reply__act_get_state_t Reply_act_get_state;
-	__Reply__act_set_state_t Reply_act_set_state;
-	__Reply__thread_get_state_t Reply_thread_get_state;
-	__Reply__thread_set_state_t Reply_thread_set_state;
-	__Reply__thread_suspend_t Reply_thread_suspend;
-	__Reply__thread_resume_t Reply_thread_resume;
-	__Reply__thread_abort_t Reply_thread_abort;
-	__Reply__thread_abort_safely_t Reply_thread_abort_safely;
-	__Reply__thread_depress_abort_t Reply_thread_depress_abort;
-	__Reply__thread_get_special_port_t Reply_thread_get_special_port;
-	__Reply__thread_set_special_port_t Reply_thread_set_special_port;
-	__Reply__thread_info_t Reply_thread_info;
-	__Reply__thread_set_exception_ports_t Reply_thread_set_exception_ports;
-	__Reply__thread_get_exception_ports_t Reply_thread_get_exception_ports;
-	__Reply__thread_swap_exception_ports_t Reply_thread_swap_exception_ports;
-	__Reply__thread_policy_t Reply_thread_policy;
-	__Reply__thread_policy_set_t Reply_thread_policy_set;
-	__Reply__thread_policy_get_t Reply_thread_policy_get;
-	__Reply__thread_sample_t Reply_thread_sample;
-	__Reply__etap_trace_thread_t Reply_etap_trace_thread;
-	__Reply__thread_assign_t Reply_thread_assign;
-	__Reply__thread_assign_default_t Reply_thread_assign_default;
-	__Reply__thread_get_assignment_t Reply_thread_get_assignment;
-	__Reply__thread_set_policy_t Reply_thread_set_policy;
-	__Reply__thread_get_mach_voucher_t Reply_thread_get_mach_voucher;
-	__Reply__thread_set_mach_voucher_t Reply_thread_set_mach_voucher;
-	__Reply__thread_swap_mach_voucher_t Reply_thread_swap_mach_voucher;
-};
-#endif /* !__RequestUnion__thread_act_subsystem__defined */
-
-#ifndef subsystem_to_name_map_thread_act
-#define subsystem_to_name_map_thread_act \
-    { "thread_terminate", 3600 },\
-    { "act_get_state", 3601 },\
-    { "act_set_state", 3602 },\
-    { "thread_get_state", 3603 },\
-    { "thread_set_state", 3604 },\
-    { "thread_suspend", 3605 },\
-    { "thread_resume", 3606 },\
-    { "thread_abort", 3607 },\
-    { "thread_abort_safely", 3608 },\
-    { "thread_depress_abort", 3609 },\
-    { "thread_get_special_port", 3610 },\
-    { "thread_set_special_port", 3611 },\
-    { "thread_info", 3612 },\
-    { "thread_set_exception_ports", 3613 },\
-    { "thread_get_exception_ports", 3614 },\
-    { "thread_swap_exception_ports", 3615 },\
-    { "thread_policy", 3616 },\
-    { "thread_policy_set", 3617 },\
-    { "thread_policy_get", 3618 },\
-    { "thread_sample", 3619 },\
-    { "etap_trace_thread", 3620 },\
-    { "thread_assign", 3621 },\
-    { "thread_assign_default", 3622 },\
-    { "thread_get_assignment", 3623 },\
-    { "thread_set_policy", 3624 },\
-    { "thread_get_mach_voucher", 3625 },\
-    { "thread_set_mach_voucher", 3626 },\
-    { "thread_swap_mach_voucher", 3627 }
-#endif
-
-#ifdef __AfterMigUserHeader
-__AfterMigUserHeader
-#endif /* __AfterMigUserHeader */
-
-#endif	 /* _thread_act_user_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/mach/thread_special_ports.h b/lib/libc/include/x86_64-macos-gnu/mach/thread_special_ports.h
deleted file mode 100644
index f777e0060c..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/mach/thread_special_ports.h
+++ /dev/null
@@ -1,83 +0,0 @@
-/*
- * Copyright (c) 2000-2002 Apple Computer, Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-/*
- * @OSF_COPYRIGHT@
- */
-/*
- * Mach Operating System
- * Copyright (c) 1991,1990,1989,1988,1987 Carnegie Mellon University
- * All Rights Reserved.
- *
- * Permission to use, copy, modify and distribute this software and its
- * documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
- * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie Mellon
- * the rights to redistribute these changes.
- */
-/*
- */
-/*
- *	File:	mach/thread_special_ports.h
- *
- *	Defines codes for special_purpose thread ports.  These are NOT
- *	port identifiers - they are only used for the thread_get_special_port
- *	and thread_set_special_port routines.
- *
- */
-
-#ifndef _MACH_THREAD_SPECIAL_PORTS_H_
-#define _MACH_THREAD_SPECIAL_PORTS_H_
-
-#define THREAD_KERNEL_PORT      1       /* Represents the thread to the outside
-	                                 *  world.*/
-
-/*
- *	Definitions for ease of use
- */
-
-#define thread_get_kernel_port(thread, port)    \
-	        (thread_get_special_port((thread), THREAD_KERNEL_PORT, (port)))
-
-#define thread_set_kernel_port(thread, port)    \
-	        (thread_set_special_port((thread), THREAD_KERNEL_PORT, (port)))
-
-#endif  /* _MACH_THREAD_SPECIAL_PORTS_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/mach/thread_status.h b/lib/libc/include/x86_64-macos-gnu/mach/thread_status.h
deleted file mode 100644
index 886cae365c..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/mach/thread_status.h
+++ /dev/null
@@ -1,97 +0,0 @@
-/*
- * Copyright (c) 2000-2002 Apple Computer, Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-/*
- * @OSF_COPYRIGHT@
- */
-/*
- * Mach Operating System
- * Copyright (c) 1991,1990,1989,1988 Carnegie Mellon University
- * All Rights Reserved.
- *
- * Permission to use, copy, modify and distribute this software and its
- * documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
- * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie Mellon
- * the rights to redistribute these changes.
- */
-/*
- */
-/*
- *	File:	mach/thread_status.h
- *	Author:	Avadis Tevanian, Jr.
- *
- *	This file contains the structure definitions for the user-visible
- *	thread state.  This thread state is examined with the thread_get_state
- *	kernel call and may be changed with the thread_set_state kernel call.
- *
- */
-
-#ifndef _MACH_THREAD_STATUS_H_
-#define _MACH_THREAD_STATUS_H_
-
-/*
- *	The actual structure that comprises the thread state is defined
- *	in the machine dependent module.
- */
-#include <mach/machine/vm_types.h>
-#include <mach/machine/thread_status.h>
-#include <mach/machine/thread_state.h>
-
-/*
- *	Generic definition for machine-dependent thread status.
- */
-
-typedef natural_t       *thread_state_t;        /* Variable-length array */
-
-/* THREAD_STATE_MAX is now defined in <mach/machine/thread_state.h> */
-typedef natural_t       thread_state_data_t[THREAD_STATE_MAX];
-
-#define THREAD_STATE_FLAVOR_LIST        0       /* List of valid flavors */
-#define THREAD_STATE_FLAVOR_LIST_NEW    128
-#define THREAD_STATE_FLAVOR_LIST_10_9   129
-#define THREAD_STATE_FLAVOR_LIST_10_13  130
-#define THREAD_STATE_FLAVOR_LIST_10_15  131
-
-typedef int                     thread_state_flavor_t;
-typedef thread_state_flavor_t   *thread_state_flavor_array_t;
-
-#endif  /* _MACH_THREAD_STATUS_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/mach/vm_map.h b/lib/libc/include/x86_64-macos-gnu/mach/vm_map.h
deleted file mode 100644
index 59b3e7ffac..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/mach/vm_map.h
+++ /dev/null
@@ -1,1440 +0,0 @@
-#ifndef	_vm_map_user_
-#define	_vm_map_user_
-
-/* Module vm_map */
-
-#include <string.h>
-#include <mach/ndr.h>
-#include <mach/boolean.h>
-#include <mach/kern_return.h>
-#include <mach/notify.h>
-#include <mach/mach_types.h>
-#include <mach/message.h>
-#include <mach/mig_errors.h>
-#include <mach/port.h>
-	
-/* BEGIN MIG_STRNCPY_ZEROFILL CODE */
-
-#if defined(__has_include)
-#if __has_include(<mach/mig_strncpy_zerofill_support.h>)
-#ifndef USING_MIG_STRNCPY_ZEROFILL
-#define USING_MIG_STRNCPY_ZEROFILL
-#endif
-#ifndef __MIG_STRNCPY_ZEROFILL_FORWARD_TYPE_DECLS__
-#define __MIG_STRNCPY_ZEROFILL_FORWARD_TYPE_DECLS__
-#ifdef __cplusplus
-extern "C" {
-#endif
-	extern int mig_strncpy_zerofill(char *dest, const char *src, int len) __attribute__((weak_import));
-#ifdef __cplusplus
-}
-#endif
-#endif /* __MIG_STRNCPY_ZEROFILL_FORWARD_TYPE_DECLS__ */
-#endif /* __has_include(<mach/mig_strncpy_zerofill_support.h>) */
-#endif /* __has_include */
-	
-/* END MIG_STRNCPY_ZEROFILL CODE */
-
-
-#ifdef AUTOTEST
-#ifndef FUNCTION_PTR_T
-#define FUNCTION_PTR_T
-typedef void (*function_ptr_t)(mach_port_t, char *, mach_msg_type_number_t);
-typedef struct {
-        char            *name;
-        function_ptr_t  function;
-} function_table_entry;
-typedef function_table_entry   *function_table_t;
-#endif /* FUNCTION_PTR_T */
-#endif /* AUTOTEST */
-
-#ifndef	vm_map_MSG_COUNT
-#define	vm_map_MSG_COUNT	32
-#endif	/* vm_map_MSG_COUNT */
-
-#include <mach/std_types.h>
-#include <mach/mig.h>
-#include <mach/mig.h>
-#include <mach/mach_types.h>
-#include <mach_debug/mach_debug_types.h>
-
-#ifdef __BeforeMigUserHeader
-__BeforeMigUserHeader
-#endif /* __BeforeMigUserHeader */
-
-#include <sys/cdefs.h>
-__BEGIN_DECLS
-
-
-/* Routine vm_region */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t vm_region
-(
-	vm_map_t target_task,
-	vm_address_t *address,
-	vm_size_t *size,
-	vm_region_flavor_t flavor,
-	vm_region_info_t info,
-	mach_msg_type_number_t *infoCnt,
-	mach_port_t *object_name
-);
-
-/* Routine vm_allocate */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t vm_allocate
-(
-	vm_map_t target_task,
-	vm_address_t *address,
-	vm_size_t size,
-	int flags
-);
-
-/* Routine vm_deallocate */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t vm_deallocate
-(
-	vm_map_t target_task,
-	vm_address_t address,
-	vm_size_t size
-);
-
-/* Routine vm_protect */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t vm_protect
-(
-	vm_map_t target_task,
-	vm_address_t address,
-	vm_size_t size,
-	boolean_t set_maximum,
-	vm_prot_t new_protection
-);
-
-/* Routine vm_inherit */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t vm_inherit
-(
-	vm_map_t target_task,
-	vm_address_t address,
-	vm_size_t size,
-	vm_inherit_t new_inheritance
-);
-
-/* Routine vm_read */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t vm_read
-(
-	vm_map_t target_task,
-	vm_address_t address,
-	vm_size_t size,
-	vm_offset_t *data,
-	mach_msg_type_number_t *dataCnt
-);
-
-/* Routine vm_read_list */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t vm_read_list
-(
-	vm_map_t target_task,
-	vm_read_entry_t data_list,
-	natural_t count
-);
-
-/* Routine vm_write */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t vm_write
-(
-	vm_map_t target_task,
-	vm_address_t address,
-	vm_offset_t data,
-	mach_msg_type_number_t dataCnt
-);
-
-/* Routine vm_copy */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t vm_copy
-(
-	vm_map_t target_task,
-	vm_address_t source_address,
-	vm_size_t size,
-	vm_address_t dest_address
-);
-
-/* Routine vm_read_overwrite */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t vm_read_overwrite
-(
-	vm_map_t target_task,
-	vm_address_t address,
-	vm_size_t size,
-	vm_address_t data,
-	vm_size_t *outsize
-);
-
-/* Routine vm_msync */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t vm_msync
-(
-	vm_map_t target_task,
-	vm_address_t address,
-	vm_size_t size,
-	vm_sync_t sync_flags
-);
-
-/* Routine vm_behavior_set */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t vm_behavior_set
-(
-	vm_map_t target_task,
-	vm_address_t address,
-	vm_size_t size,
-	vm_behavior_t new_behavior
-);
-
-/* Routine vm_map */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t vm_map
-(
-	vm_map_t target_task,
-	vm_address_t *address,
-	vm_size_t size,
-	vm_address_t mask,
-	int flags,
-	mem_entry_name_port_t object,
-	vm_offset_t offset,
-	boolean_t copy,
-	vm_prot_t cur_protection,
-	vm_prot_t max_protection,
-	vm_inherit_t inheritance
-);
-
-/* Routine vm_machine_attribute */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t vm_machine_attribute
-(
-	vm_map_t target_task,
-	vm_address_t address,
-	vm_size_t size,
-	vm_machine_attribute_t attribute,
-	vm_machine_attribute_val_t *value
-);
-
-/* Routine vm_remap */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t vm_remap
-(
-	vm_map_t target_task,
-	vm_address_t *target_address,
-	vm_size_t size,
-	vm_address_t mask,
-	int flags,
-	vm_map_t src_task,
-	vm_address_t src_address,
-	boolean_t copy,
-	vm_prot_t *cur_protection,
-	vm_prot_t *max_protection,
-	vm_inherit_t inheritance
-);
-
-/* Routine task_wire */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-__WATCHOS_PROHIBITED
-__TVOS_PROHIBITED
-kern_return_t task_wire
-(
-	vm_map_t target_task,
-	boolean_t must_wire
-);
-
-/* Routine mach_make_memory_entry */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t mach_make_memory_entry
-(
-	vm_map_t target_task,
-	vm_size_t *size,
-	vm_offset_t offset,
-	vm_prot_t permission,
-	mem_entry_name_port_t *object_handle,
-	mem_entry_name_port_t parent_entry
-);
-
-/* Routine vm_map_page_query */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t vm_map_page_query
-(
-	vm_map_t target_map,
-	vm_offset_t offset,
-	integer_t *disposition,
-	integer_t *ref_count
-);
-
-/* Routine mach_vm_region_info */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t mach_vm_region_info
-(
-	vm_map_t task,
-	vm_address_t address,
-	vm_info_region_t *region,
-	vm_info_object_array_t *objects,
-	mach_msg_type_number_t *objectsCnt
-);
-
-/* Routine vm_mapped_pages_info */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t vm_mapped_pages_info
-(
-	vm_map_t task,
-	page_address_array_t *pages,
-	mach_msg_type_number_t *pagesCnt
-);
-
-/* Routine vm_region_recurse */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t vm_region_recurse
-(
-	vm_map_t target_task,
-	vm_address_t *address,
-	vm_size_t *size,
-	natural_t *nesting_depth,
-	vm_region_recurse_info_t info,
-	mach_msg_type_number_t *infoCnt
-);
-
-/* Routine vm_region_recurse_64 */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t vm_region_recurse_64
-(
-	vm_map_t target_task,
-	vm_address_t *address,
-	vm_size_t *size,
-	natural_t *nesting_depth,
-	vm_region_recurse_info_t info,
-	mach_msg_type_number_t *infoCnt
-);
-
-/* Routine mach_vm_region_info_64 */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t mach_vm_region_info_64
-(
-	vm_map_t task,
-	vm_address_t address,
-	vm_info_region_64_t *region,
-	vm_info_object_array_t *objects,
-	mach_msg_type_number_t *objectsCnt
-);
-
-/* Routine vm_region_64 */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t vm_region_64
-(
-	vm_map_t target_task,
-	vm_address_t *address,
-	vm_size_t *size,
-	vm_region_flavor_t flavor,
-	vm_region_info_t info,
-	mach_msg_type_number_t *infoCnt,
-	mach_port_t *object_name
-);
-
-/* Routine mach_make_memory_entry_64 */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t mach_make_memory_entry_64
-(
-	vm_map_t target_task,
-	memory_object_size_t *size,
-	memory_object_offset_t offset,
-	vm_prot_t permission,
-	mach_port_t *object_handle,
-	mem_entry_name_port_t parent_entry
-);
-
-/* Routine vm_map_64 */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t vm_map_64
-(
-	vm_map_t target_task,
-	vm_address_t *address,
-	vm_size_t size,
-	vm_address_t mask,
-	int flags,
-	mem_entry_name_port_t object,
-	memory_object_offset_t offset,
-	boolean_t copy,
-	vm_prot_t cur_protection,
-	vm_prot_t max_protection,
-	vm_inherit_t inheritance
-);
-
-/* Routine vm_purgable_control */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t vm_purgable_control
-(
-	vm_map_t target_task,
-	vm_address_t address,
-	vm_purgable_t control,
-	int *state
-);
-
-/* Routine vm_map_exec_lockdown */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t vm_map_exec_lockdown
-(
-	vm_map_t target_task
-);
-
-__END_DECLS
-
-/********************** Caution **************************/
-/* The following data types should be used to calculate  */
-/* maximum message sizes only. The actual message may be */
-/* smaller, and the position of the arguments within the */
-/* message layout may vary from what is presented here.  */
-/* For example, if any of the arguments are variable-    */
-/* sized, and less than the maximum is sent, the data    */
-/* will be packed tight in the actual message to reduce  */
-/* the presence of holes.                                */
-/********************** Caution **************************/
-
-/* typedefs for all requests */
-
-#ifndef __Request__vm_map_subsystem__defined
-#define __Request__vm_map_subsystem__defined
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		vm_address_t address;
-		vm_region_flavor_t flavor;
-		mach_msg_type_number_t infoCnt;
-	} __Request__vm_region_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		vm_address_t address;
-		vm_size_t size;
-		int flags;
-	} __Request__vm_allocate_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		vm_address_t address;
-		vm_size_t size;
-	} __Request__vm_deallocate_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		vm_address_t address;
-		vm_size_t size;
-		boolean_t set_maximum;
-		vm_prot_t new_protection;
-	} __Request__vm_protect_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		vm_address_t address;
-		vm_size_t size;
-		vm_inherit_t new_inheritance;
-	} __Request__vm_inherit_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		vm_address_t address;
-		vm_size_t size;
-	} __Request__vm_read_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		vm_read_entry_t data_list;
-		natural_t count;
-	} __Request__vm_read_list_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		/* start of the kernel processed data */
-		mach_msg_body_t msgh_body;
-		mach_msg_ool_descriptor_t data;
-		/* end of the kernel processed data */
-		NDR_record_t NDR;
-		vm_address_t address;
-		mach_msg_type_number_t dataCnt;
-	} __Request__vm_write_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		vm_address_t source_address;
-		vm_size_t size;
-		vm_address_t dest_address;
-	} __Request__vm_copy_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		vm_address_t address;
-		vm_size_t size;
-		vm_address_t data;
-	} __Request__vm_read_overwrite_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		vm_address_t address;
-		vm_size_t size;
-		vm_sync_t sync_flags;
-	} __Request__vm_msync_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		vm_address_t address;
-		vm_size_t size;
-		vm_behavior_t new_behavior;
-	} __Request__vm_behavior_set_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		/* start of the kernel processed data */
-		mach_msg_body_t msgh_body;
-		mach_msg_port_descriptor_t object;
-		/* end of the kernel processed data */
-		NDR_record_t NDR;
-		vm_address_t address;
-		vm_size_t size;
-		vm_address_t mask;
-		int flags;
-		vm_offset_t offset;
-		boolean_t copy;
-		vm_prot_t cur_protection;
-		vm_prot_t max_protection;
-		vm_inherit_t inheritance;
-	} __Request__vm_map_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		vm_address_t address;
-		vm_size_t size;
-		vm_machine_attribute_t attribute;
-		vm_machine_attribute_val_t value;
-	} __Request__vm_machine_attribute_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		/* start of the kernel processed data */
-		mach_msg_body_t msgh_body;
-		mach_msg_port_descriptor_t src_task;
-		/* end of the kernel processed data */
-		NDR_record_t NDR;
-		vm_address_t target_address;
-		vm_size_t size;
-		vm_address_t mask;
-		int flags;
-		vm_address_t src_address;
-		boolean_t copy;
-		vm_inherit_t inheritance;
-	} __Request__vm_remap_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		boolean_t must_wire;
-	} __Request__task_wire_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		/* start of the kernel processed data */
-		mach_msg_body_t msgh_body;
-		mach_msg_port_descriptor_t parent_entry;
-		/* end of the kernel processed data */
-		NDR_record_t NDR;
-		vm_size_t size;
-		vm_offset_t offset;
-		vm_prot_t permission;
-	} __Request__mach_make_memory_entry_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		vm_offset_t offset;
-	} __Request__vm_map_page_query_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		vm_address_t address;
-	} __Request__mach_vm_region_info_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-	} __Request__vm_mapped_pages_info_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		vm_address_t address;
-		natural_t nesting_depth;
-		mach_msg_type_number_t infoCnt;
-	} __Request__vm_region_recurse_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		vm_address_t address;
-		natural_t nesting_depth;
-		mach_msg_type_number_t infoCnt;
-	} __Request__vm_region_recurse_64_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		vm_address_t address;
-	} __Request__mach_vm_region_info_64_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		vm_address_t address;
-		vm_region_flavor_t flavor;
-		mach_msg_type_number_t infoCnt;
-	} __Request__vm_region_64_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		/* start of the kernel processed data */
-		mach_msg_body_t msgh_body;
-		mach_msg_port_descriptor_t parent_entry;
-		/* end of the kernel processed data */
-		NDR_record_t NDR;
-		memory_object_size_t size;
-		memory_object_offset_t offset;
-		vm_prot_t permission;
-	} __Request__mach_make_memory_entry_64_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		/* start of the kernel processed data */
-		mach_msg_body_t msgh_body;
-		mach_msg_port_descriptor_t object;
-		/* end of the kernel processed data */
-		NDR_record_t NDR;
-		vm_address_t address;
-		vm_size_t size;
-		vm_address_t mask;
-		int flags;
-		memory_object_offset_t offset;
-		boolean_t copy;
-		vm_prot_t cur_protection;
-		vm_prot_t max_protection;
-		vm_inherit_t inheritance;
-	} __Request__vm_map_64_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		vm_address_t address;
-		vm_purgable_t control;
-		int state;
-	} __Request__vm_purgable_control_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-	} __Request__vm_map_exec_lockdown_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-#endif /* !__Request__vm_map_subsystem__defined */
-
-/* union of all requests */
-
-#ifndef __RequestUnion__vm_map_subsystem__defined
-#define __RequestUnion__vm_map_subsystem__defined
-union __RequestUnion__vm_map_subsystem {
-	__Request__vm_region_t Request_vm_region;
-	__Request__vm_allocate_t Request_vm_allocate;
-	__Request__vm_deallocate_t Request_vm_deallocate;
-	__Request__vm_protect_t Request_vm_protect;
-	__Request__vm_inherit_t Request_vm_inherit;
-	__Request__vm_read_t Request_vm_read;
-	__Request__vm_read_list_t Request_vm_read_list;
-	__Request__vm_write_t Request_vm_write;
-	__Request__vm_copy_t Request_vm_copy;
-	__Request__vm_read_overwrite_t Request_vm_read_overwrite;
-	__Request__vm_msync_t Request_vm_msync;
-	__Request__vm_behavior_set_t Request_vm_behavior_set;
-	__Request__vm_map_t Request_vm_map;
-	__Request__vm_machine_attribute_t Request_vm_machine_attribute;
-	__Request__vm_remap_t Request_vm_remap;
-	__Request__task_wire_t Request_task_wire;
-	__Request__mach_make_memory_entry_t Request_mach_make_memory_entry;
-	__Request__vm_map_page_query_t Request_vm_map_page_query;
-	__Request__mach_vm_region_info_t Request_mach_vm_region_info;
-	__Request__vm_mapped_pages_info_t Request_vm_mapped_pages_info;
-	__Request__vm_region_recurse_t Request_vm_region_recurse;
-	__Request__vm_region_recurse_64_t Request_vm_region_recurse_64;
-	__Request__mach_vm_region_info_64_t Request_mach_vm_region_info_64;
-	__Request__vm_region_64_t Request_vm_region_64;
-	__Request__mach_make_memory_entry_64_t Request_mach_make_memory_entry_64;
-	__Request__vm_map_64_t Request_vm_map_64;
-	__Request__vm_purgable_control_t Request_vm_purgable_control;
-	__Request__vm_map_exec_lockdown_t Request_vm_map_exec_lockdown;
-};
-#endif /* !__RequestUnion__vm_map_subsystem__defined */
-/* typedefs for all replies */
-
-#ifndef __Reply__vm_map_subsystem__defined
-#define __Reply__vm_map_subsystem__defined
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		/* start of the kernel processed data */
-		mach_msg_body_t msgh_body;
-		mach_msg_port_descriptor_t object_name;
-		/* end of the kernel processed data */
-		NDR_record_t NDR;
-		vm_address_t address;
-		vm_size_t size;
-		mach_msg_type_number_t infoCnt;
-		int info[10];
-	} __Reply__vm_region_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-		vm_address_t address;
-	} __Reply__vm_allocate_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-	} __Reply__vm_deallocate_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-	} __Reply__vm_protect_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-	} __Reply__vm_inherit_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		/* start of the kernel processed data */
-		mach_msg_body_t msgh_body;
-		mach_msg_ool_descriptor_t data;
-		/* end of the kernel processed data */
-		NDR_record_t NDR;
-		mach_msg_type_number_t dataCnt;
-	} __Reply__vm_read_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-		vm_read_entry_t data_list;
-	} __Reply__vm_read_list_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-	} __Reply__vm_write_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-	} __Reply__vm_copy_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-		vm_size_t outsize;
-	} __Reply__vm_read_overwrite_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-	} __Reply__vm_msync_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-	} __Reply__vm_behavior_set_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-		vm_address_t address;
-	} __Reply__vm_map_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-		vm_machine_attribute_val_t value;
-	} __Reply__vm_machine_attribute_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-		vm_address_t target_address;
-		vm_prot_t cur_protection;
-		vm_prot_t max_protection;
-	} __Reply__vm_remap_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-	} __Reply__task_wire_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		/* start of the kernel processed data */
-		mach_msg_body_t msgh_body;
-		mach_msg_port_descriptor_t object_handle;
-		/* end of the kernel processed data */
-		NDR_record_t NDR;
-		vm_size_t size;
-	} __Reply__mach_make_memory_entry_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-		integer_t disposition;
-		integer_t ref_count;
-	} __Reply__vm_map_page_query_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		/* start of the kernel processed data */
-		mach_msg_body_t msgh_body;
-		mach_msg_ool_descriptor_t objects;
-		/* end of the kernel processed data */
-		NDR_record_t NDR;
-		vm_info_region_t region;
-		mach_msg_type_number_t objectsCnt;
-	} __Reply__mach_vm_region_info_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		/* start of the kernel processed data */
-		mach_msg_body_t msgh_body;
-		mach_msg_ool_descriptor_t pages;
-		/* end of the kernel processed data */
-		NDR_record_t NDR;
-		mach_msg_type_number_t pagesCnt;
-	} __Reply__vm_mapped_pages_info_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-		vm_address_t address;
-		vm_size_t size;
-		natural_t nesting_depth;
-		mach_msg_type_number_t infoCnt;
-		int info[19];
-	} __Reply__vm_region_recurse_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-		vm_address_t address;
-		vm_size_t size;
-		natural_t nesting_depth;
-		mach_msg_type_number_t infoCnt;
-		int info[19];
-	} __Reply__vm_region_recurse_64_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		/* start of the kernel processed data */
-		mach_msg_body_t msgh_body;
-		mach_msg_ool_descriptor_t objects;
-		/* end of the kernel processed data */
-		NDR_record_t NDR;
-		vm_info_region_64_t region;
-		mach_msg_type_number_t objectsCnt;
-	} __Reply__mach_vm_region_info_64_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		/* start of the kernel processed data */
-		mach_msg_body_t msgh_body;
-		mach_msg_port_descriptor_t object_name;
-		/* end of the kernel processed data */
-		NDR_record_t NDR;
-		vm_address_t address;
-		vm_size_t size;
-		mach_msg_type_number_t infoCnt;
-		int info[10];
-	} __Reply__vm_region_64_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		/* start of the kernel processed data */
-		mach_msg_body_t msgh_body;
-		mach_msg_port_descriptor_t object_handle;
-		/* end of the kernel processed data */
-		NDR_record_t NDR;
-		memory_object_size_t size;
-	} __Reply__mach_make_memory_entry_64_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-		vm_address_t address;
-	} __Reply__vm_map_64_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-		int state;
-	} __Reply__vm_purgable_control_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-	} __Reply__vm_map_exec_lockdown_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-#endif /* !__Reply__vm_map_subsystem__defined */
-
-/* union of all replies */
-
-#ifndef __ReplyUnion__vm_map_subsystem__defined
-#define __ReplyUnion__vm_map_subsystem__defined
-union __ReplyUnion__vm_map_subsystem {
-	__Reply__vm_region_t Reply_vm_region;
-	__Reply__vm_allocate_t Reply_vm_allocate;
-	__Reply__vm_deallocate_t Reply_vm_deallocate;
-	__Reply__vm_protect_t Reply_vm_protect;
-	__Reply__vm_inherit_t Reply_vm_inherit;
-	__Reply__vm_read_t Reply_vm_read;
-	__Reply__vm_read_list_t Reply_vm_read_list;
-	__Reply__vm_write_t Reply_vm_write;
-	__Reply__vm_copy_t Reply_vm_copy;
-	__Reply__vm_read_overwrite_t Reply_vm_read_overwrite;
-	__Reply__vm_msync_t Reply_vm_msync;
-	__Reply__vm_behavior_set_t Reply_vm_behavior_set;
-	__Reply__vm_map_t Reply_vm_map;
-	__Reply__vm_machine_attribute_t Reply_vm_machine_attribute;
-	__Reply__vm_remap_t Reply_vm_remap;
-	__Reply__task_wire_t Reply_task_wire;
-	__Reply__mach_make_memory_entry_t Reply_mach_make_memory_entry;
-	__Reply__vm_map_page_query_t Reply_vm_map_page_query;
-	__Reply__mach_vm_region_info_t Reply_mach_vm_region_info;
-	__Reply__vm_mapped_pages_info_t Reply_vm_mapped_pages_info;
-	__Reply__vm_region_recurse_t Reply_vm_region_recurse;
-	__Reply__vm_region_recurse_64_t Reply_vm_region_recurse_64;
-	__Reply__mach_vm_region_info_64_t Reply_mach_vm_region_info_64;
-	__Reply__vm_region_64_t Reply_vm_region_64;
-	__Reply__mach_make_memory_entry_64_t Reply_mach_make_memory_entry_64;
-	__Reply__vm_map_64_t Reply_vm_map_64;
-	__Reply__vm_purgable_control_t Reply_vm_purgable_control;
-	__Reply__vm_map_exec_lockdown_t Reply_vm_map_exec_lockdown;
-};
-#endif /* !__RequestUnion__vm_map_subsystem__defined */
-
-#ifndef subsystem_to_name_map_vm_map
-#define subsystem_to_name_map_vm_map \
-    { "vm_region", 3800 },\
-    { "vm_allocate", 3801 },\
-    { "vm_deallocate", 3802 },\
-    { "vm_protect", 3803 },\
-    { "vm_inherit", 3804 },\
-    { "vm_read", 3805 },\
-    { "vm_read_list", 3806 },\
-    { "vm_write", 3807 },\
-    { "vm_copy", 3808 },\
-    { "vm_read_overwrite", 3809 },\
-    { "vm_msync", 3810 },\
-    { "vm_behavior_set", 3811 },\
-    { "vm_map", 3812 },\
-    { "vm_machine_attribute", 3813 },\
-    { "vm_remap", 3814 },\
-    { "task_wire", 3815 },\
-    { "mach_make_memory_entry", 3816 },\
-    { "vm_map_page_query", 3817 },\
-    { "mach_vm_region_info", 3818 },\
-    { "vm_mapped_pages_info", 3819 },\
-    { "vm_region_recurse", 3821 },\
-    { "vm_region_recurse_64", 3822 },\
-    { "mach_vm_region_info_64", 3823 },\
-    { "vm_region_64", 3824 },\
-    { "mach_make_memory_entry_64", 3825 },\
-    { "vm_map_64", 3826 },\
-    { "vm_purgable_control", 3830 },\
-    { "vm_map_exec_lockdown", 3831 }
-#endif
-
-#ifdef __AfterMigUserHeader
-__AfterMigUserHeader
-#endif /* __AfterMigUserHeader */
-
-#endif	 /* _vm_map_user_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/mach/vm_prot.h b/lib/libc/include/x86_64-macos-gnu/mach/vm_prot.h
deleted file mode 100644
index 75812fedf6..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/mach/vm_prot.h
+++ /dev/null
@@ -1,152 +0,0 @@
-/*
- * Copyright (c) 2000-2002 Apple Computer, Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-/*
- * @OSF_COPYRIGHT@
- */
-/*
- * Mach Operating System
- * Copyright (c) 1991,1990,1989,1988,1987 Carnegie Mellon University
- * All Rights Reserved.
- *
- * Permission to use, copy, modify and distribute this software and its
- * documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
- * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie Mellon
- * the rights to redistribute these changes.
- */
-/*
- */
-/*
- *	File:	mach/vm_prot.h
- *	Author:	Avadis Tevanian, Jr., Michael Wayne Young
- *
- *	Virtual memory protection definitions.
- *
- */
-
-#ifndef _MACH_VM_PROT_H_
-#define _MACH_VM_PROT_H_
-
-/*
- *	Types defined:
- *
- *	vm_prot_t		VM protection values.
- */
-
-typedef int             vm_prot_t;
-
-/*
- *	Protection values, defined as bits within the vm_prot_t type
- */
-
-#define VM_PROT_NONE    ((vm_prot_t) 0x00)
-
-#define VM_PROT_READ    ((vm_prot_t) 0x01)      /* read permission */
-#define VM_PROT_WRITE   ((vm_prot_t) 0x02)      /* write permission */
-#define VM_PROT_EXECUTE ((vm_prot_t) 0x04)      /* execute permission */
-
-/*
- *	The default protection for newly-created virtual memory
- */
-
-#define VM_PROT_DEFAULT (VM_PROT_READ|VM_PROT_WRITE)
-
-/*
- *	The maximum privileges possible, for parameter checking.
- */
-
-#define VM_PROT_ALL     (VM_PROT_READ|VM_PROT_WRITE|VM_PROT_EXECUTE)
-
-/*
- *	An invalid protection value.
- *	Used only by memory_object_lock_request to indicate no change
- *	to page locks.  Using -1 here is a bad idea because it
- *	looks like VM_PROT_ALL and then some.
- */
-
-#define VM_PROT_NO_CHANGE       ((vm_prot_t) 0x08)
-
-/*
- *      When a caller finds that he cannot obtain write permission on a
- *      mapped entry, the following flag can be used.  The entry will
- *      be made "needs copy" effectively copying the object (using COW),
- *      and write permission will be added to the maximum protections
- *      for the associated entry.
- */
-
-#define VM_PROT_COPY            ((vm_prot_t) 0x10)
-
-
-/*
- *	Another invalid protection value.
- *	Used only by memory_object_data_request upon an object
- *	which has specified a copy_call copy strategy. It is used
- *	when the kernel wants a page belonging to a copy of the
- *	object, and is only asking the object as a result of
- *	following a shadow chain. This solves the race between pages
- *	being pushed up by the memory manager and the kernel
- *	walking down the shadow chain.
- */
-
-#define VM_PROT_WANTS_COPY      ((vm_prot_t) 0x10)
-
-
-/*
- *      Another invalid protection value.
- *	Indicates that the other protection bits are to be applied as a mask
- *	against the actual protection bits of the map entry.
- */
-#define VM_PROT_IS_MASK         ((vm_prot_t) 0x40)
-
-/*
- * Another invalid protection value to support execute-only protection.
- * VM_PROT_STRIP_READ is a special marker that tells mprotect to not
- * set VM_PROT_READ. We have to do it this way because existing code
- * expects the system to set VM_PROT_READ if VM_PROT_EXECUTE is set.
- * VM_PROT_EXECUTE_ONLY is just a convenience value to indicate that
- * the memory should be executable and explicitly not readable. It will
- * be ignored on platforms that do not support this type of protection.
- */
-#define VM_PROT_STRIP_READ              ((vm_prot_t) 0x80)
-#define VM_PROT_EXECUTE_ONLY    (VM_PROT_EXECUTE|VM_PROT_STRIP_READ)
-
-#endif  /* _MACH_VM_PROT_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/mach/vm_statistics.h b/lib/libc/include/x86_64-macos-gnu/mach/vm_statistics.h
deleted file mode 100644
index 2bfd8136b4..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/mach/vm_statistics.h
+++ /dev/null
@@ -1,523 +0,0 @@
-/*
- * Copyright (c) 2000-2019 Apple Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-/*
- * @OSF_COPYRIGHT@
- */
-/*
- * Mach Operating System
- * Copyright (c) 1991,1990,1989,1988,1987 Carnegie Mellon University
- * All Rights Reserved.
- *
- * Permission to use, copy, modify and distribute this software and its
- * documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
- * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie Mellon
- * the rights to redistribute these changes.
- */
-/*
- */
-/*
- *	File:	mach/vm_statistics.h
- *	Author:	Avadis Tevanian, Jr., Michael Wayne Young, David Golub
- *
- *	Virtual memory statistics structure.
- *
- */
-
-#ifndef _MACH_VM_STATISTICS_H_
-#define _MACH_VM_STATISTICS_H_
-
-#include <mach/machine/vm_types.h>
-
-
-/*
- * vm_statistics
- *
- * History:
- *	rev0 -  original structure.
- *	rev1 -  added purgable info (purgable_count and purges).
- *	rev2 -  added speculative_count.
- *
- * Note: you cannot add any new fields to this structure. Add them below in
- *       vm_statistics64.
- */
-
-struct vm_statistics {
-	natural_t       free_count;             /* # of pages free */
-	natural_t       active_count;           /* # of pages active */
-	natural_t       inactive_count;         /* # of pages inactive */
-	natural_t       wire_count;             /* # of pages wired down */
-	natural_t       zero_fill_count;        /* # of zero fill pages */
-	natural_t       reactivations;          /* # of pages reactivated */
-	natural_t       pageins;                /* # of pageins */
-	natural_t       pageouts;               /* # of pageouts */
-	natural_t       faults;                 /* # of faults */
-	natural_t       cow_faults;             /* # of copy-on-writes */
-	natural_t       lookups;                /* object cache lookups */
-	natural_t       hits;                   /* object cache hits */
-
-	/* added for rev1 */
-	natural_t       purgeable_count;        /* # of pages purgeable */
-	natural_t       purges;                 /* # of pages purged */
-
-	/* added for rev2 */
-	/*
-	 * NB: speculative pages are already accounted for in "free_count",
-	 * so "speculative_count" is the number of "free" pages that are
-	 * used to hold data that was read speculatively from disk but
-	 * haven't actually been used by anyone so far.
-	 */
-	natural_t       speculative_count;      /* # of pages speculative */
-};
-
-/* Used by all architectures */
-typedef struct vm_statistics    *vm_statistics_t;
-typedef struct vm_statistics    vm_statistics_data_t;
-
-/*
- * vm_statistics64
- *
- * History:
- *	rev0 -  original structure.
- *	rev1 -  added purgable info (purgable_count and purges).
- *	rev2 -  added speculative_count.
- *	   ----
- *	rev3 -  changed name to vm_statistics64.
- *		changed some fields in structure to 64-bit on
- *		arm, i386 and x86_64 architectures.
- *	rev4 -  require 64-bit alignment for efficient access
- *		in the kernel. No change to reported data.
- *
- */
-
-struct vm_statistics64 {
-	natural_t       free_count;             /* # of pages free */
-	natural_t       active_count;           /* # of pages active */
-	natural_t       inactive_count;         /* # of pages inactive */
-	natural_t       wire_count;             /* # of pages wired down */
-	uint64_t        zero_fill_count;        /* # of zero fill pages */
-	uint64_t        reactivations;          /* # of pages reactivated */
-	uint64_t        pageins;                /* # of pageins */
-	uint64_t        pageouts;               /* # of pageouts */
-	uint64_t        faults;                 /* # of faults */
-	uint64_t        cow_faults;             /* # of copy-on-writes */
-	uint64_t        lookups;                /* object cache lookups */
-	uint64_t        hits;                   /* object cache hits */
-	uint64_t        purges;                 /* # of pages purged */
-	natural_t       purgeable_count;        /* # of pages purgeable */
-	/*
-	 * NB: speculative pages are already accounted for in "free_count",
-	 * so "speculative_count" is the number of "free" pages that are
-	 * used to hold data that was read speculatively from disk but
-	 * haven't actually been used by anyone so far.
-	 */
-	natural_t       speculative_count;      /* # of pages speculative */
-
-	/* added for rev1 */
-	uint64_t        decompressions;         /* # of pages decompressed */
-	uint64_t        compressions;           /* # of pages compressed */
-	uint64_t        swapins;                /* # of pages swapped in (via compression segments) */
-	uint64_t        swapouts;               /* # of pages swapped out (via compression segments) */
-	natural_t       compressor_page_count;  /* # of pages used by the compressed pager to hold all the compressed data */
-	natural_t       throttled_count;        /* # of pages throttled */
-	natural_t       external_page_count;    /* # of pages that are file-backed (non-swap) */
-	natural_t       internal_page_count;    /* # of pages that are anonymous */
-	uint64_t        total_uncompressed_pages_in_compressor; /* # of pages (uncompressed) held within the compressor. */
-} __attribute__((aligned(8)));
-
-typedef struct vm_statistics64  *vm_statistics64_t;
-typedef struct vm_statistics64  vm_statistics64_data_t;
-
-/*
- * VM_STATISTICS_TRUNCATE_TO_32_BIT
- *
- * This is used by host_statistics() to truncate and peg the 64-bit in-kernel values from
- * vm_statistics64 to the 32-bit values of the older structure above (vm_statistics).
- */
-#define VM_STATISTICS_TRUNCATE_TO_32_BIT(value) ((uint32_t)(((value) > UINT32_MAX ) ? UINT32_MAX : (value)))
-
-/*
- * vm_extmod_statistics
- *
- * Structure to record modifications to a task by an
- * external agent.
- *
- * History:
- *	rev0 -  original structure.
- */
-
-struct vm_extmod_statistics {
-	int64_t task_for_pid_count;                     /* # of times task port was looked up */
-	int64_t task_for_pid_caller_count;      /* # of times this task called task_for_pid */
-	int64_t thread_creation_count;          /* # of threads created in task */
-	int64_t thread_creation_caller_count;   /* # of threads created by task */
-	int64_t thread_set_state_count;         /* # of register state sets in task */
-	int64_t thread_set_state_caller_count;  /* # of register state sets by task */
-} __attribute__((aligned(8)));
-
-typedef struct vm_extmod_statistics *vm_extmod_statistics_t;
-typedef struct vm_extmod_statistics vm_extmod_statistics_data_t;
-
-typedef struct vm_purgeable_stat {
-	uint64_t        count;
-	uint64_t        size;
-}vm_purgeable_stat_t;
-
-struct vm_purgeable_info {
-	vm_purgeable_stat_t fifo_data[8];
-	vm_purgeable_stat_t obsolete_data;
-	vm_purgeable_stat_t lifo_data[8];
-};
-
-typedef struct vm_purgeable_info        *vm_purgeable_info_t;
-
-/* included for the vm_map_page_query call */
-
-#define VM_PAGE_QUERY_PAGE_PRESENT      0x1
-#define VM_PAGE_QUERY_PAGE_FICTITIOUS   0x2
-#define VM_PAGE_QUERY_PAGE_REF          0x4
-#define VM_PAGE_QUERY_PAGE_DIRTY        0x8
-#define VM_PAGE_QUERY_PAGE_PAGED_OUT    0x10
-#define VM_PAGE_QUERY_PAGE_COPIED       0x20
-#define VM_PAGE_QUERY_PAGE_SPECULATIVE  0x40
-#define VM_PAGE_QUERY_PAGE_EXTERNAL     0x80
-#define VM_PAGE_QUERY_PAGE_CS_VALIDATED 0x100
-#define VM_PAGE_QUERY_PAGE_CS_TAINTED   0x200
-#define VM_PAGE_QUERY_PAGE_CS_NX        0x400
-#define VM_PAGE_QUERY_PAGE_REUSABLE     0x800
-
-
-/*
- * VM allocation flags:
- *
- * VM_FLAGS_FIXED
- *      (really the absence of VM_FLAGS_ANYWHERE)
- *	Allocate new VM region at the specified virtual address, if possible.
- *
- * VM_FLAGS_ANYWHERE
- *	Allocate new VM region anywhere it would fit in the address space.
- *
- * VM_FLAGS_PURGABLE
- *	Create a purgable VM object for that new VM region.
- *
- * VM_FLAGS_4GB_CHUNK
- *	The new VM region will be chunked up into 4GB sized pieces.
- *
- * VM_FLAGS_NO_PMAP_CHECK
- *	(for DEBUG kernel config only, ignored for other configs)
- *	Do not check that there is no stale pmap mapping for the new VM region.
- *	This is useful for kernel memory allocations at bootstrap when building
- *	the initial kernel address space while some memory is already in use.
- *
- * VM_FLAGS_OVERWRITE
- *	The new VM region can replace existing VM regions if necessary
- *	(to be used in combination with VM_FLAGS_FIXED).
- *
- * VM_FLAGS_NO_CACHE
- *	Pages brought in to this VM region are placed on the speculative
- *	queue instead of the active queue.  In other words, they are not
- *	cached so that they will be stolen first if memory runs low.
- */
-
-#define VM_FLAGS_FIXED          0x0000
-#define VM_FLAGS_ANYWHERE       0x0001
-#define VM_FLAGS_PURGABLE       0x0002
-#define VM_FLAGS_4GB_CHUNK      0x0004
-#define VM_FLAGS_RANDOM_ADDR    0x0008
-#define VM_FLAGS_NO_CACHE       0x0010
-#define VM_FLAGS_RESILIENT_CODESIGN     0x0020
-#define VM_FLAGS_RESILIENT_MEDIA        0x0040
-#define VM_FLAGS_OVERWRITE      0x4000  /* delete any existing mappings first */
-/*
- * VM_FLAGS_SUPERPAGE_MASK
- *	3 bits that specify whether large pages should be used instead of
- *	base pages (!=0), as well as the requested page size.
- */
-#define VM_FLAGS_SUPERPAGE_MASK 0x70000 /* bits 0x10000, 0x20000, 0x40000 */
-#define VM_FLAGS_RETURN_DATA_ADDR       0x100000 /* Return address of target data, rather than base of page */
-#define VM_FLAGS_RETURN_4K_DATA_ADDR    0x800000 /* Return 4K aligned address of target data */
-#define VM_FLAGS_ALIAS_MASK     0xFF000000
-#define VM_GET_FLAGS_ALIAS(flags, alias)                        \
-	        (alias) = ((flags) & VM_FLAGS_ALIAS_MASK) >> 24
-#define VM_SET_FLAGS_ALIAS(flags, alias)                        \
-	        (flags) = (((flags) & ~VM_FLAGS_ALIAS_MASK) |   \
-	        (((alias) & ~VM_FLAGS_ALIAS_MASK) << 24))
-
-/* These are the flags that we accept from user-space */
-#define VM_FLAGS_USER_ALLOCATE  (VM_FLAGS_FIXED |               \
-	                         VM_FLAGS_ANYWHERE |            \
-	                         VM_FLAGS_PURGABLE |            \
-	                         VM_FLAGS_4GB_CHUNK |           \
-	                         VM_FLAGS_RANDOM_ADDR |         \
-	                         VM_FLAGS_NO_CACHE |            \
-	                         VM_FLAGS_OVERWRITE |           \
-	                         VM_FLAGS_SUPERPAGE_MASK |      \
-	                         VM_FLAGS_ALIAS_MASK)
-#define VM_FLAGS_USER_MAP       (VM_FLAGS_USER_ALLOCATE |       \
-	                         VM_FLAGS_RETURN_4K_DATA_ADDR | \
-	                         VM_FLAGS_RETURN_DATA_ADDR)
-#define VM_FLAGS_USER_REMAP     (VM_FLAGS_FIXED |               \
-	                         VM_FLAGS_ANYWHERE |            \
-	                         VM_FLAGS_RANDOM_ADDR |         \
-	                         VM_FLAGS_OVERWRITE|            \
-	                         VM_FLAGS_RETURN_DATA_ADDR |    \
-	                         VM_FLAGS_RESILIENT_CODESIGN |  \
-	                         VM_FLAGS_RESILIENT_MEDIA)
-
-#define VM_FLAGS_SUPERPAGE_SHIFT 16
-#define SUPERPAGE_NONE                  0       /* no superpages, if all bits are 0 */
-#define SUPERPAGE_SIZE_ANY              1
-#define VM_FLAGS_SUPERPAGE_NONE     (SUPERPAGE_NONE     << VM_FLAGS_SUPERPAGE_SHIFT)
-#define VM_FLAGS_SUPERPAGE_SIZE_ANY (SUPERPAGE_SIZE_ANY << VM_FLAGS_SUPERPAGE_SHIFT)
-#define SUPERPAGE_SIZE_2MB              2
-#define VM_FLAGS_SUPERPAGE_SIZE_2MB (SUPERPAGE_SIZE_2MB<<VM_FLAGS_SUPERPAGE_SHIFT)
-
-/*
- * EXC_GUARD definitions for virtual memory.
- */
-#define GUARD_TYPE_VIRT_MEMORY  0x5
-
-/* Reasons for exception for virtual memory */
-enum virtual_memory_guard_exception_codes {
-	kGUARD_EXC_DEALLOC_GAP  = 1u << 0
-};
-
-
-/* current accounting postmark */
-#define __VM_LEDGER_ACCOUNTING_POSTMARK 2019032600
-
-/* discrete values: */
-#define VM_LEDGER_TAG_NONE      0x00000000
-#define VM_LEDGER_TAG_DEFAULT   0x00000001
-#define VM_LEDGER_TAG_NETWORK   0x00000002
-#define VM_LEDGER_TAG_MEDIA     0x00000003
-#define VM_LEDGER_TAG_GRAPHICS  0x00000004
-#define VM_LEDGER_TAG_NEURAL    0x00000005
-#define VM_LEDGER_TAG_MAX       0x00000005
-/* individual bits: */
-#define VM_LEDGER_FLAG_NO_FOOTPRINT     0x00000001
-#define VM_LEDGER_FLAGS (VM_LEDGER_FLAG_NO_FOOTPRINT)
-
-
-#define VM_MEMORY_MALLOC 1
-#define VM_MEMORY_MALLOC_SMALL 2
-#define VM_MEMORY_MALLOC_LARGE 3
-#define VM_MEMORY_MALLOC_HUGE 4
-#define VM_MEMORY_SBRK 5// uninteresting -- no one should call
-#define VM_MEMORY_REALLOC 6
-#define VM_MEMORY_MALLOC_TINY 7
-#define VM_MEMORY_MALLOC_LARGE_REUSABLE 8
-#define VM_MEMORY_MALLOC_LARGE_REUSED 9
-
-#define VM_MEMORY_ANALYSIS_TOOL 10
-
-#define VM_MEMORY_MALLOC_NANO 11
-#define VM_MEMORY_MALLOC_MEDIUM 12
-
-#define VM_MEMORY_MACH_MSG 20
-#define VM_MEMORY_IOKIT 21
-#define VM_MEMORY_STACK  30
-#define VM_MEMORY_GUARD  31
-#define VM_MEMORY_SHARED_PMAP 32
-/* memory containing a dylib */
-#define VM_MEMORY_DYLIB 33
-#define VM_MEMORY_OBJC_DISPATCHERS 34
-
-/* Was a nested pmap (VM_MEMORY_SHARED_PMAP) which has now been unnested */
-#define VM_MEMORY_UNSHARED_PMAP 35
-
-
-// Placeholders for now -- as we analyze the libraries and find how they
-// use memory, we can make these labels more specific.
-#define VM_MEMORY_APPKIT 40
-#define VM_MEMORY_FOUNDATION 41
-#define VM_MEMORY_COREGRAPHICS 42
-#define VM_MEMORY_CORESERVICES 43
-#define VM_MEMORY_CARBON VM_MEMORY_CORESERVICES
-#define VM_MEMORY_JAVA 44
-#define VM_MEMORY_COREDATA 45
-#define VM_MEMORY_COREDATA_OBJECTIDS 46
-#define VM_MEMORY_ATS 50
-#define VM_MEMORY_LAYERKIT 51
-#define VM_MEMORY_CGIMAGE 52
-#define VM_MEMORY_TCMALLOC 53
-
-/* private raster data (i.e. layers, some images, QGL allocator) */
-#define VM_MEMORY_COREGRAPHICS_DATA     54
-
-/* shared image and font caches */
-#define VM_MEMORY_COREGRAPHICS_SHARED   55
-
-/* Memory used for virtual framebuffers, shadowing buffers, etc... */
-#define VM_MEMORY_COREGRAPHICS_FRAMEBUFFERS     56
-
-/* Window backing stores, custom shadow data, and compressed backing stores */
-#define VM_MEMORY_COREGRAPHICS_BACKINGSTORES    57
-
-/* x-alloc'd memory */
-#define VM_MEMORY_COREGRAPHICS_XALLOC 58
-
-/* catch-all for other uses, such as the read-only shared data page */
-#define VM_MEMORY_COREGRAPHICS_MISC VM_MEMORY_COREGRAPHICS
-
-/* memory allocated by the dynamic loader for itself */
-#define VM_MEMORY_DYLD 60
-/* malloc'd memory created by dyld */
-#define VM_MEMORY_DYLD_MALLOC 61
-
-/* Used for sqlite page cache */
-#define VM_MEMORY_SQLITE 62
-
-/* JavaScriptCore heaps */
-#define VM_MEMORY_JAVASCRIPT_CORE 63
-#define VM_MEMORY_WEBASSEMBLY VM_MEMORY_JAVASCRIPT_CORE
-/* memory allocated for the JIT */
-#define VM_MEMORY_JAVASCRIPT_JIT_EXECUTABLE_ALLOCATOR 64
-#define VM_MEMORY_JAVASCRIPT_JIT_REGISTER_FILE 65
-
-/* memory allocated for GLSL */
-#define VM_MEMORY_GLSL  66
-
-/* memory allocated for OpenCL.framework */
-#define VM_MEMORY_OPENCL    67
-
-/* memory allocated for QuartzCore.framework */
-#define VM_MEMORY_COREIMAGE 68
-
-/* memory allocated for WebCore Purgeable Buffers */
-#define VM_MEMORY_WEBCORE_PURGEABLE_BUFFERS 69
-
-/* ImageIO memory */
-#define VM_MEMORY_IMAGEIO       70
-
-/* CoreProfile memory */
-#define VM_MEMORY_COREPROFILE   71
-
-/* assetsd / MobileSlideShow memory */
-#define VM_MEMORY_ASSETSD       72
-
-/* libsystem_kernel os_once_alloc */
-#define VM_MEMORY_OS_ALLOC_ONCE 73
-
-/* libdispatch internal allocator */
-#define VM_MEMORY_LIBDISPATCH 74
-
-/* Accelerate.framework image backing stores */
-#define VM_MEMORY_ACCELERATE 75
-
-/* CoreUI image block data */
-#define VM_MEMORY_COREUI 76
-
-/* CoreUI image file */
-#define VM_MEMORY_COREUIFILE 77
-
-/* Genealogy buffers */
-#define VM_MEMORY_GENEALOGY 78
-
-/* RawCamera VM allocated memory */
-#define VM_MEMORY_RAWCAMERA 79
-
-/* corpse info for dead process */
-#define VM_MEMORY_CORPSEINFO 80
-
-/* Apple System Logger (ASL) messages */
-#define VM_MEMORY_ASL 81
-
-/* Swift runtime */
-#define VM_MEMORY_SWIFT_RUNTIME 82
-
-/* Swift metadata */
-#define VM_MEMORY_SWIFT_METADATA 83
-
-/* DHMM data */
-#define VM_MEMORY_DHMM 84
-
-
-/* memory allocated by SceneKit.framework */
-#define VM_MEMORY_SCENEKIT 86
-
-/* memory allocated by skywalk networking */
-#define VM_MEMORY_SKYWALK 87
-
-#define VM_MEMORY_IOSURFACE 88
-
-#define VM_MEMORY_LIBNETWORK 89
-
-#define VM_MEMORY_AUDIO 90
-
-#define VM_MEMORY_VIDEOBITSTREAM 91
-
-/* memory allocated by CoreMedia */
-#define VM_MEMORY_CM_XPC 92
-
-#define VM_MEMORY_CM_RPC 93
-
-#define VM_MEMORY_CM_MEMORYPOOL 94
-
-#define VM_MEMORY_CM_READCACHE 95
-
-#define VM_MEMORY_CM_CRABS 96
-
-/* memory allocated for QuickLookThumbnailing */
-#define VM_MEMORY_QUICKLOOK_THUMBNAILS 97
-
-/* memory allocated by Accounts framework */
-#define VM_MEMORY_ACCOUNTS 98
-
-/* memory allocated by Sanitizer runtime libraries */
-#define VM_MEMORY_SANITIZER 99
-
-/* Differentiate memory needed by GPU drivers and frameworks from generic IOKit allocations */
-#define VM_MEMORY_IOACCELERATOR 100
-
-/* memory allocated by CoreMedia for global image registration of frames */
-#define VM_MEMORY_CM_REGWARP 101
-
-/* Reserve 240-255 for application */
-#define VM_MEMORY_APPLICATION_SPECIFIC_1 240
-#define VM_MEMORY_APPLICATION_SPECIFIC_16 255
-
-#define VM_MAKE_TAG(tag) ((tag) << 24)
-
-
-
-#endif  /* _MACH_VM_STATISTICS_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/mach/vm_types.h b/lib/libc/include/x86_64-macos-gnu/mach/vm_types.h
deleted file mode 100644
index 18ff9ae771..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/mach/vm_types.h
+++ /dev/null
@@ -1,95 +0,0 @@
-/*
- * Copyright (c) 2000-2018 Apple Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-/*
- * @OSF_COPYRIGHT@
- *
- */
-#ifndef _MACH_VM_TYPES_H_
-#define _MACH_VM_TYPES_H_
-
-#include <mach/port.h>
-#include <mach/machine/vm_types.h>
-
-#include <stdint.h>
-
-typedef vm_offset_t             pointer_t;
-typedef vm_offset_t             vm_address_t;
-
-/*
- * We use addr64_t for 64-bit addresses that are used on both
- * 32 and 64-bit machines.  On PPC, they are passed and returned as
- * two adjacent 32-bit GPRs.  We use addr64_t in places where
- * common code must be useable both on 32 and 64-bit machines.
- */
-typedef uint64_t addr64_t;              /* Basic effective address */
-
-/*
- * We use reg64_t for addresses that are 32 bits on a 32-bit
- * machine, and 64 bits on a 64-bit machine, but are always
- * passed and returned in a single GPR on PPC.  This type
- * cannot be used in generic 32-bit c, since on a 64-bit
- * machine the upper half of the register will be ignored
- * by the c compiler in 32-bit mode.  In c, we can only use the
- * type in prototypes of functions that are written in and called
- * from assembly language.  This type is basically a comment.
- */
-typedef uint32_t        reg64_t;
-
-/*
- * To minimize the use of 64-bit fields, we keep some physical
- * addresses (that are page aligned) as 32-bit page numbers.
- * This limits the physical address space to 16TB of RAM.
- */
-typedef uint32_t ppnum_t;               /* Physical page number */
-#define PPNUM_MAX UINT32_MAX
-
-
-
-typedef mach_port_t             vm_map_t;
-
-
-#define VM_MAP_NULL             ((vm_map_t) 0)
-
-/*
- * Evolving definitions, likely to change.
- */
-
-typedef uint64_t                vm_object_offset_t;
-typedef uint64_t                vm_object_size_t;
-
-
-
-
-typedef mach_port_t             upl_t;
-typedef mach_port_t             vm_named_entry_t;
-
-
-#define UPL_NULL                ((upl_t) 0)
-#define VM_NAMED_ENTRY_NULL     ((vm_named_entry_t) 0)
-
-#endif  /* _MACH_VM_TYPES_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/mach_debug/ipc_info.h b/lib/libc/include/x86_64-macos-gnu/mach_debug/ipc_info.h
deleted file mode 100644
index deb07cac5e..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/mach_debug/ipc_info.h
+++ /dev/null
@@ -1,116 +0,0 @@
-/*
- * Copyright (c) 2000-2005 Apple Computer, Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-/*
- * @OSF_COPYRIGHT@
- */
-/*
- * Mach Operating System
- * Copyright (c) 1991,1990 Carnegie Mellon University
- * All Rights Reserved.
- *
- * Permission to use, copy, modify and distribute this software and its
- * documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
- * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie Mellon
- * the rights to redistribute these changes.
- */
-/*
- */
-/*
- *	File:	mach_debug/ipc_info.h
- *	Author:	Rich Draves
- *	Date:	March, 1990
- *
- *	Definitions for the IPC debugging interface.
- */
-
-#ifndef _MACH_DEBUG_IPC_INFO_H_
-#define _MACH_DEBUG_IPC_INFO_H_
-
-#include <mach/boolean.h>
-#include <mach/port.h>
-#include <mach/machine/vm_types.h>
-
-/*
- *	Remember to update the mig type definitions
- *	in mach_debug_types.defs when adding/removing fields.
- */
-
-typedef struct ipc_info_space {
-	natural_t iis_genno_mask;       /* generation number mask */
-	natural_t iis_table_size;       /* size of table */
-	natural_t iis_table_next;       /* next possible size of table */
-	natural_t iis_tree_size;        /* size of tree (UNUSED) */
-	natural_t iis_tree_small;       /* # of small entries in tree (UNUSED) */
-	natural_t iis_tree_hash;        /* # of hashed entries in tree (UNUSED) */
-} ipc_info_space_t;
-
-typedef struct ipc_info_space_basic {
-	natural_t iisb_genno_mask;      /* generation number mask */
-	natural_t iisb_table_size;      /* size of table */
-	natural_t iisb_table_next;      /* next possible size of table */
-	natural_t iisb_table_inuse;     /* number of entries in use */
-	natural_t iisb_reserved[2];     /* future expansion */
-} ipc_info_space_basic_t;
-
-typedef struct ipc_info_name {
-	mach_port_name_t iin_name;              /* port name, including gen number */
-/*boolean_t*/ integer_t iin_collision;   /* collision at this entry? */
-	mach_port_type_t iin_type;      /* straight port type */
-	mach_port_urefs_t iin_urefs;    /* user-references */
-	natural_t iin_object;           /* object pointer/identifier */
-	natural_t iin_next;             /* marequest/next in free list */
-	natural_t iin_hash;             /* hash index */
-} ipc_info_name_t;
-
-typedef ipc_info_name_t *ipc_info_name_array_t;
-
-/* UNUSED */
-typedef struct ipc_info_tree_name {
-	ipc_info_name_t iitn_name;
-	mach_port_name_t iitn_lchild;   /* name of left child */
-	mach_port_name_t iitn_rchild;   /* name of right child */
-} ipc_info_tree_name_t;
-
-typedef ipc_info_tree_name_t *ipc_info_tree_name_array_t;
-
-#endif  /* _MACH_DEBUG_IPC_INFO_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/machine/_mcontext.h b/lib/libc/include/x86_64-macos-gnu/machine/_mcontext.h
deleted file mode 100644
index 9ccd985fcc..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/machine/_mcontext.h
+++ /dev/null
@@ -1,32 +0,0 @@
-/*
- * Copyright (c) 2003-2012 Apple Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-#if defined (__i386__) || defined (__x86_64__)
-#include "i386/_mcontext.h"
-#else
-#error architecture not supported
-#endif
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/machine/_param.h b/lib/libc/include/x86_64-macos-gnu/machine/_param.h
deleted file mode 100644
index c40232c3c2..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/machine/_param.h
+++ /dev/null
@@ -1,32 +0,0 @@
-/*
- * Copyright (c) 2004-2007 Apple Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-#if defined (__i386__) || defined (__x86_64__)
-#include "i386/_param.h"
-#else
-#error architecture not supported
-#endif
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/machine/_types.h b/lib/libc/include/x86_64-macos-gnu/machine/_types.h
deleted file mode 100644
index 0ed6acf677..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/machine/_types.h
+++ /dev/null
@@ -1,37 +0,0 @@
-/*
- * Copyright (c) 2003-2007 Apple Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-#ifndef _BSD_MACHINE__TYPES_H_
-#define _BSD_MACHINE__TYPES_H_
-
-#if defined (__i386__) || defined(__x86_64__)
-#include "i386/_types.h"
-#else
-#error architecture not supported
-#endif
-
-#endif /* _BSD_MACHINE__TYPES_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/machine/endian.h b/lib/libc/include/x86_64-macos-gnu/machine/endian.h
deleted file mode 100644
index 85c8f12508..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/machine/endian.h
+++ /dev/null
@@ -1,40 +0,0 @@
-/*
- * Copyright (c) 2000-2007 Apple Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-/*
- * Copyright 1995 NeXT Computer, Inc. All rights reserved.
- */
-#ifndef _BSD_MACHINE_ENDIAN_H_
-#define _BSD_MACHINE_ENDIAN_H_
-
-#if defined (__i386__) || defined(__x86_64__)
-#include "i386/endian.h"
-#else
-#error architecture not supported
-#endif
-
-#endif /* _BSD_MACHINE_ENDIAN_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/machine/limits.h b/lib/libc/include/x86_64-macos-gnu/machine/limits.h
deleted file mode 100644
index 9763e810b6..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/machine/limits.h
+++ /dev/null
@@ -1,9 +0,0 @@
-/* This is the `system' limits.h, independent of any particular
- *  compiler.  GCC provides its own limits.h which can be found in
- *  /usr/lib/gcc, although it is not very informative.
- *  This file is public domain.  */
-#if defined (__i386__) || defined(__x86_64__)
-#include <i386/limits.h>
-#else
-#error architecture not supported
-#endif
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/machine/param.h b/lib/libc/include/x86_64-macos-gnu/machine/param.h
deleted file mode 100644
index 8435acbdfb..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/machine/param.h
+++ /dev/null
@@ -1,40 +0,0 @@
-/*
- * Copyright (c) 2000-2007 Apple Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-/*
- * Copyright 1995 NeXT Computer, Inc. All rights reserved.
- */
-#ifndef _BSD_MACHINE_PARAM_H_
-#define _BSD_MACHINE_PARAM_H_
-
-#if defined (__i386__) || defined(__x86_64__)
-#include "i386/param.h"
-#else
-#error architecture not supported
-#endif
-
-#endif /* _BSD_MACHINE_PARAM_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/machine/signal.h b/lib/libc/include/x86_64-macos-gnu/machine/signal.h
deleted file mode 100644
index 19ef535ebd..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/machine/signal.h
+++ /dev/null
@@ -1,37 +0,0 @@
-/*
- * Copyright (c) 2000-2007 Apple Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-#ifndef _BSD_MACHINE_SIGNAL_H_
-#define _BSD_MACHINE_SIGNAL_H_
-
-#if defined (__i386__) || defined(__x86_64__)
-#include "i386/signal.h"
-#else
-#error architecture not supported
-#endif
-
-#endif /* _BSD_MACHINE_SIGNAL_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/machine/types.h b/lib/libc/include/x86_64-macos-gnu/machine/types.h
deleted file mode 100644
index 5d1a1e575f..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/machine/types.h
+++ /dev/null
@@ -1,40 +0,0 @@
-/*
- * Copyright (c) 2000-2007 Apple Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-/*
- * Copyright 1995 NeXT Computer, Inc. All rights reserved.
- */
-#ifndef _BSD_MACHINE_TYPES_H_
-#define _BSD_MACHINE_TYPES_H_
-
-#if defined (__i386__) || defined(__x86_64__)
-#include "i386/types.h"
-#else
-#error architecture not supported
-#endif
-
-#endif /* _BSD_MACHINE_TYPES_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/malloc/_malloc.h b/lib/libc/include/x86_64-macos-gnu/malloc/_malloc.h
deleted file mode 100644
index 91555d11bb..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/malloc/_malloc.h
+++ /dev/null
@@ -1,56 +0,0 @@
-/*
- * Copyright (c) 2018 Apple Computer, Inc. All rights reserved.
- *
- * @APPLE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this
- * file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_LICENSE_HEADER_END@
- */
-
-#ifndef _MALLOC_UNDERSCORE_MALLOC_H_
-#define _MALLOC_UNDERSCORE_MALLOC_H_
-
-/*
- * This header is included from <stdlib.h>, so the contents of this file have
- * broad source compatibility and POSIX conformance implications.
- * Be cautious about what is included and declared here.
- */
-
-#include <Availability.h>
-#include <sys/cdefs.h>
-#include <_types.h>
-#include <sys/_types/_size_t.h>
-
-__BEGIN_DECLS
-
-void	*malloc(size_t __size) __result_use_check __alloc_size(1);
-void	*calloc(size_t __count, size_t __size) __result_use_check __alloc_size(1,2);
-void	 free(void *);
-void	*realloc(void *__ptr, size_t __size) __result_use_check __alloc_size(2);
-#if !defined(_ANSI_SOURCE) && (!defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE))
-void	*valloc(size_t) __alloc_size(1);
-#endif // !defined(_ANSI_SOURCE) && (!defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE))
-#if (__DARWIN_C_LEVEL >= __DARWIN_C_FULL) && \
-        ((defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L) || \
-         (defined(__cplusplus) && __cplusplus >= 201703L))
-void    *aligned_alloc(size_t __alignment, size_t __size) __result_use_check __alloc_size(2) __OSX_AVAILABLE(10.15) __IOS_AVAILABLE(13.0) __TVOS_AVAILABLE(13.0) __WATCHOS_AVAILABLE(6.0);
-#endif
-int 	 posix_memalign(void **__memptr, size_t __alignment, size_t __size) __OSX_AVAILABLE_STARTING(__MAC_10_6, __IPHONE_3_0);
-
-__END_DECLS
-
-#endif /* _MALLOC_UNDERSCORE_MALLOC_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/malloc/malloc.h b/lib/libc/include/x86_64-macos-gnu/malloc/malloc.h
deleted file mode 100644
index 0bddfda43b..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/malloc/malloc.h
+++ /dev/null
@@ -1,314 +0,0 @@
-/*
- * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
- *
- * @APPLE_LICENSE_HEADER_START@
- * 
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this
- * file.
- * 
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- * 
- * @APPLE_LICENSE_HEADER_END@
- */
-
-#ifndef _MALLOC_MALLOC_H_
-#define _MALLOC_MALLOC_H_
-
-#include <stddef.h>
-#include <mach/mach_types.h>
-#include <sys/cdefs.h>
-#include <Availability.h>
-
-#if __has_feature(ptrauth_calls)
-#include <ptrauth.h>
-
-// Zone function pointer, type-diversified but not address-diversified (because
-// the zone can be copied). Process-independent because the zone structure may
-// be in the shared library cache.
-#define MALLOC_ZONE_FN_PTR(fn) __ptrauth(ptrauth_key_process_independent_code, \
-		FALSE, ptrauth_string_discriminator("malloc_zone_fn." #fn)) fn
-
-// Introspection function pointer, address- and type-diversified.
-// Process-independent because the malloc_introspection_t structure that contains
-// these pointers may be in the shared library cache.
-#define MALLOC_INTROSPECT_FN_PTR(fn) __ptrauth(ptrauth_key_process_independent_code, \
-		TRUE, ptrauth_string_discriminator("malloc_introspect_fn." #fn)) fn
-
-// Pointer to the introspection pointer table, type-diversified but not
-// address-diversified (because the zone can be copied).
-// Process-independent because the table pointer may be in the shared library cache.
-#define MALLOC_INTROSPECT_TBL_PTR(ptr) __ptrauth(ptrauth_key_process_independent_data,\
-		FALSE, ptrauth_string_discriminator("malloc_introspect_tbl")) ptr
-
-#endif	// __has_feature(ptrauth_calls)
-
-#ifndef MALLOC_ZONE_FN_PTR
-#define MALLOC_ZONE_FN_PTR(fn) fn
-#define MALLOC_INTROSPECT_FN_PTR(fn) fn
-#define MALLOC_INTROSPECT_TBL_PTR(ptr) ptr
-#endif // MALLOC_ZONE_FN_PTR
-
-__BEGIN_DECLS
-/*********	Type definitions	************/
-
-typedef struct _malloc_zone_t {
-    /* Only zone implementors should depend on the layout of this structure;
-    Regular callers should use the access functions below */
-    void	*reserved1;	/* RESERVED FOR CFAllocator DO NOT USE */
-    void	*reserved2;	/* RESERVED FOR CFAllocator DO NOT USE */
-    size_t 	(* MALLOC_ZONE_FN_PTR(size))(struct _malloc_zone_t *zone, const void *ptr); /* returns the size of a block or 0 if not in this zone; must be fast, especially for negative answers */
-    void 	*(* MALLOC_ZONE_FN_PTR(malloc))(struct _malloc_zone_t *zone, size_t size);
-    void 	*(* MALLOC_ZONE_FN_PTR(calloc))(struct _malloc_zone_t *zone, size_t num_items, size_t size); /* same as malloc, but block returned is set to zero */
-    void 	*(* MALLOC_ZONE_FN_PTR(valloc))(struct _malloc_zone_t *zone, size_t size); /* same as malloc, but block returned is set to zero and is guaranteed to be page aligned */
-    void 	(* MALLOC_ZONE_FN_PTR(free))(struct _malloc_zone_t *zone, void *ptr);
-    void 	*(* MALLOC_ZONE_FN_PTR(realloc))(struct _malloc_zone_t *zone, void *ptr, size_t size);
-    void 	(* MALLOC_ZONE_FN_PTR(destroy))(struct _malloc_zone_t *zone); /* zone is destroyed and all memory reclaimed */
-    const char	*zone_name;
-
-    /* Optional batch callbacks; these may be NULL */
-    unsigned	(* MALLOC_ZONE_FN_PTR(batch_malloc))(struct _malloc_zone_t *zone, size_t size, void **results, unsigned num_requested); /* given a size, returns pointers capable of holding that size; returns the number of pointers allocated (maybe 0 or less than num_requested) */
-    void	(* MALLOC_ZONE_FN_PTR(batch_free))(struct _malloc_zone_t *zone, void **to_be_freed, unsigned num_to_be_freed); /* frees all the pointers in to_be_freed; note that to_be_freed may be overwritten during the process */
-
-    struct malloc_introspection_t	* MALLOC_INTROSPECT_TBL_PTR(introspect);
-    unsigned	version;
-    	
-    /* aligned memory allocation. The callback may be NULL. Present in version >= 5. */
-    void *(* MALLOC_ZONE_FN_PTR(memalign))(struct _malloc_zone_t *zone, size_t alignment, size_t size);
-    
-    /* free a pointer known to be in zone and known to have the given size. The callback may be NULL. Present in version >= 6.*/
-    void (* MALLOC_ZONE_FN_PTR(free_definite_size))(struct _malloc_zone_t *zone, void *ptr, size_t size);
-
-    /* Empty out caches in the face of memory pressure. The callback may be NULL. Present in version >= 8. */
-    size_t 	(* MALLOC_ZONE_FN_PTR(pressure_relief))(struct _malloc_zone_t *zone, size_t goal);
-
-	/*
-	 * Checks whether an address might belong to the zone. May be NULL. Present in version >= 10.
-	 * False positives are allowed (e.g. the pointer was freed, or it's in zone space that has
-	 * not yet been allocated. False negatives are not allowed.
-	 */
-    boolean_t (* MALLOC_ZONE_FN_PTR(claimed_address))(struct _malloc_zone_t *zone, void *ptr);
-} malloc_zone_t;
-
-/*********	Creation and destruction	************/
-
-extern malloc_zone_t *malloc_default_zone(void);
-    /* The initial zone */
-
-extern malloc_zone_t *malloc_create_zone(vm_size_t start_size, unsigned flags);
-    /* Creates a new zone with default behavior and registers it */
-
-extern void malloc_destroy_zone(malloc_zone_t *zone);
-    /* Destroys zone and everything it allocated */
-
-/*********	Block creation and manipulation	************/
-
-extern void *malloc_zone_malloc(malloc_zone_t *zone, size_t size) __alloc_size(2);
-    /* Allocates a new pointer of size size; zone must be non-NULL */
-
-extern void *malloc_zone_calloc(malloc_zone_t *zone, size_t num_items, size_t size) __alloc_size(2,3);
-    /* Allocates a new pointer of size num_items * size; block is cleared; zone must be non-NULL */
-
-extern void *malloc_zone_valloc(malloc_zone_t *zone, size_t size) __alloc_size(2);
-    /* Allocates a new pointer of size size; zone must be non-NULL; Pointer is guaranteed to be page-aligned and block is cleared */
-
-extern void malloc_zone_free(malloc_zone_t *zone, void *ptr);
-    /* Frees pointer in zone; zone must be non-NULL */
-
-extern void *malloc_zone_realloc(malloc_zone_t *zone, void *ptr, size_t size) __alloc_size(3);
-    /* Enlarges block if necessary; zone must be non-NULL */
-
-extern malloc_zone_t *malloc_zone_from_ptr(const void *ptr);
-    /* Returns the zone for a pointer, or NULL if not in any zone.
-    The ptr must have been returned from a malloc or realloc call. */
-
-extern size_t malloc_size(const void *ptr);
-    /* Returns size of given ptr */
-
-extern size_t malloc_good_size(size_t size);
-    /* Returns number of bytes greater than or equal to size that can be allocated without padding */
-
-extern void *malloc_zone_memalign(malloc_zone_t *zone, size_t alignment, size_t size) __alloc_size(3) __OSX_AVAILABLE_STARTING(__MAC_10_6, __IPHONE_3_0);
-    /* 
-     * Allocates a new pointer of size size whose address is an exact multiple of alignment.
-     * alignment must be a power of two and at least as large as sizeof(void *).
-     * zone must be non-NULL.
-     */
-
-/*********	Batch methods	************/
-
-extern unsigned malloc_zone_batch_malloc(malloc_zone_t *zone, size_t size, void **results, unsigned num_requested);
-    /* Allocates num blocks of the same size; Returns the number truly allocated (may be 0) */
-
-extern void malloc_zone_batch_free(malloc_zone_t *zone, void **to_be_freed, unsigned num);
-    /* frees all the pointers in to_be_freed; note that to_be_freed may be overwritten during the process; This function will always free even if the zone has no batch callback */
-
-/*********	Functions for libcache	************/
-
-extern malloc_zone_t *malloc_default_purgeable_zone(void) __OSX_AVAILABLE_STARTING(__MAC_10_6, __IPHONE_3_0);
-    /* Returns a pointer to the default purgeable_zone. */
-
-extern void malloc_make_purgeable(void *ptr) __OSX_AVAILABLE_STARTING(__MAC_10_6, __IPHONE_3_0);
-    /* Make an allocation from the purgeable zone purgeable if possible.  */
-
-extern int malloc_make_nonpurgeable(void *ptr) __OSX_AVAILABLE_STARTING(__MAC_10_6, __IPHONE_3_0);
-    /* Makes an allocation from the purgeable zone nonpurgeable.
-     * Returns zero if the contents were not purged since the last
-     * call to malloc_make_purgeable, else returns non-zero. */
-
-/*********	Functions for zone implementors	************/
-
-extern void malloc_zone_register(malloc_zone_t *zone);
-    /* Registers a custom malloc zone; Should typically be called after a 
-     * malloc_zone_t has been filled in with custom methods by a client.  See
-     * malloc_create_zone for creating additional malloc zones with the
-     * default allocation and free behavior. */
-
-extern void malloc_zone_unregister(malloc_zone_t *zone);
-    /* De-registers a zone
-    Should typically be called before calling the zone destruction routine */
-
-extern void malloc_set_zone_name(malloc_zone_t *zone, const char *name);
-    /* Sets the name of a zone */
-
-extern const char *malloc_get_zone_name(malloc_zone_t *zone);
-    /* Returns the name of a zone */
-
-size_t malloc_zone_pressure_relief(malloc_zone_t *zone, size_t goal) __OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_4_3);
-    /* malloc_zone_pressure_relief() advises the malloc subsystem that the process is under memory pressure and 
-     * that the subsystem should make its best effort towards releasing (i.e. munmap()-ing) "goal" bytes from "zone". 
-     * If "goal" is passed as zero, the malloc subsystem will attempt to achieve maximal pressure relief in "zone". 
-     * If "zone" is passed as NULL, all zones are examined for pressure relief opportunities. 
-     * malloc_zone_pressure_relief() returns the number of bytes released. 
-     */
-
-typedef struct {
-    vm_address_t	address;
-    vm_size_t		size;
-} vm_range_t;
-
-typedef struct malloc_statistics_t {
-    unsigned	blocks_in_use;
-    size_t	size_in_use;
-    size_t	max_size_in_use;	/* high water mark of touched memory */
-    size_t	size_allocated;		/* reserved in memory */
-} malloc_statistics_t;
-
-typedef kern_return_t memory_reader_t(task_t remote_task, vm_address_t remote_address, vm_size_t size, void **local_memory);
-    /* given a task, "reads" the memory at the given address and size
-local_memory: set to a contiguous chunk of memory; validity of local_memory is assumed to be limited (until next call) */
-
-#define MALLOC_PTR_IN_USE_RANGE_TYPE	1	/* for allocated pointers */
-#define MALLOC_PTR_REGION_RANGE_TYPE	2	/* for region containing pointers */
-#define MALLOC_ADMIN_REGION_RANGE_TYPE	4	/* for region used internally */
-#define MALLOC_ZONE_SPECIFIC_FLAGS	0xff00	/* bits reserved for zone-specific purposes */
-
-typedef void vm_range_recorder_t(task_t, void *, unsigned type, vm_range_t *, unsigned);
-    /* given a task and context, "records" the specified addresses */
-
-/* Print function for the print_task() operation. */
-typedef void print_task_printer_t(const char *fmt, ...);
-
-typedef struct malloc_introspection_t {
-	kern_return_t (* MALLOC_INTROSPECT_FN_PTR(enumerator))(task_t task, void *, unsigned type_mask, vm_address_t zone_address, memory_reader_t reader, vm_range_recorder_t recorder); /* enumerates all the malloc pointers in use */
-	size_t	(* MALLOC_INTROSPECT_FN_PTR(good_size))(malloc_zone_t *zone, size_t size);
-	boolean_t 	(* MALLOC_INTROSPECT_FN_PTR(check))(malloc_zone_t *zone); /* Consistency checker */
-	void 	(* MALLOC_INTROSPECT_FN_PTR(print))(malloc_zone_t *zone, boolean_t verbose); /* Prints zone  */
-	void	(* MALLOC_INTROSPECT_FN_PTR(log))(malloc_zone_t *zone, void *address); /* Enables logging of activity */
-	void	(* MALLOC_INTROSPECT_FN_PTR(force_lock))(malloc_zone_t *zone); /* Forces locking zone */
-	void	(* MALLOC_INTROSPECT_FN_PTR(force_unlock))(malloc_zone_t *zone); /* Forces unlocking zone */
-	void	(* MALLOC_INTROSPECT_FN_PTR(statistics))(malloc_zone_t *zone, malloc_statistics_t *stats); /* Fills statistics */
-	boolean_t   (* MALLOC_INTROSPECT_FN_PTR(zone_locked))(malloc_zone_t *zone); /* Are any zone locks held */
-
-    /* Discharge checking. Present in version >= 7. */
-	boolean_t	(* MALLOC_INTROSPECT_FN_PTR(enable_discharge_checking))(malloc_zone_t *zone);
-	void	(* MALLOC_INTROSPECT_FN_PTR(disable_discharge_checking))(malloc_zone_t *zone);
-	void	(* MALLOC_INTROSPECT_FN_PTR(discharge))(malloc_zone_t *zone, void *memory);
-#ifdef __BLOCKS__
-	void     (* MALLOC_INTROSPECT_FN_PTR(enumerate_discharged_pointers))(malloc_zone_t *zone, void (^report_discharged)(void *memory, void *info));
-	#else
-    void	*enumerate_unavailable_without_blocks;   
-#endif /* __BLOCKS__ */
-	void	(* MALLOC_INTROSPECT_FN_PTR(reinit_lock))(malloc_zone_t *zone); /* Reinitialize zone locks, called only from atfork_child handler. Present in version >= 9. */
-	void	(* MALLOC_INTROSPECT_FN_PTR(print_task))(task_t task, unsigned level, vm_address_t zone_address, memory_reader_t reader, print_task_printer_t printer); /* debug print for another process. Present in version >= 11. */
-	void (* MALLOC_INTROSPECT_FN_PTR(task_statistics))(task_t task, vm_address_t zone_address, memory_reader_t reader, malloc_statistics_t *stats); /* Present in version >= 12 */
-} malloc_introspection_t;
-
-// The value of "level" when passed to print_task() that corresponds to
-// verbose passed to print()
-#define MALLOC_VERBOSE_PRINT_LEVEL	2
-
-extern void malloc_printf(const char *format, ...);
-    /* Convenience for logging errors and warnings;
-    No allocation is performed during execution of this function;
-    Only understands usual %p %d %s formats, and %y that expresses a number of bytes (5b,10KB,1MB...)
-    */
-
-/*********	Functions for performance tools	************/
-
-extern kern_return_t malloc_get_all_zones(task_t task, memory_reader_t reader, vm_address_t **addresses, unsigned *count);
-    /* Fills addresses and count with the addresses of the zones in task;
-    Note that the validity of the addresses returned correspond to the validity of the memory returned by reader */
-
-/*********	Debug helpers	************/
-
-extern void malloc_zone_print_ptr_info(void *ptr);
-    /* print to stdout if this pointer is in the malloc heap, free status, and size */
-
-extern boolean_t malloc_zone_check(malloc_zone_t *zone);
-    /* Checks zone is well formed; if !zone, checks all zones */
-
-extern void malloc_zone_print(malloc_zone_t *zone, boolean_t verbose);
-    /* Prints summary on zone; if !zone, prints all zones */
-
-extern void malloc_zone_statistics(malloc_zone_t *zone, malloc_statistics_t *stats);
-    /* Fills statistics for zone; if !zone, sums up all zones */
-
-extern void malloc_zone_log(malloc_zone_t *zone, void *address);
-    /* Controls logging of all activity; if !zone, for all zones;
-    If address==0 nothing is logged;
-    If address==-1 all activity is logged;
-    Else only the activity regarding address is logged */
-
-struct mstats {
-    size_t	bytes_total;
-    size_t	chunks_used;
-    size_t	bytes_used;
-    size_t	chunks_free;
-    size_t	bytes_free;
-};
-
-extern struct mstats mstats(void);
-
-extern boolean_t malloc_zone_enable_discharge_checking(malloc_zone_t *zone) __OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_4_3);
-/* Increment the discharge checking enabled counter for a zone. Returns true if the zone supports checking, false if it does not. */
-
-extern void malloc_zone_disable_discharge_checking(malloc_zone_t *zone) __OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_4_3);
-/* Decrement the discharge checking enabled counter for a zone. */
-
-extern void malloc_zone_discharge(malloc_zone_t *zone, void *memory) __OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_4_3);
-/* Register memory that the programmer expects to be freed soon. 
-   zone may be NULL in which case the zone is determined using malloc_zone_from_ptr(). 
-   If discharge checking is off for the zone this function is a no-op. */
- 
-#ifdef __BLOCKS__
-extern void malloc_zone_enumerate_discharged_pointers(malloc_zone_t *zone, void (^report_discharged)(void *memory, void *info)) __OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_4_3);
-/* Calls report_discharged for each block that was registered using malloc_zone_discharge() but has not yet been freed. 
-   info is used to provide zone defined information about the memory block. 
-   If zone is NULL then the enumeration covers all zones. */
-#else
-extern void malloc_zone_enumerate_discharged_pointers(malloc_zone_t *zone, void *) __OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_4_3);
-#endif /* __BLOCKS__ */
-
-__END_DECLS
-
-#endif /* _MALLOC_MALLOC_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/math.h b/lib/libc/include/x86_64-macos-gnu/math.h
deleted file mode 100644
index 8bb019247e..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/math.h
+++ /dev/null
@@ -1,771 +0,0 @@
-/*
- * Copyright (c) 2002-2017 Apple Inc. All rights reserved.
- *
- * @APPLE_LICENSE_HEADER_START@
- * 
- * The contents of this file constitute Original Code as defined in and
- * are subject to the Apple Public Source License Version 1.1 (the
- * "License").  You may not use this file except in compliance with the
- * License.  Please obtain a copy of the License at
- * http://www.apple.com/publicsource and read it before using this file.
- * 
- * This Original Code and all software distributed under the License are
- * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT.  Please see the
- * License for the specific language governing rights and limitations
- * under the License.
- * 
- * @APPLE_LICENSE_HEADER_END@
- */
-
-#ifndef __MATH_H__
-#define __MATH_H__
-
-#ifndef __MATH__
-#define __MATH__
-#endif
-
-#include <sys/cdefs.h>
-#include <Availability.h>
-
-__BEGIN_DECLS
-
-/******************************************************************************
- * Floating point data types                                                  *
- ******************************************************************************/
-
-/*  Define float_t and double_t per C standard, ISO/IEC 9899:2011 7.12 2,
-    taking advantage of GCC's __FLT_EVAL_METHOD__ (which a compiler may
-    define anytime and GCC does) that shadows FLT_EVAL_METHOD (which a
-    compiler must define only in float.h).                                    */
-#if __FLT_EVAL_METHOD__ == 0
-    typedef float float_t;
-    typedef double double_t;
-#elif __FLT_EVAL_METHOD__ == 1
-    typedef double float_t;
-    typedef double double_t;
-#elif __FLT_EVAL_METHOD__ == 2 || __FLT_EVAL_METHOD__ == -1
-    typedef long double float_t;
-    typedef long double double_t;
-#else /* __FLT_EVAL_METHOD__ */
-#   error "Unsupported value of __FLT_EVAL_METHOD__."
-#endif /* __FLT_EVAL_METHOD__ */
-
-#if defined(__GNUC__)
-#   define    HUGE_VAL     __builtin_huge_val()
-#   define    HUGE_VALF    __builtin_huge_valf()
-#   define    HUGE_VALL    __builtin_huge_vall()
-#   define    NAN          __builtin_nanf("0x7fc00000")
-#else
-#   define    HUGE_VAL     1e500
-#   define    HUGE_VALF    1e50f
-#   define    HUGE_VALL    1e5000L
-#   define    NAN          __nan()
-#endif
-
-#define INFINITY    HUGE_VALF
-
-/******************************************************************************
- *      Taxonomy of floating point data types                                 *
- ******************************************************************************/
-
-#define FP_NAN          1
-#define FP_INFINITE     2
-#define FP_ZERO         3
-#define FP_NORMAL       4
-#define FP_SUBNORMAL    5
-#define FP_SUPERNORMAL  6 /* legacy PowerPC support; this is otherwise unused */
-
-#if defined __arm64__ || defined __ARM_VFPV4__
-/*  On these architectures, fma(), fmaf( ), and fmal( ) are generally about as
-    fast as (or faster than) separate multiply and add of the same operands.  */
-#   define FP_FAST_FMA     1
-#   define FP_FAST_FMAF    1
-#   define FP_FAST_FMAL    1
-#elif (defined __i386__ || defined __x86_64__) && (defined __FMA__ || defined __AVX512F__)
-/*  When targeting the FMA ISA extension, fma() and fmaf( ) are generally
-    about as fast as (or faster than) separate multiply and add of the same
-    operands, but fmal( ) may be more costly.                                 */
-#   define FP_FAST_FMA     1
-#   define FP_FAST_FMAF    1
-#   undef  FP_FAST_FMAL
-#else
-/*  On these architectures, fma( ), fmaf( ), and fmal( ) function calls are
-    significantly more costly than separate multiply and add operations.      */
-#   undef  FP_FAST_FMA
-#   undef  FP_FAST_FMAF
-#   undef  FP_FAST_FMAL
-#endif
-
-/* The values returned by `ilogb' for 0 and NaN respectively. */
-#define FP_ILOGB0      (-2147483647 - 1)
-#define FP_ILOGBNAN    (-2147483647 - 1)
-
-/* Bitmasks for the math_errhandling macro.  */
-#define MATH_ERRNO        1    /* errno set by math functions.  */
-#define MATH_ERREXCEPT    2    /* Exceptions raised by math functions.  */
-
-#define math_errhandling (__math_errhandling())
-extern int __math_errhandling(void);
-
-/******************************************************************************
- *                                                                            *
- *                              Inquiry macros                                *
- *                                                                            *
- *  fpclassify      Returns one of the FP_* values.                           *
- *  isnormal        Non-zero if and only if the argument x is normalized.     *
- *  isfinite        Non-zero if and only if the argument x is finite.         *
- *  isnan           Non-zero if and only if the argument x is a NaN.          *
- *  signbit         Non-zero if and only if the sign of the argument x is     *
- *                  negative.  This includes, NaNs, infinities and zeros.     *
- *                                                                            *
- ******************************************************************************/
-
-#define fpclassify(x)                                                    \
-    ( sizeof(x) == sizeof(float)  ? __fpclassifyf((float)(x))            \
-    : sizeof(x) == sizeof(double) ? __fpclassifyd((double)(x))           \
-                                  : __fpclassifyl((long double)(x)))
-
-extern int __fpclassifyf(float);
-extern int __fpclassifyd(double);
-extern int __fpclassifyl(long double);
-
-#if (defined(__GNUC__) && 0 == __FINITE_MATH_ONLY__)
-/*  These inline functions may fail to return expected results if unsafe
-    math optimizations like those enabled by -ffast-math are turned on.
-    Thus, (somewhat surprisingly) you only get the fast inline
-    implementations if such compiler options are NOT enabled.  This is
-    because the inline functions require the compiler to be adhering to
-    the standard in order to work properly; -ffast-math, among other
-    things, implies that NaNs don't happen, which allows the compiler to
-    optimize away checks like x != x, which might lead to things like
-    isnan(NaN) returning false.                                               
- 
-    Thus, if you compile with -ffast-math, actual function calls are
-    generated for these utilities.                                            */
-    
-#define isnormal(x)                                                      \
-    ( sizeof(x) == sizeof(float)  ? __inline_isnormalf((float)(x))       \
-    : sizeof(x) == sizeof(double) ? __inline_isnormald((double)(x))      \
-                                  : __inline_isnormall((long double)(x)))
-
-#define isfinite(x)                                                      \
-    ( sizeof(x) == sizeof(float)  ? __inline_isfinitef((float)(x))       \
-    : sizeof(x) == sizeof(double) ? __inline_isfinited((double)(x))      \
-                                  : __inline_isfinitel((long double)(x)))
-
-#define isinf(x)                                                         \
-    ( sizeof(x) == sizeof(float)  ? __inline_isinff((float)(x))          \
-    : sizeof(x) == sizeof(double) ? __inline_isinfd((double)(x))         \
-                                  : __inline_isinfl((long double)(x)))
-
-#define isnan(x)                                                         \
-    ( sizeof(x) == sizeof(float)  ? __inline_isnanf((float)(x))          \
-    : sizeof(x) == sizeof(double) ? __inline_isnand((double)(x))         \
-                                  : __inline_isnanl((long double)(x)))
-
-#define signbit(x)                                                       \
-    ( sizeof(x) == sizeof(float)  ? __inline_signbitf((float)(x))        \
-    : sizeof(x) == sizeof(double) ? __inline_signbitd((double)(x))       \
-                                  : __inline_signbitl((long double)(x)))
-
-__header_always_inline int __inline_isfinitef(float);
-__header_always_inline int __inline_isfinited(double);
-__header_always_inline int __inline_isfinitel(long double);
-__header_always_inline int __inline_isinff(float);
-__header_always_inline int __inline_isinfd(double);
-__header_always_inline int __inline_isinfl(long double);
-__header_always_inline int __inline_isnanf(float);
-__header_always_inline int __inline_isnand(double);
-__header_always_inline int __inline_isnanl(long double);
-__header_always_inline int __inline_isnormalf(float);
-__header_always_inline int __inline_isnormald(double);
-__header_always_inline int __inline_isnormall(long double);
-__header_always_inline int __inline_signbitf(float);
-__header_always_inline int __inline_signbitd(double);
-__header_always_inline int __inline_signbitl(long double);
-    
-__header_always_inline int __inline_isfinitef(float __x) {
-    return __x == __x && __builtin_fabsf(__x) != __builtin_inff();
-}
-__header_always_inline int __inline_isfinited(double __x) {
-    return __x == __x && __builtin_fabs(__x) != __builtin_inf();
-}
-__header_always_inline int __inline_isfinitel(long double __x) {
-    return __x == __x && __builtin_fabsl(__x) != __builtin_infl();
-}
-__header_always_inline int __inline_isinff(float __x) {
-    return __builtin_fabsf(__x) == __builtin_inff();
-}
-__header_always_inline int __inline_isinfd(double __x) {
-    return __builtin_fabs(__x) == __builtin_inf();
-}
-__header_always_inline int __inline_isinfl(long double __x) {
-    return __builtin_fabsl(__x) == __builtin_infl();
-}
-__header_always_inline int __inline_isnanf(float __x) {
-    return __x != __x;
-}
-__header_always_inline int __inline_isnand(double __x) {
-    return __x != __x;
-}
-__header_always_inline int __inline_isnanl(long double __x) {
-    return __x != __x;
-}
-__header_always_inline int __inline_signbitf(float __x) {
-    union { float __f; unsigned int __u; } __u;
-    __u.__f = __x;
-    return (int)(__u.__u >> 31);
-}
-__header_always_inline int __inline_signbitd(double __x) {
-    union { double __f; unsigned long long __u; } __u;
-    __u.__f = __x;
-    return (int)(__u.__u >> 63);
-}
-#if defined __i386__ || defined __x86_64__
-__header_always_inline int __inline_signbitl(long double __x) {
-    union {
-        long double __ld;
-        struct{ unsigned long long __m; unsigned short __sexp; } __p;
-    } __u;
-    __u.__ld = __x;
-    return (int)(__u.__p.__sexp >> 15);
-}
-#else
-__header_always_inline int __inline_signbitl(long double __x) {
-    union { long double __f; unsigned long long __u;} __u;
-    __u.__f = __x;
-    return (int)(__u.__u >> 63);
-}
-#endif
-__header_always_inline int __inline_isnormalf(float __x) {
-    return __inline_isfinitef(__x) && __builtin_fabsf(__x) >= __FLT_MIN__;
-}
-__header_always_inline int __inline_isnormald(double __x) {
-    return __inline_isfinited(__x) && __builtin_fabs(__x) >= __DBL_MIN__;
-}
-__header_always_inline int __inline_isnormall(long double __x) {
-    return __inline_isfinitel(__x) && __builtin_fabsl(__x) >= __LDBL_MIN__;
-}
-    
-#else /* defined(__GNUC__) && 0 == __FINITE_MATH_ONLY__ */
-
-/*  Implementations making function calls to fall back on when -ffast-math
-    or similar is specified.  These are not available in iOS versions prior
-    to 6.0.  If you need them, you must target that version or later.         */
-    
-#define isnormal(x)                                               \
-    ( sizeof(x) == sizeof(float)  ? __isnormalf((float)(x))       \
-    : sizeof(x) == sizeof(double) ? __isnormald((double)(x))      \
-                                  : __isnormall((long double)(x)))
-    
-#define isfinite(x)                                               \
-    ( sizeof(x) == sizeof(float)  ? __isfinitef((float)(x))       \
-    : sizeof(x) == sizeof(double) ? __isfinited((double)(x))      \
-                                  : __isfinitel((long double)(x)))
-    
-#define isinf(x)                                                  \
-    ( sizeof(x) == sizeof(float)  ? __isinff((float)(x))          \
-    : sizeof(x) == sizeof(double) ? __isinfd((double)(x))         \
-                                  : __isinfl((long double)(x)))
-    
-#define isnan(x)                                                  \
-    ( sizeof(x) == sizeof(float)  ? __isnanf((float)(x))          \
-    : sizeof(x) == sizeof(double) ? __isnand((double)(x))         \
-                                  : __isnanl((long double)(x)))
-    
-#define signbit(x)                                                \
-    ( sizeof(x) == sizeof(float)  ? __signbitf((float)(x))        \
-    : sizeof(x) == sizeof(double) ? __signbitd((double)(x))       \
-                                  : __signbitl((long double)(x)))
-    
-extern int __isnormalf(float);
-extern int __isnormald(double);
-extern int __isnormall(long double);
-extern int __isfinitef(float);
-extern int __isfinited(double);
-extern int __isfinitel(long double);
-extern int __isinff(float);
-extern int __isinfd(double);
-extern int __isinfl(long double);
-extern int __isnanf(float);
-extern int __isnand(double);
-extern int __isnanl(long double);
-extern int __signbitf(float);
-extern int __signbitd(double);
-extern int __signbitl(long double);
-
-#endif /* defined(__GNUC__) && 0 == __FINITE_MATH_ONLY__ */
-
-/******************************************************************************
- *                                                                            *
- *                              Math Functions                                *
- *                                                                            *
- ******************************************************************************/
-    
-extern float acosf(float);
-extern double acos(double);
-extern long double acosl(long double);
-    
-extern float asinf(float);
-extern double asin(double);
-extern long double asinl(long double);
-    
-extern float atanf(float);
-extern double atan(double);
-extern long double atanl(long double);
-    
-extern float atan2f(float, float);
-extern double atan2(double, double);
-extern long double atan2l(long double, long double);
-    
-extern float cosf(float);
-extern double cos(double);
-extern long double cosl(long double);
-    
-extern float sinf(float);
-extern double sin(double);
-extern long double sinl(long double);
-    
-extern float tanf(float);
-extern double tan(double);
-extern long double tanl(long double);
-    
-extern float acoshf(float);
-extern double acosh(double);
-extern long double acoshl(long double);
-    
-extern float asinhf(float);
-extern double asinh(double);
-extern long double asinhl(long double);
-    
-extern float atanhf(float);
-extern double atanh(double);
-extern long double atanhl(long double);
-    
-extern float coshf(float);
-extern double cosh(double);
-extern long double coshl(long double);
-    
-extern float sinhf(float);
-extern double sinh(double);
-extern long double sinhl(long double);
-    
-extern float tanhf(float);
-extern double tanh(double);
-extern long double tanhl(long double);
-    
-extern float expf(float);
-extern double exp(double);
-extern long double expl(long double);
-
-extern float exp2f(float);
-extern double exp2(double); 
-extern long double exp2l(long double); 
-
-extern float expm1f(float);
-extern double expm1(double); 
-extern long double expm1l(long double); 
-
-extern float logf(float);
-extern double log(double);
-extern long double logl(long double);
-
-extern float log10f(float);
-extern double log10(double);
-extern long double log10l(long double);
-
-extern float log2f(float);
-extern double log2(double);
-extern long double log2l(long double);
-
-extern float log1pf(float);
-extern double log1p(double);
-extern long double log1pl(long double);
-
-extern float logbf(float);
-extern double logb(double);
-extern long double logbl(long double);
-
-extern float modff(float, float *);
-extern double modf(double, double *);
-extern long double modfl(long double, long double *);
-
-extern float ldexpf(float, int);
-extern double ldexp(double, int);
-extern long double ldexpl(long double, int);
-
-extern float frexpf(float, int *);
-extern double frexp(double, int *);
-extern long double frexpl(long double, int *);
-
-extern int ilogbf(float);
-extern int ilogb(double);
-extern int ilogbl(long double);
-
-extern float scalbnf(float, int);
-extern double scalbn(double, int);
-extern long double scalbnl(long double, int);
-
-extern float scalblnf(float, long int);
-extern double scalbln(double, long int);
-extern long double scalblnl(long double, long int);
-
-extern float fabsf(float);
-extern double fabs(double);
-extern long double fabsl(long double);
-
-extern float cbrtf(float);
-extern double cbrt(double);
-extern long double cbrtl(long double);
-
-extern float hypotf(float, float);
-extern double hypot(double, double);
-extern long double hypotl(long double, long double);
-
-extern float powf(float, float);
-extern double pow(double, double);
-extern long double powl(long double, long double);
-
-extern float sqrtf(float);
-extern double sqrt(double);
-extern long double sqrtl(long double);
-
-extern float erff(float);
-extern double erf(double);
-extern long double erfl(long double);
-
-extern float erfcf(float);
-extern double erfc(double);
-extern long double erfcl(long double);
-
-/*	lgammaf, lgamma, and lgammal are not thread-safe. The thread-safe
-    variants lgammaf_r, lgamma_r, and lgammal_r are made available if
-    you define the _REENTRANT symbol before including <math.h>                */
-extern float lgammaf(float);
-extern double lgamma(double);
-extern long double lgammal(long double);
-
-extern float tgammaf(float);
-extern double tgamma(double);
-extern long double tgammal(long double);
-
-extern float ceilf(float);
-extern double ceil(double);
-extern long double ceill(long double);
-
-extern float floorf(float);
-extern double floor(double);
-extern long double floorl(long double);
-
-extern float nearbyintf(float);
-extern double nearbyint(double);
-extern long double nearbyintl(long double);
-
-extern float rintf(float);
-extern double rint(double);
-extern long double rintl(long double);
-
-extern long int lrintf(float);
-extern long int lrint(double);
-extern long int lrintl(long double);
-
-extern float roundf(float);
-extern double round(double);
-extern long double roundl(long double);
-
-extern long int lroundf(float);
-extern long int lround(double);
-extern long int lroundl(long double);
-    
-/*  long long is not part of C90. Make sure you are passing -std=c99 or
-    -std=gnu99 or higher if you need these functions returning long longs     */
-#if !(__DARWIN_NO_LONG_LONG)
-extern long long int llrintf(float);
-extern long long int llrint(double);
-extern long long int llrintl(long double);
-
-extern long long int llroundf(float);
-extern long long int llround(double);
-extern long long int llroundl(long double);
-#endif /* !(__DARWIN_NO_LONG_LONG) */
-
-extern float truncf(float);
-extern double trunc(double);
-extern long double truncl(long double);
-
-extern float fmodf(float, float);
-extern double fmod(double, double);
-extern long double fmodl(long double, long double);
-
-extern float remainderf(float, float);
-extern double remainder(double, double);
-extern long double remainderl(long double, long double);
-
-extern float remquof(float, float, int *);
-extern double remquo(double, double, int *);
-extern long double remquol(long double, long double, int *);
-
-extern float copysignf(float, float);
-extern double copysign(double, double);
-extern long double copysignl(long double, long double);
-
-extern float nanf(const char *);
-extern double nan(const char *);
-extern long double nanl(const char *);
-
-extern float nextafterf(float, float);
-extern double nextafter(double, double);
-extern long double nextafterl(long double, long double);
-
-extern double nexttoward(double, long double);
-extern float nexttowardf(float, long double);
-extern long double nexttowardl(long double, long double);
-
-extern float fdimf(float, float);
-extern double fdim(double, double);
-extern long double fdiml(long double, long double);
-
-extern float fmaxf(float, float);
-extern double fmax(double, double);
-extern long double fmaxl(long double, long double);
-
-extern float fminf(float, float);
-extern double fmin(double, double);
-extern long double fminl(long double, long double);
-
-extern float fmaf(float, float, float);
-extern double fma(double, double, double);
-extern long double fmal(long double, long double, long double);
-
-#define isgreater(x, y) __builtin_isgreater((x),(y))
-#define isgreaterequal(x, y) __builtin_isgreaterequal((x),(y))
-#define isless(x, y) __builtin_isless((x),(y))
-#define islessequal(x, y) __builtin_islessequal((x),(y))
-#define islessgreater(x, y) __builtin_islessgreater((x),(y))
-#define isunordered(x, y) __builtin_isunordered((x),(y))
-
-/* Deprecated functions; use the INFINITY and NAN macros instead.             */
-extern float __inff(void)
-__API_DEPRECATED("use `(float)INFINITY` instead", macos(10.0, 10.9)) __API_UNAVAILABLE(ios, watchos, tvos);
-extern double __inf(void)
-__API_DEPRECATED("use `INFINITY` instead", macos(10.0, 10.9)) __API_UNAVAILABLE(ios, watchos, tvos);
-extern long double __infl(void)
-__API_DEPRECATED("use `(long double)INFINITY` instead", macos(10.0, 10.9)) __API_UNAVAILABLE(ios, watchos, tvos);
-extern float __nan(void)
-__API_DEPRECATED("use `NAN` instead", macos(10.0, 10.14)) __API_UNAVAILABLE(ios, watchos, tvos);
-
-/******************************************************************************
- *  Reentrant variants of lgamma[fl]                                          *
- ******************************************************************************/
-
-#ifdef _REENTRANT
-/*  Reentrant variants of the lgamma[fl] functions.                           */
-extern float lgammaf_r(float, int *) __API_AVAILABLE(macos(10.6), ios(3.1));
-extern double lgamma_r(double, int *) __API_AVAILABLE(macos(10.6), ios(3.1));
-extern long double lgammal_r(long double, int *) __API_AVAILABLE(macos(10.6), ios(3.1));
-#endif /* _REENTRANT */
-
-/******************************************************************************
- *  Apple extensions to the C standard                                        *
- ******************************************************************************/
-
-/*  Because these functions are not specified by any relevant standard, they
-    are prefixed with __, which places them in the implementor's namespace, so
-    they should not conflict with any developer or third-party code.  If they
-    are added to a relevant standard in the future, un-prefixed names may be
-    added to the library and they may be moved out of this section of the
-    header.                                                                   
- 
-    Because these functions are non-standard, they may not be available on non-
-    Apple platforms.                                                          */
-
-/*  __exp10(x) returns 10**x.  Edge cases match those of exp( ) and exp2( ).  */
-extern float __exp10f(float) __API_AVAILABLE(macos(10.9), ios(7.0));
-extern double __exp10(double) __API_AVAILABLE(macos(10.9), ios(7.0));
-
-/*  __sincos(x,sinp,cosp) computes the sine and cosine of x with a single
-    function call, storing the sine in the memory pointed to by sinp, and
-    the cosine in the memory pointed to by cosp. Edge cases match those of
-    separate calls to sin( ) and cos( ).                                      */
-__header_always_inline void __sincosf(float __x, float *__sinp, float *__cosp);
-__header_always_inline void __sincos(double __x, double *__sinp, double *__cosp);
-
-/*  __sinpi(x) returns the sine of pi times x; __cospi(x) and __tanpi(x) return
-    the cosine and tangent, respectively.  These functions can produce a more
-    accurate answer than expressions of the form sin(M_PI * x) because they
-    avoid any loss of precision that results from rounding the result of the
-    multiplication M_PI * x.  They may also be significantly more efficient in
-    some cases because the argument reduction for these functions is easier
-    to compute.  Consult the man pages for edge case details.                 */
-extern float __cospif(float) __API_AVAILABLE(macos(10.9), ios(7.0));
-extern double __cospi(double) __API_AVAILABLE(macos(10.9), ios(7.0));
-extern float __sinpif(float) __API_AVAILABLE(macos(10.9), ios(7.0));
-extern double __sinpi(double) __API_AVAILABLE(macos(10.9), ios(7.0));
-extern float __tanpif(float) __API_AVAILABLE(macos(10.9), ios(7.0));
-extern double __tanpi(double) __API_AVAILABLE(macos(10.9), ios(7.0));
-
-#if (defined __MAC_OS_X_VERSION_MIN_REQUIRED && __MAC_OS_X_VERSION_MIN_REQUIRED < 1090) || \
-    (defined __IPHONE_OS_VERSION_MIN_REQUIRED && __IPHONE_OS_VERSION_MIN_REQUIRED < 70000)
-/*  __sincos and __sincosf were introduced in OSX 10.9 and iOS 7.0.  When
-    targeting an older system, we simply split them up into discrete calls
-    to sin( ) and cos( ).                                                     */
-__header_always_inline void __sincosf(float __x, float *__sinp, float *__cosp) {
-  *__sinp = sinf(__x);
-  *__cosp = cosf(__x);
-}
-
-__header_always_inline void __sincos(double __x, double *__sinp, double *__cosp) {
-  *__sinp = sin(__x);
-  *__cosp = cos(__x);
-}
-#else
-/*  __sincospi(x,sinp,cosp) computes the sine and cosine of pi times x with a
-    single function call, storing the sine in the memory pointed to by sinp,
-    and the cosine in the memory pointed to by cosp.  Edge cases match those
-    of separate calls to __sinpi( ) and __cospi( ), and are documented in the
-    man pages.
- 
-    These functions were introduced in OSX 10.9 and iOS 7.0.  Because they are
-    implemented as header inlines, weak-linking does not function as normal,
-    and they are simply hidden when targeting earlier OS versions.            */
-__header_always_inline void __sincospif(float __x, float *__sinp, float *__cosp);
-__header_always_inline void __sincospi(double __x, double *__sinp, double *__cosp);
-
-/*  Implementation details of __sincos and __sincospi allowing them to return
-    two results while allowing the compiler to optimize away unnecessary load-
-    store traffic.  Although these interfaces are exposed in the math.h header
-    to allow compilers to generate better code, users should call __sincos[f]
-    and __sincospi[f] instead and allow the compiler to emit these calls.     */
-struct __float2 { float __sinval; float __cosval; };
-struct __double2 { double __sinval; double __cosval; };
-
-extern struct __float2 __sincosf_stret(float);
-extern struct __double2 __sincos_stret(double);
-extern struct __float2 __sincospif_stret(float);
-extern struct __double2 __sincospi_stret(double);
-
-__header_always_inline void __sincosf(float __x, float *__sinp, float *__cosp) {
-    const struct __float2 __stret = __sincosf_stret(__x);
-    *__sinp = __stret.__sinval; *__cosp = __stret.__cosval;
-}
-
-__header_always_inline void __sincos(double __x, double *__sinp, double *__cosp) {
-    const struct __double2 __stret = __sincos_stret(__x);
-    *__sinp = __stret.__sinval; *__cosp = __stret.__cosval;
-}
-
-__header_always_inline void __sincospif(float __x, float *__sinp, float *__cosp) {
-    const struct __float2 __stret = __sincospif_stret(__x);
-    *__sinp = __stret.__sinval; *__cosp = __stret.__cosval;
-}
-
-__header_always_inline void __sincospi(double __x, double *__sinp, double *__cosp) {
-    const struct __double2 __stret = __sincospi_stret(__x);
-    *__sinp = __stret.__sinval; *__cosp = __stret.__cosval;
-}
-#endif
-
-/******************************************************************************
- *  POSIX/UNIX extensions to the C standard                                   *
- ******************************************************************************/
-
-#if __DARWIN_C_LEVEL >= 199506L
-extern double j0(double) __API_AVAILABLE(macos(10.0), ios(3.2));
-extern double j1(double) __API_AVAILABLE(macos(10.0), ios(3.2));
-extern double jn(int, double) __API_AVAILABLE(macos(10.0), ios(3.2));
-extern double y0(double) __API_AVAILABLE(macos(10.0), ios(3.2));
-extern double y1(double) __API_AVAILABLE(macos(10.0), ios(3.2));
-extern double yn(int, double) __API_AVAILABLE(macos(10.0), ios(3.2));
-extern double scalb(double, double); 
-extern int signgam;
-
-/*  Even though these might be more useful as long doubles, POSIX requires
-    that they be double-precision literals.                                   */
-#define M_E         2.71828182845904523536028747135266250   /* e              */
-#define M_LOG2E     1.44269504088896340735992468100189214   /* log2(e)        */
-#define M_LOG10E    0.434294481903251827651128918916605082  /* log10(e)       */
-#define M_LN2       0.693147180559945309417232121458176568  /* loge(2)        */
-#define M_LN10      2.30258509299404568401799145468436421   /* loge(10)       */
-#define M_PI        3.14159265358979323846264338327950288   /* pi             */
-#define M_PI_2      1.57079632679489661923132169163975144   /* pi/2           */
-#define M_PI_4      0.785398163397448309615660845819875721  /* pi/4           */
-#define M_1_PI      0.318309886183790671537767526745028724  /* 1/pi           */
-#define M_2_PI      0.636619772367581343075535053490057448  /* 2/pi           */
-#define M_2_SQRTPI  1.12837916709551257389615890312154517   /* 2/sqrt(pi)     */
-#define M_SQRT2     1.41421356237309504880168872420969808   /* sqrt(2)        */
-#define M_SQRT1_2   0.707106781186547524400844362104849039  /* 1/sqrt(2)      */
-
-#define MAXFLOAT    0x1.fffffep+127f
-#endif /* __DARWIN_C_LEVEL >= 199506L */
-
-/*  Long-double versions of M_E, etc for convenience on Intel where long-
-    double is not the same as double.  Define __MATH_LONG_DOUBLE_CONSTANTS
-    to make these constants available.                                        */
-#if defined __MATH_LONG_DOUBLE_CONSTANTS
-#define M_El        0xa.df85458a2bb4a9bp-2L
-#define M_LOG2El    0xb.8aa3b295c17f0bcp-3L
-#define M_LOG10El   0xd.e5bd8a937287195p-5L
-#define M_LN2l      0xb.17217f7d1cf79acp-4L
-#define M_LN10l     0x9.35d8dddaaa8ac17p-2L
-#define M_PIl       0xc.90fdaa22168c235p-2L
-#define M_PI_2l     0xc.90fdaa22168c235p-3L
-#define M_PI_4l     0xc.90fdaa22168c235p-4L
-#define M_1_PIl     0xa.2f9836e4e44152ap-5L
-#define M_2_PIl     0xa.2f9836e4e44152ap-4L
-#define M_2_SQRTPIl 0x9.06eba8214db688dp-3L
-#define M_SQRT2l    0xb.504f333f9de6484p-3L
-#define M_SQRT1_2l  0xb.504f333f9de6484p-4L
-#endif /* defined __MATH_LONG_DOUBLE_CONSTANTS */
-
-/******************************************************************************
- *  Legacy BSD extensions to the C standard                                   *
- ******************************************************************************/
-
-#if __DARWIN_C_LEVEL >= __DARWIN_C_FULL
-#define FP_SNAN		FP_NAN
-#define FP_QNAN		FP_NAN
-#define	HUGE		MAXFLOAT
-#define X_TLOSS		1.41484755040568800000e+16 
-#define	DOMAIN		1
-#define	SING		2
-#define	OVERFLOW	3
-#define	UNDERFLOW	4
-#define	TLOSS		5
-#define	PLOSS		6
-
-/* Legacy BSD API; use the C99 `lrint( )` function instead.                   */
-extern long int rinttol(double)
-__API_DEPRECATED_WITH_REPLACEMENT("lrint", macos(10.0, 10.9)) __API_UNAVAILABLE(ios, watchos, tvos);
-/* Legacy BSD API; use the C99 `lround( )` function instead.                  */
-extern long int roundtol(double)
-__API_DEPRECATED_WITH_REPLACEMENT("lround", macos(10.0, 10.9)) __API_UNAVAILABLE(ios, watchos, tvos);
-/* Legacy BSD API; use the C99 `remainder( )` function instead.               */
-extern double drem(double, double)
-__API_DEPRECATED_WITH_REPLACEMENT("remainder", macos(10.0, 10.9)) __API_UNAVAILABLE(ios, watchos, tvos);
-/* Legacy BSD API; use the C99 `isfinite( )` macro instead.                   */
-extern int finite(double)
-__API_DEPRECATED("Use `isfinite((double)x)` instead.", macos(10.0, 10.9)) __API_UNAVAILABLE(ios, watchos, tvos);
-/* Legacy BSD API; use the C99 `tgamma( )` function instead.                  */
-extern double gamma(double)
-__API_DEPRECATED_WITH_REPLACEMENT("tgamma", macos(10.0, 10.9)) __API_UNAVAILABLE(ios, watchos, tvos);
-/* Legacy BSD API; use `2*frexp( )` or `scalbn(x, -ilogb(x))` instead.        */
-extern double significand(double)
-__API_DEPRECATED("Use `2*frexp( )` or `scalbn(x, -ilogb(x))` instead.", macos(10.0, 10.9)) __API_UNAVAILABLE(ios, watchos, tvos);
-
-#if !defined __cplusplus
-struct exception {
-    int type;
-    char *name;
-    double arg1;
-    double arg2;
-    double retval;
-};
-
-#endif /* !defined __cplusplus */
-#endif /* __DARWIN_C_LEVEL >= __DARWIN_C_FULL */
-
-__END_DECLS
-#endif /* __MATH_H__ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/net/if.h b/lib/libc/include/x86_64-macos-gnu/net/if.h
deleted file mode 100644
index c0729f0eb8..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/net/if.h
+++ /dev/null
@@ -1,442 +0,0 @@
-/*
- * Copyright (c) 2000-2019 Apple Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-/*
- * Copyright (c) 1982, 1986, 1989, 1993
- *	The Regents of the University of California.  All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *	This product includes software developed by the University of
- *	California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *	@(#)if.h	8.1 (Berkeley) 6/10/93
- */
-
-#ifndef _NET_IF_H_
-#define _NET_IF_H_
-
-#include <sys/cdefs.h>
-#include <net/net_kev.h>
-
-#define IF_NAMESIZE     16
-
-#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-#include <sys/appleapiopts.h>
-#ifdef __APPLE__
-
-#include <net/if_var.h>
-#include <sys/types.h>
-#include <sys/socket.h>
-
-#endif
-
-struct if_clonereq {
-	int     ifcr_total;             /* total cloners (out) */
-	int     ifcr_count;             /* room for this many in user buffer */
-	char    *ifcr_buffer;           /* buffer for cloner names */
-};
-
-
-#define IFF_UP          0x1             /* interface is up */
-#define IFF_BROADCAST   0x2             /* broadcast address valid */
-#define IFF_DEBUG       0x4             /* turn on debugging */
-#define IFF_LOOPBACK    0x8             /* is a loopback net */
-#define IFF_POINTOPOINT 0x10            /* interface is point-to-point link */
-#define IFF_NOTRAILERS  0x20            /* obsolete: avoid use of trailers */
-#define IFF_RUNNING     0x40            /* resources allocated */
-#define IFF_NOARP       0x80            /* no address resolution protocol */
-#define IFF_PROMISC     0x100           /* receive all packets */
-#define IFF_ALLMULTI    0x200           /* receive all multicast packets */
-#define IFF_OACTIVE     0x400           /* transmission in progress */
-#define IFF_SIMPLEX     0x800           /* can't hear own transmissions */
-#define IFF_LINK0       0x1000          /* per link layer defined bit */
-#define IFF_LINK1       0x2000          /* per link layer defined bit */
-#define IFF_LINK2       0x4000          /* per link layer defined bit */
-#define IFF_ALTPHYS     IFF_LINK2       /* use alternate physical connection */
-#define IFF_MULTICAST   0x8000          /* supports multicast */
-
-
-
-/*
- * Capabilities that interfaces can advertise.
- *
- * struct ifnet.if_capabilities
- *   contains the optional features & capabilities a particular interface
- *   supports (not only the driver but also the detected hw revision).
- *   Capabilities are defined by IFCAP_* below.
- * struct ifnet.if_capenable
- *   contains the enabled (either by default or through ifconfig) optional
- *   features & capabilities on this interface.
- *   Capabilities are defined by IFCAP_* below.
- * struct if_data.ifi_hwassist in IFNET_* form, defined in net/kpi_interface.h,
- *   contains the enabled optional features & capabilites that can be used
- *   individually per packet and are specified in the mbuf pkthdr.csum_flags
- *   field.  IFCAP_* and IFNET_* do not match one to one and IFNET_* may be
- *   more detailed or differentiated than IFCAP_*.
- *   IFNET_* hwassist flags have corresponding CSUM_* in sys/mbuf.h
- */
-#define IFCAP_RXCSUM            0x00001 /* can offload checksum on RX */
-#define IFCAP_TXCSUM            0x00002 /* can offload checksum on TX */
-#define IFCAP_VLAN_MTU          0x00004 /* VLAN-compatible MTU */
-#define IFCAP_VLAN_HWTAGGING    0x00008 /* hardware VLAN tag support */
-#define IFCAP_JUMBO_MTU         0x00010 /* 9000 byte MTU supported */
-#define IFCAP_TSO4              0x00020 /* can do TCP Segmentation Offload */
-#define IFCAP_TSO6              0x00040 /* can do TCP6 Segmentation Offload */
-#define IFCAP_LRO               0x00080 /* can do Large Receive Offload */
-#define IFCAP_AV                0x00100 /* can do 802.1 AV Bridging */
-#define IFCAP_TXSTATUS          0x00200 /* can return linklevel xmit status */
-#define IFCAP_SKYWALK           0x00400 /* Skywalk mode supported/enabled */
-#define IFCAP_HW_TIMESTAMP      0x00800 /* Time stamping in hardware */
-#define IFCAP_SW_TIMESTAMP      0x01000 /* Time stamping in software */
-#define IFCAP_CSUM_PARTIAL      0x02000 /* can offload partial checksum */
-#define IFCAP_CSUM_ZERO_INVERT  0x04000 /* can invert 0 to -0 (0xffff) */
-
-#define IFCAP_HWCSUM    (IFCAP_RXCSUM | IFCAP_TXCSUM)
-#define IFCAP_TSO       (IFCAP_TSO4 | IFCAP_TSO6)
-
-#define IFCAP_VALID (IFCAP_HWCSUM | IFCAP_TSO | IFCAP_LRO | IFCAP_VLAN_MTU | \
-	IFCAP_VLAN_HWTAGGING | IFCAP_JUMBO_MTU | IFCAP_AV | IFCAP_TXSTATUS | \
-	IFCAP_SKYWALK | IFCAP_SW_TIMESTAMP | IFCAP_HW_TIMESTAMP | \
-	IFCAP_CSUM_PARTIAL | IFCAP_CSUM_ZERO_INVERT)
-
-#define IFQ_MAXLEN      128
-#define IFNET_SLOWHZ    1       /* granularity is 1 second */
-#define IFQ_TARGET_DELAY        (10ULL * 1000 * 1000)   /* 10 ms */
-#define IFQ_UPDATE_INTERVAL     (100ULL * 1000 * 1000)  /* 100 ms */
-
-/*
- * Message format for use in obtaining information about interfaces
- * from sysctl and the routing socket
- */
-struct if_msghdr {
-	unsigned short  ifm_msglen;     /* to skip non-understood messages */
-	unsigned char   ifm_version;    /* future binary compatability */
-	unsigned char   ifm_type;       /* message type */
-	int             ifm_addrs;      /* like rtm_addrs */
-	int             ifm_flags;      /* value of if_flags */
-	unsigned short  ifm_index;      /* index for associated ifp */
-	struct  if_data ifm_data;       /* statistics and other data about if */
-};
-
-/*
- * Message format for use in obtaining information about interface addresses
- * from sysctl and the routing socket
- */
-struct ifa_msghdr {
-	unsigned short  ifam_msglen;    /* to skip non-understood messages */
-	unsigned char   ifam_version;   /* future binary compatability */
-	unsigned char   ifam_type;      /* message type */
-	int             ifam_addrs;     /* like rtm_addrs */
-	int             ifam_flags;     /* value of ifa_flags */
-	unsigned short  ifam_index;     /* index for associated ifp */
-	int             ifam_metric;    /* value of ifa_metric */
-};
-
-/*
- * Message format for use in obtaining information about multicast addresses
- * from the routing socket
- */
-struct ifma_msghdr {
-	unsigned short  ifmam_msglen;   /* to skip non-understood messages */
-	unsigned char   ifmam_version;  /* future binary compatability */
-	unsigned char   ifmam_type;     /* message type */
-	int             ifmam_addrs;    /* like rtm_addrs */
-	int             ifmam_flags;    /* value of ifa_flags */
-	unsigned short  ifmam_index;    /* index for associated ifp */
-};
-
-/*
- * Message format for use in obtaining information about interfaces
- * from sysctl
- */
-struct if_msghdr2 {
-	u_short ifm_msglen;     /* to skip over non-understood messages */
-	u_char  ifm_version;    /* future binary compatability */
-	u_char  ifm_type;       /* message type */
-	int     ifm_addrs;      /* like rtm_addrs */
-	int     ifm_flags;      /* value of if_flags */
-	u_short ifm_index;      /* index for associated ifp */
-	int     ifm_snd_len;    /* instantaneous length of send queue */
-	int     ifm_snd_maxlen; /* maximum length of send queue */
-	int     ifm_snd_drops;  /* number of drops in send queue */
-	int     ifm_timer;      /* time until if_watchdog called */
-	struct if_data64        ifm_data;       /* statistics and other data */
-};
-
-/*
- * Message format for use in obtaining information about multicast addresses
- * from sysctl
- */
-struct ifma_msghdr2 {
-	u_short ifmam_msglen;   /* to skip over non-understood messages */
-	u_char  ifmam_version;  /* future binary compatability */
-	u_char  ifmam_type;     /* message type */
-	int     ifmam_addrs;    /* like rtm_addrs */
-	int     ifmam_flags;    /* value of ifa_flags */
-	u_short ifmam_index;    /* index for associated ifp */
-	int32_t ifmam_refcount;
-};
-
-/*
- * ifdevmtu: interface device mtu
- *    Used with SIOCGIFDEVMTU to get the current mtu in use by the device,
- *    as well as the minimum and maximum mtu allowed by the device.
- */
-struct ifdevmtu {
-	int     ifdm_current;
-	int     ifdm_min;
-	int     ifdm_max;
-};
-
-#pragma pack(4)
-
-/*
- *  ifkpi: interface kpi ioctl
- *  Used with SIOCSIFKPI and SIOCGIFKPI.
- *
- *  ifk_module_id - From in the kernel, a value from kev_vendor_code_find. From
- *       user space, a value from SIOCGKEVVENDOR ioctl on a kernel event socket.
- *  ifk_type - The type. Types are specific to each module id.
- *  ifk_data - The data. ifk_ptr may be a 64bit pointer for 64 bit processes.
- *
- *  Copying data between user space and kernel space is done using copyin
- *  and copyout. A process may be running in 64bit mode. In such a case,
- *  the pointer will be a 64bit pointer, not a 32bit pointer. The following
- *  sample is a safe way to copy the data in to the kernel from either a
- *  32bit or 64bit process:
- *
- *  user_addr_t tmp_ptr;
- *  if (IS_64BIT_PROCESS(current_proc())) {
- *       tmp_ptr = CAST_USER_ADDR_T(ifkpi.ifk_data.ifk_ptr64);
- *  }
- *  else {
- *       tmp_ptr = CAST_USER_ADDR_T(ifkpi.ifk_data.ifk_ptr);
- *  }
- *  error = copyin(tmp_ptr, allocated_dst_buffer, size of allocated_dst_buffer);
- */
-
-struct ifkpi {
-	unsigned int    ifk_module_id;
-	unsigned int    ifk_type;
-	union {
-		void            *ifk_ptr;
-		int             ifk_value;
-	} ifk_data;
-};
-
-/* Wake capabilities of a interface */
-#define IF_WAKE_ON_MAGIC_PACKET         0x01
-
-
-#pragma pack()
-
-/*
- * Interface request structure used for socket
- * ioctl's.  All interface ioctl's must have parameter
- * definitions which begin with ifr_name.  The
- * remainder may be interface specific.
- */
-struct  ifreq {
-#ifndef IFNAMSIZ
-#define IFNAMSIZ        IF_NAMESIZE
-#endif
-	char    ifr_name[IFNAMSIZ];             /* if name, e.g. "en0" */
-	union {
-		struct  sockaddr ifru_addr;
-		struct  sockaddr ifru_dstaddr;
-		struct  sockaddr ifru_broadaddr;
-		short   ifru_flags;
-		int     ifru_metric;
-		int     ifru_mtu;
-		int     ifru_phys;
-		int     ifru_media;
-		int     ifru_intval;
-		caddr_t ifru_data;
-		struct  ifdevmtu ifru_devmtu;
-		struct  ifkpi   ifru_kpi;
-		u_int32_t ifru_wake_flags;
-		u_int32_t ifru_route_refcnt;
-		int     ifru_cap[2];
-		u_int32_t ifru_functional_type;
-#define IFRTYPE_FUNCTIONAL_UNKNOWN              0
-#define IFRTYPE_FUNCTIONAL_LOOPBACK             1
-#define IFRTYPE_FUNCTIONAL_WIRED                2
-#define IFRTYPE_FUNCTIONAL_WIFI_INFRA           3
-#define IFRTYPE_FUNCTIONAL_WIFI_AWDL            4
-#define IFRTYPE_FUNCTIONAL_CELLULAR             5
-#define IFRTYPE_FUNCTIONAL_INTCOPROC            6
-#define IFRTYPE_FUNCTIONAL_COMPANIONLINK        7
-#define IFRTYPE_FUNCTIONAL_LAST                 7
-	} ifr_ifru;
-#define ifr_addr        ifr_ifru.ifru_addr      /* address */
-#define ifr_dstaddr     ifr_ifru.ifru_dstaddr   /* other end of p-to-p link */
-#define ifr_broadaddr   ifr_ifru.ifru_broadaddr /* broadcast address */
-#ifdef __APPLE__
-#define ifr_flags       ifr_ifru.ifru_flags     /* flags */
-#else
-#define ifr_flags       ifr_ifru.ifru_flags[0]  /* flags */
-#define ifr_prevflags   ifr_ifru.ifru_flags[1]  /* flags */
-#endif /* __APPLE__ */
-#define ifr_metric      ifr_ifru.ifru_metric    /* metric */
-#define ifr_mtu         ifr_ifru.ifru_mtu       /* mtu */
-#define ifr_phys        ifr_ifru.ifru_phys      /* physical wire */
-#define ifr_media       ifr_ifru.ifru_media     /* physical media */
-#define ifr_data        ifr_ifru.ifru_data      /* for use by interface */
-#define ifr_devmtu      ifr_ifru.ifru_devmtu
-#define ifr_intval      ifr_ifru.ifru_intval    /* integer value */
-#define ifr_kpi         ifr_ifru.ifru_kpi
-#define ifr_wake_flags  ifr_ifru.ifru_wake_flags /* wake capabilities */
-#define ifr_route_refcnt ifr_ifru.ifru_route_refcnt /* route references count */
-#define ifr_reqcap      ifr_ifru.ifru_cap[0]    /* requested capabilities */
-#define ifr_curcap      ifr_ifru.ifru_cap[1]    /* current capabilities */
-};
-
-#define _SIZEOF_ADDR_IFREQ(ifr) \
-	((ifr).ifr_addr.sa_len > sizeof (struct sockaddr) ? \
-	(sizeof (struct ifreq) - sizeof (struct sockaddr) + \
-	(ifr).ifr_addr.sa_len) : sizeof (struct ifreq))
-
-struct ifaliasreq {
-	char    ifra_name[IFNAMSIZ];            /* if name, e.g. "en0" */
-	struct  sockaddr ifra_addr;
-	struct  sockaddr ifra_broadaddr;
-	struct  sockaddr ifra_mask;
-};
-
-struct rslvmulti_req {
-	struct sockaddr *sa;
-	struct sockaddr **llsa;
-};
-
-#pragma pack(4)
-
-struct ifmediareq {
-	char    ifm_name[IFNAMSIZ];     /* if name, e.g. "en0" */
-	int     ifm_current;            /* current media options */
-	int     ifm_mask;               /* don't care mask */
-	int     ifm_status;             /* media status */
-	int     ifm_active;             /* active options */
-	int     ifm_count;              /* # entries in ifm_ulist array */
-	int     *ifm_ulist;             /* media words */
-};
-
-#pragma pack()
-
-
-
-#pragma pack(4)
-struct  ifdrv {
-	char            ifd_name[IFNAMSIZ];     /* if name, e.g. "en0" */
-	unsigned long   ifd_cmd;
-	size_t          ifd_len;                /* length of ifd_data buffer */
-	void            *ifd_data;
-};
-#pragma pack()
-
-
-/*
- * Structure used to retrieve aux status data from interfaces.
- * Kernel suppliers to this interface should respect the formatting
- * needed by ifconfig(8): each line starts with a TAB and ends with
- * a newline.
- */
-
-#define IFSTATMAX       800             /* 10 lines of text */
-struct ifstat {
-	char    ifs_name[IFNAMSIZ];     /* if name, e.g. "en0" */
-	char    ascii[IFSTATMAX + 1];
-};
-
-/*
- * Structure used in SIOCGIFCONF request.
- * Used to retrieve interface configuration
- * for machine (useful for programs which
- * must know all networks accessible).
- */
-#pragma pack(4)
-struct  ifconf {
-	int     ifc_len;                /* size of associated buffer */
-	union {
-		caddr_t ifcu_buf;
-		struct  ifreq *ifcu_req;
-	} ifc_ifcu;
-};
-#pragma pack()
-#define ifc_buf ifc_ifcu.ifcu_buf       /* buffer address */
-#define ifc_req ifc_ifcu.ifcu_req       /* array of structures returned */
-
-
-/*
- * DLIL KEV_DL_PROTO_ATTACHED/DETACHED structure
- */
-struct kev_dl_proto_data {
-	struct net_event_data           link_data;
-	u_int32_t                       proto_family;
-	u_int32_t                       proto_remaining_count;
-};
-
-
-#endif /* (_POSIX_C_SOURCE && !_DARWIN_C_SOURCE) */
-
-struct if_nameindex {
-	unsigned int     if_index;      /* 1, 2, ... */
-	char            *if_name;       /* null terminated name: "le0", ... */
-};
-
-__BEGIN_DECLS
-unsigned int     if_nametoindex(const char *);
-char            *if_indextoname(unsigned int, char *);
-struct           if_nameindex *if_nameindex(void);
-void             if_freenameindex(struct if_nameindex *);
-__END_DECLS
-
-
-#endif /* !_NET_IF_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/net/if_var.h b/lib/libc/include/x86_64-macos-gnu/net/if_var.h
deleted file mode 100644
index 6dcaa3842e..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/net/if_var.h
+++ /dev/null
@@ -1,242 +0,0 @@
-/*
- * Copyright (c) 2000-2019 Apple Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-/*
- * Copyright (c) 1982, 1986, 1989, 1993
- *	The Regents of the University of California.  All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *	This product includes software developed by the University of
- *	California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *	From: @(#)if.h	8.1 (Berkeley) 6/10/93
- * $FreeBSD: src/sys/net/if_var.h,v 1.18.2.7 2001/07/24 19:10:18 brooks Exp $
- */
-
-#ifndef _NET_IF_VAR_H_
-#define _NET_IF_VAR_H_
-
-#include <sys/appleapiopts.h>
-#include <stdint.h>
-#include <sys/types.h>
-#include <sys/time.h>
-#include <sys/queue.h>          /* get TAILQ macros */
-#ifdef BSD_KERN_PRIVATE
-#include <sys/eventhandler.h>
-#endif
-
-
-#ifdef __APPLE__
-#define APPLE_IF_FAM_LOOPBACK  1
-#define APPLE_IF_FAM_ETHERNET  2
-#define APPLE_IF_FAM_SLIP      3
-#define APPLE_IF_FAM_TUN       4
-#define APPLE_IF_FAM_VLAN      5
-#define APPLE_IF_FAM_PPP       6
-#define APPLE_IF_FAM_PVC       7
-#define APPLE_IF_FAM_DISC      8
-#define APPLE_IF_FAM_MDECAP    9
-#define APPLE_IF_FAM_GIF       10
-#define APPLE_IF_FAM_FAITH     11       /* deprecated */
-#define APPLE_IF_FAM_STF       12
-#define APPLE_IF_FAM_FIREWIRE  13
-#define APPLE_IF_FAM_BOND      14
-#define APPLE_IF_FAM_CELLULAR  15
-#define APPLE_IF_FAM_6LOWPAN   16
-#define APPLE_IF_FAM_UTUN      17
-#define APPLE_IF_FAM_IPSEC     18
-#endif /* __APPLE__ */
-
-/*
- * 72 was chosen below because it is the size of a TCP/IP
- * header (40) + the minimum mss (32).
- */
-#define IF_MINMTU       72
-#define IF_MAXMTU       65535
-
-/*
- * Structures defining a network interface, providing a packet
- * transport mechanism (ala level 0 of the PUP protocols).
- *
- * Each interface accepts output datagrams of a specified maximum
- * length, and provides higher level routines with input datagrams
- * received from its medium.
- *
- * Output occurs when the routine if_output is called, with three parameters:
- *	(*ifp->if_output)(ifp, m, dst, rt)
- * Here m is the mbuf chain to be sent and dst is the destination address.
- * The output routine encapsulates the supplied datagram if necessary,
- * and then transmits it on its medium.
- *
- * On input, each interface unwraps the data received by it, and either
- * places it on the input queue of a internetwork datagram routine
- * and posts the associated software interrupt, or passes the datagram to a raw
- * packet input routine.
- *
- * Routines exist for locating interfaces by their addresses
- * or for locating a interface on a certain network, as well as more general
- * routing and gateway routines maintaining information used to locate
- * interfaces.  These routines live in the files if.c and route.c
- */
-
-#define IFNAMSIZ        16
-
-/* This belongs up in socket.h or socketvar.h, depending on how far the
- *   event bubbles up.
- */
-
-struct net_event_data {
-	u_int32_t       if_family;
-	u_int32_t       if_unit;
-	char            if_name[IFNAMSIZ];
-};
-
-#if defined(__LP64__)
-#include <sys/_types/_timeval32.h>
-#define IF_DATA_TIMEVAL timeval32
-#else
-#define IF_DATA_TIMEVAL timeval
-#endif
-
-#pragma pack(4)
-
-/*
- * Structure describing information about an interface
- * which may be of interest to management entities.
- */
-struct if_data {
-	/* generic interface information */
-	u_char          ifi_type;       /* ethernet, tokenring, etc */
-	u_char          ifi_typelen;    /* Length of frame type id */
-	u_char          ifi_physical;   /* e.g., AUI, Thinnet, 10base-T, etc */
-	u_char          ifi_addrlen;    /* media address length */
-	u_char          ifi_hdrlen;     /* media header length */
-	u_char          ifi_recvquota;  /* polling quota for receive intrs */
-	u_char          ifi_xmitquota;  /* polling quota for xmit intrs */
-	u_char          ifi_unused1;    /* for future use */
-	u_int32_t       ifi_mtu;        /* maximum transmission unit */
-	u_int32_t       ifi_metric;     /* routing metric (external only) */
-	u_int32_t       ifi_baudrate;   /* linespeed */
-	/* volatile statistics */
-	u_int32_t       ifi_ipackets;   /* packets received on interface */
-	u_int32_t       ifi_ierrors;    /* input errors on interface */
-	u_int32_t       ifi_opackets;   /* packets sent on interface */
-	u_int32_t       ifi_oerrors;    /* output errors on interface */
-	u_int32_t       ifi_collisions; /* collisions on csma interfaces */
-	u_int32_t       ifi_ibytes;     /* total number of octets received */
-	u_int32_t       ifi_obytes;     /* total number of octets sent */
-	u_int32_t       ifi_imcasts;    /* packets received via multicast */
-	u_int32_t       ifi_omcasts;    /* packets sent via multicast */
-	u_int32_t       ifi_iqdrops;    /* dropped on input, this interface */
-	u_int32_t       ifi_noproto;    /* destined for unsupported protocol */
-	u_int32_t       ifi_recvtiming; /* usec spent receiving when timing */
-	u_int32_t       ifi_xmittiming; /* usec spent xmitting when timing */
-	struct IF_DATA_TIMEVAL ifi_lastchange;  /* time of last administrative change */
-	u_int32_t       ifi_unused2;    /* used to be the default_proto */
-	u_int32_t       ifi_hwassist;   /* HW offload capabilities */
-	u_int32_t       ifi_reserved1;  /* for future use */
-	u_int32_t       ifi_reserved2;  /* for future use */
-};
-
-/*
- * Structure describing information about an interface
- * which may be of interest to management entities.
- */
-struct if_data64 {
-	/* generic interface information */
-	u_char          ifi_type;               /* ethernet, tokenring, etc */
-	u_char          ifi_typelen;            /* Length of frame type id */
-	u_char          ifi_physical;           /* e.g., AUI, Thinnet, 10base-T, etc */
-	u_char          ifi_addrlen;            /* media address length */
-	u_char          ifi_hdrlen;             /* media header length */
-	u_char          ifi_recvquota;          /* polling quota for receive intrs */
-	u_char          ifi_xmitquota;          /* polling quota for xmit intrs */
-	u_char          ifi_unused1;            /* for future use */
-	u_int32_t       ifi_mtu;                /* maximum transmission unit */
-	u_int32_t       ifi_metric;             /* routing metric (external only) */
-	u_int64_t       ifi_baudrate;           /* linespeed */
-	/* volatile statistics */
-	u_int64_t       ifi_ipackets;           /* packets received on interface */
-	u_int64_t       ifi_ierrors;            /* input errors on interface */
-	u_int64_t       ifi_opackets;           /* packets sent on interface */
-	u_int64_t       ifi_oerrors;            /* output errors on interface */
-	u_int64_t       ifi_collisions;         /* collisions on csma interfaces */
-	u_int64_t       ifi_ibytes;             /* total number of octets received */
-	u_int64_t       ifi_obytes;             /* total number of octets sent */
-	u_int64_t       ifi_imcasts;            /* packets received via multicast */
-	u_int64_t       ifi_omcasts;            /* packets sent via multicast */
-	u_int64_t       ifi_iqdrops;            /* dropped on input, this interface */
-	u_int64_t       ifi_noproto;            /* destined for unsupported protocol */
-	u_int32_t       ifi_recvtiming;         /* usec spent receiving when timing */
-	u_int32_t       ifi_xmittiming;         /* usec spent xmitting when timing */
-	struct IF_DATA_TIMEVAL ifi_lastchange;  /* time of last administrative change */
-};
-
-
-#pragma pack()
-
-/*
- * Structure defining a queue for a network interface.
- */
-struct  ifqueue {
-	void    *ifq_head;
-	void    *ifq_tail;
-	int     ifq_len;
-	int     ifq_maxlen;
-	int     ifq_drops;
-};
-
-
-
-
-
-
-#endif /* !_NET_IF_VAR_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/net/route.h b/lib/libc/include/x86_64-macos-gnu/net/route.h
deleted file mode 100644
index ff5abdd268..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/net/route.h
+++ /dev/null
@@ -1,257 +0,0 @@
-/*
- * Copyright (c) 2000-2017 Apple Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-/*
- * Copyright (c) 1980, 1986, 1993
- *	The Regents of the University of California.  All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *	This product includes software developed by the University of
- *	California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *	@(#)route.h	8.3 (Berkeley) 4/19/94
- * $FreeBSD: src/sys/net/route.h,v 1.36.2.1 2000/08/16 06:14:23 jayanth Exp $
- */
-
-#ifndef _NET_ROUTE_H_
-#define _NET_ROUTE_H_
-#include <sys/appleapiopts.h>
-#include <stdint.h>
-#include <sys/types.h>
-#include <sys/socket.h>
-
-/*
- * These numbers are used by reliable protocols for determining
- * retransmission behavior and are included in the routing structure.
- */
-struct rt_metrics {
-	u_int32_t       rmx_locks;      /* Kernel leaves these values alone */
-	u_int32_t       rmx_mtu;        /* MTU for this path */
-	u_int32_t       rmx_hopcount;   /* max hops expected */
-	int32_t         rmx_expire;     /* lifetime for route, e.g. redirect */
-	u_int32_t       rmx_recvpipe;   /* inbound delay-bandwidth product */
-	u_int32_t       rmx_sendpipe;   /* outbound delay-bandwidth product */
-	u_int32_t       rmx_ssthresh;   /* outbound gateway buffer limit */
-	u_int32_t       rmx_rtt;        /* estimated round trip time */
-	u_int32_t       rmx_rttvar;     /* estimated rtt variance */
-	u_int32_t       rmx_pksent;     /* packets sent using this route */
-	u_int32_t       rmx_state;      /* route state */
-	u_int32_t       rmx_filler[3];  /* will be used for TCP's peer-MSS cache */
-};
-
-/*
- * rmx_rtt and rmx_rttvar are stored as microseconds;
- */
-#define RTM_RTTUNIT     1000000 /* units for rtt, rttvar, as units per sec */
-
-
-
-#define RTF_UP          0x1             /* route usable */
-#define RTF_GATEWAY     0x2             /* destination is a gateway */
-#define RTF_HOST        0x4             /* host entry (net otherwise) */
-#define RTF_REJECT      0x8             /* host or net unreachable */
-#define RTF_DYNAMIC     0x10            /* created dynamically (by redirect) */
-#define RTF_MODIFIED    0x20            /* modified dynamically (by redirect) */
-#define RTF_DONE        0x40            /* message confirmed */
-#define RTF_DELCLONE    0x80            /* delete cloned route */
-#define RTF_CLONING     0x100           /* generate new routes on use */
-#define RTF_XRESOLVE    0x200           /* external daemon resolves name */
-#define RTF_LLINFO      0x400           /* DEPRECATED - exists ONLY for backward
-	                                 *  compatibility */
-#define RTF_LLDATA      0x400           /* used by apps to add/del L2 entries */
-#define RTF_STATIC      0x800           /* manually added */
-#define RTF_BLACKHOLE   0x1000          /* just discard pkts (during updates) */
-#define RTF_NOIFREF     0x2000          /* not eligible for RTF_IFREF */
-#define RTF_PROTO2      0x4000          /* protocol specific routing flag */
-#define RTF_PROTO1      0x8000          /* protocol specific routing flag */
-
-#define RTF_PRCLONING   0x10000         /* protocol requires cloning */
-#define RTF_WASCLONED   0x20000         /* route generated through cloning */
-#define RTF_PROTO3      0x40000         /* protocol specific routing flag */
-                                        /* 0x80000 unused */
-#define RTF_PINNED      0x100000        /* future use */
-#define RTF_LOCAL       0x200000        /* route represents a local address */
-#define RTF_BROADCAST   0x400000        /* route represents a bcast address */
-#define RTF_MULTICAST   0x800000        /* route represents a mcast address */
-#define RTF_IFSCOPE     0x1000000       /* has valid interface scope */
-#define RTF_CONDEMNED   0x2000000       /* defunct; no longer modifiable */
-#define RTF_IFREF       0x4000000       /* route holds a ref to interface */
-#define RTF_PROXY       0x8000000       /* proxying, no interface scope */
-#define RTF_ROUTER      0x10000000      /* host is a router */
-#define RTF_DEAD        0x20000000      /* Route entry is being freed */
-                                        /* 0x40000000 and up unassigned */
-
-#define RTPRF_OURS      RTF_PROTO3      /* set on routes we manage */
-#define RTF_BITS \
-	"\020\1UP\2GATEWAY\3HOST\4REJECT\5DYNAMIC\6MODIFIED\7DONE" \
-	"\10DELCLONE\11CLONING\12XRESOLVE\13LLINFO\14STATIC\15BLACKHOLE" \
-	"\16NOIFREF\17PROTO2\20PROTO1\21PRCLONING\22WASCLONED\23PROTO3" \
-	"\25PINNED\26LOCAL\27BROADCAST\30MULTICAST\31IFSCOPE\32CONDEMNED" \
-	"\33IFREF\34PROXY\35ROUTER"
-
-#define IS_DIRECT_HOSTROUTE(rt) \
-	(((rt)->rt_flags & (RTF_HOST | RTF_GATEWAY)) == RTF_HOST)
-/*
- * Routing statistics.
- */
-struct  rtstat {
-	short   rts_badredirect;        /* bogus redirect calls */
-	short   rts_dynamic;            /* routes created by redirects */
-	short   rts_newgateway;         /* routes modified by redirects */
-	short   rts_unreach;            /* lookups which failed */
-	short   rts_wildcard;           /* lookups satisfied by a wildcard */
-	short   rts_badrtgwroute;       /* route to gateway is not direct */
-};
-
-/*
- * Structures for routing messages.
- */
-struct rt_msghdr {
-	u_short rtm_msglen;     /* to skip over non-understood messages */
-	u_char  rtm_version;    /* future binary compatibility */
-	u_char  rtm_type;       /* message type */
-	u_short rtm_index;      /* index for associated ifp */
-	int     rtm_flags;      /* flags, incl. kern & message, e.g. DONE */
-	int     rtm_addrs;      /* bitmask identifying sockaddrs in msg */
-	pid_t   rtm_pid;        /* identify sender */
-	int     rtm_seq;        /* for sender to identify action */
-	int     rtm_errno;      /* why failed */
-	int     rtm_use;        /* from rtentry */
-	u_int32_t rtm_inits;    /* which metrics we are initializing */
-	struct rt_metrics rtm_rmx; /* metrics themselves */
-};
-
-struct rt_msghdr2 {
-	u_short rtm_msglen;     /* to skip over non-understood messages */
-	u_char  rtm_version;    /* future binary compatibility */
-	u_char  rtm_type;       /* message type */
-	u_short rtm_index;      /* index for associated ifp */
-	int     rtm_flags;      /* flags, incl. kern & message, e.g. DONE */
-	int     rtm_addrs;      /* bitmask identifying sockaddrs in msg */
-	int32_t rtm_refcnt;     /* reference count */
-	int     rtm_parentflags; /* flags of the parent route */
-	int     rtm_reserved;   /* reserved field set to 0 */
-	int     rtm_use;        /* from rtentry */
-	u_int32_t rtm_inits;    /* which metrics we are initializing */
-	struct rt_metrics rtm_rmx; /* metrics themselves */
-};
-
-
-#define RTM_VERSION     5       /* Up the ante and ignore older versions */
-
-/*
- * Message types.
- */
-#define RTM_ADD         0x1     /* Add Route */
-#define RTM_DELETE      0x2     /* Delete Route */
-#define RTM_CHANGE      0x3     /* Change Metrics or flags */
-#define RTM_GET         0x4     /* Report Metrics */
-#define RTM_LOSING      0x5     /* RTM_LOSING is no longer generated by xnu
-	                         *  and is deprecated */
-#define RTM_REDIRECT    0x6     /* Told to use different route */
-#define RTM_MISS        0x7     /* Lookup failed on this address */
-#define RTM_LOCK        0x8     /* fix specified metrics */
-#define RTM_OLDADD      0x9     /* caused by SIOCADDRT */
-#define RTM_OLDDEL      0xa     /* caused by SIOCDELRT */
-#define RTM_RESOLVE     0xb     /* req to resolve dst to LL addr */
-#define RTM_NEWADDR     0xc     /* address being added to iface */
-#define RTM_DELADDR     0xd     /* address being removed from iface */
-#define RTM_IFINFO      0xe     /* iface going up/down etc. */
-#define RTM_NEWMADDR    0xf     /* mcast group membership being added to if */
-#define RTM_DELMADDR    0x10    /* mcast group membership being deleted */
-#define RTM_IFINFO2     0x12    /* */
-#define RTM_NEWMADDR2   0x13    /* */
-#define RTM_GET2        0x14    /* */
-
-/*
- * Bitmask values for rtm_inits and rmx_locks.
- */
-#define RTV_MTU         0x1     /* init or lock _mtu */
-#define RTV_HOPCOUNT    0x2     /* init or lock _hopcount */
-#define RTV_EXPIRE      0x4     /* init or lock _expire */
-#define RTV_RPIPE       0x8     /* init or lock _recvpipe */
-#define RTV_SPIPE       0x10    /* init or lock _sendpipe */
-#define RTV_SSTHRESH    0x20    /* init or lock _ssthresh */
-#define RTV_RTT         0x40    /* init or lock _rtt */
-#define RTV_RTTVAR      0x80    /* init or lock _rttvar */
-
-/*
- * Bitmask values for rtm_addrs.
- */
-#define RTA_DST         0x1     /* destination sockaddr present */
-#define RTA_GATEWAY     0x2     /* gateway sockaddr present */
-#define RTA_NETMASK     0x4     /* netmask sockaddr present */
-#define RTA_GENMASK     0x8     /* cloning mask sockaddr present */
-#define RTA_IFP         0x10    /* interface name sockaddr present */
-#define RTA_IFA         0x20    /* interface addr sockaddr present */
-#define RTA_AUTHOR      0x40    /* sockaddr for author of redirect */
-#define RTA_BRD         0x80    /* for NEWADDR, broadcast or p-p dest addr */
-
-/*
- * Index offsets for sockaddr array for alternate internal encoding.
- */
-#define RTAX_DST        0       /* destination sockaddr present */
-#define RTAX_GATEWAY    1       /* gateway sockaddr present */
-#define RTAX_NETMASK    2       /* netmask sockaddr present */
-#define RTAX_GENMASK    3       /* cloning mask sockaddr present */
-#define RTAX_IFP        4       /* interface name sockaddr present */
-#define RTAX_IFA        5       /* interface addr sockaddr present */
-#define RTAX_AUTHOR     6       /* sockaddr for author of redirect */
-#define RTAX_BRD        7       /* for NEWADDR, broadcast or p-p dest addr */
-#define RTAX_MAX        8       /* size of array to allocate */
-
-struct rt_addrinfo {
-	int     rti_addrs;
-	struct  sockaddr *rti_info[RTAX_MAX];
-};
-
-
-#endif /* _NET_ROUTE_H_ */
diff --git a/lib/libc/include/x86_64-macos-gnu/netinet/in.h b/lib/libc/include/x86_64-macos-gnu/netinet/in.h
deleted file mode 100644
index 0e921c2965..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/netinet/in.h
+++ /dev/null
@@ -1,671 +0,0 @@
-/*
- * Copyright (c) 2000-2018 Apple Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-/*
- * Copyright (c) 1982, 1986, 1990, 1993
- *	The Regents of the University of California.  All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *	This product includes software developed by the University of
- *	California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *	@(#)in.h	8.3 (Berkeley) 1/3/94
- * $FreeBSD: src/sys/netinet/in.h,v 1.48.2.2 2001/04/21 14:53:06 ume Exp $
- */
-
-#ifndef _NETINET_IN_H_
-#define _NETINET_IN_H_
-#include <sys/appleapiopts.h>
-#include <sys/_types.h>
-#include <stdint.h>             /* uint(8|16|32)_t */
-
-#include <Availability.h>
-
-#include <sys/_types/_in_addr_t.h>
-
-#include <sys/_types/_in_port_t.h>
-
-/*
- * POSIX 1003.1-2003
- * "Inclusion of the <netinet/in.h> header may also make visible all
- *  symbols from <inttypes.h> and <sys/socket.h>".
- */
-#include <sys/socket.h>
-
-/*
- * The following two #includes insure htonl and family are defined
- */
-#include <machine/endian.h>
-#include <sys/_endian.h>
-
-/*
- * Constants and structures defined by the internet system,
- * Per RFC 790, September 1981, and numerous additions.
- */
-
-/*
- * Protocols (RFC 1700)
- */
-#define IPPROTO_IP              0               /* dummy for IP */
-#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-#define IPPROTO_HOPOPTS 0               /* IP6 hop-by-hop options */
-#endif  /* (!_POSIX_C_SOURCE || _DARWIN_C_SOURCE) */
-#define IPPROTO_ICMP            1               /* control message protocol */
-#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-#define IPPROTO_IGMP            2               /* group mgmt protocol */
-#define IPPROTO_GGP             3               /* gateway^2 (deprecated) */
-#define IPPROTO_IPV4            4               /* IPv4 encapsulation */
-#define IPPROTO_IPIP            IPPROTO_IPV4    /* for compatibility */
-#endif  /* (!_POSIX_C_SOURCE || _DARWIN_C_SOURCE) */
-#define IPPROTO_TCP             6               /* tcp */
-#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-#define IPPROTO_ST              7               /* Stream protocol II */
-#define IPPROTO_EGP             8               /* exterior gateway protocol */
-#define IPPROTO_PIGP            9               /* private interior gateway */
-#define IPPROTO_RCCMON          10              /* BBN RCC Monitoring */
-#define IPPROTO_NVPII           11              /* network voice protocol*/
-#define IPPROTO_PUP             12              /* pup */
-#define IPPROTO_ARGUS           13              /* Argus */
-#define IPPROTO_EMCON           14              /* EMCON */
-#define IPPROTO_XNET            15              /* Cross Net Debugger */
-#define IPPROTO_CHAOS           16              /* Chaos*/
-#endif  /* (!_POSIX_C_SOURCE || _DARWIN_C_SOURCE) */
-#define IPPROTO_UDP             17              /* user datagram protocol */
-#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-#define IPPROTO_MUX             18              /* Multiplexing */
-#define IPPROTO_MEAS            19              /* DCN Measurement Subsystems */
-#define IPPROTO_HMP             20              /* Host Monitoring */
-#define IPPROTO_PRM             21              /* Packet Radio Measurement */
-#define IPPROTO_IDP             22              /* xns idp */
-#define IPPROTO_TRUNK1          23              /* Trunk-1 */
-#define IPPROTO_TRUNK2          24              /* Trunk-2 */
-#define IPPROTO_LEAF1           25              /* Leaf-1 */
-#define IPPROTO_LEAF2           26              /* Leaf-2 */
-#define IPPROTO_RDP             27              /* Reliable Data */
-#define IPPROTO_IRTP            28              /* Reliable Transaction */
-#define IPPROTO_TP              29              /* tp-4 w/ class negotiation */
-#define IPPROTO_BLT             30              /* Bulk Data Transfer */
-#define IPPROTO_NSP             31              /* Network Services */
-#define IPPROTO_INP             32              /* Merit Internodal */
-#define IPPROTO_SEP             33              /* Sequential Exchange */
-#define IPPROTO_3PC             34              /* Third Party Connect */
-#define IPPROTO_IDPR            35              /* InterDomain Policy Routing */
-#define IPPROTO_XTP             36              /* XTP */
-#define IPPROTO_DDP             37              /* Datagram Delivery */
-#define IPPROTO_CMTP            38              /* Control Message Transport */
-#define IPPROTO_TPXX            39              /* TP++ Transport */
-#define IPPROTO_IL              40              /* IL transport protocol */
-#endif  /* (!_POSIX_C_SOURCE || _DARWIN_C_SOURCE) */
-#define         IPPROTO_IPV6            41              /* IP6 header */
-#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-#define IPPROTO_SDRP            42              /* Source Demand Routing */
-#define         IPPROTO_ROUTING 43              /* IP6 routing header */
-#define         IPPROTO_FRAGMENT        44              /* IP6 fragmentation header */
-#define IPPROTO_IDRP            45              /* InterDomain Routing*/
-#define         IPPROTO_RSVP            46              /* resource reservation */
-#define IPPROTO_GRE             47              /* General Routing Encap. */
-#define IPPROTO_MHRP            48              /* Mobile Host Routing */
-#define IPPROTO_BHA             49              /* BHA */
-#define IPPROTO_ESP             50              /* IP6 Encap Sec. Payload */
-#define IPPROTO_AH              51              /* IP6 Auth Header */
-#define IPPROTO_INLSP           52              /* Integ. Net Layer Security */
-#define IPPROTO_SWIPE           53              /* IP with encryption */
-#define IPPROTO_NHRP            54              /* Next Hop Resolution */
-/* 55-57: Unassigned */
-#define IPPROTO_ICMPV6          58              /* ICMP6 */
-#define IPPROTO_NONE            59              /* IP6 no next header */
-#define IPPROTO_DSTOPTS         60              /* IP6 destination option */
-#define IPPROTO_AHIP            61              /* any host internal protocol */
-#define IPPROTO_CFTP            62              /* CFTP */
-#define IPPROTO_HELLO           63              /* "hello" routing protocol */
-#define IPPROTO_SATEXPAK        64              /* SATNET/Backroom EXPAK */
-#define IPPROTO_KRYPTOLAN       65              /* Kryptolan */
-#define IPPROTO_RVD             66              /* Remote Virtual Disk */
-#define IPPROTO_IPPC            67              /* Pluribus Packet Core */
-#define IPPROTO_ADFS            68              /* Any distributed FS */
-#define IPPROTO_SATMON          69              /* Satnet Monitoring */
-#define IPPROTO_VISA            70              /* VISA Protocol */
-#define IPPROTO_IPCV            71              /* Packet Core Utility */
-#define IPPROTO_CPNX            72              /* Comp. Prot. Net. Executive */
-#define IPPROTO_CPHB            73              /* Comp. Prot. HeartBeat */
-#define IPPROTO_WSN             74              /* Wang Span Network */
-#define IPPROTO_PVP             75              /* Packet Video Protocol */
-#define IPPROTO_BRSATMON        76              /* BackRoom SATNET Monitoring */
-#define IPPROTO_ND              77              /* Sun net disk proto (temp.) */
-#define IPPROTO_WBMON           78              /* WIDEBAND Monitoring */
-#define IPPROTO_WBEXPAK         79              /* WIDEBAND EXPAK */
-#define IPPROTO_EON             80              /* ISO cnlp */
-#define IPPROTO_VMTP            81              /* VMTP */
-#define IPPROTO_SVMTP           82              /* Secure VMTP */
-#define IPPROTO_VINES           83              /* Banyon VINES */
-#define IPPROTO_TTP             84              /* TTP */
-#define IPPROTO_IGP             85              /* NSFNET-IGP */
-#define IPPROTO_DGP             86              /* dissimilar gateway prot. */
-#define IPPROTO_TCF             87              /* TCF */
-#define IPPROTO_IGRP            88              /* Cisco/GXS IGRP */
-#define IPPROTO_OSPFIGP         89              /* OSPFIGP */
-#define IPPROTO_SRPC            90              /* Strite RPC protocol */
-#define IPPROTO_LARP            91              /* Locus Address Resoloution */
-#define IPPROTO_MTP             92              /* Multicast Transport */
-#define IPPROTO_AX25            93              /* AX.25 Frames */
-#define IPPROTO_IPEIP           94              /* IP encapsulated in IP */
-#define IPPROTO_MICP            95              /* Mobile Int.ing control */
-#define IPPROTO_SCCSP           96              /* Semaphore Comm. security */
-#define IPPROTO_ETHERIP         97              /* Ethernet IP encapsulation */
-#define IPPROTO_ENCAP           98              /* encapsulation header */
-#define IPPROTO_APES            99              /* any private encr. scheme */
-#define IPPROTO_GMTP            100             /* GMTP*/
-/* 101-252: Partly Unassigned */
-#define IPPROTO_PIM             103             /* Protocol Independent Mcast */
-#define IPPROTO_IPCOMP          108             /* payload compression (IPComp) */
-#define IPPROTO_PGM             113             /* PGM */
-#define IPPROTO_SCTP            132             /* SCTP */
-/* 253-254: Experimentation and testing; 255: Reserved (RFC3692) */
-/* BSD Private, local use, namespace incursion */
-#define IPPROTO_DIVERT          254             /* divert pseudo-protocol */
-#endif  /* (!_POSIX_C_SOURCE || _DARWIN_C_SOURCE) */
-#define IPPROTO_RAW             255             /* raw IP packet */
-
-#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-#define IPPROTO_MAX             256
-
-/* last return value of *_input(), meaning "all job for this pkt is done".  */
-#define IPPROTO_DONE            257
-#endif /* (_POSIX_C_SOURCE && !_DARWIN_C_SOURCE) */
-
-/*
- * Local port number conventions:
- *
- * When a user does a bind(2) or connect(2) with a port number of zero,
- * a non-conflicting local port address is chosen.
- * The default range is IPPORT_RESERVED through
- * IPPORT_USERRESERVED, although that is settable by sysctl.
- *
- * A user may set the IPPROTO_IP option IP_PORTRANGE to change this
- * default assignment range.
- *
- * The value IP_PORTRANGE_DEFAULT causes the default behavior.
- *
- * The value IP_PORTRANGE_HIGH changes the range of candidate port numbers
- * into the "high" range.  These are reserved for client outbound connections
- * which do not want to be filtered by any firewalls.
- *
- * The value IP_PORTRANGE_LOW changes the range to the "low" are
- * that is (by convention) restricted to privileged processes.  This
- * convention is based on "vouchsafe" principles only.  It is only secure
- * if you trust the remote host to restrict these ports.
- *
- * The default range of ports and the high range can be changed by
- * sysctl(3).  (net.inet.ip.port{hi,low}{first,last}_auto)
- *
- * Changing those values has bad security implications if you are
- * using a a stateless firewall that is allowing packets outside of that
- * range in order to allow transparent outgoing connections.
- *
- * Such a firewall configuration will generally depend on the use of these
- * default values.  If you change them, you may find your Security
- * Administrator looking for you with a heavy object.
- *
- * For a slightly more orthodox text view on this:
- *
- *            ftp://ftp.isi.edu/in-notes/iana/assignments/port-numbers
- *
- *    port numbers are divided into three ranges:
- *
- *                0 -  1023 Well Known Ports
- *             1024 - 49151 Registered Ports
- *            49152 - 65535 Dynamic and/or Private Ports
- *
- */
-
-#define __DARWIN_IPPORT_RESERVED        1024
-
-#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-/*
- * Ports < IPPORT_RESERVED are reserved for
- * privileged processes (e.g. root).         (IP_PORTRANGE_LOW)
- * Ports > IPPORT_USERRESERVED are reserved
- * for servers, not necessarily privileged.  (IP_PORTRANGE_DEFAULT)
- */
-#ifndef IPPORT_RESERVED
-#define IPPORT_RESERVED         __DARWIN_IPPORT_RESERVED
-#endif
-#define IPPORT_USERRESERVED     5000
-
-/*
- * Default local port range to use by setting IP_PORTRANGE_HIGH
- */
-#define IPPORT_HIFIRSTAUTO      49152
-#define IPPORT_HILASTAUTO       65535
-
-/*
- * Scanning for a free reserved port return a value below IPPORT_RESERVED,
- * but higher than IPPORT_RESERVEDSTART.  Traditionally the start value was
- * 512, but that conflicts with some well-known-services that firewalls may
- * have a fit if we use.
- */
-#define IPPORT_RESERVEDSTART    600
-#endif  /* (!_POSIX_C_SOURCE || _DARWIN_C_SOURCE) */
-
-/*
- * Internet address (a structure for historical reasons)
- */
-struct in_addr {
-	in_addr_t s_addr;
-};
-
-/*
- * Definitions of bits in internet address integers.
- * On subnets, the decomposition of addresses to host and net parts
- * is done according to subnet mask, not the masks here.
- */
-#define INADDR_ANY              (u_int32_t)0x00000000
-#define INADDR_BROADCAST        (u_int32_t)0xffffffff   /* must be masked */
-
-#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-#define IN_CLASSA(i)            (((u_int32_t)(i) & 0x80000000) == 0)
-#define IN_CLASSA_NET           0xff000000
-#define IN_CLASSA_NSHIFT        24
-#define IN_CLASSA_HOST          0x00ffffff
-#define IN_CLASSA_MAX           128
-
-#define IN_CLASSB(i)            (((u_int32_t)(i) & 0xc0000000) == 0x80000000)
-#define IN_CLASSB_NET           0xffff0000
-#define IN_CLASSB_NSHIFT        16
-#define IN_CLASSB_HOST          0x0000ffff
-#define IN_CLASSB_MAX           65536
-
-#define IN_CLASSC(i)            (((u_int32_t)(i) & 0xe0000000) == 0xc0000000)
-#define IN_CLASSC_NET           0xffffff00
-#define IN_CLASSC_NSHIFT        8
-#define IN_CLASSC_HOST          0x000000ff
-
-#define IN_CLASSD(i)            (((u_int32_t)(i) & 0xf0000000) == 0xe0000000)
-#define IN_CLASSD_NET           0xf0000000      /* These ones aren't really */
-#define IN_CLASSD_NSHIFT        28              /* net and host fields, but */
-#define IN_CLASSD_HOST          0x0fffffff      /* routing needn't know.    */
-#define IN_MULTICAST(i)         IN_CLASSD(i)
-
-#define IN_EXPERIMENTAL(i)      (((u_int32_t)(i) & 0xf0000000) == 0xf0000000)
-#define IN_BADCLASS(i)          (((u_int32_t)(i) & 0xf0000000) == 0xf0000000)
-
-#define INADDR_LOOPBACK         (u_int32_t)0x7f000001
-
-#define INADDR_NONE             0xffffffff              /* -1 return */
-
-#define INADDR_UNSPEC_GROUP     (u_int32_t)0xe0000000   /* 224.0.0.0 */
-#define INADDR_ALLHOSTS_GROUP   (u_int32_t)0xe0000001   /* 224.0.0.1 */
-#define INADDR_ALLRTRS_GROUP    (u_int32_t)0xe0000002   /* 224.0.0.2 */
-#define INADDR_ALLRPTS_GROUP    (u_int32_t)0xe0000016   /* 224.0.0.22, IGMPv3 */
-#define INADDR_CARP_GROUP       (u_int32_t)0xe0000012   /* 224.0.0.18 */
-#define INADDR_PFSYNC_GROUP     (u_int32_t)0xe00000f0   /* 224.0.0.240 */
-#define INADDR_ALLMDNS_GROUP    (u_int32_t)0xe00000fb   /* 224.0.0.251 */
-#define INADDR_MAX_LOCAL_GROUP  (u_int32_t)0xe00000ff   /* 224.0.0.255 */
-
-#ifdef __APPLE__
-#define IN_LINKLOCALNETNUM      (u_int32_t)0xA9FE0000 /* 169.254.0.0 */
-#define IN_LINKLOCAL(i)         (((u_int32_t)(i) & IN_CLASSB_NET) == IN_LINKLOCALNETNUM)
-#define IN_LOOPBACK(i)          (((u_int32_t)(i) & 0xff000000) == 0x7f000000)
-#define IN_ZERONET(i)           (((u_int32_t)(i) & 0xff000000) == 0)
-
-#define IN_PRIVATE(i)   ((((u_int32_t)(i) & 0xff000000) == 0x0a000000) || \
-	                 (((u_int32_t)(i) & 0xfff00000) == 0xac100000) || \
-	                 (((u_int32_t)(i) & 0xffff0000) == 0xc0a80000))
-
-
-#define IN_LOCAL_GROUP(i)       (((u_int32_t)(i) & 0xffffff00) == 0xe0000000)
-
-#define IN_ANY_LOCAL(i)         (IN_LINKLOCAL(i) || IN_LOCAL_GROUP(i))
-#endif /* __APPLE__ */
-
-#define IN_LOOPBACKNET          127                     /* official! */
-#endif  /* (!_POSIX_C_SOURCE || _DARWIN_C_SOURCE) */
-
-/*
- * Socket address, internet style.
- */
-struct sockaddr_in {
-	__uint8_t       sin_len;
-	sa_family_t     sin_family;
-	in_port_t       sin_port;
-	struct  in_addr sin_addr;
-	char            sin_zero[8];
-};
-
-#define IN_ARE_ADDR_EQUAL(a, b) \
-    (bcmp(&(a)->s_addr, &(b)->s_addr, \
-	sizeof (struct in_addr)) == 0)
-
-
-#define INET_ADDRSTRLEN                 16
-
-#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-/*
- * Structure used to describe IP options.
- * Used to store options internally, to pass them to a process,
- * or to restore options retrieved earlier.
- * The ip_dst is used for the first-hop gateway when using a source route
- * (this gets put into the header proper).
- */
-struct ip_opts {
-	struct  in_addr ip_dst;         /* first hop, 0 w/o src rt */
-	char    ip_opts[40];            /* actually variable in size */
-};
-
-/*
- * Options for use with [gs]etsockopt at the IP level.
- * First word of comment is data type; bool is stored in int.
- */
-#define IP_OPTIONS              1    /* buf/ip_opts; set/get IP options */
-#define IP_HDRINCL              2    /* int; header is included with data */
-#define IP_TOS                  3    /* int; IP type of service and preced. */
-#define IP_TTL                  4    /* int; IP time to live */
-#define IP_RECVOPTS             5    /* bool; receive all IP opts w/dgram */
-#define IP_RECVRETOPTS          6    /* bool; receive IP opts for response */
-#define IP_RECVDSTADDR          7    /* bool; receive IP dst addr w/dgram */
-#define IP_RETOPTS              8    /* ip_opts; set/get IP options */
-#define IP_MULTICAST_IF         9    /* u_char; set/get IP multicast i/f  */
-#define IP_MULTICAST_TTL        10   /* u_char; set/get IP multicast ttl */
-#define IP_MULTICAST_LOOP       11   /* u_char; set/get IP multicast loopback */
-#define IP_ADD_MEMBERSHIP       12   /* ip_mreq; add an IP group membership */
-#define IP_DROP_MEMBERSHIP      13   /* ip_mreq; drop an IP group membership */
-#define IP_MULTICAST_VIF        14   /* set/get IP mcast virt. iface */
-#define IP_RSVP_ON              15   /* enable RSVP in kernel */
-#define IP_RSVP_OFF             16   /* disable RSVP in kernel */
-#define IP_RSVP_VIF_ON          17   /* set RSVP per-vif socket */
-#define IP_RSVP_VIF_OFF         18   /* unset RSVP per-vif socket */
-#define IP_PORTRANGE            19   /* int; range to choose for unspec port */
-#define IP_RECVIF               20   /* bool; receive reception if w/dgram */
-/* for IPSEC */
-#define IP_IPSEC_POLICY         21   /* int; set/get security policy */
-#define IP_FAITH                22   /* deprecated */
-#ifdef __APPLE__
-#define IP_STRIPHDR             23   /* bool: drop receive of raw IP header */
-#endif
-#define IP_RECVTTL              24   /* bool; receive reception TTL w/dgram */
-#define IP_BOUND_IF             25   /* int; set/get bound interface */
-#define IP_PKTINFO              26   /* get pktinfo on recv socket, set src on sent dgram  */
-#define IP_RECVPKTINFO          IP_PKTINFO      /* receive pktinfo w/dgram */
-#define IP_RECVTOS              27   /* bool; receive IP TOS w/dgram */
-
-#define IP_FW_ADD               40   /* add a firewall rule to chain */
-#define IP_FW_DEL               41   /* delete a firewall rule from chain */
-#define IP_FW_FLUSH             42   /* flush firewall rule chain */
-#define IP_FW_ZERO              43   /* clear single/all firewall counter(s) */
-#define IP_FW_GET               44   /* get entire firewall rule chain */
-#define IP_FW_RESETLOG          45   /* reset logging counters */
-
-/* These older firewall socket option codes are maintained for backward compatibility. */
-#define IP_OLD_FW_ADD           50   /* add a firewall rule to chain */
-#define IP_OLD_FW_DEL           51   /* delete a firewall rule from chain */
-#define IP_OLD_FW_FLUSH         52   /* flush firewall rule chain */
-#define IP_OLD_FW_ZERO          53   /* clear single/all firewall counter(s) */
-#define IP_OLD_FW_GET           54   /* get entire firewall rule chain */
-#define IP_NAT__XXX                     55   /* set/get NAT opts XXX Deprecated, do not use */
-#define IP_OLD_FW_RESETLOG      56   /* reset logging counters */
-
-#define IP_DUMMYNET_CONFIGURE   60   /* add/configure a dummynet pipe */
-#define IP_DUMMYNET_DEL         61   /* delete a dummynet pipe from chain */
-#define IP_DUMMYNET_FLUSH       62   /* flush dummynet */
-#define IP_DUMMYNET_GET         64   /* get entire dummynet pipes */
-
-#define IP_TRAFFIC_MGT_BACKGROUND       65   /* int*; get background IO flags; set background IO */
-#define IP_MULTICAST_IFINDEX    66   /* int*; set/get IP multicast i/f index */
-
-/* IPv4 Source Filter Multicast API [RFC3678] */
-#define IP_ADD_SOURCE_MEMBERSHIP        70   /* join a source-specific group */
-#define IP_DROP_SOURCE_MEMBERSHIP       71   /* drop a single source */
-#define IP_BLOCK_SOURCE                 72   /* block a source */
-#define IP_UNBLOCK_SOURCE               73   /* unblock a source */
-
-/* The following option is private; do not use it from user applications. */
-#define IP_MSFILTER                     74   /* set/get filter list */
-
-/* Protocol Independent Multicast API [RFC3678] */
-#define MCAST_JOIN_GROUP                80   /* join an any-source group */
-#define MCAST_LEAVE_GROUP               81   /* leave all sources for group */
-#define MCAST_JOIN_SOURCE_GROUP         82   /* join a source-specific group */
-#define MCAST_LEAVE_SOURCE_GROUP        83   /* leave a single source */
-#define MCAST_BLOCK_SOURCE              84   /* block a source */
-#define MCAST_UNBLOCK_SOURCE            85   /* unblock a source */
-
-
-/*
- * Defaults and limits for options
- */
-#define IP_DEFAULT_MULTICAST_TTL  1     /* normally limit m'casts to 1 hop  */
-#define IP_DEFAULT_MULTICAST_LOOP 1     /* normally hear sends if a member  */
-
-/*
- * The imo_membership vector for each socket is now dynamically allocated at
- * run-time, bounded by USHRT_MAX, and is reallocated when needed, sized
- * according to a power-of-two increment.
- */
-#define IP_MIN_MEMBERSHIPS      31
-#define IP_MAX_MEMBERSHIPS      4095
-
-/*
- * Default resource limits for IPv4 multicast source filtering.
- * These may be modified by sysctl.
- */
-#define IP_MAX_GROUP_SRC_FILTER         512     /* sources per group */
-#define IP_MAX_SOCK_SRC_FILTER          128     /* sources per socket/group */
-#define IP_MAX_SOCK_MUTE_FILTER         128     /* XXX no longer used */
-
-/*
- * Argument structure for IP_ADD_MEMBERSHIP and IP_DROP_MEMBERSHIP.
- */
-struct ip_mreq {
-	struct  in_addr imr_multiaddr;  /* IP multicast address of group */
-	struct  in_addr imr_interface;  /* local IP address of interface */
-};
-
-/*
- * Modified argument structure for IP_MULTICAST_IF, obtained from Linux.
- * This is used to specify an interface index for multicast sends, as
- * the IPv4 legacy APIs do not support this (unless IP_SENDIF is available).
- */
-struct ip_mreqn {
-	struct  in_addr imr_multiaddr;  /* IP multicast address of group */
-	struct  in_addr imr_address;    /* local IP address of interface */
-	int             imr_ifindex;    /* Interface index; cast to uint32_t */
-};
-
-#pragma pack(4)
-/*
- * Argument structure for IPv4 Multicast Source Filter APIs. [RFC3678]
- */
-struct ip_mreq_source {
-	struct  in_addr imr_multiaddr;  /* IP multicast address of group */
-	struct  in_addr imr_sourceaddr; /* IP address of source */
-	struct  in_addr imr_interface;  /* local IP address of interface */
-};
-
-/*
- * Argument structures for Protocol-Independent Multicast Source
- * Filter APIs. [RFC3678]
- */
-struct group_req {
-	uint32_t                gr_interface;   /* interface index */
-	struct sockaddr_storage gr_group;       /* group address */
-};
-
-struct group_source_req {
-	uint32_t                gsr_interface;  /* interface index */
-	struct sockaddr_storage gsr_group;      /* group address */
-	struct sockaddr_storage gsr_source;     /* source address */
-};
-
-#ifndef __MSFILTERREQ_DEFINED
-#define __MSFILTERREQ_DEFINED
-/*
- * The following structure is private; do not use it from user applications.
- * It is used to communicate IP_MSFILTER/IPV6_MSFILTER information between
- * the RFC 3678 libc functions and the kernel.
- */
-struct __msfilterreq {
-	uint32_t                 msfr_ifindex;  /* interface index */
-	uint32_t                 msfr_fmode;    /* filter mode for group */
-	uint32_t                 msfr_nsrcs;    /* # of sources in msfr_srcs */
-	uint32_t                __msfr_align;
-	struct sockaddr_storage  msfr_group;    /* group address */
-	struct sockaddr_storage *msfr_srcs;
-};
-
-#endif /* __MSFILTERREQ_DEFINED */
-
-#pragma pack()
-struct sockaddr;
-
-/*
- * Advanced (Full-state) APIs [RFC3678]
- * The RFC specifies uint_t for the 6th argument to [sg]etsourcefilter().
- * We use uint32_t here to be consistent.
- */
-int     setipv4sourcefilter(int, struct in_addr, struct in_addr, uint32_t,
-    uint32_t, struct in_addr *) __OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_4_3);
-int     getipv4sourcefilter(int, struct in_addr, struct in_addr, uint32_t *,
-    uint32_t *, struct in_addr *) __OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_4_3);
-int     setsourcefilter(int, uint32_t, struct sockaddr *, socklen_t,
-    uint32_t, uint32_t, struct sockaddr_storage *) __OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_4_3);
-int     getsourcefilter(int, uint32_t, struct sockaddr *, socklen_t,
-    uint32_t *, uint32_t *, struct sockaddr_storage *) __OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_4_3);
-
-/*
- * Filter modes; also used to represent per-socket filter mode internally.
- */
-#define MCAST_UNDEFINED 0       /* fmode: not yet defined */
-#define MCAST_INCLUDE   1       /* fmode: include these source(s) */
-#define MCAST_EXCLUDE   2       /* fmode: exclude these source(s) */
-
-/*
- * Argument for IP_PORTRANGE:
- * - which range to search when port is unspecified at bind() or connect()
- */
-#define IP_PORTRANGE_DEFAULT    0       /* default range */
-#define IP_PORTRANGE_HIGH       1       /* "high" - request firewall bypass */
-#define IP_PORTRANGE_LOW        2       /* "low" - vouchsafe security */
-
-
-/*
- * IP_PKTINFO: Packet information (equivalent to  RFC2292 sec 5 for IPv4)
- * This structure is used for
- *
- * 1) Receiving ancilliary data about the datagram if IP_PKTINFO sockopt is
- *    set on the socket. In this case ipi_ifindex will contain the interface
- *    index the datagram was received on, ipi_addr is the IP address the
- *    datagram was received to.
- *
- * 2) Sending a datagram using a specific interface or IP source address.
- *    if ipi_ifindex is set to non-zero when in_pktinfo is passed as
- *    ancilliary data of type IP_PKTINFO, this will be used as the source
- *    interface to send the datagram from. If ipi_ifindex is null, ip_spec_dst
- *    will be used for the source address.
- *
- *    Note: if IP_BOUND_IF is set on the socket, ipi_ifindex in the ancillary
- *    IP_PKTINFO option silently overrides the bound interface when it is
- *    specified during send time.
- */
-struct in_pktinfo {
-	unsigned int    ipi_ifindex;    /* send/recv interface index */
-	struct in_addr  ipi_spec_dst;   /* Local address */
-	struct in_addr  ipi_addr;       /* IP Header dst address */
-};
-
-/*
- * Definitions for inet sysctl operations.
- *
- * Third level is protocol number.
- * Fourth level is desired variable within that protocol.
- */
-#define IPPROTO_MAXID   (IPPROTO_AH + 1)        /* don't list to IPPROTO_MAX */
-
-
-/*
- * Names for IP sysctl objects
- */
-#define IPCTL_FORWARDING        1       /* act as router */
-#define IPCTL_SENDREDIRECTS     2       /* may send redirects when forwarding */
-#define IPCTL_DEFTTL            3       /* default TTL */
-#ifdef notyet
-#define IPCTL_DEFMTU            4       /* default MTU */
-#endif
-#define IPCTL_RTEXPIRE          5       /* cloned route expiration time */
-#define IPCTL_RTMINEXPIRE       6       /* min value for expiration time */
-#define IPCTL_RTMAXCACHE        7       /* trigger level for dynamic expire */
-#define IPCTL_SOURCEROUTE       8       /* may perform source routes */
-#define IPCTL_DIRECTEDBROADCAST 9       /* may re-broadcast received packets */
-#define IPCTL_INTRQMAXLEN       10      /* max length of netisr queue */
-#define IPCTL_INTRQDROPS        11      /* number of netisr q drops */
-#define IPCTL_STATS             12      /* ipstat structure */
-#define IPCTL_ACCEPTSOURCEROUTE 13      /* may accept source routed packets */
-#define IPCTL_FASTFORWARDING    14      /* use fast IP forwarding code */
-#define IPCTL_KEEPFAITH         15      /* deprecated */
-#define IPCTL_GIF_TTL           16      /* default TTL for gif encap packet */
-#define IPCTL_MAXID             17
-
-#endif  /* (!_POSIX_C_SOURCE || _DARWIN_C_SOURCE) */
-
-/* INET6 stuff */
-#define __KAME_NETINET_IN_H_INCLUDED_
-#include <netinet6/in6.h>
-#undef __KAME_NETINET_IN_H_INCLUDED_
-
-
-
-#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-__BEGIN_DECLS
-int        bindresvport(int, struct sockaddr_in *);
-struct sockaddr;
-int        bindresvport_sa(int, struct sockaddr *);
-__END_DECLS
-#endif
-#endif /* _NETINET_IN_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/netinet/tcp.h b/lib/libc/include/x86_64-macos-gnu/netinet/tcp.h
deleted file mode 100644
index f089db156e..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/netinet/tcp.h
+++ /dev/null
@@ -1,283 +0,0 @@
-/*
- * Copyright (c) 2000-2018 Apple Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-/*
- * Copyright (c) 1982, 1986, 1993
- *	The Regents of the University of California.  All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *	This product includes software developed by the University of
- *	California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *	@(#)tcp.h	8.1 (Berkeley) 6/10/93
- * $FreeBSD: src/sys/netinet/tcp.h,v 1.13.2.3 2001/03/01 22:08:42 jlemon Exp $
- */
-
-#ifndef _NETINET_TCP_H_
-#define _NETINET_TCP_H_
-#include <sys/types.h>
-#include <sys/appleapiopts.h>
-#include <machine/endian.h>
-#include <machine/types.h> /* __uint32_t */
-
-#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-typedef __uint32_t tcp_seq;
-typedef __uint32_t tcp_cc;              /* connection count per rfc1644 */
-
-#define tcp6_seq        tcp_seq /* for KAME src sync over BSD*'s */
-#define tcp6hdr         tcphdr  /* for KAME src sync over BSD*'s */
-
-/*
- * TCP header.
- * Per RFC 793, September, 1981.
- */
-struct tcphdr {
-	unsigned short  th_sport;       /* source port */
-	unsigned short  th_dport;       /* destination port */
-	tcp_seq th_seq;                 /* sequence number */
-	tcp_seq th_ack;                 /* acknowledgement number */
-#if __DARWIN_BYTE_ORDER == __DARWIN_LITTLE_ENDIAN
-	unsigned int    th_x2:4,        /* (unused) */
-	    th_off:4;                   /* data offset */
-#endif
-#if __DARWIN_BYTE_ORDER == __DARWIN_BIG_ENDIAN
-	unsigned int    th_off:4,       /* data offset */
-	    th_x2:4;                    /* (unused) */
-#endif
-	unsigned char   th_flags;
-#define TH_FIN  0x01
-#define TH_SYN  0x02
-#define TH_RST  0x04
-#define TH_PUSH 0x08
-#define TH_ACK  0x10
-#define TH_URG  0x20
-#define TH_ECE  0x40
-#define TH_CWR  0x80
-#define TH_FLAGS        (TH_FIN|TH_SYN|TH_RST|TH_ACK|TH_URG|TH_ECE|TH_CWR)
-#define TH_ACCEPT       (TH_FIN|TH_SYN|TH_RST|TH_ACK)
-
-	unsigned short  th_win;         /* window */
-	unsigned short  th_sum;         /* checksum */
-	unsigned short  th_urp;         /* urgent pointer */
-};
-
-#define TCPOPT_EOL              0
-#define TCPOPT_NOP              1
-#define TCPOPT_MAXSEG           2
-#define TCPOLEN_MAXSEG          4
-#define TCPOPT_WINDOW           3
-#define TCPOLEN_WINDOW          3
-#define TCPOPT_SACK_PERMITTED   4               /* Experimental */
-#define TCPOLEN_SACK_PERMITTED  2
-#define TCPOPT_SACK             5               /* Experimental */
-#define TCPOLEN_SACK            8               /* len of sack block */
-#define TCPOPT_TIMESTAMP        8
-#define TCPOLEN_TIMESTAMP       10
-#define TCPOLEN_TSTAMP_APPA             (TCPOLEN_TIMESTAMP+2) /* appendix A */
-#define TCPOPT_TSTAMP_HDR               \
-    (TCPOPT_NOP<<24|TCPOPT_NOP<<16|TCPOPT_TIMESTAMP<<8|TCPOLEN_TIMESTAMP)
-
-#define MAX_TCPOPTLEN           40      /* Absolute maximum TCP options len */
-
-#define TCPOPT_CC               11              /* CC options: RFC-1644 */
-#define TCPOPT_CCNEW            12
-#define TCPOPT_CCECHO           13
-#define    TCPOLEN_CC                   6
-#define    TCPOLEN_CC_APPA              (TCPOLEN_CC+2)
-#define    TCPOPT_CC_HDR(ccopt)         \
-    (TCPOPT_NOP<<24|TCPOPT_NOP<<16|(ccopt)<<8|TCPOLEN_CC)
-#define TCPOPT_SIGNATURE                19      /* Keyed MD5: RFC 2385 */
-#define    TCPOLEN_SIGNATURE            18
-#if MPTCP
-#define TCPOPT_MULTIPATH                30
-#endif
-
-#define TCPOPT_FASTOPEN                 34
-#define TCPOLEN_FASTOPEN_REQ            2
-
-/* Option definitions */
-#define TCPOPT_SACK_PERMIT_HDR  \
-(TCPOPT_NOP<<24|TCPOPT_NOP<<16|TCPOPT_SACK_PERMITTED<<8|TCPOLEN_SACK_PERMITTED)
-#define TCPOPT_SACK_HDR         (TCPOPT_NOP<<24|TCPOPT_NOP<<16|TCPOPT_SACK<<8)
-/* Miscellaneous constants */
-#define MAX_SACK_BLKS   6       /* Max # SACK blocks stored at sender side */
-
-/*
- * A SACK option that specifies n blocks will have a length of (8*n + 2)
- * bytes, so the 40 bytes available for TCP options can specify a
- * maximum of 4 blocks.
- */
-
-#define TCP_MAX_SACK    4       /* MAX # SACKs sent in any segment */
-
-
-/*
- * Default maximum segment size for TCP.
- * With an IP MTU of 576, this is 536,
- * but 512 is probably more convenient.
- * This should be defined as MIN(512, IP_MSS - sizeof (struct tcpiphdr)).
- */
-#define TCP_MSS 512
-
-/*
- * TCP_MINMSS is defined to be 216 which is fine for the smallest
- * link MTU (256 bytes, SLIP interface) in the Internet.
- * However it is very unlikely to come across such low MTU interfaces
- * these days (anno dato 2004).
- * Probably it can be set to 512 without ill effects. But we play safe.
- * See tcp_subr.c tcp_minmss SYSCTL declaration for more comments.
- * Setting this to "0" disables the minmss check.
- */
-#define TCP_MINMSS 216
-
-/*
- * Default maximum segment size for TCP6.
- * With an IP6 MSS of 1280, this is 1220,
- * but 1024 is probably more convenient. (xxx kazu in doubt)
- * This should be defined as MIN(1024, IP6_MSS - sizeof (struct tcpip6hdr))
- */
-#define TCP6_MSS        1024
-
-#define TCP_MAXWIN      65535   /* largest value for (unscaled) window */
-#define TTCP_CLIENT_SND_WND     4096    /* dflt send window for T/TCP client */
-
-#define TCP_MAX_WINSHIFT        14      /* maximum window shift */
-
-#define TCP_MAXHLEN     (0xf<<2)        /* max length of header in bytes */
-#define TCP_MAXOLEN     (TCP_MAXHLEN - sizeof(struct tcphdr))
-/* max space left for options */
-#endif /* (_POSIX_C_SOURCE && !_DARWIN_C_SOURCE) */
-
-/*
- * User-settable options (used with setsockopt).
- */
-#define TCP_NODELAY             0x01    /* don't delay send to coalesce packets */
-#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-#define TCP_MAXSEG              0x02    /* set maximum segment size */
-#define TCP_NOPUSH              0x04    /* don't push last block of write */
-#define TCP_NOOPT               0x08    /* don't use TCP options */
-#define TCP_KEEPALIVE           0x10    /* idle time used when SO_KEEPALIVE is enabled */
-#define TCP_CONNECTIONTIMEOUT   0x20    /* connection timeout */
-#define PERSIST_TIMEOUT         0x40    /* time after which a connection in
-	                                 *  persist timeout will terminate.
-	                                 *  see draft-ananth-tcpm-persist-02.txt
-	                                 */
-#define TCP_RXT_CONNDROPTIME    0x80    /* time after which tcp retransmissions will be
-	                                 * stopped and the connection will be dropped
-	                                 */
-#define TCP_RXT_FINDROP         0x100   /* when this option is set, drop a connection
-	                                 * after retransmitting the FIN 3 times. It will
-	                                 * prevent holding too many mbufs in socket
-	                                 * buffer queues.
-	                                 */
-#define TCP_KEEPINTVL           0x101   /* interval between keepalives */
-#define TCP_KEEPCNT             0x102   /* number of keepalives before close */
-#define TCP_SENDMOREACKS        0x103   /* always ack every other packet */
-#define TCP_ENABLE_ECN          0x104   /* Enable ECN on a connection */
-#define TCP_FASTOPEN            0x105   /* Enable/Disable TCP Fastopen on this socket */
-#define TCP_CONNECTION_INFO     0x106   /* State of TCP connection */
-
-
-
-#define TCP_NOTSENT_LOWAT       0x201   /* Low water mark for TCP unsent data */
-
-
-struct tcp_connection_info {
-	u_int8_t        tcpi_state;     /* connection state */
-	u_int8_t        tcpi_snd_wscale; /* Window scale for send window */
-	u_int8_t        tcpi_rcv_wscale; /* Window scale for receive window */
-	u_int8_t        __pad1;
-	u_int32_t       tcpi_options;   /* TCP options supported */
-#define TCPCI_OPT_TIMESTAMPS    0x00000001 /* Timestamps enabled */
-#define TCPCI_OPT_SACK          0x00000002 /* SACK enabled */
-#define TCPCI_OPT_WSCALE        0x00000004 /* Window scaling enabled */
-#define TCPCI_OPT_ECN           0x00000008 /* ECN enabled */
-	u_int32_t       tcpi_flags;     /* flags */
-#define TCPCI_FLAG_LOSSRECOVERY 0x00000001
-#define TCPCI_FLAG_REORDERING_DETECTED  0x00000002
-	u_int32_t       tcpi_rto;       /* retransmit timeout in ms */
-	u_int32_t       tcpi_maxseg;    /* maximum segment size supported */
-	u_int32_t       tcpi_snd_ssthresh; /* slow start threshold in bytes */
-	u_int32_t       tcpi_snd_cwnd;  /* send congestion window in bytes */
-	u_int32_t       tcpi_snd_wnd;   /* send widnow in bytes */
-	u_int32_t       tcpi_snd_sbbytes; /* bytes in send socket buffer, including in-flight data */
-	u_int32_t       tcpi_rcv_wnd;   /* receive window in bytes*/
-	u_int32_t       tcpi_rttcur;    /* most recent RTT in ms */
-	u_int32_t       tcpi_srtt;      /* average RTT in ms */
-	u_int32_t       tcpi_rttvar;    /* RTT variance */
-	u_int32_t
-	    tcpi_tfo_cookie_req:1,             /* Cookie requested? */
-	    tcpi_tfo_cookie_rcv:1,             /* Cookie received? */
-	    tcpi_tfo_syn_loss:1,               /* Fallback to reg. TCP after SYN-loss */
-	    tcpi_tfo_syn_data_sent:1,             /* SYN+data has been sent out */
-	    tcpi_tfo_syn_data_acked:1,             /* SYN+data has been fully acknowledged */
-	    tcpi_tfo_syn_data_rcv:1,             /* Server received SYN+data with a valid cookie */
-	    tcpi_tfo_cookie_req_rcv:1,             /* Server received cookie-request */
-	    tcpi_tfo_cookie_sent:1,             /* Server announced cookie */
-	    tcpi_tfo_cookie_invalid:1,             /* Server received an invalid cookie */
-	    tcpi_tfo_cookie_wrong:1,             /* Our sent cookie was wrong */
-	    tcpi_tfo_no_cookie_rcv:1,             /* We did not receive a cookie upon our request */
-	    tcpi_tfo_heuristics_disable:1,             /* TFO-heuristics disabled it */
-	    tcpi_tfo_send_blackhole:1,             /* A sending-blackhole got detected */
-	    tcpi_tfo_recv_blackhole:1,             /* A receiver-blackhole got detected */
-	    tcpi_tfo_onebyte_proxy:1,             /* A proxy acknowledges all but one byte of the SYN */
-	    __pad2:17;
-	u_int64_t       tcpi_txpackets __attribute__((aligned(8)));
-	u_int64_t       tcpi_txbytes __attribute__((aligned(8)));
-	u_int64_t       tcpi_txretransmitbytes __attribute__((aligned(8)));
-	u_int64_t       tcpi_rxpackets __attribute__((aligned(8)));
-	u_int64_t       tcpi_rxbytes __attribute__((aligned(8)));
-	u_int64_t       tcpi_rxoutoforderbytes __attribute__((aligned(8)));
-	u_int64_t       tcpi_txretransmitpackets __attribute__((aligned(8)));
-};
-#endif /* (_POSIX_C_SOURCE && !_DARWIN_C_SOURCE) */
-
-#endif
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/netinet6/in6.h b/lib/libc/include/x86_64-macos-gnu/netinet6/in6.h
deleted file mode 100644
index 19899090ad..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/netinet6/in6.h
+++ /dev/null
@@ -1,667 +0,0 @@
-/*
- * Copyright (c) 2008-2018 Apple Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-
-/*
- * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. Neither the name of the project nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-/*
- * Copyright (c) 1982, 1986, 1990, 1993
- *	The Regents of the University of California.  All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *	This product includes software developed by the University of
- *	California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *	@(#)in.h	8.3 (Berkeley) 1/3/94
- */
-
-#ifndef __KAME_NETINET_IN_H_INCLUDED_
-#error "do not include netinet6/in6.h directly, include netinet/in.h. " \
-        " see RFC2553"
-#endif
-
-#ifndef _NETINET6_IN6_H_
-#define _NETINET6_IN6_H_
-#include <sys/appleapiopts.h>
-#include <sys/_types.h>
-#include <sys/_types/_sa_family_t.h>
-
-/*
- * Identification of the network protocol stack
- * for *BSD-current/release: http://www.kame.net/dev/cvsweb.cgi/kame/COVERAGE
- * has the table of implementation/integration differences.
- */
-#define __KAME__
-#define __KAME_VERSION          "2009/apple-darwin"
-
-#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-/*
- * Local port number conventions:
- *
- * Ports < IPPORT_RESERVED are reserved for privileged processes (e.g. root),
- * unless a kernel is compiled with IPNOPRIVPORTS defined.
- *
- * When a user does a bind(2) or connect(2) with a port number of zero,
- * a non-conflicting local port address is chosen.
- *
- * The default range is IPPORT_ANONMIN to IPPORT_ANONMAX, although
- * that is settable by sysctl(3); net.inet.ip.anonportmin and
- * net.inet.ip.anonportmax respectively.
- *
- * A user may set the IPPROTO_IP option IP_PORTRANGE to change this
- * default assignment range.
- *
- * The value IP_PORTRANGE_DEFAULT causes the default behavior.
- *
- * The value IP_PORTRANGE_HIGH is the same as IP_PORTRANGE_DEFAULT,
- * and exists only for FreeBSD compatibility purposes.
- *
- * The value IP_PORTRANGE_LOW changes the range to the "low" are
- * that is (by convention) restricted to privileged processes.
- * This convention is based on "vouchsafe" principles only.
- * It is only secure if you trust the remote host to restrict these ports.
- * The range is IPPORT_RESERVEDMIN to IPPORT_RESERVEDMAX.
- */
-
-#define IPV6PORT_RESERVED       1024
-#define IPV6PORT_ANONMIN        49152
-#define IPV6PORT_ANONMAX        65535
-#define IPV6PORT_RESERVEDMIN    600
-#define IPV6PORT_RESERVEDMAX    (IPV6PORT_RESERVED-1)
-#endif /* (_POSIX_C_SOURCE && !_DARWIN_C_SOURCE) */
-
-/*
- * IPv6 address
- */
-typedef struct in6_addr {
-	union {
-		__uint8_t   __u6_addr8[16];
-		__uint16_t  __u6_addr16[8];
-		__uint32_t  __u6_addr32[4];
-	} __u6_addr;                    /* 128-bit IP6 address */
-} in6_addr_t;
-
-#define s6_addr   __u6_addr.__u6_addr8
-
-#define INET6_ADDRSTRLEN        46
-
-/*
- * Socket address for IPv6
- */
-#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-#define SIN6_LEN
-#endif /* (_POSIX_C_SOURCE && !_DARWIN_C_SOURCE) */
-struct sockaddr_in6 {
-	__uint8_t       sin6_len;       /* length of this struct(sa_family_t) */
-	sa_family_t     sin6_family;    /* AF_INET6 (sa_family_t) */
-	in_port_t       sin6_port;      /* Transport layer port # (in_port_t) */
-	__uint32_t      sin6_flowinfo;  /* IP6 flow information */
-	struct in6_addr sin6_addr;      /* IP6 address */
-	__uint32_t      sin6_scope_id;  /* scope zone index */
-};
-
-
-
-
-/*
- * Definition of some useful macros to handle IP6 addresses
- */
-#define IN6ADDR_ANY_INIT \
-	{{{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
-	    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }}}
-#define IN6ADDR_LOOPBACK_INIT \
-	{{{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
-	    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 }}}
-#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-#define IN6ADDR_NODELOCAL_ALLNODES_INIT \
-	{{{ 0xff, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
-	    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 }}}
-#define IN6ADDR_INTFACELOCAL_ALLNODES_INIT \
-	{{{ 0xff, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
-	    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 }}}
-#define IN6ADDR_LINKLOCAL_ALLNODES_INIT \
-	{{{ 0xff, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
-	    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 }}}
-#define IN6ADDR_LINKLOCAL_ALLROUTERS_INIT \
-	{{{ 0xff, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
-	    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02 }}}
-#define IN6ADDR_LINKLOCAL_ALLV2ROUTERS_INIT \
-	{{{ 0xff, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
-	    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x16 }}}
-#define IN6ADDR_V4MAPPED_INIT \
-	{{{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
-	    0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00 }}}
-#endif /* (_POSIX_C_SOURCE && !_DARWIN_C_SOURCE) */
-
-extern const struct in6_addr in6addr_any;
-extern const struct in6_addr in6addr_loopback;
-#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-extern const struct in6_addr in6addr_nodelocal_allnodes;
-extern const struct in6_addr in6addr_linklocal_allnodes;
-extern const struct in6_addr in6addr_linklocal_allrouters;
-extern const struct in6_addr in6addr_linklocal_allv2routers;
-#endif /* (_POSIX_C_SOURCE && !_DARWIN_C_SOURCE) */
-
-/*
- * Equality
- * NOTE: Some of kernel programming environment (for example, openbsd/sparc)
- * does not supply memcmp().  For userland memcmp() is preferred as it is
- * in ANSI standard.
- */
-#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-#define IN6_ARE_ADDR_EQUAL(a, b) \
-	(memcmp(&(a)->s6_addr[0], &(b)->s6_addr[0], sizeof (struct in6_addr)) \
-	== 0)
-#endif /* (_POSIX_C_SOURCE && !_DARWIN_C_SOURCE) */
-
-
-/*
- * Unspecified
- */
-#define IN6_IS_ADDR_UNSPECIFIED(a)      \
-	((*(const __uint32_t *)(const void *)(&(a)->s6_addr[0]) == 0) && \
-	(*(const __uint32_t *)(const void *)(&(a)->s6_addr[4]) == 0) && \
-	(*(const __uint32_t *)(const void *)(&(a)->s6_addr[8]) == 0) && \
-	(*(const __uint32_t *)(const void *)(&(a)->s6_addr[12]) == 0))
-
-/*
- * Loopback
- */
-#define IN6_IS_ADDR_LOOPBACK(a)         \
-	((*(const __uint32_t *)(const void *)(&(a)->s6_addr[0]) == 0) && \
-	(*(const __uint32_t *)(const void *)(&(a)->s6_addr[4]) == 0) && \
-	(*(const __uint32_t *)(const void *)(&(a)->s6_addr[8]) == 0) && \
-	(*(const __uint32_t *)(const void *)(&(a)->s6_addr[12]) == ntohl(1)))
-
-/*
- * IPv4 compatible
- */
-#define IN6_IS_ADDR_V4COMPAT(a)         \
-	((*(const __uint32_t *)(const void *)(&(a)->s6_addr[0]) == 0) && \
-	(*(const __uint32_t *)(const void *)(&(a)->s6_addr[4]) == 0) && \
-	(*(const __uint32_t *)(const void *)(&(a)->s6_addr[8]) == 0) && \
-	(*(const __uint32_t *)(const void *)(&(a)->s6_addr[12]) != 0) && \
-	(*(const __uint32_t *)(const void *)(&(a)->s6_addr[12]) != ntohl(1)))
-
-/*
- * Mapped
- */
-#define IN6_IS_ADDR_V4MAPPED(a)               \
-	((*(const __uint32_t *)(const void *)(&(a)->s6_addr[0]) == 0) && \
-	(*(const __uint32_t *)(const void *)(&(a)->s6_addr[4]) == 0) && \
-	(*(const __uint32_t *)(const void *)(&(a)->s6_addr[8]) == \
-	ntohl(0x0000ffff)))
-
-/*
- * 6to4
- */
-#define IN6_IS_ADDR_6TO4(x)     (ntohs((x)->s6_addr16[0]) == 0x2002)
-
-/*
- * KAME Scope Values
- */
-
-#define __IPV6_ADDR_SCOPE_NODELOCAL     0x01
-#define __IPV6_ADDR_SCOPE_INTFACELOCAL  0x01
-#define __IPV6_ADDR_SCOPE_LINKLOCAL     0x02
-#define __IPV6_ADDR_SCOPE_SITELOCAL     0x05
-#define __IPV6_ADDR_SCOPE_ORGLOCAL      0x08    /* just used in this file */
-#define __IPV6_ADDR_SCOPE_GLOBAL        0x0e
-
-/*
- * Unicast Scope
- * Note that we must check topmost 10 bits only, not 16 bits (see RFC2373).
- */
-#define IN6_IS_ADDR_LINKLOCAL(a)        \
-	(((a)->s6_addr[0] == 0xfe) && (((a)->s6_addr[1] & 0xc0) == 0x80))
-#define IN6_IS_ADDR_SITELOCAL(a)        \
-	(((a)->s6_addr[0] == 0xfe) && (((a)->s6_addr[1] & 0xc0) == 0xc0))
-
-/*
- * Multicast
- */
-#define IN6_IS_ADDR_MULTICAST(a)        ((a)->s6_addr[0] == 0xff)
-
-/*
- * Unique Local IPv6 Unicast Addresses (per RFC 4193)
- */
-#define IN6_IS_ADDR_UNIQUE_LOCAL(a) \
-	(((a)->s6_addr[0] == 0xfc) || ((a)->s6_addr[0] == 0xfd))
-
-#define __IPV6_ADDR_MC_SCOPE(a)         ((a)->s6_addr[1] & 0x0f)
-
-/*
- * Multicast Scope
- */
-#define IN6_IS_ADDR_MC_NODELOCAL(a)     \
-	(IN6_IS_ADDR_MULTICAST(a) &&    \
-	(__IPV6_ADDR_MC_SCOPE(a) == __IPV6_ADDR_SCOPE_NODELOCAL))
-#define IN6_IS_ADDR_MC_LINKLOCAL(a)     \
-	(IN6_IS_ADDR_MULTICAST(a) &&    \
-	(__IPV6_ADDR_MC_SCOPE(a) == __IPV6_ADDR_SCOPE_LINKLOCAL))
-#define IN6_IS_ADDR_MC_SITELOCAL(a)     \
-	(IN6_IS_ADDR_MULTICAST(a) &&    \
-	(__IPV6_ADDR_MC_SCOPE(a) == __IPV6_ADDR_SCOPE_SITELOCAL))
-#define IN6_IS_ADDR_MC_ORGLOCAL(a)      \
-	(IN6_IS_ADDR_MULTICAST(a) &&    \
-	(__IPV6_ADDR_MC_SCOPE(a) == __IPV6_ADDR_SCOPE_ORGLOCAL))
-#define IN6_IS_ADDR_MC_GLOBAL(a)        \
-	(IN6_IS_ADDR_MULTICAST(a) &&    \
-	(__IPV6_ADDR_MC_SCOPE(a) == __IPV6_ADDR_SCOPE_GLOBAL))
-
-
-
-
-/*
- * Options for use with [gs]etsockopt at the IPV6 level.
- * First word of comment is data type; bool is stored in int.
- */
-/* no hdrincl */
-#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-/*
- * RFC 3542 define the following socket options in a manner incompatible
- * with RFC 2292:
- *   IPV6_PKTINFO
- *   IPV6_HOPLIMIT
- *   IPV6_NEXTHOP
- *   IPV6_HOPOPTS
- *   IPV6_DSTOPTS
- *   IPV6_RTHDR
- *
- * To use the new IPv6 Sockets options introduced by RFC 3542
- * the constant __APPLE_USE_RFC_3542 must be defined before
- * including <netinet/in.h>
- *
- * To use the old IPv6 Sockets options from RFC 2292
- * the constant __APPLE_USE_RFC_2292 must be defined before
- * including <netinet/in.h>
- *
- * Note that eventually RFC 3542 is going to be the
- * default and RFC 2292 will be obsolete.
- */
-
-#if defined(__APPLE_USE_RFC_3542) && defined(__APPLE_USE_RFC_2292)
-#error "__APPLE_USE_RFC_3542 and __APPLE_USE_RFC_2292 cannot be both defined"
-#endif
-
-#if 0 /* the followings are relic in IPv4 and hence are disabled */
-#define IPV6_OPTIONS            1  /* buf/ip6_opts; set/get IP6 options */
-#define IPV6_RECVOPTS           5  /* bool; receive all IP6 opts w/dgram */
-#define IPV6_RECVRETOPTS        6  /* bool; receive IP6 opts for response */
-#define IPV6_RECVDSTADDR        7  /* bool; receive IP6 dst addr w/dgram */
-#define IPV6_RETOPTS            8  /* ip6_opts; set/get IP6 options */
-#endif /* 0 */
-#define IPV6_SOCKOPT_RESERVED1  3  /* reserved for future use */
-#endif /* (_POSIX_C_SOURCE && !_DARWIN_C_SOURCE) */
-#define IPV6_UNICAST_HOPS       4  /* int; IP6 hops */
-#define IPV6_MULTICAST_IF       9  /* __uint8_t; set/get IP6 multicast i/f  */
-#define IPV6_MULTICAST_HOPS     10 /* __uint8_t; set/get IP6 multicast hops */
-#define IPV6_MULTICAST_LOOP     11 /* __uint8_t; set/get IP6 mcast loopback */
-#define IPV6_JOIN_GROUP         12 /* ip6_mreq; join a group membership */
-#define IPV6_LEAVE_GROUP        13 /* ip6_mreq; leave a group membership */
-
-#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-#define IPV6_PORTRANGE          14 /* int; range to choose for unspec port */
-#define ICMP6_FILTER            18 /* icmp6_filter; icmp6 filter */
-#define IPV6_2292PKTINFO        19 /* bool; send/recv if, src/dst addr */
-#define IPV6_2292HOPLIMIT       20 /* bool; hop limit */
-#define IPV6_2292NEXTHOP        21 /* bool; next hop addr */
-#define IPV6_2292HOPOPTS        22 /* bool; hop-by-hop option */
-#define IPV6_2292DSTOPTS        23 /* bool; destinaion option */
-#define IPV6_2292RTHDR          24 /* ip6_rthdr: routing header */
-
-/* buf/cmsghdr; set/get IPv6 options [obsoleted by RFC3542] */
-#define IPV6_2292PKTOPTIONS     25
-
-#ifdef __APPLE_USE_RFC_2292
-#define IPV6_PKTINFO    IPV6_2292PKTINFO
-#define IPV6_HOPLIMIT   IPV6_2292HOPLIMIT
-#define IPV6_NEXTHOP    IPV6_2292NEXTHOP
-#define IPV6_HOPOPTS    IPV6_2292HOPOPTS
-#define IPV6_DSTOPTS    IPV6_2292DSTOPTS
-#define IPV6_RTHDR      IPV6_2292RTHDR
-#define IPV6_PKTOPTIONS IPV6_2292PKTOPTIONS
-#endif /* __APPLE_USE_RFC_2292 */
-
-#define IPV6_CHECKSUM           26 /* int; checksum offset for raw socket */
-#endif /* (_POSIX_C_SOURCE && !_DARWIN_C_SOURCE) */
-#define IPV6_V6ONLY             27 /* bool; only bind INET6 at wildcard bind */
-#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-#define IPV6_BINDV6ONLY         IPV6_V6ONLY
-
-
-#if 1 /* IPSEC */
-#define IPV6_IPSEC_POLICY       28 /* struct; get/set security policy */
-#endif /* 1 */
-#define IPV6_FAITH              29 /* deprecated */
-
-#if 1 /* IPV6FIREWALL */
-#define IPV6_FW_ADD             30 /* add a firewall rule to chain */
-#define IPV6_FW_DEL             31 /* delete a firewall rule from chain */
-#define IPV6_FW_FLUSH           32 /* flush firewall rule chain */
-#define IPV6_FW_ZERO            33 /* clear single/all firewall counter(s) */
-#define IPV6_FW_GET             34 /* get entire firewall rule chain */
-#endif /* 1 */
-
-/*
- * APPLE: NOTE the value of those 2 options is kept unchanged from
- *   previous version of darwin/OS X for binary compatibility reasons
- *   and differ from FreeBSD (values 57 and 61). See below.
- */
-#define IPV6_RECVTCLASS         35 /* bool; recv traffic class values */
-#define IPV6_TCLASS             36 /* int; send traffic class value */
-
-#ifdef __APPLE_USE_RFC_3542
-/* new socket options introduced in RFC3542 */
-/*
- * ip6_dest; send dst option before rthdr
- * APPLE: Value purposely different than FreeBSD (35) to avoid
- * collision with definition of IPV6_RECVTCLASS in previous
- * darwin implementations
- */
-#define IPV6_RTHDRDSTOPTS       57
-
-/*
- * bool; recv if, dst addr
- * APPLE: Value purposely different than FreeBSD(36) to avoid
- * collision with definition of IPV6_TCLASS in previous
- * darwin implementations
- */
-#define IPV6_RECVPKTINFO        61
-
-#define IPV6_RECVHOPLIMIT       37 /* bool; recv hop limit */
-#define IPV6_RECVRTHDR          38 /* bool; recv routing header */
-#define IPV6_RECVHOPOPTS        39 /* bool; recv hop-by-hop option */
-#define IPV6_RECVDSTOPTS        40 /* bool; recv dst option after rthdr */
-
-#define IPV6_USE_MIN_MTU        42 /* bool; send packets at the minimum MTU */
-#define IPV6_RECVPATHMTU        43 /* bool; notify an according MTU */
-
-/*
- * mtuinfo; get the current path MTU (sopt), 4 bytes int;
- * MTU notification (cmsg)
- */
-#define IPV6_PATHMTU            44
-
-#if 0 /* obsoleted during 2292bis -> 3542 */
-/* no data; ND reachability confirm (cmsg only/not in of RFC3542) */
-#define IPV6_REACHCONF          45
-#endif
-/* more new socket options introduced in RFC3542 */
-#define IPV6_3542PKTINFO        46 /* in6_pktinfo; send if, src addr */
-#define IPV6_3542HOPLIMIT       47 /* int; send hop limit */
-#define IPV6_3542NEXTHOP        48 /* sockaddr; next hop addr */
-#define IPV6_3542HOPOPTS        49 /* ip6_hbh; send hop-by-hop option */
-#define IPV6_3542DSTOPTS        50 /* ip6_dest; send dst option befor rthdr */
-#define IPV6_3542RTHDR          51 /* ip6_rthdr; send routing header */
-
-#define IPV6_PKTINFO    IPV6_3542PKTINFO
-#define IPV6_HOPLIMIT   IPV6_3542HOPLIMIT
-#define IPV6_NEXTHOP    IPV6_3542NEXTHOP
-#define IPV6_HOPOPTS    IPV6_3542HOPOPTS
-#define IPV6_DSTOPTS    IPV6_3542DSTOPTS
-#define IPV6_RTHDR      IPV6_3542RTHDR
-
-#define IPV6_AUTOFLOWLABEL      59 /* bool; attach flowlabel automagically */
-
-#define IPV6_DONTFRAG           62 /* bool; disable IPv6 fragmentation */
-
-/* int; prefer temporary addresses as the source address. */
-#define IPV6_PREFER_TEMPADDR    63
-
-/*
- * The following option is private; do not use it from user applications.
- * It is deliberately defined to the same value as IP_MSFILTER.
- */
-#define IPV6_MSFILTER           74 /* struct __msfilterreq; */
-#endif /* __APPLE_USE_RFC_3542 */
-
-#define IPV6_BOUND_IF           125 /* int; set/get bound interface */
-
-
-/* to define items, should talk with KAME guys first, for *BSD compatibility */
-
-#define IPV6_RTHDR_LOOSE        0 /* this hop need not be a neighbor. */
-#define IPV6_RTHDR_STRICT       1 /* this hop must be a neighbor. */
-#define IPV6_RTHDR_TYPE_0       0 /* IPv6 routing header type 0 */
-
-/*
- * Defaults and limits for options
- */
-#define IPV6_DEFAULT_MULTICAST_HOPS 1   /* normally limit m'casts to 1 hop  */
-#define IPV6_DEFAULT_MULTICAST_LOOP 1   /* normally hear sends if a member  */
-
-/*
- * The im6o_membership vector for each socket is now dynamically allocated at
- * run-time, bounded by USHRT_MAX, and is reallocated when needed, sized
- * according to a power-of-two increment.
- */
-#define IPV6_MIN_MEMBERSHIPS    31
-#define IPV6_MAX_MEMBERSHIPS    4095
-
-/*
- * Default resource limits for IPv6 multicast source filtering.
- * These may be modified by sysctl.
- */
-#define IPV6_MAX_GROUP_SRC_FILTER       512     /* sources per group */
-#define IPV6_MAX_SOCK_SRC_FILTER        128     /* sources per socket/group */
-
-/*
- * Argument structure for IPV6_JOIN_GROUP and IPV6_LEAVE_GROUP.
- */
-struct ipv6_mreq {
-	struct in6_addr ipv6mr_multiaddr;
-	unsigned int    ipv6mr_interface;
-};
-
-/*
- * IPV6_2292PKTINFO: Packet information(RFC2292 sec 5)
- */
-struct in6_pktinfo {
-	struct in6_addr ipi6_addr;      /* src/dst IPv6 address */
-	unsigned int    ipi6_ifindex;   /* send/recv interface index */
-};
-
-/*
- * Control structure for IPV6_RECVPATHMTU socket option.
- */
-struct ip6_mtuinfo {
-	struct sockaddr_in6 ip6m_addr;  /* or sockaddr_storage? */
-	uint32_t ip6m_mtu;
-};
-
-/*
- * Argument for IPV6_PORTRANGE:
- * - which range to search when port is unspecified at bind() or connect()
- */
-#define IPV6_PORTRANGE_DEFAULT  0       /* default range */
-#define IPV6_PORTRANGE_HIGH     1       /* "high" - request firewall bypass */
-#define IPV6_PORTRANGE_LOW      2       /* "low" - vouchsafe security */
-
-/*
- * Definitions for inet6 sysctl operations.
- *
- * Third level is protocol number.
- * Fourth level is desired variable within that protocol.
- */
-#define IPV6PROTO_MAXID (IPPROTO_PIM + 1)  /* don't list to IPV6PROTO_MAX */
-
-/*
- * Names for IP sysctl objects
- */
-#define IPV6CTL_FORWARDING      1       /* act as router */
-#define IPV6CTL_SENDREDIRECTS   2       /* may send redirects when forwarding */
-#define IPV6CTL_DEFHLIM         3       /* default Hop-Limit */
-#ifdef notyet
-#define IPV6CTL_DEFMTU          4       /* default MTU */
-#endif
-#define IPV6CTL_FORWSRCRT       5       /* forward source-routed dgrams */
-#define IPV6CTL_STATS           6       /* stats */
-#define IPV6CTL_MRTSTATS        7       /* multicast forwarding stats */
-#define IPV6CTL_MRTPROTO        8       /* multicast routing protocol */
-#define IPV6CTL_MAXFRAGPACKETS  9       /* max packets reassembly queue */
-#define IPV6CTL_SOURCECHECK     10      /* verify source route and intf */
-#define IPV6CTL_SOURCECHECK_LOGINT 11   /* minimume logging interval */
-#define IPV6CTL_ACCEPT_RTADV    12
-#define IPV6CTL_KEEPFAITH       13      /* deprecated */
-#define IPV6CTL_LOG_INTERVAL    14
-#define IPV6CTL_HDRNESTLIMIT    15
-#define IPV6CTL_DAD_COUNT       16
-#define IPV6CTL_AUTO_FLOWLABEL  17
-#define IPV6CTL_DEFMCASTHLIM    18
-#define IPV6CTL_GIF_HLIM        19      /* default HLIM for gif encap packet */
-#define IPV6CTL_KAME_VERSION    20
-#define IPV6CTL_USE_DEPRECATED  21      /* use deprec addr (RFC2462 5.5.4) */
-#define IPV6CTL_RR_PRUNE        22      /* walk timer for router renumbering */
-#if 0   /* obsolete */
-#define IPV6CTL_MAPPED_ADDR     23
-#endif
-#define IPV6CTL_V6ONLY          24
-#define IPV6CTL_RTEXPIRE        25      /* cloned route expiration time */
-#define IPV6CTL_RTMINEXPIRE     26      /* min value for expiration time */
-#define IPV6CTL_RTMAXCACHE      27      /* trigger level for dynamic expire */
-
-#define IPV6CTL_USETEMPADDR     32      /* use temporary addresses [RFC 4941] */
-#define IPV6CTL_TEMPPLTIME      33      /* preferred lifetime for tmpaddrs */
-#define IPV6CTL_TEMPVLTIME      34      /* valid lifetime for tmpaddrs */
-#define IPV6CTL_AUTO_LINKLOCAL  35      /* automatic link-local addr assign */
-#define IPV6CTL_RIP6STATS       36      /* raw_ip6 stats */
-#define IPV6CTL_PREFER_TEMPADDR 37      /* prefer temporary addr as src */
-#define IPV6CTL_ADDRCTLPOLICY   38      /* get/set address selection policy */
-#define IPV6CTL_USE_DEFAULTZONE 39      /* use default scope zone */
-
-#define IPV6CTL_MAXFRAGS        41      /* max fragments */
-#define IPV6CTL_MCAST_PMTU      44      /* enable pMTU discovery for mcast? */
-
-#define IPV6CTL_NEIGHBORGCTHRESH 46
-#define IPV6CTL_MAXIFPREFIXES   47
-#define IPV6CTL_MAXIFDEFROUTERS 48
-#define IPV6CTL_MAXDYNROUTES    49
-#define ICMPV6CTL_ND6_ONLINKNSRFC4861   50
-
-/* New entries should be added here from current IPV6CTL_MAXID value. */
-/* to define items, should talk with KAME guys first, for *BSD compatibility */
-#define IPV6CTL_MAXID           51
-
-
-
-
-
-__BEGIN_DECLS
-struct cmsghdr;
-
-extern int inet6_option_space(int);
-extern int inet6_option_init(void *, struct cmsghdr **, int);
-extern int inet6_option_append(struct cmsghdr *, const __uint8_t *, int, int);
-extern __uint8_t *inet6_option_alloc(struct cmsghdr *, int, int, int);
-extern int inet6_option_next(const struct cmsghdr *, __uint8_t **);
-extern int inet6_option_find(const struct cmsghdr *, __uint8_t **, int);
-
-extern size_t inet6_rthdr_space(int, int);
-extern struct cmsghdr *inet6_rthdr_init(void *, int);
-extern int inet6_rthdr_add(struct cmsghdr *, const struct in6_addr *,
-    unsigned int);
-extern int inet6_rthdr_lasthop(struct cmsghdr *, unsigned int);
-#if 0 /* not implemented yet */
-extern int inet6_rthdr_reverse(const struct cmsghdr *, struct cmsghdr *);
-#endif
-extern int inet6_rthdr_segments(const struct cmsghdr *);
-extern struct in6_addr *inet6_rthdr_getaddr(struct cmsghdr *, int);
-extern int inet6_rthdr_getflags(const struct cmsghdr *, int);
-
-extern int inet6_opt_init(void *, socklen_t);
-extern int inet6_opt_append(void *, socklen_t, int, __uint8_t, socklen_t,
-    __uint8_t, void **);
-extern int inet6_opt_finish(void *, socklen_t, int);
-extern int inet6_opt_set_val(void *, int, void *, socklen_t);
-
-extern int inet6_opt_next(void *, socklen_t, int, __uint8_t *, socklen_t *,
-    void **);
-extern int inet6_opt_find(void *, socklen_t, int, __uint8_t, socklen_t *,
-    void **);
-extern int inet6_opt_get_val(void *, int, void *, socklen_t);
-extern socklen_t inet6_rth_space(int, int);
-extern void *inet6_rth_init(void *, socklen_t, int, int);
-extern int inet6_rth_add(void *, const struct in6_addr *);
-extern int inet6_rth_reverse(const void *, void *);
-extern int inet6_rth_segments(const void *);
-extern struct in6_addr *inet6_rth_getaddr(const void *, int);
-
-__END_DECLS
-#endif /* (_POSIX_C_SOURCE && !_DARWIN_C_SOURCE) */
-#endif /* !_NETINET6_IN6_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/objc/objc-api.h b/lib/libc/include/x86_64-macos-gnu/objc/objc-api.h
deleted file mode 100644
index 504fee6113..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/objc/objc-api.h
+++ /dev/null
@@ -1,280 +0,0 @@
-/*
- * Copyright (c) 1999-2006 Apple Inc.  All Rights Reserved.
- * 
- * @APPLE_LICENSE_HEADER_START@
- * 
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this
- * file.
- * 
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- * 
- * @APPLE_LICENSE_HEADER_END@
- */
-// Copyright 1988-1996 NeXT Software, Inc.
-
-#ifndef _OBJC_OBJC_API_H_
-#define _OBJC_OBJC_API_H_
-
-#include <Availability.h>
-#include <AvailabilityMacros.h>
-#include <TargetConditionals.h>
-#include <sys/types.h>
-
-#ifndef __has_feature
-#   define __has_feature(x) 0
-#endif
-
-#ifndef __has_extension
-#   define __has_extension __has_feature
-#endif
-
-#ifndef __has_attribute
-#   define __has_attribute(x) 0
-#endif
-
-#if !__has_feature(nullability)
-#   ifndef _Nullable
-#       define _Nullable
-#   endif
-#   ifndef _Nonnull
-#       define _Nonnull
-#   endif
-#   ifndef _Null_unspecified
-#       define _Null_unspecified
-#   endif
-#endif
-
-
-
-/*
- * OBJC_API_VERSION 0 or undef: Tiger and earlier API only
- * OBJC_API_VERSION 2: Leopard and later API available
- */
-#if !defined(OBJC_API_VERSION)
-#   if defined(__MAC_OS_X_VERSION_MIN_REQUIRED)  &&  __MAC_OS_X_VERSION_MIN_REQUIRED < __MAC_10_5
-#       define OBJC_API_VERSION 0
-#   else
-#       define OBJC_API_VERSION 2
-#   endif
-#endif
-
-
-/*
- * OBJC_NO_GC 1: GC is not supported
- * OBJC_NO_GC undef: GC is supported. This SDK no longer supports this mode.
- *
- * OBJC_NO_GC_API undef: Libraries must export any symbols that 
- *                       dual-mode code may links to.
- * OBJC_NO_GC_API 1: Libraries need not export GC-related symbols.
- */
-#if defined(__OBJC_GC__)
-#   error Objective-C garbage collection is not supported.
-#elif TARGET_OS_OSX
-    /* GC is unsupported. GC API symbols are exported. */
-#   define OBJC_NO_GC 1
-#   undef  OBJC_NO_GC_API
-#else
-    /* GC is unsupported. GC API symbols are not exported. */
-#   define OBJC_NO_GC 1
-#   define OBJC_NO_GC_API 1
-#endif
-
-
-/* NS_ENFORCE_NSOBJECT_DESIGNATED_INITIALIZER == 1 
- * marks -[NSObject init] as a designated initializer. */
-#if !defined(NS_ENFORCE_NSOBJECT_DESIGNATED_INITIALIZER)
-#   define NS_ENFORCE_NSOBJECT_DESIGNATED_INITIALIZER 1
-#endif
-
-
-/* OBJC_OLD_DISPATCH_PROTOTYPES == 0 enforces the rule that the dispatch 
- * functions must be cast to an appropriate function pointer type. */
-#if !defined(OBJC_OLD_DISPATCH_PROTOTYPES)
-#   if __swift__
-        // Existing Swift code expects IMP to be Comparable.
-        // Variadic IMP is comparable via OpaquePointer; non-variadic IMP isn't.
-#       define OBJC_OLD_DISPATCH_PROTOTYPES 1
-#   else
-#       define OBJC_OLD_DISPATCH_PROTOTYPES 0
-#   endif
-#endif
-
-
-/* OBJC_AVAILABLE: shorthand for all-OS availability */
-
-#   if !defined(OBJC_AVAILABLE)
-#       define OBJC_AVAILABLE(x, i, t, w, b)                            \
-            __OSX_AVAILABLE(x)  __IOS_AVAILABLE(i)  __TVOS_AVAILABLE(t) \
-            __WATCHOS_AVAILABLE(w)
-#   endif
-
-
-
-/* OBJC_OSX_DEPRECATED_OTHERS_UNAVAILABLE: Deprecated on OS X,
- * unavailable everywhere else. */
-
-#   if !defined(OBJC_OSX_DEPRECATED_OTHERS_UNAVAILABLE)
-#       define OBJC_OSX_DEPRECATED_OTHERS_UNAVAILABLE(_start, _dep, _msg) \
-            __OSX_DEPRECATED(_start, _dep, _msg)                          \
-            __IOS_UNAVAILABLE __TVOS_UNAVAILABLE                          \
-            __WATCHOS_UNAVAILABLE
-#   endif
-
-
-
-/* OBJC_OSX_AVAILABLE_OTHERS_UNAVAILABLE: Available on OS X,
- * unavailable everywhere else. */
-
-#   if !defined(OBJC_OSX_AVAILABLE_OTHERS_UNAVAILABLE)
-#       define OBJC_OSX_AVAILABLE_OTHERS_UNAVAILABLE(vers) \
-            __OSX_AVAILABLE(vers)                          \
-            __IOS_UNAVAILABLE __TVOS_UNAVAILABLE           \
-            __WATCHOS_UNAVAILABLE
-#    endif
-
-
-
-/* OBJC_ISA_AVAILABILITY: `isa` will be deprecated or unavailable 
- * in the future */
-#if !defined(OBJC_ISA_AVAILABILITY)
-#   if __OBJC2__
-#       define OBJC_ISA_AVAILABILITY  __attribute__((deprecated))
-#   else
-#       define OBJC_ISA_AVAILABILITY  /* still available */
-#   endif
-#endif
-
-
-/* OBJC2_UNAVAILABLE: unavailable in objc 2.0, deprecated in Leopard */
-#if !defined(OBJC2_UNAVAILABLE)
-#   if __OBJC2__
-#       define OBJC2_UNAVAILABLE UNAVAILABLE_ATTRIBUTE
-#   else
-        /* plain C code also falls here, but this is close enough */
-#       define OBJC2_UNAVAILABLE                                       \
-            __OSX_DEPRECATED(10.5, 10.5, "not available in __OBJC2__") \
-            __IOS_DEPRECATED(2.0, 2.0, "not available in __OBJC2__")   \
-            __TVOS_UNAVAILABLE __WATCHOS_UNAVAILABLE 
-#   endif
-#endif
-
-/* OBJC_UNAVAILABLE: unavailable, with a message where supported */
-#if !defined(OBJC_UNAVAILABLE)
-#   if __has_extension(attribute_unavailable_with_message)
-#       define OBJC_UNAVAILABLE(_msg) __attribute__((unavailable(_msg)))
-#   else
-#       define OBJC_UNAVAILABLE(_msg) __attribute__((unavailable))
-#   endif
-#endif
-
-/* OBJC_DEPRECATED: deprecated, with a message where supported */
-#if !defined(OBJC_DEPRECATED)
-#   if __has_extension(attribute_deprecated_with_message)
-#       define OBJC_DEPRECATED(_msg) __attribute__((deprecated(_msg)))
-#   else
-#       define OBJC_DEPRECATED(_msg) __attribute__((deprecated))
-#   endif
-#endif
-
-/* OBJC_ARC_UNAVAILABLE: unavailable with -fobjc-arc */
-#if !defined(OBJC_ARC_UNAVAILABLE)
-#   if __has_feature(objc_arc)
-#       define OBJC_ARC_UNAVAILABLE OBJC_UNAVAILABLE("not available in automatic reference counting mode")
-#   else
-#       define OBJC_ARC_UNAVAILABLE
-#   endif
-#endif
-
-/* OBJC_SWIFT_UNAVAILABLE: unavailable in Swift */
-#if !defined(OBJC_SWIFT_UNAVAILABLE)
-#   if __has_feature(attribute_availability_swift)
-#       define OBJC_SWIFT_UNAVAILABLE(_msg) __attribute__((availability(swift, unavailable, message=_msg)))
-#   else
-#       define OBJC_SWIFT_UNAVAILABLE(_msg)
-#   endif
-#endif
-
-/* OBJC_ARM64_UNAVAILABLE: unavailable on arm64 (i.e. stret dispatch) */
-#if !defined(OBJC_ARM64_UNAVAILABLE)
-#   if defined(__arm64__)
-#       define OBJC_ARM64_UNAVAILABLE OBJC_UNAVAILABLE("not available in arm64")
-#   else
-#       define OBJC_ARM64_UNAVAILABLE 
-#   endif
-#endif
-
-/* OBJC_GC_UNAVAILABLE: unavailable with -fobjc-gc or -fobjc-gc-only */
-#if !defined(OBJC_GC_UNAVAILABLE)
-#   define OBJC_GC_UNAVAILABLE
-#endif
-
-#if !defined(OBJC_EXTERN)
-#   if defined(__cplusplus)
-#       define OBJC_EXTERN extern "C" 
-#   else
-#       define OBJC_EXTERN extern
-#   endif
-#endif
-
-#if !defined(OBJC_VISIBLE)
-
-#       define OBJC_VISIBLE  __attribute__((visibility("default")))
-
-#endif
-
-#if !defined(OBJC_EXPORT)
-#   define OBJC_EXPORT  OBJC_EXTERN OBJC_VISIBLE
-#endif
-
-#if !defined(OBJC_IMPORT)
-#   define OBJC_IMPORT extern
-#endif
-
-#if !defined(OBJC_ROOT_CLASS)
-#   if __has_attribute(objc_root_class)
-#       define OBJC_ROOT_CLASS __attribute__((objc_root_class))
-#   else
-#       define OBJC_ROOT_CLASS
-#   endif
-#endif
-
-#ifndef __DARWIN_NULL
-#define __DARWIN_NULL NULL
-#endif
-
-#if !defined(OBJC_INLINE)
-#   define OBJC_INLINE __inline
-#endif
-
-// Declares an enum type or option bits type as appropriate for each language.
-#if (__cplusplus && __cplusplus >= 201103L && (__has_extension(cxx_strong_enums) || __has_feature(objc_fixed_enum))) || (!__cplusplus && __has_feature(objc_fixed_enum))
-#define OBJC_ENUM(_type, _name) enum _name : _type _name; enum _name : _type
-#if (__cplusplus)
-#define OBJC_OPTIONS(_type, _name) _type _name; enum : _type
-#else
-#define OBJC_OPTIONS(_type, _name) enum _name : _type _name; enum _name : _type
-#endif
-#else
-#define OBJC_ENUM(_type, _name) _type _name; enum
-#define OBJC_OPTIONS(_type, _name) _type _name; enum
-#endif
-
-#if !defined(OBJC_RETURNS_RETAINED)
-#   if __OBJC__ && __has_attribute(ns_returns_retained)
-#       define OBJC_RETURNS_RETAINED __attribute__((ns_returns_retained))
-#   else
-#       define OBJC_RETURNS_RETAINED
-#   endif
-#endif
-
-#endif
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/objc/runtime.h b/lib/libc/include/x86_64-macos-gnu/objc/runtime.h
deleted file mode 100644
index 0b49b72559..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/objc/runtime.h
+++ /dev/null
@@ -1,2169 +0,0 @@
-/*
- * Copyright (c) 1999-2007 Apple Inc.  All Rights Reserved.
- * 
- * @APPLE_LICENSE_HEADER_START@
- * 
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this
- * file.
- * 
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- * 
- * @APPLE_LICENSE_HEADER_END@
- */
-
-#ifndef _OBJC_RUNTIME_H
-#define _OBJC_RUNTIME_H
-
-#include <objc/objc.h>
-#include <stdarg.h>
-#include <stdint.h>
-#include <stddef.h>
-#include <Availability.h>
-#include <TargetConditionals.h>
-
-#if TARGET_OS_MAC
-#include <sys/types.h>
-#endif
-
-
-/* Types */
-
-#if !OBJC_TYPES_DEFINED
-
-/// An opaque type that represents a method in a class definition.
-typedef struct objc_method *Method;
-
-/// An opaque type that represents an instance variable.
-typedef struct objc_ivar *Ivar;
-
-/// An opaque type that represents a category.
-typedef struct objc_category *Category;
-
-/// An opaque type that represents an Objective-C declared property.
-typedef struct objc_property *objc_property_t;
-
-struct objc_class {
-    Class _Nonnull isa  OBJC_ISA_AVAILABILITY;
-
-#if !__OBJC2__
-    Class _Nullable super_class                              OBJC2_UNAVAILABLE;
-    const char * _Nonnull name                               OBJC2_UNAVAILABLE;
-    long version                                             OBJC2_UNAVAILABLE;
-    long info                                                OBJC2_UNAVAILABLE;
-    long instance_size                                       OBJC2_UNAVAILABLE;
-    struct objc_ivar_list * _Nullable ivars                  OBJC2_UNAVAILABLE;
-    struct objc_method_list * _Nullable * _Nullable methodLists                    OBJC2_UNAVAILABLE;
-    struct objc_cache * _Nonnull cache                       OBJC2_UNAVAILABLE;
-    struct objc_protocol_list * _Nullable protocols          OBJC2_UNAVAILABLE;
-#endif
-
-} OBJC2_UNAVAILABLE;
-/* Use `Class` instead of `struct objc_class *` */
-
-#endif
-
-#ifdef __OBJC__
-@class Protocol;
-#else
-typedef struct objc_object Protocol;
-#endif
-
-/// Defines a method
-struct objc_method_description {
-    SEL _Nullable name;               /**< The name of the method */
-    char * _Nullable types;           /**< The types of the method arguments */
-};
-
-/// Defines a property attribute
-typedef struct {
-    const char * _Nonnull name;           /**< The name of the attribute */
-    const char * _Nonnull value;          /**< The value of the attribute (usually empty) */
-} objc_property_attribute_t;
-
-
-/* Functions */
-
-/* Working with Instances */
-
-/** 
- * Returns a copy of a given object.
- * 
- * @param obj An Objective-C object.
- * @param size The size of the object \e obj.
- * 
- * @return A copy of \e obj.
- */
-OBJC_EXPORT id _Nullable object_copy(id _Nullable obj, size_t size)
-    OBJC_AVAILABLE(10.0, 2.0, 9.0, 1.0, 2.0)
-    OBJC_ARC_UNAVAILABLE;
-
-/** 
- * Frees the memory occupied by a given object.
- * 
- * @param obj An Objective-C object.
- * 
- * @return nil
- */
-OBJC_EXPORT id _Nullable
-object_dispose(id _Nullable obj)
-    OBJC_AVAILABLE(10.0, 2.0, 9.0, 1.0, 2.0)
-    OBJC_ARC_UNAVAILABLE;
-
-/** 
- * Returns the class of an object.
- * 
- * @param obj The object you want to inspect.
- * 
- * @return The class object of which \e object is an instance, 
- *  or \c Nil if \e object is \c nil.
- */
-OBJC_EXPORT Class _Nullable
-object_getClass(id _Nullable obj) 
-    OBJC_AVAILABLE(10.5, 2.0, 9.0, 1.0, 2.0);
-
-/** 
- * Sets the class of an object.
- * 
- * @param obj The object to modify.
- * @param cls A class object.
- * 
- * @return The previous value of \e object's class, or \c Nil if \e object is \c nil.
- */
-OBJC_EXPORT Class _Nullable
-object_setClass(id _Nullable obj, Class _Nonnull cls) 
-    OBJC_AVAILABLE(10.5, 2.0, 9.0, 1.0, 2.0);
-
-
-/** 
- * Returns whether an object is a class object.
- * 
- * @param obj An Objective-C object.
- * 
- * @return true if the object is a class or metaclass, false otherwise.
- */
-OBJC_EXPORT BOOL
-object_isClass(id _Nullable obj)
-    OBJC_AVAILABLE(10.10, 8.0, 9.0, 1.0, 2.0);
-
-
-/** 
- * Reads the value of an instance variable in an object.
- * 
- * @param obj The object containing the instance variable whose value you want to read.
- * @param ivar The Ivar describing the instance variable whose value you want to read.
- * 
- * @return The value of the instance variable specified by \e ivar, or \c nil if \e object is \c nil.
- * 
- * @note \c object_getIvar is faster than \c object_getInstanceVariable if the Ivar
- *  for the instance variable is already known.
- */
-OBJC_EXPORT id _Nullable
-object_getIvar(id _Nullable obj, Ivar _Nonnull ivar) 
-    OBJC_AVAILABLE(10.5, 2.0, 9.0, 1.0, 2.0);
-
-/** 
- * Sets the value of an instance variable in an object.
- * 
- * @param obj The object containing the instance variable whose value you want to set.
- * @param ivar The Ivar describing the instance variable whose value you want to set.
- * @param value The new value for the instance variable.
- * 
- * @note Instance variables with known memory management (such as ARC strong and weak)
- *  use that memory management. Instance variables with unknown memory management 
- *  are assigned as if they were unsafe_unretained.
- * @note \c object_setIvar is faster than \c object_setInstanceVariable if the Ivar
- *  for the instance variable is already known.
- */
-OBJC_EXPORT void
-object_setIvar(id _Nullable obj, Ivar _Nonnull ivar, id _Nullable value) 
-    OBJC_AVAILABLE(10.5, 2.0, 9.0, 1.0, 2.0);
-
-/** 
- * Sets the value of an instance variable in an object.
- * 
- * @param obj The object containing the instance variable whose value you want to set.
- * @param ivar The Ivar describing the instance variable whose value you want to set.
- * @param value The new value for the instance variable.
- * 
- * @note Instance variables with known memory management (such as ARC strong and weak)
- *  use that memory management. Instance variables with unknown memory management 
- *  are assigned as if they were strong.
- * @note \c object_setIvar is faster than \c object_setInstanceVariable if the Ivar
- *  for the instance variable is already known.
- */
-OBJC_EXPORT void
-object_setIvarWithStrongDefault(id _Nullable obj, Ivar _Nonnull ivar,
-                                id _Nullable value) 
-    OBJC_AVAILABLE(10.12, 10.0, 10.0, 3.0, 2.0);
-
-/** 
- * Changes the value of an instance variable of a class instance.
- * 
- * @param obj A pointer to an instance of a class. Pass the object containing
- *  the instance variable whose value you wish to modify.
- * @param name A C string. Pass the name of the instance variable whose value you wish to modify.
- * @param value The new value for the instance variable.
- * 
- * @return A pointer to the \c Ivar data structure that defines the type and 
- *  name of the instance variable specified by \e name.
- *
- * @note Instance variables with known memory management (such as ARC strong and weak)
- *  use that memory management. Instance variables with unknown memory management 
- *  are assigned as if they were unsafe_unretained.
- */
-OBJC_EXPORT Ivar _Nullable
-object_setInstanceVariable(id _Nullable obj, const char * _Nonnull name,
-                           void * _Nullable value)
-    OBJC_AVAILABLE(10.0, 2.0, 9.0, 1.0, 2.0)
-    OBJC_ARC_UNAVAILABLE;
-
-/** 
- * Changes the value of an instance variable of a class instance.
- * 
- * @param obj A pointer to an instance of a class. Pass the object containing
- *  the instance variable whose value you wish to modify.
- * @param name A C string. Pass the name of the instance variable whose value you wish to modify.
- * @param value The new value for the instance variable.
- * 
- * @return A pointer to the \c Ivar data structure that defines the type and 
- *  name of the instance variable specified by \e name.
- *
- * @note Instance variables with known memory management (such as ARC strong and weak)
- *  use that memory management. Instance variables with unknown memory management 
- *  are assigned as if they were strong.
- */
-OBJC_EXPORT Ivar _Nullable
-object_setInstanceVariableWithStrongDefault(id _Nullable obj,
-                                            const char * _Nonnull name,
-                                            void * _Nullable value)
-    OBJC_AVAILABLE(10.12, 10.0, 10.0, 3.0, 2.0)
-    OBJC_ARC_UNAVAILABLE;
-
-/** 
- * Obtains the value of an instance variable of a class instance.
- * 
- * @param obj A pointer to an instance of a class. Pass the object containing
- *  the instance variable whose value you wish to obtain.
- * @param name A C string. Pass the name of the instance variable whose value you wish to obtain.
- * @param outValue On return, contains a pointer to the value of the instance variable.
- * 
- * @return A pointer to the \c Ivar data structure that defines the type and name of
- *  the instance variable specified by \e name.
- */
-OBJC_EXPORT Ivar _Nullable
-object_getInstanceVariable(id _Nullable obj, const char * _Nonnull name,
-                           void * _Nullable * _Nullable outValue)
-    OBJC_AVAILABLE(10.0, 2.0, 9.0, 1.0, 2.0)
-    OBJC_ARC_UNAVAILABLE;
-
-
-/* Obtaining Class Definitions */
-
-/** 
- * Returns the class definition of a specified class.
- * 
- * @param name The name of the class to look up.
- * 
- * @return The Class object for the named class, or \c nil
- *  if the class is not registered with the Objective-C runtime.
- * 
- * @note \c objc_getClass is different from \c objc_lookUpClass in that if the class
- *  is not registered, \c objc_getClass calls the class handler callback and then checks
- *  a second time to see whether the class is registered. \c objc_lookUpClass does 
- *  not call the class handler callback.
- * 
- * @warning Earlier implementations of this function (prior to OS X v10.0)
- *  terminate the program if the class does not exist.
- */
-OBJC_EXPORT Class _Nullable
-objc_getClass(const char * _Nonnull name)
-    OBJC_AVAILABLE(10.0, 2.0, 9.0, 1.0, 2.0);
-
-/** 
- * Returns the metaclass definition of a specified class.
- * 
- * @param name The name of the class to look up.
- * 
- * @return The \c Class object for the metaclass of the named class, or \c nil if the class
- *  is not registered with the Objective-C runtime.
- * 
- * @note If the definition for the named class is not registered, this function calls the class handler
- *  callback and then checks a second time to see if the class is registered. However, every class
- *  definition must have a valid metaclass definition, and so the metaclass definition is always returned,
- *  whether it’s valid or not.
- */
-OBJC_EXPORT Class _Nullable
-objc_getMetaClass(const char * _Nonnull name)
-    OBJC_AVAILABLE(10.0, 2.0, 9.0, 1.0, 2.0);
-
-/** 
- * Returns the class definition of a specified class.
- * 
- * @param name The name of the class to look up.
- * 
- * @return The Class object for the named class, or \c nil if the class
- *  is not registered with the Objective-C runtime.
- * 
- * @note \c objc_getClass is different from this function in that if the class is not
- *  registered, \c objc_getClass calls the class handler callback and then checks a second
- *  time to see whether the class is registered. This function does not call the class handler callback.
- */
-OBJC_EXPORT Class _Nullable
-objc_lookUpClass(const char * _Nonnull name)
-    OBJC_AVAILABLE(10.0, 2.0, 9.0, 1.0, 2.0);
-
-/** 
- * Returns the class definition of a specified class.
- * 
- * @param name The name of the class to look up.
- * 
- * @return The Class object for the named class.
- * 
- * @note This function is the same as \c objc_getClass, but kills the process if the class is not found.
- * @note This function is used by ZeroLink, where failing to find a class would be a compile-time link error without ZeroLink.
- */
-OBJC_EXPORT Class _Nonnull
-objc_getRequiredClass(const char * _Nonnull name)
-    OBJC_AVAILABLE(10.0, 2.0, 9.0, 1.0, 2.0);
-
-/** 
- * Obtains the list of registered class definitions.
- * 
- * @param buffer An array of \c Class values. On output, each \c Class value points to
- *  one class definition, up to either \e bufferCount or the total number of registered classes,
- *  whichever is less. You can pass \c NULL to obtain the total number of registered class
- *  definitions without actually retrieving any class definitions.
- * @param bufferCount An integer value. Pass the number of pointers for which you have allocated space
- *  in \e buffer. On return, this function fills in only this number of elements. If this number is less
- *  than the number of registered classes, this function returns an arbitrary subset of the registered classes.
- * 
- * @return An integer value indicating the total number of registered classes.
- * 
- * @note The Objective-C runtime library automatically registers all the classes defined in your source code.
- *  You can create class definitions at runtime and register them with the \c objc_addClass function.
- * 
- * @warning You cannot assume that class objects you get from this function are classes that inherit from \c NSObject,
- *  so you cannot safely call any methods on such classes without detecting that the method is implemented first.
- */
-OBJC_EXPORT int
-objc_getClassList(Class _Nonnull * _Nullable buffer, int bufferCount)
-    OBJC_AVAILABLE(10.0, 2.0, 9.0, 1.0, 2.0);
-
-/** 
- * Creates and returns a list of pointers to all registered class definitions.
- * 
- * @param outCount An integer pointer used to store the number of classes returned by
- *  this function in the list. It can be \c nil.
- * 
- * @return A nil terminated array of classes. It must be freed with \c free().
- * 
- * @see objc_getClassList
- */
-OBJC_EXPORT Class _Nonnull * _Nullable
-objc_copyClassList(unsigned int * _Nullable outCount)
-    OBJC_AVAILABLE(10.7, 3.1, 9.0, 1.0, 2.0);
-
-
-/* Working with Classes */
-
-/** 
- * Returns the name of a class.
- * 
- * @param cls A class object.
- * 
- * @return The name of the class, or the empty string if \e cls is \c Nil.
- */
-OBJC_EXPORT const char * _Nonnull
-class_getName(Class _Nullable cls) 
-    OBJC_AVAILABLE(10.5, 2.0, 9.0, 1.0, 2.0);
-
-/** 
- * Returns a Boolean value that indicates whether a class object is a metaclass.
- * 
- * @param cls A class object.
- * 
- * @return \c YES if \e cls is a metaclass, \c NO if \e cls is a non-meta class, 
- *  \c NO if \e cls is \c Nil.
- */
-OBJC_EXPORT BOOL
-class_isMetaClass(Class _Nullable cls) 
-    OBJC_AVAILABLE(10.5, 2.0, 9.0, 1.0, 2.0);
-
-/** 
- * Returns the superclass of a class.
- * 
- * @param cls A class object.
- * 
- * @return The superclass of the class, or \c Nil if
- *  \e cls is a root class, or \c Nil if \e cls is \c Nil.
- *
- * @note You should usually use \c NSObject's \c superclass method instead of this function.
- */
-OBJC_EXPORT Class _Nullable
-class_getSuperclass(Class _Nullable cls) 
-    OBJC_AVAILABLE(10.5, 2.0, 9.0, 1.0, 2.0);
-
-/** 
- * Sets the superclass of a given class.
- * 
- * @param cls The class whose superclass you want to set.
- * @param newSuper The new superclass for cls.
- * 
- * @return The old superclass for cls.
- * 
- * @warning You should not use this function.
- */
-OBJC_EXPORT Class _Nonnull
-class_setSuperclass(Class _Nonnull cls, Class _Nonnull newSuper) 
-    __OSX_DEPRECATED(10.5, 10.5, "not recommended")
-    __IOS_DEPRECATED(2.0, 2.0, "not recommended")
-    __TVOS_DEPRECATED(9.0, 9.0, "not recommended")
-    __WATCHOS_DEPRECATED(1.0, 1.0, "not recommended")
-
-;
-
-/** 
- * Returns the version number of a class definition.
- * 
- * @param cls A pointer to a \c Class data structure. Pass
- *  the class definition for which you wish to obtain the version.
- * 
- * @return An integer indicating the version number of the class definition.
- *
- * @see class_setVersion
- */
-OBJC_EXPORT int
-class_getVersion(Class _Nullable cls)
-    OBJC_AVAILABLE(10.0, 2.0, 9.0, 1.0, 2.0);
-
-/** 
- * Sets the version number of a class definition.
- * 
- * @param cls A pointer to an Class data structure. 
- *  Pass the class definition for which you wish to set the version.
- * @param version An integer. Pass the new version number of the class definition.
- *
- * @note You can use the version number of the class definition to provide versioning of the
- *  interface that your class represents to other classes. This is especially useful for object
- *  serialization (that is, archiving of the object in a flattened form), where it is important to
- *  recognize changes to the layout of the instance variables in different class-definition versions.
- * @note Classes derived from the Foundation framework \c NSObject class can set the class-definition
- *  version number using the \c setVersion: class method, which is implemented using the \c class_setVersion function.
- */
-OBJC_EXPORT void
-class_setVersion(Class _Nullable cls, int version)
-    OBJC_AVAILABLE(10.0, 2.0, 9.0, 1.0, 2.0);
-
-/** 
- * Returns the size of instances of a class.
- * 
- * @param cls A class object.
- * 
- * @return The size in bytes of instances of the class \e cls, or \c 0 if \e cls is \c Nil.
- */
-OBJC_EXPORT size_t
-class_getInstanceSize(Class _Nullable cls) 
-    OBJC_AVAILABLE(10.5, 2.0, 9.0, 1.0, 2.0);
-
-/** 
- * Returns the \c Ivar for a specified instance variable of a given class.
- * 
- * @param cls The class whose instance variable you wish to obtain.
- * @param name The name of the instance variable definition to obtain.
- * 
- * @return A pointer to an \c Ivar data structure containing information about 
- *  the instance variable specified by \e name.
- */
-OBJC_EXPORT Ivar _Nullable
-class_getInstanceVariable(Class _Nullable cls, const char * _Nonnull name)
-    OBJC_AVAILABLE(10.0, 2.0, 9.0, 1.0, 2.0);
-
-/** 
- * Returns the Ivar for a specified class variable of a given class.
- * 
- * @param cls The class definition whose class variable you wish to obtain.
- * @param name The name of the class variable definition to obtain.
- * 
- * @return A pointer to an \c Ivar data structure containing information about the class variable specified by \e name.
- */
-OBJC_EXPORT Ivar _Nullable
-class_getClassVariable(Class _Nullable cls, const char * _Nonnull name) 
-    OBJC_AVAILABLE(10.5, 2.0, 9.0, 1.0, 2.0);
-
-/** 
- * Describes the instance variables declared by a class.
- * 
- * @param cls The class to inspect.
- * @param outCount On return, contains the length of the returned array. 
- *  If outCount is NULL, the length is not returned.
- * 
- * @return An array of pointers of type Ivar describing the instance variables declared by the class. 
- *  Any instance variables declared by superclasses are not included. The array contains *outCount 
- *  pointers followed by a NULL terminator. You must free the array with free().
- * 
- *  If the class declares no instance variables, or cls is Nil, NULL is returned and *outCount is 0.
- */
-OBJC_EXPORT Ivar _Nonnull * _Nullable
-class_copyIvarList(Class _Nullable cls, unsigned int * _Nullable outCount) 
-    OBJC_AVAILABLE(10.5, 2.0, 9.0, 1.0, 2.0);
-
-/** 
- * Returns a specified instance method for a given class.
- * 
- * @param cls The class you want to inspect.
- * @param name The selector of the method you want to retrieve.
- * 
- * @return The method that corresponds to the implementation of the selector specified by 
- *  \e name for the class specified by \e cls, or \c NULL if the specified class or its 
- *  superclasses do not contain an instance method with the specified selector.
- *
- * @note This function searches superclasses for implementations, whereas \c class_copyMethodList does not.
- */
-OBJC_EXPORT Method _Nullable
-class_getInstanceMethod(Class _Nullable cls, SEL _Nonnull name)
-    OBJC_AVAILABLE(10.0, 2.0, 9.0, 1.0, 2.0);
-
-/** 
- * Returns a pointer to the data structure describing a given class method for a given class.
- * 
- * @param cls A pointer to a class definition. Pass the class that contains the method you want to retrieve.
- * @param name A pointer of type \c SEL. Pass the selector of the method you want to retrieve.
- * 
- * @return A pointer to the \c Method data structure that corresponds to the implementation of the 
- *  selector specified by aSelector for the class specified by aClass, or NULL if the specified 
- *  class or its superclasses do not contain an instance method with the specified selector.
- *
- * @note Note that this function searches superclasses for implementations, 
- *  whereas \c class_copyMethodList does not.
- */
-OBJC_EXPORT Method _Nullable
-class_getClassMethod(Class _Nullable cls, SEL _Nonnull name)
-    OBJC_AVAILABLE(10.0, 2.0, 9.0, 1.0, 2.0);
-
-/** 
- * Returns the function pointer that would be called if a 
- * particular message were sent to an instance of a class.
- * 
- * @param cls The class you want to inspect.
- * @param name A selector.
- * 
- * @return The function pointer that would be called if \c [object name] were called
- *  with an instance of the class, or \c NULL if \e cls is \c Nil.
- *
- * @note \c class_getMethodImplementation may be faster than \c method_getImplementation(class_getInstanceMethod(cls, name)).
- * @note The function pointer returned may be a function internal to the runtime instead of
- *  an actual method implementation. For example, if instances of the class do not respond to
- *  the selector, the function pointer returned will be part of the runtime's message forwarding machinery.
- */
-OBJC_EXPORT IMP _Nullable
-class_getMethodImplementation(Class _Nullable cls, SEL _Nonnull name) 
-    OBJC_AVAILABLE(10.5, 2.0, 9.0, 1.0, 2.0);
-
-/** 
- * Returns the function pointer that would be called if a particular 
- * message were sent to an instance of a class.
- * 
- * @param cls The class you want to inspect.
- * @param name A selector.
- * 
- * @return The function pointer that would be called if \c [object name] were called
- *  with an instance of the class, or \c NULL if \e cls is \c Nil.
- */
-OBJC_EXPORT IMP _Nullable
-class_getMethodImplementation_stret(Class _Nullable cls, SEL _Nonnull name) 
-    OBJC_AVAILABLE(10.5, 2.0, 9.0, 1.0, 2.0)
-    OBJC_ARM64_UNAVAILABLE;
-
-/** 
- * Returns a Boolean value that indicates whether instances of a class respond to a particular selector.
- * 
- * @param cls The class you want to inspect.
- * @param sel A selector.
- * 
- * @return \c YES if instances of the class respond to the selector, otherwise \c NO.
- * 
- * @note You should usually use \c NSObject's \c respondsToSelector: or \c instancesRespondToSelector: 
- *  methods instead of this function.
- */
-OBJC_EXPORT BOOL
-class_respondsToSelector(Class _Nullable cls, SEL _Nonnull sel) 
-    OBJC_AVAILABLE(10.5, 2.0, 9.0, 1.0, 2.0);
-
-/** 
- * Describes the instance methods implemented by a class.
- * 
- * @param cls The class you want to inspect.
- * @param outCount On return, contains the length of the returned array. 
- *  If outCount is NULL, the length is not returned.
- * 
- * @return An array of pointers of type Method describing the instance methods 
- *  implemented by the class—any instance methods implemented by superclasses are not included. 
- *  The array contains *outCount pointers followed by a NULL terminator. You must free the array with free().
- * 
- *  If cls implements no instance methods, or cls is Nil, returns NULL and *outCount is 0.
- * 
- * @note To get the class methods of a class, use \c class_copyMethodList(object_getClass(cls), &count).
- * @note To get the implementations of methods that may be implemented by superclasses, 
- *  use \c class_getInstanceMethod or \c class_getClassMethod.
- */
-OBJC_EXPORT Method _Nonnull * _Nullable
-class_copyMethodList(Class _Nullable cls, unsigned int * _Nullable outCount) 
-    OBJC_AVAILABLE(10.5, 2.0, 9.0, 1.0, 2.0);
-
-/** 
- * Returns a Boolean value that indicates whether a class conforms to a given protocol.
- * 
- * @param cls The class you want to inspect.
- * @param protocol A protocol.
- *
- * @return YES if cls conforms to protocol, otherwise NO.
- *
- * @note You should usually use NSObject's conformsToProtocol: method instead of this function.
- */
-OBJC_EXPORT BOOL
-class_conformsToProtocol(Class _Nullable cls, Protocol * _Nullable protocol) 
-    OBJC_AVAILABLE(10.5, 2.0, 9.0, 1.0, 2.0);
-
-/** 
- * Describes the protocols adopted by a class.
- * 
- * @param cls The class you want to inspect.
- * @param outCount On return, contains the length of the returned array. 
- *  If outCount is NULL, the length is not returned.
- * 
- * @return An array of pointers of type Protocol* describing the protocols adopted 
- *  by the class. Any protocols adopted by superclasses or other protocols are not included. 
- *  The array contains *outCount pointers followed by a NULL terminator. You must free the array with free().
- * 
- *  If cls adopts no protocols, or cls is Nil, returns NULL and *outCount is 0.
- */
-OBJC_EXPORT Protocol * __unsafe_unretained _Nonnull * _Nullable 
-class_copyProtocolList(Class _Nullable cls, unsigned int * _Nullable outCount)
-    OBJC_AVAILABLE(10.5, 2.0, 9.0, 1.0, 2.0);
-
-/** 
- * Returns a property with a given name of a given class.
- * 
- * @param cls The class you want to inspect.
- * @param name The name of the property you want to inspect.
- * 
- * @return A pointer of type \c objc_property_t describing the property, or
- *  \c NULL if the class does not declare a property with that name, 
- *  or \c NULL if \e cls is \c Nil.
- */
-OBJC_EXPORT objc_property_t _Nullable
-class_getProperty(Class _Nullable cls, const char * _Nonnull name)
-    OBJC_AVAILABLE(10.5, 2.0, 9.0, 1.0, 2.0);
-
-/** 
- * Describes the properties declared by a class.
- * 
- * @param cls The class you want to inspect.
- * @param outCount On return, contains the length of the returned array. 
- *  If \e outCount is \c NULL, the length is not returned.        
- * 
- * @return An array of pointers of type \c objc_property_t describing the properties 
- *  declared by the class. Any properties declared by superclasses are not included. 
- *  The array contains \c *outCount pointers followed by a \c NULL terminator. You must free the array with \c free().
- * 
- *  If \e cls declares no properties, or \e cls is \c Nil, returns \c NULL and \c *outCount is \c 0.
- */
-OBJC_EXPORT objc_property_t _Nonnull * _Nullable
-class_copyPropertyList(Class _Nullable cls, unsigned int * _Nullable outCount)
-    OBJC_AVAILABLE(10.5, 2.0, 9.0, 1.0, 2.0);
-
-/** 
- * Returns a description of the \c Ivar layout for a given class.
- * 
- * @param cls The class to inspect.
- * 
- * @return A description of the \c Ivar layout for \e cls.
- */
-OBJC_EXPORT const uint8_t * _Nullable
-class_getIvarLayout(Class _Nullable cls)
-    OBJC_AVAILABLE(10.5, 2.0, 9.0, 1.0, 2.0);
-
-/** 
- * Returns a description of the layout of weak Ivars for a given class.
- * 
- * @param cls The class to inspect.
- * 
- * @return A description of the layout of the weak \c Ivars for \e cls.
- */
-OBJC_EXPORT const uint8_t * _Nullable
-class_getWeakIvarLayout(Class _Nullable cls)
-    OBJC_AVAILABLE(10.5, 2.0, 9.0, 1.0, 2.0);
-
-/** 
- * Adds a new method to a class with a given name and implementation.
- * 
- * @param cls The class to which to add a method.
- * @param name A selector that specifies the name of the method being added.
- * @param imp A function which is the implementation of the new method. The function must take at least two arguments—self and _cmd.
- * @param types An array of characters that describe the types of the arguments to the method. 
- * 
- * @return YES if the method was added successfully, otherwise NO 
- *  (for example, the class already contains a method implementation with that name).
- *
- * @note class_addMethod will add an override of a superclass's implementation, 
- *  but will not replace an existing implementation in this class. 
- *  To change an existing implementation, use method_setImplementation.
- */
-OBJC_EXPORT BOOL
-class_addMethod(Class _Nullable cls, SEL _Nonnull name, IMP _Nonnull imp, 
-                const char * _Nullable types) 
-    OBJC_AVAILABLE(10.5, 2.0, 9.0, 1.0, 2.0);
-
-/** 
- * Replaces the implementation of a method for a given class.
- * 
- * @param cls The class you want to modify.
- * @param name A selector that identifies the method whose implementation you want to replace.
- * @param imp The new implementation for the method identified by name for the class identified by cls.
- * @param types An array of characters that describe the types of the arguments to the method. 
- *  Since the function must take at least two arguments—self and _cmd, the second and third characters
- *  must be “@:” (the first character is the return type).
- * 
- * @return The previous implementation of the method identified by \e name for the class identified by \e cls.
- * 
- * @note This function behaves in two different ways:
- *  - If the method identified by \e name does not yet exist, it is added as if \c class_addMethod were called. 
- *    The type encoding specified by \e types is used as given.
- *  - If the method identified by \e name does exist, its \c IMP is replaced as if \c method_setImplementation were called.
- *    The type encoding specified by \e types is ignored.
- */
-OBJC_EXPORT IMP _Nullable
-class_replaceMethod(Class _Nullable cls, SEL _Nonnull name, IMP _Nonnull imp, 
-                    const char * _Nullable types) 
-    OBJC_AVAILABLE(10.5, 2.0, 9.0, 1.0, 2.0);
-
-/** 
- * Adds a new instance variable to a class.
- * 
- * @return YES if the instance variable was added successfully, otherwise NO 
- *         (for example, the class already contains an instance variable with that name).
- *
- * @note This function may only be called after objc_allocateClassPair and before objc_registerClassPair. 
- *       Adding an instance variable to an existing class is not supported.
- * @note The class must not be a metaclass. Adding an instance variable to a metaclass is not supported.
- * @note The instance variable's minimum alignment in bytes is 1<<align. The minimum alignment of an instance 
- *       variable depends on the ivar's type and the machine architecture. 
- *       For variables of any pointer type, pass log2(sizeof(pointer_type)).
- */
-OBJC_EXPORT BOOL
-class_addIvar(Class _Nullable cls, const char * _Nonnull name, size_t size, 
-              uint8_t alignment, const char * _Nullable types) 
-    OBJC_AVAILABLE(10.5, 2.0, 9.0, 1.0, 2.0);
-
-/** 
- * Adds a protocol to a class.
- * 
- * @param cls The class to modify.
- * @param protocol The protocol to add to \e cls.
- * 
- * @return \c YES if the method was added successfully, otherwise \c NO 
- *  (for example, the class already conforms to that protocol).
- */
-OBJC_EXPORT BOOL
-class_addProtocol(Class _Nullable cls, Protocol * _Nonnull protocol) 
-    OBJC_AVAILABLE(10.5, 2.0, 9.0, 1.0, 2.0);
-
-/** 
- * Adds a property to a class.
- * 
- * @param cls The class to modify.
- * @param name The name of the property.
- * @param attributes An array of property attributes.
- * @param attributeCount The number of attributes in \e attributes.
- * 
- * @return \c YES if the property was added successfully, otherwise \c NO
- *  (for example, the class already has that property).
- */
-OBJC_EXPORT BOOL
-class_addProperty(Class _Nullable cls, const char * _Nonnull name,
-                  const objc_property_attribute_t * _Nullable attributes,
-                  unsigned int attributeCount)
-    OBJC_AVAILABLE(10.7, 4.3, 9.0, 1.0, 2.0);
-
-/** 
- * Replace a property of a class. 
- * 
- * @param cls The class to modify.
- * @param name The name of the property.
- * @param attributes An array of property attributes.
- * @param attributeCount The number of attributes in \e attributes. 
- */
-OBJC_EXPORT void
-class_replaceProperty(Class _Nullable cls, const char * _Nonnull name,
-                      const objc_property_attribute_t * _Nullable attributes,
-                      unsigned int attributeCount)
-    OBJC_AVAILABLE(10.7, 4.3, 9.0, 1.0, 2.0);
-
-/** 
- * Sets the Ivar layout for a given class.
- * 
- * @param cls The class to modify.
- * @param layout The layout of the \c Ivars for \e cls.
- */
-OBJC_EXPORT void
-class_setIvarLayout(Class _Nullable cls, const uint8_t * _Nullable layout)
-    OBJC_AVAILABLE(10.5, 2.0, 9.0, 1.0, 2.0);
-
-/** 
- * Sets the layout for weak Ivars for a given class.
- * 
- * @param cls The class to modify.
- * @param layout The layout of the weak Ivars for \e cls.
- */
-OBJC_EXPORT void
-class_setWeakIvarLayout(Class _Nullable cls, const uint8_t * _Nullable layout)
-    OBJC_AVAILABLE(10.5, 2.0, 9.0, 1.0, 2.0);
-
-/** 
- * Used by CoreFoundation's toll-free bridging.
- * Return the id of the named class.
- * 
- * @return The id of the named class, or an uninitialized class
- *  structure that will be used for the class when and if it does 
- *  get loaded.
- * 
- * @warning Do not call this function yourself.
- */
-OBJC_EXPORT Class _Nonnull
-objc_getFutureClass(const char * _Nonnull name) 
-    OBJC_AVAILABLE(10.5, 2.0, 9.0, 1.0, 2.0)
-    OBJC_ARC_UNAVAILABLE;
-
-
-/* Instantiating Classes */
-
-/** 
- * Creates an instance of a class, allocating memory for the class in the 
- * default malloc memory zone.
- * 
- * @param cls The class that you wish to allocate an instance of.
- * @param extraBytes An integer indicating the number of extra bytes to allocate. 
- *  The additional bytes can be used to store additional instance variables beyond 
- *  those defined in the class definition.
- * 
- * @return An instance of the class \e cls.
- */
-OBJC_EXPORT id _Nullable
-class_createInstance(Class _Nullable cls, size_t extraBytes)
-    OBJC_RETURNS_RETAINED
-    OBJC_AVAILABLE(10.0, 2.0, 9.0, 1.0, 2.0);
-
-/** 
- * Creates an instance of a class at the specific location provided.
- * 
- * @param cls The class that you wish to allocate an instance of.
- * @param bytes The location at which to allocate an instance of \e cls.
- *  Must point to at least \c class_getInstanceSize(cls) bytes of well-aligned,
- *  zero-filled memory.
- *
- * @return \e bytes on success, \c nil otherwise. (For example, \e cls or \e bytes
- *  might be \c nil)
- *
- * @see class_createInstance
- */
-OBJC_EXPORT id _Nullable
-objc_constructInstance(Class _Nullable cls, void * _Nullable bytes) 
-    OBJC_AVAILABLE(10.6, 3.0, 9.0, 1.0, 2.0)
-    OBJC_ARC_UNAVAILABLE;
-
-/** 
- * Destroys an instance of a class without freeing memory and removes any
- * associated references this instance might have had.
- * 
- * @param obj The class instance to destroy.
- * 
- * @return \e obj. Does nothing if \e obj is nil.
- * 
- * @note CF and other clients do call this under GC.
- */
-OBJC_EXPORT void * _Nullable objc_destructInstance(id _Nullable obj) 
-    OBJC_AVAILABLE(10.6, 3.0, 9.0, 1.0, 2.0)
-    OBJC_ARC_UNAVAILABLE;
-
-
-/* Adding Classes */
-
-/** 
- * Creates a new class and metaclass.
- * 
- * @param superclass The class to use as the new class's superclass, or \c Nil to create a new root class.
- * @param name The string to use as the new class's name. The string will be copied.
- * @param extraBytes The number of bytes to allocate for indexed ivars at the end of 
- *  the class and metaclass objects. This should usually be \c 0.
- * 
- * @return The new class, or Nil if the class could not be created (for example, the desired name is already in use).
- * 
- * @note You can get a pointer to the new metaclass by calling \c object_getClass(newClass).
- * @note To create a new class, start by calling \c objc_allocateClassPair. 
- *  Then set the class's attributes with functions like \c class_addMethod and \c class_addIvar.
- *  When you are done building the class, call \c objc_registerClassPair. The new class is now ready for use.
- * @note Instance methods and instance variables should be added to the class itself. 
- *  Class methods should be added to the metaclass.
- */
-OBJC_EXPORT Class _Nullable
-objc_allocateClassPair(Class _Nullable superclass, const char * _Nonnull name, 
-                       size_t extraBytes) 
-    OBJC_AVAILABLE(10.5, 2.0, 9.0, 1.0, 2.0);
-
-/** 
- * Registers a class that was allocated using \c objc_allocateClassPair.
- * 
- * @param cls The class you want to register.
- */
-OBJC_EXPORT void
-objc_registerClassPair(Class _Nonnull cls) 
-    OBJC_AVAILABLE(10.5, 2.0, 9.0, 1.0, 2.0);
-
-/** 
- * Used by Foundation's Key-Value Observing.
- * 
- * @warning Do not call this function yourself.
- */
-OBJC_EXPORT Class _Nonnull
-objc_duplicateClass(Class _Nonnull original, const char * _Nonnull name,
-                    size_t extraBytes)
-    OBJC_AVAILABLE(10.5, 2.0, 9.0, 1.0, 2.0);
-
-/** 
- * Destroy a class and its associated metaclass. 
- * 
- * @param cls The class to be destroyed. It must have been allocated with 
- *  \c objc_allocateClassPair
- * 
- * @warning Do not call if instances of this class or a subclass exist.
- */
-OBJC_EXPORT void
-objc_disposeClassPair(Class _Nonnull cls) 
-    OBJC_AVAILABLE(10.5, 2.0, 9.0, 1.0, 2.0);
-
-
-/* Working with Methods */
-
-/** 
- * Returns the name of a method.
- * 
- * @param m The method to inspect.
- * 
- * @return A pointer of type SEL.
- * 
- * @note To get the method name as a C string, call \c sel_getName(method_getName(method)).
- */
-OBJC_EXPORT SEL _Nonnull
-method_getName(Method _Nonnull m) 
-    OBJC_AVAILABLE(10.5, 2.0, 9.0, 1.0, 2.0);
-
-/** 
- * Returns the implementation of a method.
- * 
- * @param m The method to inspect.
- * 
- * @return A function pointer of type IMP.
- */
-OBJC_EXPORT IMP _Nonnull
-method_getImplementation(Method _Nonnull m) 
-    OBJC_AVAILABLE(10.5, 2.0, 9.0, 1.0, 2.0);
-
-/** 
- * Returns a string describing a method's parameter and return types.
- * 
- * @param m The method to inspect.
- * 
- * @return A C string. The string may be \c NULL.
- */
-OBJC_EXPORT const char * _Nullable
-method_getTypeEncoding(Method _Nonnull m) 
-    OBJC_AVAILABLE(10.5, 2.0, 9.0, 1.0, 2.0);
-
-/** 
- * Returns the number of arguments accepted by a method.
- * 
- * @param m A pointer to a \c Method data structure. Pass the method in question.
- * 
- * @return An integer containing the number of arguments accepted by the given method.
- */
-OBJC_EXPORT unsigned int
-method_getNumberOfArguments(Method _Nonnull m)
-    OBJC_AVAILABLE(10.0, 2.0, 9.0, 1.0, 2.0);
-
-/** 
- * Returns a string describing a method's return type.
- * 
- * @param m The method to inspect.
- * 
- * @return A C string describing the return type. You must free the string with \c free().
- */
-OBJC_EXPORT char * _Nonnull
-method_copyReturnType(Method _Nonnull m) 
-    OBJC_AVAILABLE(10.5, 2.0, 9.0, 1.0, 2.0);
-
-/** 
- * Returns a string describing a single parameter type of a method.
- * 
- * @param m The method to inspect.
- * @param index The index of the parameter to inspect.
- * 
- * @return A C string describing the type of the parameter at index \e index, or \c NULL
- *  if method has no parameter index \e index. You must free the string with \c free().
- */
-OBJC_EXPORT char * _Nullable
-method_copyArgumentType(Method _Nonnull m, unsigned int index) 
-    OBJC_AVAILABLE(10.5, 2.0, 9.0, 1.0, 2.0);
-
-/** 
- * Returns by reference a string describing a method's return type.
- * 
- * @param m The method you want to inquire about. 
- * @param dst The reference string to store the description.
- * @param dst_len The maximum number of characters that can be stored in \e dst.
- *
- * @note The method's return type string is copied to \e dst.
- *  \e dst is filled as if \c strncpy(dst, parameter_type, dst_len) were called.
- */
-OBJC_EXPORT void
-method_getReturnType(Method _Nonnull m, char * _Nonnull dst, size_t dst_len) 
-    OBJC_AVAILABLE(10.5, 2.0, 9.0, 1.0, 2.0);
-
-/** 
- * Returns by reference a string describing a single parameter type of a method.
- * 
- * @param m The method you want to inquire about. 
- * @param index The index of the parameter you want to inquire about.
- * @param dst The reference string to store the description.
- * @param dst_len The maximum number of characters that can be stored in \e dst.
- * 
- * @note The parameter type string is copied to \e dst. \e dst is filled as if \c strncpy(dst, parameter_type, dst_len) 
- *  were called. If the method contains no parameter with that index, \e dst is filled as
- *  if \c strncpy(dst, "", dst_len) were called.
- */
-OBJC_EXPORT void
-method_getArgumentType(Method _Nonnull m, unsigned int index, 
-                       char * _Nullable dst, size_t dst_len) 
-    OBJC_AVAILABLE(10.5, 2.0, 9.0, 1.0, 2.0);
-
-OBJC_EXPORT struct objc_method_description * _Nonnull
-method_getDescription(Method _Nonnull m) 
-    OBJC_AVAILABLE(10.5, 2.0, 9.0, 1.0, 2.0);
-
-/** 
- * Sets the implementation of a method.
- * 
- * @param m The method for which to set an implementation.
- * @param imp The implemention to set to this method.
- * 
- * @return The previous implementation of the method.
- */
-OBJC_EXPORT IMP _Nonnull
-method_setImplementation(Method _Nonnull m, IMP _Nonnull imp) 
-    OBJC_AVAILABLE(10.5, 2.0, 9.0, 1.0, 2.0);
-
-/** 
- * Exchanges the implementations of two methods.
- * 
- * @param m1 Method to exchange with second method.
- * @param m2 Method to exchange with first method.
- * 
- * @note This is an atomic version of the following:
- *  \code 
- *  IMP imp1 = method_getImplementation(m1);
- *  IMP imp2 = method_getImplementation(m2);
- *  method_setImplementation(m1, imp2);
- *  method_setImplementation(m2, imp1);
- *  \endcode
- */
-OBJC_EXPORT void
-method_exchangeImplementations(Method _Nonnull m1, Method _Nonnull m2) 
-    OBJC_AVAILABLE(10.5, 2.0, 9.0, 1.0, 2.0);
-
-
-/* Working with Instance Variables */
-
-/** 
- * Returns the name of an instance variable.
- * 
- * @param v The instance variable you want to enquire about.
- * 
- * @return A C string containing the instance variable's name.
- */
-OBJC_EXPORT const char * _Nullable
-ivar_getName(Ivar _Nonnull v) 
-    OBJC_AVAILABLE(10.5, 2.0, 9.0, 1.0, 2.0);
-
-/** 
- * Returns the type string of an instance variable.
- * 
- * @param v The instance variable you want to enquire about.
- * 
- * @return A C string containing the instance variable's type encoding.
- *
- * @note For possible values, see Objective-C Runtime Programming Guide > Type Encodings.
- */
-OBJC_EXPORT const char * _Nullable
-ivar_getTypeEncoding(Ivar _Nonnull v) 
-    OBJC_AVAILABLE(10.5, 2.0, 9.0, 1.0, 2.0);
-
-/** 
- * Returns the offset of an instance variable.
- * 
- * @param v The instance variable you want to enquire about.
- * 
- * @return The offset of \e v.
- * 
- * @note For instance variables of type \c id or other object types, call \c object_getIvar
- *  and \c object_setIvar instead of using this offset to access the instance variable data directly.
- */
-OBJC_EXPORT ptrdiff_t
-ivar_getOffset(Ivar _Nonnull v) 
-    OBJC_AVAILABLE(10.5, 2.0, 9.0, 1.0, 2.0);
-
-
-/* Working with Properties */
-
-/** 
- * Returns the name of a property.
- * 
- * @param property The property you want to inquire about.
- * 
- * @return A C string containing the property's name.
- */
-OBJC_EXPORT const char * _Nonnull
-property_getName(objc_property_t _Nonnull property) 
-    OBJC_AVAILABLE(10.5, 2.0, 9.0, 1.0, 2.0);
-
-/** 
- * Returns the attribute string of a property.
- * 
- * @param property A property.
- *
- * @return A C string containing the property's attributes.
- * 
- * @note The format of the attribute string is described in Declared Properties in Objective-C Runtime Programming Guide.
- */
-OBJC_EXPORT const char * _Nullable
-property_getAttributes(objc_property_t _Nonnull property) 
-    OBJC_AVAILABLE(10.5, 2.0, 9.0, 1.0, 2.0);
-
-/** 
- * Returns an array of property attributes for a property. 
- * 
- * @param property The property whose attributes you want copied.
- * @param outCount The number of attributes returned in the array.
- * 
- * @return An array of property attributes; must be free'd() by the caller. 
- */
-OBJC_EXPORT objc_property_attribute_t * _Nullable
-property_copyAttributeList(objc_property_t _Nonnull property,
-                           unsigned int * _Nullable outCount)
-    OBJC_AVAILABLE(10.7, 4.3, 9.0, 1.0, 2.0);
-
-/** 
- * Returns the value of a property attribute given the attribute name.
- * 
- * @param property The property whose attribute value you are interested in.
- * @param attributeName C string representing the attribute name.
- *
- * @return The value string of the attribute \e attributeName if it exists in
- *  \e property, \c nil otherwise. 
- */
-OBJC_EXPORT char * _Nullable
-property_copyAttributeValue(objc_property_t _Nonnull property,
-                            const char * _Nonnull attributeName)
-    OBJC_AVAILABLE(10.7, 4.3, 9.0, 1.0, 2.0);
-
-
-/* Working with Protocols */
-
-/** 
- * Returns a specified protocol.
- * 
- * @param name The name of a protocol.
- * 
- * @return The protocol named \e name, or \c NULL if no protocol named \e name could be found.
- * 
- * @note This function acquires the runtime lock.
- */
-OBJC_EXPORT Protocol * _Nullable
-objc_getProtocol(const char * _Nonnull name)
-    OBJC_AVAILABLE(10.5, 2.0, 9.0, 1.0, 2.0);
-
-/** 
- * Returns an array of all the protocols known to the runtime.
- * 
- * @param outCount Upon return, contains the number of protocols in the returned array.
- * 
- * @return A C array of all the protocols known to the runtime. The array contains \c *outCount
- *  pointers followed by a \c NULL terminator. You must free the list with \c free().
- * 
- * @note This function acquires the runtime lock.
- */
-OBJC_EXPORT Protocol * __unsafe_unretained _Nonnull * _Nullable
-objc_copyProtocolList(unsigned int * _Nullable outCount)
-    OBJC_AVAILABLE(10.5, 2.0, 9.0, 1.0, 2.0);
-
-/** 
- * Returns a Boolean value that indicates whether one protocol conforms to another protocol.
- * 
- * @param proto A protocol.
- * @param other A protocol.
- * 
- * @return \c YES if \e proto conforms to \e other, otherwise \c NO.
- * 
- * @note One protocol can incorporate other protocols using the same syntax 
- *  that classes use to adopt a protocol:
- *  \code
- *  @protocol ProtocolName < protocol list >
- *  \endcode
- *  All the protocols listed between angle brackets are considered part of the ProtocolName protocol.
- */
-OBJC_EXPORT BOOL
-protocol_conformsToProtocol(Protocol * _Nullable proto,
-                            Protocol * _Nullable other)
-    OBJC_AVAILABLE(10.5, 2.0, 9.0, 1.0, 2.0);
-
-/** 
- * Returns a Boolean value that indicates whether two protocols are equal.
- * 
- * @param proto A protocol.
- * @param other A protocol.
- * 
- * @return \c YES if \e proto is the same as \e other, otherwise \c NO.
- */
-OBJC_EXPORT BOOL
-protocol_isEqual(Protocol * _Nullable proto, Protocol * _Nullable other)
-    OBJC_AVAILABLE(10.5, 2.0, 9.0, 1.0, 2.0);
-
-/** 
- * Returns the name of a protocol.
- * 
- * @param proto A protocol.
- * 
- * @return The name of the protocol \e p as a C string.
- */
-OBJC_EXPORT const char * _Nonnull
-protocol_getName(Protocol * _Nonnull proto)
-    OBJC_AVAILABLE(10.5, 2.0, 9.0, 1.0, 2.0);
-
-/** 
- * Returns a method description structure for a specified method of a given protocol.
- * 
- * @param proto A protocol.
- * @param aSel A selector.
- * @param isRequiredMethod A Boolean value that indicates whether aSel is a required method.
- * @param isInstanceMethod A Boolean value that indicates whether aSel is an instance method.
- * 
- * @return An \c objc_method_description structure that describes the method specified by \e aSel,
- *  \e isRequiredMethod, and \e isInstanceMethod for the protocol \e p.
- *  If the protocol does not contain the specified method, returns an \c objc_method_description structure
- *  with the value \c {NULL, \c NULL}.
- * 
- * @note This function recursively searches any protocols that this protocol conforms to.
- */
-OBJC_EXPORT struct objc_method_description
-protocol_getMethodDescription(Protocol * _Nonnull proto, SEL _Nonnull aSel,
-                              BOOL isRequiredMethod, BOOL isInstanceMethod)
-    OBJC_AVAILABLE(10.5, 2.0, 9.0, 1.0, 2.0);
-
-/** 
- * Returns an array of method descriptions of methods meeting a given specification for a given protocol.
- * 
- * @param proto A protocol.
- * @param isRequiredMethod A Boolean value that indicates whether returned methods should
- *  be required methods (pass YES to specify required methods).
- * @param isInstanceMethod A Boolean value that indicates whether returned methods should
- *  be instance methods (pass YES to specify instance methods).
- * @param outCount Upon return, contains the number of method description structures in the returned array.
- * 
- * @return A C array of \c objc_method_description structures containing the names and types of \e p's methods 
- *  specified by \e isRequiredMethod and \e isInstanceMethod. The array contains \c *outCount pointers followed
- *  by a \c NULL terminator. You must free the list with \c free().
- *  If the protocol declares no methods that meet the specification, \c NULL is returned and \c *outCount is 0.
- * 
- * @note Methods in other protocols adopted by this protocol are not included.
- */
-OBJC_EXPORT struct objc_method_description * _Nullable
-protocol_copyMethodDescriptionList(Protocol * _Nonnull proto,
-                                   BOOL isRequiredMethod,
-                                   BOOL isInstanceMethod,
-                                   unsigned int * _Nullable outCount)
-    OBJC_AVAILABLE(10.5, 2.0, 9.0, 1.0, 2.0);
-
-/** 
- * Returns the specified property of a given protocol.
- * 
- * @param proto A protocol.
- * @param name The name of a property.
- * @param isRequiredProperty \c YES searches for a required property, \c NO searches for an optional property.
- * @param isInstanceProperty \c YES searches for an instance property, \c NO searches for a class property.
- * 
- * @return The property specified by \e name, \e isRequiredProperty, and \e isInstanceProperty for \e proto,
- *  or \c NULL if none of \e proto's properties meets the specification.
- */
-OBJC_EXPORT objc_property_t _Nullable
-protocol_getProperty(Protocol * _Nonnull proto,
-                     const char * _Nonnull name,
-                     BOOL isRequiredProperty, BOOL isInstanceProperty)
-    OBJC_AVAILABLE(10.5, 2.0, 9.0, 1.0, 2.0);
-
-/** 
- * Returns an array of the required instance properties declared by a protocol.
- * 
- * @note Identical to 
- * \code
- * protocol_copyPropertyList2(proto, outCount, YES, YES);
- * \endcode
- */
-OBJC_EXPORT objc_property_t _Nonnull * _Nullable
-protocol_copyPropertyList(Protocol * _Nonnull proto,
-                          unsigned int * _Nullable outCount)
-    OBJC_AVAILABLE(10.5, 2.0, 9.0, 1.0, 2.0);
-
-/** 
- * Returns an array of properties declared by a protocol.
- * 
- * @param proto A protocol.
- * @param outCount Upon return, contains the number of elements in the returned array.
- * @param isRequiredProperty \c YES returns required properties, \c NO returns optional properties.
- * @param isInstanceProperty \c YES returns instance properties, \c NO returns class properties.
- * 
- * @return A C array of pointers of type \c objc_property_t describing the properties declared by \e proto.
- *  Any properties declared by other protocols adopted by this protocol are not included. The array contains
- *  \c *outCount pointers followed by a \c NULL terminator. You must free the array with \c free().
- *  If the protocol declares no matching properties, \c NULL is returned and \c *outCount is \c 0.
- */
-OBJC_EXPORT objc_property_t _Nonnull * _Nullable
-protocol_copyPropertyList2(Protocol * _Nonnull proto,
-                           unsigned int * _Nullable outCount,
-                           BOOL isRequiredProperty, BOOL isInstanceProperty)
-    OBJC_AVAILABLE(10.12, 10.0, 10.0, 3.0, 2.0);
-
-/** 
- * Returns an array of the protocols adopted by a protocol.
- * 
- * @param proto A protocol.
- * @param outCount Upon return, contains the number of elements in the returned array.
- * 
- * @return A C array of protocols adopted by \e proto. The array contains \e *outCount pointers
- *  followed by a \c NULL terminator. You must free the array with \c free().
- *  If the protocol adopts no other protocols, \c NULL is returned and \c *outCount is \c 0.
- */
-OBJC_EXPORT Protocol * __unsafe_unretained _Nonnull * _Nullable
-protocol_copyProtocolList(Protocol * _Nonnull proto,
-                          unsigned int * _Nullable outCount)
-    OBJC_AVAILABLE(10.5, 2.0, 9.0, 1.0, 2.0);
-
-/** 
- * Creates a new protocol instance that cannot be used until registered with
- * \c objc_registerProtocol()
- * 
- * @param name The name of the protocol to create.
- *
- * @return The Protocol instance on success, \c nil if a protocol
- *  with the same name already exists. 
- * @note There is no dispose method for this. 
- */
-OBJC_EXPORT Protocol * _Nullable
-objc_allocateProtocol(const char * _Nonnull name) 
-    OBJC_AVAILABLE(10.7, 4.3, 9.0, 1.0, 2.0);
-
-/** 
- * Registers a newly constructed protocol with the runtime. The protocol
- * will be ready for use and is immutable after this.
- * 
- * @param proto The protocol you want to register.
- */
-OBJC_EXPORT void
-objc_registerProtocol(Protocol * _Nonnull proto) 
-    OBJC_AVAILABLE(10.7, 4.3, 9.0, 1.0, 2.0);
-
-/** 
- * Adds a method to a protocol. The protocol must be under construction.
- * 
- * @param proto The protocol to add a method to.
- * @param name The name of the method to add.
- * @param types A C string that represents the method signature.
- * @param isRequiredMethod YES if the method is not an optional method.
- * @param isInstanceMethod YES if the method is an instance method. 
- */
-OBJC_EXPORT void
-protocol_addMethodDescription(Protocol * _Nonnull proto, SEL _Nonnull name,
-                              const char * _Nullable types,
-                              BOOL isRequiredMethod, BOOL isInstanceMethod) 
-    OBJC_AVAILABLE(10.7, 4.3, 9.0, 1.0, 2.0);
-
-/** 
- * Adds an incorporated protocol to another protocol. The protocol being
- * added to must still be under construction, while the additional protocol
- * must be already constructed.
- * 
- * @param proto The protocol you want to add to, it must be under construction.
- * @param addition The protocol you want to incorporate into \e proto, it must be registered.
- */
-OBJC_EXPORT void
-protocol_addProtocol(Protocol * _Nonnull proto, Protocol * _Nonnull addition) 
-    OBJC_AVAILABLE(10.7, 4.3, 9.0, 1.0, 2.0);
-
-/** 
- * Adds a property to a protocol. The protocol must be under construction. 
- * 
- * @param proto The protocol to add a property to.
- * @param name The name of the property.
- * @param attributes An array of property attributes.
- * @param attributeCount The number of attributes in \e attributes.
- * @param isRequiredProperty YES if the property (accessor methods) is not optional. 
- * @param isInstanceProperty YES if the property (accessor methods) are instance methods. 
- *  This is the only case allowed fo a property, as a result, setting this to NO will 
- *  not add the property to the protocol at all. 
- */
-OBJC_EXPORT void
-protocol_addProperty(Protocol * _Nonnull proto, const char * _Nonnull name,
-                     const objc_property_attribute_t * _Nullable attributes,
-                     unsigned int attributeCount,
-                     BOOL isRequiredProperty, BOOL isInstanceProperty)
-    OBJC_AVAILABLE(10.7, 4.3, 9.0, 1.0, 2.0);
-
-
-/* Working with Libraries */
-
-/** 
- * Returns the names of all the loaded Objective-C frameworks and dynamic
- * libraries.
- * 
- * @param outCount The number of names returned.
- * 
- * @return An array of C strings of names. Must be free()'d by caller.
- */
-OBJC_EXPORT const char * _Nonnull * _Nonnull
-objc_copyImageNames(unsigned int * _Nullable outCount) 
-    OBJC_AVAILABLE(10.5, 2.0, 9.0, 1.0, 2.0);
-
-/** 
- * Returns the dynamic library name a class originated from.
- * 
- * @param cls The class you are inquiring about.
- * 
- * @return The name of the library containing this class.
- */
-OBJC_EXPORT const char * _Nullable
-class_getImageName(Class _Nullable cls) 
-    OBJC_AVAILABLE(10.5, 2.0, 9.0, 1.0, 2.0);
-
-/** 
- * Returns the names of all the classes within a library.
- * 
- * @param image The library or framework you are inquiring about.
- * @param outCount The number of class names returned.
- * 
- * @return An array of C strings representing the class names.
- */
-OBJC_EXPORT const char * _Nonnull * _Nullable
-objc_copyClassNamesForImage(const char * _Nonnull image,
-                            unsigned int * _Nullable outCount) 
-    OBJC_AVAILABLE(10.5, 2.0, 9.0, 1.0, 2.0);
-
-
-/* Working with Selectors */
-
-/** 
- * Returns the name of the method specified by a given selector.
- * 
- * @param sel A pointer of type \c SEL. Pass the selector whose name you wish to determine.
- * 
- * @return A C string indicating the name of the selector.
- */
-OBJC_EXPORT const char * _Nonnull
-sel_getName(SEL _Nonnull sel)
-    OBJC_AVAILABLE(10.0, 2.0, 9.0, 1.0, 2.0);
-
-
-/** 
- * Registers a method with the Objective-C runtime system, maps the method 
- * name to a selector, and returns the selector value.
- * 
- * @param str A pointer to a C string. Pass the name of the method you wish to register.
- * 
- * @return A pointer of type SEL specifying the selector for the named method.
- * 
- * @note You must register a method name with the Objective-C runtime system to obtain the
- *  method’s selector before you can add the method to a class definition. If the method name
- *  has already been registered, this function simply returns the selector.
- */
-OBJC_EXPORT SEL _Nonnull
-sel_registerName(const char * _Nonnull str)
-    OBJC_AVAILABLE(10.0, 2.0, 9.0, 1.0, 2.0);
-
-/** 
- * Returns a Boolean value that indicates whether two selectors are equal.
- * 
- * @param lhs The selector to compare with rhs.
- * @param rhs The selector to compare with lhs.
- * 
- * @return \c YES if \e lhs and \e rhs are equal, otherwise \c NO.
- * 
- * @note sel_isEqual is equivalent to ==.
- */
-OBJC_EXPORT BOOL
-sel_isEqual(SEL _Nonnull lhs, SEL _Nonnull rhs) 
-    OBJC_AVAILABLE(10.5, 2.0, 9.0, 1.0, 2.0);
-
-
-/* Objective-C Language Features */
-
-/** 
- * This function is inserted by the compiler when a mutation
- * is detected during a foreach iteration. It gets called 
- * when a mutation occurs, and the enumerationMutationHandler
- * is enacted if it is set up. A fatal error occurs if a handler is not set up.
- *
- * @param obj The object being mutated.
- * 
- */
-OBJC_EXPORT void
-objc_enumerationMutation(id _Nonnull obj) 
-    OBJC_AVAILABLE(10.5, 2.0, 9.0, 1.0, 2.0);
-
-/** 
- * Sets the current mutation handler. 
- * 
- * @param handler Function pointer to the new mutation handler.
- */
-OBJC_EXPORT void
-objc_setEnumerationMutationHandler(void (*_Nullable handler)(id _Nonnull )) 
-    OBJC_AVAILABLE(10.5, 2.0, 9.0, 1.0, 2.0);
-
-/** 
- * Set the function to be called by objc_msgForward.
- * 
- * @param fwd Function to be jumped to by objc_msgForward.
- * @param fwd_stret Function to be jumped to by objc_msgForward_stret.
- * 
- * @see message.h::_objc_msgForward
- */
-OBJC_EXPORT void
-objc_setForwardHandler(void * _Nonnull fwd, void * _Nonnull fwd_stret) 
-    OBJC_AVAILABLE(10.5, 2.0, 9.0, 1.0, 2.0);
-
-/** 
- * Creates a pointer to a function that will call the block
- * when the method is called.
- * 
- * @param block The block that implements this method. Its signature should
- *  be: method_return_type ^(id self, method_args...). 
- *  The selector is not available as a parameter to this block.
- *  The block is copied with \c Block_copy().
- * 
- * @return The IMP that calls this block. Must be disposed of with
- *  \c imp_removeBlock.
- */
-OBJC_EXPORT IMP _Nonnull
-imp_implementationWithBlock(id _Nonnull block)
-    OBJC_AVAILABLE(10.7, 4.3, 9.0, 1.0, 2.0);
-
-/** 
- * Return the block associated with an IMP that was created using
- * \c imp_implementationWithBlock.
- * 
- * @param anImp The IMP that calls this block.
- * 
- * @return The block called by \e anImp.
- */
-OBJC_EXPORT id _Nullable
-imp_getBlock(IMP _Nonnull anImp)
-    OBJC_AVAILABLE(10.7, 4.3, 9.0, 1.0, 2.0);
-
-/** 
- * Disassociates a block from an IMP that was created using
- * \c imp_implementationWithBlock and releases the copy of the 
- * block that was created.
- * 
- * @param anImp An IMP that was created using \c imp_implementationWithBlock.
- * 
- * @return YES if the block was released successfully, NO otherwise. 
- *  (For example, the block might not have been used to create an IMP previously).
- */
-OBJC_EXPORT BOOL
-imp_removeBlock(IMP _Nonnull anImp)
-    OBJC_AVAILABLE(10.7, 4.3, 9.0, 1.0, 2.0);
-
-/** 
- * This loads the object referenced by a weak pointer and returns it, after
- * retaining and autoreleasing the object to ensure that it stays alive
- * long enough for the caller to use it. This function would be used
- * anywhere a __weak variable is used in an expression.
- * 
- * @param location The weak pointer address
- * 
- * @return The object pointed to by \e location, or \c nil if \e *location is \c nil.
- */
-OBJC_EXPORT id _Nullable
-objc_loadWeak(id _Nullable * _Nonnull location)
-    OBJC_AVAILABLE(10.7, 5.0, 9.0, 1.0, 2.0);
-
-/** 
- * This function stores a new value into a __weak variable. It would
- * be used anywhere a __weak variable is the target of an assignment.
- * 
- * @param location The address of the weak pointer itself
- * @param obj The new object this weak ptr should now point to
- * 
- * @return The value stored into \e location, i.e. \e obj
- */
-OBJC_EXPORT id _Nullable
-objc_storeWeak(id _Nullable * _Nonnull location, id _Nullable obj) 
-    OBJC_AVAILABLE(10.7, 5.0, 9.0, 1.0, 2.0);
-
-
-/* Associative References */
-
-/**
- * Policies related to associative references.
- * These are options to objc_setAssociatedObject()
- */
-typedef OBJC_ENUM(uintptr_t, objc_AssociationPolicy) {
-    OBJC_ASSOCIATION_ASSIGN = 0,           /**< Specifies a weak reference to the associated object. */
-    OBJC_ASSOCIATION_RETAIN_NONATOMIC = 1, /**< Specifies a strong reference to the associated object. 
-                                            *   The association is not made atomically. */
-    OBJC_ASSOCIATION_COPY_NONATOMIC = 3,   /**< Specifies that the associated object is copied. 
-                                            *   The association is not made atomically. */
-    OBJC_ASSOCIATION_RETAIN = 01401,       /**< Specifies a strong reference to the associated object.
-                                            *   The association is made atomically. */
-    OBJC_ASSOCIATION_COPY = 01403          /**< Specifies that the associated object is copied.
-                                            *   The association is made atomically. */
-};
-
-/** 
- * Sets an associated value for a given object using a given key and association policy.
- * 
- * @param object The source object for the association.
- * @param key The key for the association.
- * @param value The value to associate with the key key for object. Pass nil to clear an existing association.
- * @param policy The policy for the association. For possible values, see “Associative Object Behaviors.”
- * 
- * @see objc_setAssociatedObject
- * @see objc_removeAssociatedObjects
- */
-OBJC_EXPORT void
-objc_setAssociatedObject(id _Nonnull object, const void * _Nonnull key,
-                         id _Nullable value, objc_AssociationPolicy policy)
-    OBJC_AVAILABLE(10.6, 3.1, 9.0, 1.0, 2.0);
-
-/** 
- * Returns the value associated with a given object for a given key.
- * 
- * @param object The source object for the association.
- * @param key The key for the association.
- * 
- * @return The value associated with the key \e key for \e object.
- * 
- * @see objc_setAssociatedObject
- */
-OBJC_EXPORT id _Nullable
-objc_getAssociatedObject(id _Nonnull object, const void * _Nonnull key)
-    OBJC_AVAILABLE(10.6, 3.1, 9.0, 1.0, 2.0);
-
-/** 
- * Removes all associations for a given object.
- * 
- * @param object An object that maintains associated objects.
- * 
- * @note The main purpose of this function is to make it easy to return an object 
- *  to a "pristine state”. You should not use this function for general removal of
- *  associations from objects, since it also removes associations that other clients
- *  may have added to the object. Typically you should use \c objc_setAssociatedObject 
- *  with a nil value to clear an association.
- * 
- * @see objc_setAssociatedObject
- * @see objc_getAssociatedObject
- */
-OBJC_EXPORT void
-objc_removeAssociatedObjects(id _Nonnull object)
-    OBJC_AVAILABLE(10.6, 3.1, 9.0, 1.0, 2.0);
-
-
-/* Hooks for Swift */
-
-/**
- * Function type for a hook that intercepts class_getImageName().
- *
- * @param cls The class whose image name is being looked up.
- * @param outImageName On return, the result of the image name lookup.
- * @return YES if an image name for this class was found, NO otherwise.
- *
- * @see class_getImageName
- * @see objc_setHook_getImageName
- */
-typedef BOOL (*objc_hook_getImageName)(Class _Nonnull cls, const char * _Nullable * _Nonnull outImageName);
-
-/**
- * Install a hook for class_getImageName().
- *
- * @param newValue The hook function to install.
- * @param outOldValue The address of a function pointer variable. On return,
- *  the old hook function is stored in the variable.
- *
- * @note The store to *outOldValue is thread-safe: the variable will be
- *  updated before class_getImageName() calls your new hook to read it,
- *  even if your new hook is called from another thread before this
- *  setter completes.
- * @note The first hook in the chain is the native implementation of
- *  class_getImageName(). Your hook should call the previous hook for
- *  classes that you do not recognize.
- *
- * @see class_getImageName
- * @see objc_hook_getImageName
- */
-OBJC_EXPORT void objc_setHook_getImageName(objc_hook_getImageName _Nonnull newValue,
-                                           objc_hook_getImageName _Nullable * _Nonnull outOldValue)
-    OBJC_AVAILABLE(10.14, 12.0, 12.0, 5.0, 3.0);
-
-/**
- * Function type for a hook that assists objc_getClass() and related functions.
- *
- * @param name The class name to look up.
- * @param outClass On return, the result of the class lookup.
- * @return YES if a class with this name was found, NO otherwise.
- *
- * @see objc_getClass
- * @see objc_setHook_getClass
- */
-typedef BOOL (*objc_hook_getClass)(const char * _Nonnull name, Class _Nullable * _Nonnull outClass);
-
-/**
- * Install a hook for objc_getClass() and related functions.
- *
- * @param newValue The hook function to install.
- * @param outOldValue The address of a function pointer variable. On return,
- *  the old hook function is stored in the variable.
- *
- * @note The store to *outOldValue is thread-safe: the variable will be
- *  updated before objc_getClass() calls your new hook to read it,
- *  even if your new hook is called from another thread before this
- *  setter completes.
- * @note Your hook should call the previous hook for class names
- *  that you do not recognize.
- *
- * @see objc_getClass
- * @see objc_hook_getClass
- */
-#if !(TARGET_OS_OSX && __i386__)
-#define OBJC_GETCLASSHOOK_DEFINED 1
-OBJC_EXPORT void objc_setHook_getClass(objc_hook_getClass _Nonnull newValue,
-                                       objc_hook_getClass _Nullable * _Nonnull outOldValue)
-    OBJC_AVAILABLE(10.14.4, 12.2, 12.2, 5.2, 3.2);
-#endif
-
-/**
- * Function type for a hook that assists objc_setAssociatedObject().
- *
- * @param object The source object for the association.
- * @param key The key for the association.
- * @param value The value to associate with the key key for object. Pass nil to clear an existing association.
- * @param policy The policy for the association. For possible values, see “Associative Object Behaviors.”
- *
- * @see objc_setAssociatedObject
- * @see objc_setHook_setAssociatedObject
- */
-typedef void (*objc_hook_setAssociatedObject)(id _Nonnull object, const void * _Nonnull key,
-                                              id _Nullable value, objc_AssociationPolicy policy);
-
-/**
- * Install a hook for objc_setAssociatedObject().
- *
- * @param newValue The hook function to install.
- * @param outOldValue The address of a function pointer variable. On return,
- *  the old hook function is stored in the variable.
- *
- * @note The store to *outOldValue is thread-safe: the variable will be
- *  updated before objc_setAssociatedObject() calls your new hook to read it,
- *  even if your new hook is called from another thread before this
- *  setter completes.
- * @note Your hook should always call the previous hook.
- *
- * @see objc_setAssociatedObject
- * @see objc_hook_setAssociatedObject
- */
-#if !(TARGET_OS_OSX && __i386__)
-#define OBJC_SETASSOCIATEDOBJECTHOOK_DEFINED 1
-OBJC_EXPORT void objc_setHook_setAssociatedObject(objc_hook_setAssociatedObject _Nonnull newValue,
-                                       objc_hook_setAssociatedObject _Nullable * _Nonnull outOldValue)
-    OBJC_AVAILABLE(10.15, 13.0, 13.0, 6.0, 4.0);
-#endif
-
-/**
- * Function type for a function that is called when an image is loaded.
- *
- * @param header The newly loaded header.
- */
-struct mach_header;
-typedef void (*objc_func_loadImage)(const struct mach_header * _Nonnull header);
-
-/**
- * Add a function to be called when a new image is loaded. The function is
- * called after ObjC has scanned and fixed up the image. It is called
- * BEFORE +load methods are invoked.
- *
- * When adding a new function, that function is immediately called with all
- * images that are currently loaded. It is then called as needed for images
- * that are loaded afterwards.
- *
- * Note: the function is called with ObjC's internal runtime lock held.
- * Be VERY careful with what the function does to avoid deadlocks or
- * poor performance.
- *
- * @param func The function to add.
- */
-#define OBJC_ADDLOADIMAGEFUNC_DEFINED 1
-OBJC_EXPORT void objc_addLoadImageFunc(objc_func_loadImage _Nonnull func)
-    OBJC_AVAILABLE(10.15, 13.0, 13.0, 6.0, 4.0);
-
-/** 
- * Callback from Objective-C to Swift to perform Swift class initialization.
- */
-#if !(TARGET_OS_OSX && __i386__)
-typedef Class _Nullable
-(*_objc_swiftMetadataInitializer)(Class _Nonnull cls, void * _Nullable arg);
-#endif
-
-
-/** 
- * Perform Objective-C initialization of a Swift class.
- * Do not call this function. It is provided for the Swift runtime's use only 
- * and will change without notice or mercy.
- */
-#if !(TARGET_OS_OSX && __i386__)
-#define OBJC_REALIZECLASSFROMSWIFT_DEFINED 1
-OBJC_EXPORT Class _Nullable
-_objc_realizeClassFromSwift(Class _Nullable cls, void * _Nullable previously)
-    OBJC_AVAILABLE(10.14.4, 12.2, 12.2, 5.2, 3.2);
-#endif
-
-
-#define _C_ID       '@'
-#define _C_CLASS    '#'
-#define _C_SEL      ':'
-#define _C_CHR      'c'
-#define _C_UCHR     'C'
-#define _C_SHT      's'
-#define _C_USHT     'S'
-#define _C_INT      'i'
-#define _C_UINT     'I'
-#define _C_LNG      'l'
-#define _C_ULNG     'L'
-#define _C_LNG_LNG  'q'
-#define _C_ULNG_LNG 'Q'
-#define _C_FLT      'f'
-#define _C_DBL      'd'
-#define _C_BFLD     'b'
-#define _C_BOOL     'B'
-#define _C_VOID     'v'
-#define _C_UNDEF    '?'
-#define _C_PTR      '^'
-#define _C_CHARPTR  '*'
-#define _C_ATOM     '%'
-#define _C_ARY_B    '['
-#define _C_ARY_E    ']'
-#define _C_UNION_B  '('
-#define _C_UNION_E  ')'
-#define _C_STRUCT_B '{'
-#define _C_STRUCT_E '}'
-#define _C_VECTOR   '!'
-#define _C_CONST    'r'
-
-
-/* Obsolete types */
-
-#if !__OBJC2__
-
-#define CLS_GETINFO(cls,infomask)        ((cls)->info & (infomask))
-#define CLS_SETINFO(cls,infomask)        ((cls)->info |= (infomask))
-
-// class is not a metaclass
-#define CLS_CLASS               0x1
-// class is a metaclass
-#define CLS_META                0x2
-// class's +initialize method has completed
-#define CLS_INITIALIZED         0x4
-// class is posing
-#define CLS_POSING              0x8
-// unused
-#define CLS_MAPPED              0x10
-// class and subclasses need cache flush during image loading
-#define CLS_FLUSH_CACHE         0x20
-// method cache should grow when full
-#define CLS_GROW_CACHE          0x40
-// unused
-#define CLS_NEED_BIND           0x80
-// methodLists is array of method lists
-#define CLS_METHOD_ARRAY        0x100
-// the JavaBridge constructs classes with these markers
-#define CLS_JAVA_HYBRID         0x200
-#define CLS_JAVA_CLASS          0x400
-// thread-safe +initialize
-#define CLS_INITIALIZING        0x800
-// bundle unloading
-#define CLS_FROM_BUNDLE         0x1000
-// C++ ivar support
-#define CLS_HAS_CXX_STRUCTORS   0x2000
-// Lazy method list arrays
-#define CLS_NO_METHOD_ARRAY     0x4000
-// +load implementation
-#define CLS_HAS_LOAD_METHOD     0x8000
-// objc_allocateClassPair API
-#define CLS_CONSTRUCTING        0x10000
-// class compiled with bigger class structure
-#define CLS_EXT                 0x20000
-
-
-struct objc_method_description_list {
-    int count;
-    struct objc_method_description list[1];
-};
-
-
-struct objc_protocol_list {
-    struct objc_protocol_list * _Nullable next;
-    long count;
-    __unsafe_unretained Protocol * _Nullable list[1];
-};
-
-
-struct objc_category {
-    char * _Nonnull category_name                            OBJC2_UNAVAILABLE;
-    char * _Nonnull class_name                               OBJC2_UNAVAILABLE;
-    struct objc_method_list * _Nullable instance_methods     OBJC2_UNAVAILABLE;
-    struct objc_method_list * _Nullable class_methods        OBJC2_UNAVAILABLE;
-    struct objc_protocol_list * _Nullable protocols          OBJC2_UNAVAILABLE;
-}                                                            OBJC2_UNAVAILABLE;
-
-
-struct objc_ivar {
-    char * _Nullable ivar_name                               OBJC2_UNAVAILABLE;
-    char * _Nullable ivar_type                               OBJC2_UNAVAILABLE;
-    int ivar_offset                                          OBJC2_UNAVAILABLE;
-#ifdef __LP64__
-    int space                                                OBJC2_UNAVAILABLE;
-#endif
-}                                                            OBJC2_UNAVAILABLE;
-
-struct objc_ivar_list {
-    int ivar_count                                           OBJC2_UNAVAILABLE;
-#ifdef __LP64__
-    int space                                                OBJC2_UNAVAILABLE;
-#endif
-    /* variable length structure */
-    struct objc_ivar ivar_list[1]                            OBJC2_UNAVAILABLE;
-}                                                            OBJC2_UNAVAILABLE;
-
-
-struct objc_method {
-    SEL _Nonnull method_name                                 OBJC2_UNAVAILABLE;
-    char * _Nullable method_types                            OBJC2_UNAVAILABLE;
-    IMP _Nonnull method_imp                                  OBJC2_UNAVAILABLE;
-}                                                            OBJC2_UNAVAILABLE;
-
-struct objc_method_list {
-    struct objc_method_list * _Nullable obsolete             OBJC2_UNAVAILABLE;
-
-    int method_count                                         OBJC2_UNAVAILABLE;
-#ifdef __LP64__
-    int space                                                OBJC2_UNAVAILABLE;
-#endif
-    /* variable length structure */
-    struct objc_method method_list[1]                        OBJC2_UNAVAILABLE;
-}                                                            OBJC2_UNAVAILABLE;
-
-
-typedef struct objc_symtab *Symtab                           OBJC2_UNAVAILABLE;
-
-struct objc_symtab {
-    unsigned long sel_ref_cnt                                OBJC2_UNAVAILABLE;
-    SEL _Nonnull * _Nullable refs                            OBJC2_UNAVAILABLE;
-    unsigned short cls_def_cnt                               OBJC2_UNAVAILABLE;
-    unsigned short cat_def_cnt                               OBJC2_UNAVAILABLE;
-    void * _Nullable defs[1] /* variable size */             OBJC2_UNAVAILABLE;
-}                                                            OBJC2_UNAVAILABLE;
-
-
-typedef struct objc_cache *Cache                             OBJC2_UNAVAILABLE;
-
-#define CACHE_BUCKET_NAME(B)  ((B)->method_name)
-#define CACHE_BUCKET_IMP(B)   ((B)->method_imp)
-#define CACHE_BUCKET_VALID(B) (B)
-#ifndef __LP64__
-#define CACHE_HASH(sel, mask) (((uintptr_t)(sel)>>2) & (mask))
-#else
-#define CACHE_HASH(sel, mask) (((unsigned int)((uintptr_t)(sel)>>3)) & (mask))
-#endif
-struct objc_cache {
-    unsigned int mask /* total = mask + 1 */                 OBJC2_UNAVAILABLE;
-    unsigned int occupied                                    OBJC2_UNAVAILABLE;
-    Method _Nullable buckets[1]                              OBJC2_UNAVAILABLE;
-};
-
-
-typedef struct objc_module *Module                           OBJC2_UNAVAILABLE;
-
-struct objc_module {
-    unsigned long version                                    OBJC2_UNAVAILABLE;
-    unsigned long size                                       OBJC2_UNAVAILABLE;
-    const char * _Nullable name                              OBJC2_UNAVAILABLE;
-    Symtab _Nullable symtab                                  OBJC2_UNAVAILABLE;
-}                                                            OBJC2_UNAVAILABLE;
-
-#else
-
-struct objc_method_list;
-
-#endif
-
-
-/* Obsolete functions */
-
-OBJC_EXPORT IMP _Nullable
-class_lookupMethod(Class _Nullable cls, SEL _Nonnull sel) 
-    __OSX_DEPRECATED(10.0, 10.5, "use class_getMethodImplementation instead")
-    __IOS_DEPRECATED(2.0, 2.0, "use class_getMethodImplementation instead")
-    __TVOS_DEPRECATED(9.0, 9.0, "use class_getMethodImplementation instead")
-    __WATCHOS_DEPRECATED(1.0, 1.0, "use class_getMethodImplementation instead")
-
-;
-OBJC_EXPORT BOOL
-class_respondsToMethod(Class _Nullable cls, SEL _Nonnull sel)
-    __OSX_DEPRECATED(10.0, 10.5, "use class_respondsToSelector instead")
-    __IOS_DEPRECATED(2.0, 2.0, "use class_respondsToSelector instead")
-    __TVOS_DEPRECATED(9.0, 9.0, "use class_respondsToSelector instead")
-    __WATCHOS_DEPRECATED(1.0, 1.0, "use class_respondsToSelector instead")
-
-;
-
-OBJC_EXPORT void
-_objc_flush_caches(Class _Nullable cls) 
-    __OSX_DEPRECATED(10.0, 10.5, "not recommended")
-    __IOS_DEPRECATED(2.0, 2.0, "not recommended")
-    __TVOS_DEPRECATED(9.0, 9.0, "not recommended")
-    __WATCHOS_DEPRECATED(1.0, 1.0, "not recommended")
-
-;
-
-OBJC_EXPORT id _Nullable
-object_copyFromZone(id _Nullable anObject, size_t nBytes, void * _Nullable z) 
-    OBJC_OSX_DEPRECATED_OTHERS_UNAVAILABLE(10.0, 10.5, "use object_copy instead");
-
-OBJC_EXPORT id _Nullable
-object_realloc(id _Nullable anObject, size_t nBytes)
-    OBJC2_UNAVAILABLE;
-
-OBJC_EXPORT id _Nullable
-object_reallocFromZone(id _Nullable anObject, size_t nBytes, void * _Nullable z)
-    OBJC2_UNAVAILABLE;
-
-#define OBSOLETE_OBJC_GETCLASSES 1
-OBJC_EXPORT void * _Nonnull
-objc_getClasses(void)
-    OBJC2_UNAVAILABLE;
-
-OBJC_EXPORT void
-objc_addClass(Class _Nonnull myClass)
-    OBJC2_UNAVAILABLE;
-
-OBJC_EXPORT void
-objc_setClassHandler(int (* _Nullable )(const char * _Nonnull))
-    OBJC2_UNAVAILABLE;
-
-OBJC_EXPORT void
-objc_setMultithreaded(BOOL flag)
-    OBJC2_UNAVAILABLE;
-
-OBJC_EXPORT id _Nullable
-class_createInstanceFromZone(Class _Nullable, size_t idxIvars,
-                             void * _Nullable z)
-    OBJC_OSX_DEPRECATED_OTHERS_UNAVAILABLE(10.0, 10.5, "use class_createInstance instead");
-
-OBJC_EXPORT void
-class_addMethods(Class _Nullable, struct objc_method_list * _Nonnull)
-    OBJC2_UNAVAILABLE;
-
-OBJC_EXPORT void
-class_removeMethods(Class _Nullable, struct objc_method_list * _Nonnull)
-    OBJC2_UNAVAILABLE;
-
-OBJC_EXPORT void
-_objc_resolve_categories_for_class(Class _Nonnull cls)
-    OBJC2_UNAVAILABLE;
-
-OBJC_EXPORT Class _Nonnull
-class_poseAs(Class _Nonnull imposter, Class _Nonnull original)
-    OBJC2_UNAVAILABLE;
-
-OBJC_EXPORT unsigned int
-method_getSizeOfArguments(Method _Nonnull m)
-    OBJC2_UNAVAILABLE;
-
-OBJC_EXPORT unsigned
-method_getArgumentInfo(struct objc_method * _Nonnull m, int arg,
-                       const char * _Nullable * _Nonnull type,
-                       int * _Nonnull offset)
-    UNAVAILABLE_ATTRIBUTE  // This function was accidentally deleted in 10.9.
-    OBJC2_UNAVAILABLE;
-
-OBJC_EXPORT Class _Nullable
-objc_getOrigClass(const char * _Nonnull name)
-    OBJC2_UNAVAILABLE;
-
-#define OBJC_NEXT_METHOD_LIST 1
-OBJC_EXPORT struct objc_method_list * _Nullable
-class_nextMethodList(Class _Nullable, void * _Nullable * _Nullable)
-    OBJC2_UNAVAILABLE;
-// usage for nextMethodList
-//
-// void *iterator = 0;
-// struct objc_method_list *mlist;
-// while ( mlist = class_nextMethodList( cls, &iterator ) )
-//    ;
- 
-OBJC_EXPORT id _Nullable
-(* _Nonnull _alloc)(Class _Nullable, size_t)
-    OBJC2_UNAVAILABLE;
-
-OBJC_EXPORT id _Nullable
-(* _Nonnull _copy)(id _Nullable, size_t)
-     OBJC2_UNAVAILABLE;
-     
-OBJC_EXPORT id _Nullable
-(* _Nonnull _realloc)(id _Nullable, size_t)
-     OBJC2_UNAVAILABLE;
-
-OBJC_EXPORT id _Nullable
-(* _Nonnull _dealloc)(id _Nullable)
-     OBJC2_UNAVAILABLE;
-     
-OBJC_EXPORT id _Nullable
-(* _Nonnull _zoneAlloc)(Class _Nullable, size_t, void * _Nullable)
-     OBJC2_UNAVAILABLE;
-     
-OBJC_EXPORT id _Nullable
-(* _Nonnull _zoneRealloc)(id _Nullable, size_t, void * _Nullable)
-     OBJC2_UNAVAILABLE;
-     
-OBJC_EXPORT id _Nullable
-(* _Nonnull _zoneCopy)(id _Nullable, size_t, void * _Nullable)
-     OBJC2_UNAVAILABLE;
-     
-OBJC_EXPORT void
-(* _Nonnull _error)(id _Nullable, const char * _Nonnull, va_list)
-     OBJC2_UNAVAILABLE;
-
-#endif
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/os/base.h b/lib/libc/include/x86_64-macos-gnu/os/base.h
deleted file mode 100644
index a57f8373a4..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/os/base.h
+++ /dev/null
@@ -1,325 +0,0 @@
-/*
- * Copyright (c) 2008-2013 Apple Inc. All rights reserved.
- *
- * @APPLE_APACHE_LICENSE_HEADER_START@
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @APPLE_APACHE_LICENSE_HEADER_END@
- */
-
-#ifndef __OS_BASE__
-#define __OS_BASE__
-
-#include <sys/cdefs.h>
-
-#ifndef __has_builtin
-#define __has_builtin(x) 0
-#endif
-#ifndef __has_include
-#define __has_include(x) 0
-#endif
-#ifndef __has_feature
-#define __has_feature(x) 0
-#endif
-#ifndef __has_attribute
-#define __has_attribute(x) 0
-#endif
-#ifndef __has_extension
-#define __has_extension(x) 0
-#endif
-
-#undef OS_INLINE // <sys/_types/_os_inline.h>
-#if __GNUC__
-#define OS_NORETURN __attribute__((__noreturn__))
-#define OS_NOTHROW __attribute__((__nothrow__))
-#define OS_NONNULL1 __attribute__((__nonnull__(1)))
-#define OS_NONNULL2 __attribute__((__nonnull__(2)))
-#define OS_NONNULL3 __attribute__((__nonnull__(3)))
-#define OS_NONNULL4 __attribute__((__nonnull__(4)))
-#define OS_NONNULL5 __attribute__((__nonnull__(5)))
-#define OS_NONNULL6 __attribute__((__nonnull__(6)))
-#define OS_NONNULL7 __attribute__((__nonnull__(7)))
-#define OS_NONNULL8 __attribute__((__nonnull__(8)))
-#define OS_NONNULL9 __attribute__((__nonnull__(9)))
-#define OS_NONNULL10 __attribute__((__nonnull__(10)))
-#define OS_NONNULL11 __attribute__((__nonnull__(11)))
-#define OS_NONNULL12 __attribute__((__nonnull__(12)))
-#define OS_NONNULL13 __attribute__((__nonnull__(13)))
-#define OS_NONNULL14 __attribute__((__nonnull__(14)))
-#define OS_NONNULL15 __attribute__((__nonnull__(15)))
-#define OS_NONNULL_ALL __attribute__((__nonnull__))
-#define OS_SENTINEL __attribute__((__sentinel__))
-#define OS_PURE __attribute__((__pure__))
-#define OS_CONST __attribute__((__const__))
-#define OS_WARN_RESULT __attribute__((__warn_unused_result__))
-#define OS_MALLOC __attribute__((__malloc__))
-#define OS_USED __attribute__((__used__))
-#define OS_UNUSED __attribute__((__unused__))
-#define OS_COLD __attribute__((__cold__))
-#define OS_WEAK __attribute__((__weak__))
-#define OS_WEAK_IMPORT __attribute__((__weak_import__))
-#define OS_NOINLINE __attribute__((__noinline__))
-#define OS_ALWAYS_INLINE __attribute__((__always_inline__))
-#define OS_TRANSPARENT_UNION __attribute__((__transparent_union__))
-#define OS_ALIGNED(n) __attribute__((__aligned__((n))))
-#define OS_FORMAT_PRINTF(x,y) __attribute__((__format__(printf,x,y)))
-#define OS_EXPORT extern __attribute__((__visibility__("default")))
-#define OS_INLINE static __inline__
-#define OS_EXPECT(x, v) __builtin_expect((x), (v))
-#else
-#define OS_NORETURN
-#define OS_NOTHROW
-#define OS_NONNULL1
-#define OS_NONNULL2
-#define OS_NONNULL3
-#define OS_NONNULL4
-#define OS_NONNULL5
-#define OS_NONNULL6
-#define OS_NONNULL7
-#define OS_NONNULL8
-#define OS_NONNULL9
-#define OS_NONNULL10
-#define OS_NONNULL11
-#define OS_NONNULL12
-#define OS_NONNULL13
-#define OS_NONNULL14
-#define OS_NONNULL15
-#define OS_NONNULL_ALL
-#define OS_SENTINEL
-#define OS_PURE
-#define OS_CONST
-#define OS_WARN_RESULT
-#define OS_MALLOC
-#define OS_USED
-#define OS_UNUSED
-#define OS_COLD
-#define OS_WEAK
-#define OS_WEAK_IMPORT
-#define OS_NOINLINE
-#define OS_ALWAYS_INLINE
-#define OS_TRANSPARENT_UNION
-#define OS_ALIGNED(n)
-#define OS_FORMAT_PRINTF(x,y)
-#define OS_EXPORT extern
-#define OS_INLINE static inline
-#define OS_EXPECT(x, v) (x)
-#endif
-
-#if __has_attribute(noescape)
-#define OS_NOESCAPE __attribute__((__noescape__))
-#else
-#define OS_NOESCAPE
-#endif
-
-#if defined(__cplusplus) && defined(__clang__)
-#define OS_FALLTHROUGH [[clang::fallthrough]]
-#else
-#define OS_FALLTHROUGH
-#endif
-
-#if __has_feature(assume_nonnull)
-#define OS_ASSUME_NONNULL_BEGIN _Pragma("clang assume_nonnull begin")
-#define OS_ASSUME_NONNULL_END   _Pragma("clang assume_nonnull end")
-#else
-#define OS_ASSUME_NONNULL_BEGIN
-#define OS_ASSUME_NONNULL_END
-#endif
-
-#if __has_builtin(__builtin_assume)
-#define OS_COMPILER_CAN_ASSUME(expr) __builtin_assume(expr)
-#else
-#define OS_COMPILER_CAN_ASSUME(expr) ((void)(expr))
-#endif
-
-#if __has_extension(attribute_overloadable)
-#define OS_OVERLOADABLE __attribute__((__overloadable__))
-#else
-#define OS_OVERLOADABLE
-#endif
-
-#if __has_attribute(enum_extensibility)
-#define __OS_ENUM_ATTR __attribute__((enum_extensibility(open)))
-#define __OS_ENUM_ATTR_CLOSED __attribute__((enum_extensibility(closed)))
-#else
-#define __OS_ENUM_ATTR
-#define __OS_ENUM_ATTR_CLOSED
-#endif // __has_attribute(enum_extensibility)
-
-#if __has_attribute(flag_enum)
-/*!
- * Compile with -Wflag-enum and -Wassign-enum to enforce at definition and
- * assignment, respectively, i.e. -Wflag-enum prevents you from creating new
- * enumeration values from illegal values within the enum definition, and
- * -Wassign-enum prevents you from assigning illegal values to a variable of the
- * enum type.
- */
-#ifndef __OPEN_SOURCE__
-/*!
- * @internal
- * <rdar://problem/37799789>
- */
-#endif // __OPEN_SOURCE__
-#define __OS_OPTIONS_ATTR __attribute__((flag_enum))
-#else
-#define __OS_OPTIONS_ATTR
-#endif // __has_attribute(flag_enum)
-
-#if __has_feature(objc_fixed_enum) || __has_extension(cxx_fixed_enum) || \
-		__has_extension(cxx_strong_enums)
-#define OS_ENUM(_name, _type, ...) \
-		typedef enum : _type { __VA_ARGS__ } _name##_t
-#define OS_CLOSED_ENUM(_name, _type, ...) \
-		typedef enum : _type { __VA_ARGS__ } \
-			__OS_ENUM_ATTR_CLOSED _name##_t
-#define OS_OPTIONS(_name, _type, ...) \
-		typedef enum : _type { __VA_ARGS__ } \
-			__OS_ENUM_ATTR __OS_OPTIONS_ATTR _name##_t
-#define OS_CLOSED_OPTIONS(_name, _type, ...) \
-		typedef enum : _type { __VA_ARGS__ } \
-			__OS_ENUM_ATTR_CLOSED __OS_OPTIONS_ATTR _name##_t
-#else
-/*!
- * There is unfortunately no good way in plain C to have both fixed-type enums
- * and enforcement for clang's enum_extensibility extensions. The primary goal
- * of these macros is to allow you to define an enum and specify its width in a
- * single statement, and for plain C that is accomplished by defining an
- * anonymous enum and then separately typedef'ing the requested type name to the
- * requested underlying integer type. So the type emitted actually has no
- * relationship at all to the enum, and therefore while the compiler could
- * enforce enum extensibility if you used the enum type, it cannot do so if you
- * use the "_t" type resulting from this expression.
- *
- * But we still define a named enum type and decorate it appropriately for you,
- * so if you really want the enum extensibility enforcement, you can use the
- * enum type yourself, i.e. when compiling with a C compiler:
- *
- *     OS_CLOSED_ENUM(my_type, uint64_t,
- *         FOO,
- *         BAR,
- *         BAZ,
- *     );
- *
- *     my_type_t mt = 98; // legal
- *     enum my_type emt = 98; // illegal
- *
- * But be aware that the underlying enum type's width is subject only to the C
- * language's guarantees -- namely that it will be compatible with int, char,
- * and unsigned char. It is not safe to rely on the size of this type.
- *
- * When compiling in ObjC or C++, both of the above assignments are illegal.
- */
-#define __OS_ENUM_C_FALLBACK(_name, _type, ...) \
-		typedef _type _name##_t; enum _name { __VA_ARGS__ }
-
-#define OS_ENUM(_name, _type, ...) \
-		typedef _type _name##_t; enum { __VA_ARGS__ }
-#define OS_CLOSED_ENUM(_name, _type, ...) \
-		__OS_ENUM_C_FALLBACK(_name, _type, ## __VA_ARGS__) \
-		__OS_ENUM_ATTR_CLOSED
-#define OS_OPTIONS(_name, _type, ...) \
-		__OS_ENUM_C_FALLBACK(_name, _type, ## __VA_ARGS__) \
-		__OS_ENUM_ATTR __OS_OPTIONS_ATTR
-#define OS_CLOSED_OPTIONS(_name, _type, ...) \
-		__OS_ENUM_C_FALLBACK(_name, _type, ## __VA_ARGS__) \
-		__OS_ENUM_ATTR_CLOSED __OS_OPTIONS_ATTR
-#endif // __has_feature(objc_fixed_enum) || __has_extension(cxx_strong_enums)
-
-#if __has_feature(attribute_availability_swift)
-// equivalent to __SWIFT_UNAVAILABLE from Availability.h
-#define OS_SWIFT_UNAVAILABLE(_msg) \
-		__attribute__((__availability__(swift, unavailable, message=_msg)))
-#else
-#define OS_SWIFT_UNAVAILABLE(_msg)
-#endif
-
-#if __has_attribute(swift_private)
-# define OS_REFINED_FOR_SWIFT __attribute__((__swift_private__))
-#else
-# define OS_REFINED_FOR_SWIFT
-#endif
-
-#if __has_attribute(swift_name)
-# define OS_SWIFT_NAME(_name) __attribute__((__swift_name__(#_name)))
-#else
-# define OS_SWIFT_NAME(_name)
-#endif
-
-#define __OS_STRINGIFY(s) #s
-#define OS_STRINGIFY(s) __OS_STRINGIFY(s)
-#define __OS_CONCAT(x, y) x ## y
-#define OS_CONCAT(x, y) __OS_CONCAT(x, y)
-
-#ifdef __GNUC__
-#define os_prevent_tail_call_optimization()  __asm__("")
-#define os_is_compile_time_constant(expr)  __builtin_constant_p(expr)
-#define os_compiler_barrier()  __asm__ __volatile__("" ::: "memory")
-#else
-#define os_prevent_tail_call_optimization()  do { } while (0)
-#define os_is_compile_time_constant(expr)  0
-#define os_compiler_barrier()  do { } while (0)
-#endif
-
-#if __has_attribute(not_tail_called)
-#define OS_NOT_TAIL_CALLED __attribute__((__not_tail_called__))
-#else
-#define OS_NOT_TAIL_CALLED
-#endif
-
-typedef void (*os_function_t)(void *_Nullable);
-
-#ifdef __BLOCKS__
-/*!
- * @typedef os_block_t
- *
- * @abstract
- * Generic type for a block taking no arguments and returning no value.
- *
- * @discussion
- * When not building with Objective-C ARC, a block object allocated on or
- * copied to the heap must be released with a -[release] message or the
- * Block_release() function.
- *
- * The declaration of a block literal allocates storage on the stack.
- * Therefore, this is an invalid construct:
- * <code>
- * os_block_t block;
- * if (x) {
- *     block = ^{ printf("true\n"); };
- * } else {
- *     block = ^{ printf("false\n"); };
- * }
- * block(); // unsafe!!!
- * </code>
- *
- * What is happening behind the scenes:
- * <code>
- * if (x) {
- *     struct Block __tmp_1 = ...; // setup details
- *     block = &__tmp_1;
- * } else {
- *     struct Block __tmp_2 = ...; // setup details
- *     block = &__tmp_2;
- * }
- * </code>
- *
- * As the example demonstrates, the address of a stack variable is escaping the
- * scope in which it is allocated. That is a classic C bug.
- *
- * Instead, the block literal must be copied to the heap with the Block_copy()
- * function or by sending it a -[copy] message.
- */
-typedef void (^os_block_t)(void);
-#endif
-
-#endif // __OS_BASE__
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/os/clock.h b/lib/libc/include/x86_64-macos-gnu/os/clock.h
deleted file mode 100644
index 665e1d8716..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/os/clock.h
+++ /dev/null
@@ -1,18 +0,0 @@
-#ifndef __OS_CLOCK__
-#define __OS_CLOCK__
-
-#include <os/base.h>
-#include <stdint.h>
-
-/*
- * @typedef os_clockid_t
- *
- * @abstract
- * Describes the kind of clock that the workgroup timestamp parameters are
- * specified in
- */
-OS_ENUM(os_clockid, uint32_t,
-		OS_CLOCK_MACH_ABSOLUTE_TIME = 32,
-);
-
-#endif /* __OS_CLOCK__ */
diff --git a/lib/libc/include/x86_64-macos-gnu/os/object.h b/lib/libc/include/x86_64-macos-gnu/os/object.h
deleted file mode 100644
index be281bcd9a..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/os/object.h
+++ /dev/null
@@ -1,271 +0,0 @@
-/*
- * Copyright (c) 2011-2014 Apple Inc. All rights reserved.
- *
- * @APPLE_APACHE_LICENSE_HEADER_START@
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @APPLE_APACHE_LICENSE_HEADER_END@
- */
-
-#ifndef __OS_OBJECT__
-#define __OS_OBJECT__
-
-#ifdef __APPLE__
-#include <Availability.h>
-#include <os/availability.h>
-#include <TargetConditionals.h>
-#include <os/base.h>
-#elif defined(_WIN32)
-#include <os/generic_win_base.h>
-#elif defined(__unix__)
-#include <os/generic_unix_base.h>
-#endif
-
-/*!
- * @header
- *
- * @preprocinfo
- * By default, libSystem objects such as GCD and XPC objects are declared as
- * Objective-C types when building with an Objective-C compiler. This allows
- * them to participate in ARC, in RR management by the Blocks runtime and in
- * leaks checking by the static analyzer, and enables them to be added to Cocoa
- * collections.
- *
- * NOTE: this requires explicit cancellation of dispatch sources and xpc
- *       connections whose handler blocks capture the source/connection object,
- *       resp. ensuring that such captures do not form retain cycles (e.g. by
- *       declaring the source as __weak).
- *
- * To opt-out of this default behavior, add -DOS_OBJECT_USE_OBJC=0 to your
- * compiler flags.
- *
- * This mode requires a platform with the modern Objective-C runtime, the
- * Objective-C GC compiler option to be disabled, and at least a Mac OS X 10.8
- * or iOS 6.0 deployment target.
- */
-
-#ifndef OS_OBJECT_HAVE_OBJC_SUPPORT
-#if !defined(__OBJC__) || defined(__OBJC_GC__)
-#  define OS_OBJECT_HAVE_OBJC_SUPPORT 0
-#elif !defined(TARGET_OS_MAC) || !TARGET_OS_MAC
-#  define OS_OBJECT_HAVE_OBJC_SUPPORT 0
-#elif TARGET_OS_IOS && __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_6_0
-#  define OS_OBJECT_HAVE_OBJC_SUPPORT 0
-#elif TARGET_OS_MAC && !TARGET_OS_IPHONE
-#  if __MAC_OS_X_VERSION_MIN_REQUIRED < __MAC_10_8
-#  define OS_OBJECT_HAVE_OBJC_SUPPORT 0
-#  elif defined(__i386__) && __MAC_OS_X_VERSION_MIN_REQUIRED < __MAC_10_12
-#  define OS_OBJECT_HAVE_OBJC_SUPPORT 0
-#  else
-#  define OS_OBJECT_HAVE_OBJC_SUPPORT 1
-#  endif
-#else
-#  define OS_OBJECT_HAVE_OBJC_SUPPORT 1
-#endif
-#endif // OS_OBJECT_HAVE_OBJC_SUPPORT
-
-#if OS_OBJECT_HAVE_OBJC_SUPPORT
-#if defined(__swift__) && __swift__ && !OS_OBJECT_USE_OBJC
-#define OS_OBJECT_USE_OBJC 1
-#endif
-#ifndef OS_OBJECT_USE_OBJC
-#define OS_OBJECT_USE_OBJC 1
-#endif
-#elif defined(OS_OBJECT_USE_OBJC) && OS_OBJECT_USE_OBJC
-/* Unsupported platform for OS_OBJECT_USE_OBJC=1 */
-#undef OS_OBJECT_USE_OBJC
-#define OS_OBJECT_USE_OBJC 0
-#else
-#define OS_OBJECT_USE_OBJC 0
-#endif
-
-#ifndef OS_OBJECT_SWIFT3
-#ifdef __swift__
-#define OS_OBJECT_SWIFT3 1
-#else // __swift__
-#define OS_OBJECT_SWIFT3 0
-#endif // __swift__
-#endif // OS_OBJECT_SWIFT3
-
-#if OS_OBJECT_USE_OBJC
-#import <objc/NSObject.h>
-#if __has_attribute(objc_independent_class)
-#define OS_OBJC_INDEPENDENT_CLASS __attribute__((objc_independent_class))
-#endif // __has_attribute(objc_independent_class)
-#ifndef OS_OBJC_INDEPENDENT_CLASS
-#define OS_OBJC_INDEPENDENT_CLASS
-#endif
-#define OS_OBJECT_CLASS(name) OS_##name
-#define OS_OBJECT_DECL_PROTOCOL(name, ...) \
-		@protocol OS_OBJECT_CLASS(name) __VA_ARGS__ \
-		@end
-#define OS_OBJECT_CLASS_IMPLEMENTS_PROTOCOL_IMPL(name, proto) \
-		@interface name () <proto> \
-		@end
-#define OS_OBJECT_CLASS_IMPLEMENTS_PROTOCOL(name, proto) \
-		OS_OBJECT_CLASS_IMPLEMENTS_PROTOCOL_IMPL( \
-				OS_OBJECT_CLASS(name), OS_OBJECT_CLASS(proto))
-#define OS_OBJECT_DECL_IMPL(name, ...) \
-		OS_OBJECT_DECL_PROTOCOL(name, __VA_ARGS__) \
-		typedef NSObject<OS_OBJECT_CLASS(name)> \
-				* OS_OBJC_INDEPENDENT_CLASS name##_t
-#define OS_OBJECT_DECL_BASE(name, ...) \
-		@interface OS_OBJECT_CLASS(name) : __VA_ARGS__ \
-		- (instancetype)init OS_SWIFT_UNAVAILABLE("Unavailable in Swift"); \
-		@end
-#define OS_OBJECT_DECL_IMPL_CLASS(name, ...) \
-		OS_OBJECT_DECL_BASE(name, ## __VA_ARGS__) \
-		typedef OS_OBJECT_CLASS(name) \
-				* OS_OBJC_INDEPENDENT_CLASS name##_t
-#define OS_OBJECT_DECL(name, ...) \
-		OS_OBJECT_DECL_IMPL(name, <NSObject>)
-#define OS_OBJECT_DECL_SUBCLASS(name, super) \
-		OS_OBJECT_DECL_IMPL(name, <OS_OBJECT_CLASS(super)>)
-#if __has_attribute(ns_returns_retained)
-#define OS_OBJECT_RETURNS_RETAINED __attribute__((__ns_returns_retained__))
-#else
-#define OS_OBJECT_RETURNS_RETAINED
-#endif
-#if __has_attribute(ns_consumed)
-#define OS_OBJECT_CONSUMED __attribute__((__ns_consumed__))
-#else
-#define OS_OBJECT_CONSUMED
-#endif
-#if __has_feature(objc_arc)
-#define OS_OBJECT_BRIDGE __bridge
-#define OS_WARN_RESULT_NEEDS_RELEASE
-#else
-#define OS_OBJECT_BRIDGE
-#define OS_WARN_RESULT_NEEDS_RELEASE OS_WARN_RESULT
-#endif
-#if __has_attribute(objc_runtime_visible) && \
-		((defined(__MAC_OS_X_VERSION_MIN_REQUIRED) && \
-		__MAC_OS_X_VERSION_MIN_REQUIRED < __MAC_10_12) || \
-		(defined(__IPHONE_OS_VERSION_MIN_REQUIRED) && \
-		!defined(__TV_OS_VERSION_MIN_REQUIRED) && \
-		!defined(__WATCH_OS_VERSION_MIN_REQUIRED) && \
-		__IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_10_0) || \
-		(defined(__TV_OS_VERSION_MIN_REQUIRED) && \
-		__TV_OS_VERSION_MIN_REQUIRED < __TVOS_10_0) || \
-		(defined(__WATCH_OS_VERSION_MIN_REQUIRED) && \
-		__WATCH_OS_VERSION_MIN_REQUIRED < __WATCHOS_3_0))
-/*
- * To provide backward deployment of ObjC objects in Swift on pre-10.12
- * SDKs, OS_object classes can be marked as OS_OBJECT_OBJC_RUNTIME_VISIBLE.
- * When compiling with a deployment target earlier than OS X 10.12 (iOS 10.0, 
- * tvOS 10.0, watchOS 3.0) the Swift compiler will only refer to this type at
- * runtime (using the ObjC runtime).
- */
-#define OS_OBJECT_OBJC_RUNTIME_VISIBLE __attribute__((objc_runtime_visible))
-#else
-#define OS_OBJECT_OBJC_RUNTIME_VISIBLE
-#endif
-#ifndef OS_OBJECT_USE_OBJC_RETAIN_RELEASE
-#if defined(__clang_analyzer__)
-#define OS_OBJECT_USE_OBJC_RETAIN_RELEASE 1
-#elif __has_feature(objc_arc) && !OS_OBJECT_SWIFT3
-#define OS_OBJECT_USE_OBJC_RETAIN_RELEASE 1
-#else
-#define OS_OBJECT_USE_OBJC_RETAIN_RELEASE 0
-#endif
-#endif
-#if OS_OBJECT_SWIFT3
-#define OS_OBJECT_DECL_SWIFT(name) \
-		OS_EXPORT OS_OBJECT_OBJC_RUNTIME_VISIBLE \
-		OS_OBJECT_DECL_IMPL_CLASS(name, NSObject)
-#define OS_OBJECT_DECL_SUBCLASS_SWIFT(name, super) \
-		OS_EXPORT OS_OBJECT_OBJC_RUNTIME_VISIBLE \
-		OS_OBJECT_DECL_IMPL_CLASS(name, OS_OBJECT_CLASS(super))
-OS_EXPORT OS_OBJECT_OBJC_RUNTIME_VISIBLE
-OS_OBJECT_DECL_BASE(object, NSObject);
-#endif // OS_OBJECT_SWIFT3
-#else
-/*! @parseOnly */
-#define OS_OBJECT_RETURNS_RETAINED
-/*! @parseOnly */
-#define OS_OBJECT_CONSUMED
-/*! @parseOnly */
-#define OS_OBJECT_BRIDGE
-/*! @parseOnly */
-#define OS_WARN_RESULT_NEEDS_RELEASE OS_WARN_RESULT
-/*! @parseOnly */
-#define OS_OBJECT_OBJC_RUNTIME_VISIBLE
-#define OS_OBJECT_USE_OBJC_RETAIN_RELEASE 0
-#endif
-
-#if OS_OBJECT_SWIFT3
-#define OS_OBJECT_DECL_CLASS(name) \
-		OS_OBJECT_DECL_SUBCLASS_SWIFT(name, object)
-#elif OS_OBJECT_USE_OBJC
-#define OS_OBJECT_DECL_CLASS(name) \
-		OS_OBJECT_DECL(name)
-#else
-#define OS_OBJECT_DECL_CLASS(name) \
-		typedef struct name##_s *name##_t
-#endif
-
-#define OS_OBJECT_GLOBAL_OBJECT(type, object) ((OS_OBJECT_BRIDGE type)&(object))
-
-__BEGIN_DECLS
-
-/*!
- * @function os_retain
- *
- * @abstract
- * Increment the reference count of an os_object.
- *
- * @discussion
- * On a platform with the modern Objective-C runtime this is exactly equivalent
- * to sending the object the -[retain] message.
- *
- * @param object
- * The object to retain.
- *
- * @result
- * The retained object.
- */
-API_AVAILABLE(macos(10.10), ios(8.0))
-OS_EXPORT OS_SWIFT_UNAVAILABLE("Can't be used with ARC")
-void*
-os_retain(void *object);
-#if OS_OBJECT_USE_OBJC
-#undef os_retain
-#define os_retain(object) [object retain]
-#endif
-
-/*!
- * @function os_release
- *
- * @abstract
- * Decrement the reference count of a os_object.
- *
- * @discussion
- * On a platform with the modern Objective-C runtime this is exactly equivalent
- * to sending the object the -[release] message.
- *
- * @param object
- * The object to release.
- */
-API_AVAILABLE(macos(10.10), ios(8.0))
-OS_EXPORT
-void OS_SWIFT_UNAVAILABLE("Can't be used with ARC")
-os_release(void *object);
-#if OS_OBJECT_USE_OBJC
-#undef os_release
-#define os_release(object) [object release]
-#endif
-
-__END_DECLS
-
-#endif
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/os/workgroup.h b/lib/libc/include/x86_64-macos-gnu/os/workgroup.h
deleted file mode 100644
index 96b870c10c..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/os/workgroup.h
+++ /dev/null
@@ -1,37 +0,0 @@
-/*
- * Copyright (c) 2020 Apple Inc. All rights reserved.
- *
- * @APPLE_APACHE_LICENSE_HEADER_START@
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @APPLE_APACHE_LICENSE_HEADER_END@
- */
-
-#ifndef __OS_WORKGROUP__
-#define __OS_WORKGROUP__
-
-#ifndef __DISPATCH_BUILDING_DISPATCH__
-#ifndef __OS_WORKGROUP_INDIRECT__
-#define __OS_WORKGROUP_INDIRECT__
-#endif /* __OS_WORKGROUP_INDIRECT__ */
-
-#include <os/workgroup_base.h>
-#include <os/workgroup_object.h>
-#include <os/workgroup_interval.h>
-#include <os/workgroup_parallel.h>
-
-#undef __OS_WORKGROUP_INDIRECT__
-#endif /* __DISPATCH_BUILDING_DISPATCH__ */
-
-#endif /* __OS_WORKGROUP__ */
diff --git a/lib/libc/include/x86_64-macos-gnu/os/workgroup_base.h b/lib/libc/include/x86_64-macos-gnu/os/workgroup_base.h
deleted file mode 100644
index 3983f002ae..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/os/workgroup_base.h
+++ /dev/null
@@ -1,78 +0,0 @@
-#ifndef __OS_WORKGROUP_BASE__
-#define __OS_WORKGROUP_BASE__
-
-#ifndef __OS_WORKGROUP_INDIRECT__
-#error "Please #include <os/workgroup.h> instead of this file directly."
-#endif
-
-#include <sys/types.h>
-#include <stddef.h>
-#include <stdint.h>
-#include <stdbool.h>
-#include <string.h>
-#include <stdlib.h>
-
-#include <mach/port.h>
-
-#include <Availability.h>
-#include <os/base.h>
-#include <os/object.h>
-#include <os/clock.h>
-
-#if __has_feature(assume_nonnull)
-#define OS_WORKGROUP_ASSUME_NONNULL_BEGIN _Pragma("clang assume_nonnull begin")
-#define OS_WORKGROUP_ASSUME_NONNULL_END   _Pragma("clang assume_nonnull end")
-#else
-#define OS_WORKGROUP_ASSUME_NONNULL_BEGIN
-#define OS_WORKGROUP_ASSUME_NONNULL_END
-#endif
-#define OS_WORKGROUP_WARN_RESULT __attribute__((__warn_unused_result__))
-#define OS_WORKGROUP_EXPORT OS_EXPORT
-#define OS_WORKGROUP_RETURNS_RETAINED OS_OBJECT_RETURNS_RETAINED
-
-#define OS_WORKGROUP_DECL(name, swift_name) \
-	OS_SWIFT_NAME(swift_name) \
-	OS_OBJECT_SHOW_CLASS(name, OS_OBJECT_CLASS(object))
-
-#if OS_OBJECT_USE_OBJC
-#define OS_WORKGROUP_SUBCLASS_DECL_PROTO(name, swift_name, ...) \
-	OS_SWIFT_NAME(swift_name) \
-	OS_OBJECT_DECL_PROTOCOL(name ## __VA_ARGS__ )
-#else
-#define OS_WORKGROUP_SUBCLASS_DECL_PROTO(name, swift_name, ...)
-#endif
-
-#define OS_WORKGROUP_SUBCLASS_DECL(name, super, swift_name, ...) \
-	OS_SWIFT_NAME(swift_name) \
-	OS_OBJECT_SHOW_SUBCLASS(name, super, name, ## __VA_ARGS__)
-
-#if defined(__LP64__)
-#define __OS_WORKGROUP_ATTR_SIZE__ 60
-#define __OS_WORKGROUP_INTERVAL_DATA_SIZE__ 56
-#define __OS_WORKGROUP_JOIN_TOKEN_SIZE__ 36
-#else
-#define __OS_WORKGROUP_ATTR_SIZE__ 60
-#define __OS_WORKGROUP_INTERVAL_DATA_SIZE__ 56
-#define __OS_WORKGROUP_JOIN_TOKEN_SIZE__ 28
-#endif
-
-#define _OS_WORKGROUP_ATTR_SIG_DEFAULT_INIT 0x2FA863B4
-#define _OS_WORKGROUP_ATTR_SIG_EMPTY_INIT 0x2FA863C4
-
-struct OS_REFINED_FOR_SWIFT os_workgroup_attr_opaque_s {
-	uint32_t sig;
-	char opaque[__OS_WORKGROUP_ATTR_SIZE__];
-};
-
-#define _OS_WORKGROUP_INTERVAL_DATA_SIG_INIT 0x52A74C4D
-struct OS_REFINED_FOR_SWIFT os_workgroup_interval_data_opaque_s {
-	uint32_t sig;
-	char opaque[__OS_WORKGROUP_INTERVAL_DATA_SIZE__];
-};
-
-struct OS_REFINED_FOR_SWIFT os_workgroup_join_token_opaque_s {
-	uint32_t sig;
-	char opaque[__OS_WORKGROUP_JOIN_TOKEN_SIZE__];
-};
-
-#endif /* __OS_WORKGROUP_BASE__ */
diff --git a/lib/libc/include/x86_64-macos-gnu/os/workgroup_interval.h b/lib/libc/include/x86_64-macos-gnu/os/workgroup_interval.h
deleted file mode 100644
index 8594aed529..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/os/workgroup_interval.h
+++ /dev/null
@@ -1,155 +0,0 @@
-/*
- * Copyright (c) 2020 Apple Inc. All rights reserved.
- *
- * @APPLE_APACHE_LICENSE_HEADER_START@
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @APPLE_APACHE_LICENSE_HEADER_END@
- */
-
-#ifndef __OS_WORKGROUP_INTERVAL__
-#define __OS_WORKGROUP_INTERVAL__
-
-#ifndef __OS_WORKGROUP_INDIRECT__
-#error "Please #include <os/workgroup.h> instead of this file directly."
-#include <os/workgroup_base.h> // For header doc
-#endif
-
-__BEGIN_DECLS
-
-OS_WORKGROUP_ASSUME_NONNULL_BEGIN
-
-/*!
- * @typedef os_workgroup_interval_t
- *
- * @abstract
- * A subclass of an os_workgroup_t for tracking work performed as part of
- * a repeating interval-driven workload.
- */
-OS_WORKGROUP_SUBCLASS_DECL_PROTO(os_workgroup_interval, Repeatable);
-OS_WORKGROUP_SUBCLASS_DECL(os_workgroup_interval, os_workgroup, WorkGroupInterval);
-
-/* During the first instance of this API, the only supported interval
- * workgroups are for audio workloads. Please refer to the AudioToolbox
- * framework for more information.
- */
-
-/*
- * @typedef os_workgroup_interval_data, os_workgroup_interval_data_t
- *
- * @abstract
- * An opaque structure containing additional configuration for the workgroup
- * interval.
- */
-typedef struct os_workgroup_interval_data_opaque_s os_workgroup_interval_data_s;
-typedef struct os_workgroup_interval_data_opaque_s *os_workgroup_interval_data_t;
-#define OS_WORKGROUP_INTERVAL_DATA_INITIALIZER \
-	{ .sig = _OS_WORKGROUP_INTERVAL_DATA_SIG_INIT }
-
-/*!
- * @function os_workgroup_interval_start
- *
- * @abstract
- * Indicates to the system that the member threads of this
- * os_workgroup_interval_t have begun working on an instance of the repeatable
- * interval workload with the specified timestamps. This function is real time
- * safe.
- *
- * This function will set and return an errno in the following cases:
- *
- * - The current thread is not a member of the os_workgroup_interval_t
- * - The os_workgroup_interval_t has been cancelled
- * - The timestamps passed in are malformed
- * - os_workgroup_interval_start() was previously called on the
- * os_workgroup_interval_t without an intervening os_workgroup_interval_finish()
- * - A concurrent workgroup interval configuration operation is taking place.
- *
- * @param start
- * Start timestamp specified in the os_clockid_t with which the
- * os_workgroup_interval_t was created. This is generally a time in the past and
- * indicates when the workgroup started working on an interval period
- *
- * @param deadline
- * Deadline timestamp specified in the os_clockid_t with which the
- * os_workgroup_interval_t was created. This specifies the deadline which the
- * interval period would like to meet.
- *
- * @param data
- * This field is currently unused and should be NULL
- */
-API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0), watchos(7.0))
-OS_REFINED_FOR_SWIFT OS_WORKGROUP_EXPORT OS_WORKGROUP_WARN_RESULT
-int
-os_workgroup_interval_start(os_workgroup_interval_t wg, uint64_t start, uint64_t
-		deadline, os_workgroup_interval_data_t _Nullable data);
-
-/*!
- * @function os_workgroup_interval_update
- *
- * @abstract
- * Updates an already started interval workgroup to have the new
- * deadline specified. This function is real time safe.
- *
- * This function will return an error in the following cases:
- * - The current thread is not a member of the os_workgroup_interval_t
- * - The os_workgroup_interval_t has been cancelled
- * - The timestamp passed in is malformed
- * - os_workgroup_interval_start() was not previously called on the
- * os_workgroup_interval_t or was already matched with an
- * os_workgroup_interval_finish()
- * - A concurrent workgroup interval configuration operation is taking place
- *
- * @param deadline
- * Timestamp specified in the os_clockid_t with
- * which the os_workgroup_interval_t was created.
- *
- * @param data
- * This field is currently unused and should be NULL
- */
-API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0), watchos(7.0))
-OS_REFINED_FOR_SWIFT OS_WORKGROUP_EXPORT OS_WORKGROUP_WARN_RESULT
-int
-os_workgroup_interval_update(os_workgroup_interval_t wg, uint64_t deadline,
-		os_workgroup_interval_data_t _Nullable data);
-
-/*!
- * @function os_workgroup_interval_finish
- *
- * @abstract
- * Indicates to the system that the member threads of
- * this os_workgroup_interval_t have finished working on the current instance
- * of the interval workload. This function is real time safe.
- *
- * This function will return an error in the following cases:
- *  - The current thread is not a member of the os_workgroup_interval_t
- *  - os_workgroup_interval_start() was not previously called on the
- * os_workgroup_interval_t or was already matched with an
- * os_workgroup_interval_finish()
- * - A concurrent workgroup interval configuration operation is taking place.
- *
- * @param data
- * This field is currently unused and should be NULL
- *
- */
-API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0), watchos(7.0))
-OS_REFINED_FOR_SWIFT OS_WORKGROUP_EXPORT OS_WORKGROUP_WARN_RESULT
-int
-os_workgroup_interval_finish(os_workgroup_interval_t wg,
-		os_workgroup_interval_data_t _Nullable data);
-
-OS_WORKGROUP_ASSUME_NONNULL_END
-
-__END_DECLS
-
-#endif /* __OS_WORKGROUP_INTERVAL__ */
diff --git a/lib/libc/include/x86_64-macos-gnu/os/workgroup_object.h b/lib/libc/include/x86_64-macos-gnu/os/workgroup_object.h
deleted file mode 100644
index 984d3e2e80..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/os/workgroup_object.h
+++ /dev/null
@@ -1,357 +0,0 @@
-/*
- * Copyright (c) 2020 Apple Inc. All rights reserved.
- *
- * @APPLE_APACHE_LICENSE_HEADER_START@
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @APPLE_APACHE_LICENSE_HEADER_END@
- */
-
-#ifndef __OS_WORKGROUP_OBJECT__
-#define __OS_WORKGROUP_OBJECT__
-
-#ifndef __OS_WORKGROUP_INDIRECT__
-#error "Please #include <os/workgroup.h> instead of this file directly."
-#include <os/workgroup_base.h> // For header doc
-#endif
-
-__BEGIN_DECLS
-
-OS_WORKGROUP_ASSUME_NONNULL_BEGIN
-
-/*!
- * @typedef os_workgroup_t
- *
- * @abstract
- * A reference counted os object representing a workload that needs to
- * be distinctly recognized and tracked by the system.  The workgroup
- * tracks a collection of threads all working cooperatively. An os_workgroup
- * object - when not an instance of a specific os_workgroup_t subclass -
- * represents a generic workload and makes no assumptions about the kind of
- * work done.
- *
- * @discussion
- * Threads can explicitly join an os_workgroup_t to mark themselves as
- * participants in the workload.
- */
-OS_WORKGROUP_DECL(os_workgroup, WorkGroup);
-
-
-/* Attribute creation and specification */
-
-/*!
- * @typedef os_workgroup_attr_t
- *
- * @abstract
- * Pointer to an opaque structure for describing attributes that can be
- * configured on a workgroup at creation.
- */
-typedef struct os_workgroup_attr_opaque_s os_workgroup_attr_s;
-typedef struct os_workgroup_attr_opaque_s *os_workgroup_attr_t;
-
-/* os_workgroup_t attributes need to be initialized before use. This initializer
- * allows you to create a workgroup with the system default attributes. */
-#define OS_WORKGROUP_ATTR_INITIALIZER_DEFAULT \
-	{ .sig = _OS_WORKGROUP_ATTR_SIG_DEFAULT_INIT }
-
-
-
-/* The main use of the workgroup API is through instantiations of the concrete
- * subclasses - please refer to os/workgroup_interval.h and
- * os/workgroup_parallel.h for more information on creating workgroups.
- *
- * The functions below operate on all subclasses of os_workgroup_t.
- */
-
-/*!
- * @function os_workgroup_copy_port
- *
- * @abstract
- * Returns a reference to a send right representing this workgroup that is to be
- * sent to other processes. This port is to be passed to
- * os_workgroup_create_with_port() to create a workgroup object.
- *
- * It is the client's responsibility to release the send right reference.
- *
- * If an error is encountered, errno is set and returned.
- */
-API_AVAILABLE(macos(11.0))
-API_UNAVAILABLE(ios, tvos, watchos)
-OS_REFINED_FOR_SWIFT OS_WORKGROUP_EXPORT OS_WORKGROUP_WARN_RESULT
-int
-os_workgroup_copy_port(os_workgroup_t wg, mach_port_t *mach_port_out);
-
-/*!
- * @function os_workgroup_create_with_port
- *
- * @abstract
- * Create an os_workgroup_t object from a send right returned by a previous
- * call to os_workgroup_copy_port, potentially in a different process.
- *
- * A newly created os_workgroup_t has no initial member threads - in particular
- * the creating thread does not join the os_workgroup_t implicitly.
- *
- * @param name
- * A client specified string for labelling the workgroup. This parameter is
- * optional and can be NULL.
- *
- * @param mach_port
- * The send right to create the workgroup from. No reference is consumed
- * on the specified send right.
- */
-API_AVAILABLE(macos(11.0))
-API_UNAVAILABLE(ios, tvos, watchos)
-OS_SWIFT_NAME(WorkGroup.init(__name:port:)) OS_WORKGROUP_EXPORT OS_WORKGROUP_RETURNS_RETAINED
-os_workgroup_t _Nullable
-os_workgroup_create_with_port(const char *_Nullable name, mach_port_t mach_port);
-
-/*!
- * @function os_workgroup_create_with_workgroup
- *
- * @abstract
- * Create a new os_workgroup object from an existing os_workgroup.
- *
- * The newly created os_workgroup has no initial member threads - in particular
- * the creating threaad does not join the os_workgroup_t implicitly.
- *
- * @param name
- * A client specified string for labelling the workgroup. This parameter is
- * optional and can be NULL.
- *
- * @param wg
- * The existing workgroup to create a new workgroup object from.
- */
-API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0), watchos(7.0))
-OS_REFINED_FOR_SWIFT OS_WORKGROUP_EXPORT OS_WORKGROUP_RETURNS_RETAINED
-os_workgroup_t _Nullable
-os_workgroup_create_with_workgroup(const char * _Nullable name, os_workgroup_t wg);
-
-/*!
- * @typedef os_workgroup_join_token, os_workgroup_join_token_t
- *
- * @abstract
- * An opaque join token which the client needs to pass to os_workgroup_join
- * and os_workgroup_leave
- */
-OS_REFINED_FOR_SWIFT
-typedef struct os_workgroup_join_token_opaque_s os_workgroup_join_token_s;
-OS_REFINED_FOR_SWIFT
-typedef struct os_workgroup_join_token_opaque_s *os_workgroup_join_token_t;
-
-
-/*!
- * @function os_workgroup_join
- *
- * @abstract
- * Joins the current thread to the specified workgroup and populates the join
- * token that has been passed in. This API is real-time safe.
- *
- * @param wg
- * The workgroup that the current thread would like to join
- *
- * @param token_out
- * Pointer to a client allocated struct which the function will populate
- * with the join token. This token must be passed in by the thread when it calls
- * os_workgroup_leave().
- *
- * Errors will be returned in the following cases:
- *
- * EALREADY		The thread is already part of a workgroup that the specified
- *				workgroup does not nest with
- * EINVAL		The workgroup has been cancelled
- */
-API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0), watchos(7.0))
-OS_REFINED_FOR_SWIFT OS_WORKGROUP_EXPORT OS_WORKGROUP_WARN_RESULT
-int
-os_workgroup_join(os_workgroup_t wg, os_workgroup_join_token_t token_out);
-
-/*!
- * @function os_workgroup_leave
- *
- * @abstract
- * This removes the current thread from a workgroup it has previously
- * joined. Threads must leave all workgroups in the reverse order that they
- * have joined them. Failing to do so before exiting will result in undefined
- * behavior.
- *
- * If the join token is malformed, the process will be aborted.
- *
- * This API is real time safe.
- *
- * @param wg
- * The workgroup that the current thread would like to leave.
- *
- * @param token
- * This is the join token populated by the most recent call to
- * os_workgroup_join().
- */
-API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0), watchos(7.0))
-OS_REFINED_FOR_SWIFT OS_WORKGROUP_EXPORT
-void
-os_workgroup_leave(os_workgroup_t wg, os_workgroup_join_token_t token);
-
-/* Working Arena index of a thread in a workgroup */
-typedef uint32_t os_workgroup_index;
-/* Destructor for Working Arena */
-typedef void (*os_workgroup_working_arena_destructor_t)(void * _Nullable);
-
-/*!
- * @function os_workgroup_set_working_arena
- *
- * @abstract
- * Associates a client defined working arena with the workgroup. The arena
- * is local to the workgroup object in the process. This is intended for
- * distributing a manually managed memory allocation between member threads
- * of the workgroup.
- *
- * This function can be called multiple times and the client specified
- * destructor will be called on the previously assigned arena, if any. This
- * function can only be called when no threads have currently joined the
- * workgroup and all workloops associated with the workgroup are idle.
- *
- * @param wg
- * The workgroup to associate the working arena with
- *
- * @param arena
- * The client managed arena to associate with the workgroup. This value can
- * be NULL.
- *
- * @param max_workers
- * The maximum number of threads that will ever query the workgroup for the
- * arena and request an index into it.  If the arena is not used to partition
- * work amongst member threads, then this field can be 0.
- *
- * @param destructor
- * A destructor to call on the previously assigned working arena, if any
- */
-API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0), watchos(7.0))
-OS_REFINED_FOR_SWIFT OS_WORKGROUP_EXPORT OS_WORKGROUP_WARN_RESULT
-int
-os_workgroup_set_working_arena(os_workgroup_t wg, void * _Nullable arena,
-	uint32_t max_workers, os_workgroup_working_arena_destructor_t destructor);
-
-/*!
- * @function os_workgroup_get_working_arena
- *
- * @abstract
- * Returns the working arena associated with the workgroup and the current
- * thread's index in the workgroup. This function can only be called by a member
- * of the workgroup. Multiple calls to this API by a member thread will return
- * the same arena and index until the thread leaves the workgroup.
- *
- * For workloops with an associated workgroup, every work item on the workloop
- * will receive the same index in the arena.
- *
- * This method returns NULL if no arena is set on the workgroup. The index
- * returned by this function is zero-based and is namespaced per workgroup
- * object in the process. The indices provided are strictly monotonic and never
- * reused until a future call to os_workgroup_set_working_arena.
- *
- * @param wg
- * The workgroup to get the working arena from.
- *
- * @param index_out
- * A pointer to a os_workgroup_index which will be populated by the caller's
- * index in the workgroup.
- */
-API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0), watchos(7.0))
-OS_REFINED_FOR_SWIFT OS_WORKGROUP_EXPORT
-void * _Nullable
-os_workgroup_get_working_arena(os_workgroup_t wg,
-		os_workgroup_index * _Nullable index_out);
-
-/*!
- * @function os_workgroup_cancel
- *
- * @abstract
- * This API invalidates a workgroup and indicates to the system that the
- * workload is no longer relevant to the caller.
- *
- * No new work should be initiated for a cancelled workgroup and
- * work that is already underway should periodically check for
- * cancellation with os_workgroup_testcancel and initiate cleanup if needed.
- *
- * Threads currently in the workgroup continue to be tracked together but no
- * new threads may join this workgroup - the only possible operation allowed is
- * to leave the workgroup. Other actions may have undefined behavior or
- * otherwise fail.
- *
- * This API is idempotent. Cancellation is local to the workgroup object
- * it is called on and does not affect other workgroups.
- *
- * @param wg
- * The workgroup that that the thread would like to cancel
- */
-API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0), watchos(7.0))
-OS_REFINED_FOR_SWIFT OS_WORKGROUP_EXPORT
-void
-os_workgroup_cancel(os_workgroup_t wg);
-
-/*!
- * @function os_workgroup_testcancel
- *
- * @abstract
- * Returns true if the workgroup object has been cancelled. See also
- * os_workgroup_cancel
- */
-API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0), watchos(7.0))
-OS_REFINED_FOR_SWIFT OS_WORKGROUP_EXPORT
-bool
-os_workgroup_testcancel(os_workgroup_t wg);
-
-/*!
- * @typedef os_workgroup_max_parallel_threads_attr_t
- *
- * @abstract
- * A pointer to a structure describing the set of properties of a workgroup to
- * override with the explicitly specified values in the structure.
- *
- * See also os_workgroup_max_parallel_threads.
- */
-OS_REFINED_FOR_SWIFT
-typedef struct os_workgroup_max_parallel_threads_attr_s os_workgroup_mpt_attr_s;
-OS_REFINED_FOR_SWIFT
-typedef struct os_workgroup_max_parallel_threads_attr_s *os_workgroup_mpt_attr_t;
-
-/*!
- * @function os_workgroup_max_parallel_threads
- *
- * @abstract
- * Returns the system's recommendation for maximum number of threads the client
- * should make for a multi-threaded workload in a given workgroup.
- *
- * This API takes into consideration the current hardware the code is running on
- * and the attributes of the workgroup. It does not take into consideration the
- * current load of the system and therefore always provides the most optimal
- * recommendation for the workload.
- *
- * @param wg
- * The workgroup in which the multi-threaded workload will be performed in. The
- * threads performing the multi-threaded workload are expected to join this
- * workgroup.
- *
- * @param attr
- * This value is currently unused and should be NULL.
- */
-API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0), watchos(7.0))
-OS_REFINED_FOR_SWIFT OS_WORKGROUP_EXPORT
-int
-os_workgroup_max_parallel_threads(os_workgroup_t wg, os_workgroup_mpt_attr_t
-		_Nullable attr);
-
-OS_WORKGROUP_ASSUME_NONNULL_END
-
-__END_DECLS
-
-#endif /* __OS_WORKGROUP_OBJECT__ */
diff --git a/lib/libc/include/x86_64-macos-gnu/os/workgroup_parallel.h b/lib/libc/include/x86_64-macos-gnu/os/workgroup_parallel.h
deleted file mode 100644
index 48d232e47a..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/os/workgroup_parallel.h
+++ /dev/null
@@ -1,74 +0,0 @@
-/*
- * Copyright (c) 2020 Apple Inc. All rights reserved.
- *
- * @APPLE_APACHE_LICENSE_HEADER_START@
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @APPLE_APACHE_LICENSE_HEADER_END@
- */
-
-#ifndef __OS_WORKGROUP_PARALLEL__
-#define __OS_WORKGROUP_PARALLEL__
-
-#ifndef __OS_WORKGROUP_INDIRECT__
-#error "Please #include <os/workgroup.h> instead of this file directly."
-#include <os/workgroup_base.h> // For header doc
-#endif
-
-#include <os/workgroup_object.h>
-
-__BEGIN_DECLS
-
-OS_WORKGROUP_ASSUME_NONNULL_BEGIN
-
-/*!
- * @typedef os_workgroup_parallel_t
- *
- * @abstract
- * A subclass of an os_workgroup_t for tracking parallel work.
- */
-OS_WORKGROUP_SUBCLASS_DECL_PROTO(os_workgroup_parallel, Parallelizable);
-OS_WORKGROUP_SUBCLASS_DECL(os_workgroup_parallel, os_workgroup, WorkGroupParallel);
-
-/*!
- * @function os_workgroup_parallel_create
- *
- * @abstract
- * Creates an os_workgroup_t which tracks a parallel workload.
- * A newly created os_workgroup_interval_t has no initial member threads -
- * in particular the creating thread does not join the os_workgroup_parallel_t
- * implicitly.
- *
- * See also os_workgroup_max_parallel_threads().
- *
- * @param name
- * A client specified string for labelling the workgroup. This parameter is
- * optional and can be NULL.
- *
- * @param attr
- * The requested set of workgroup attributes. NULL is to be specified for the
- * default set of attributes.
- */
-API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0), watchos(7.0))
-OS_WORKGROUP_EXPORT OS_WORKGROUP_RETURNS_RETAINED
-OS_SWIFT_NAME(WorkGroupParallel.init(__name:attr:))
-os_workgroup_parallel_t _Nullable
-os_workgroup_parallel_create(const char * _Nullable name,
-	os_workgroup_attr_t _Nullable attr);
-
-OS_WORKGROUP_ASSUME_NONNULL_END
-
-__END_DECLS
-
-#endif /* __OS_WORKGROUP_PARALLEL__ */
diff --git a/lib/libc/include/x86_64-macos-gnu/pthread.h b/lib/libc/include/x86_64-macos-gnu/pthread.h
deleted file mode 100644
index 0826a7dc70..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/pthread.h
+++ /dev/null
@@ -1,568 +0,0 @@
-/*
- * Copyright (c) 2000-2012 Apple Inc. All rights reserved.
- *
- * @APPLE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this
- * file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_LICENSE_HEADER_END@
- */
-/*
- * Copyright 1996 1995 by Open Software Foundation, Inc. 1997 1996 1995 1994 1993 1992 1991
- *              All Rights Reserved
- *
- * Permission to use, copy, modify, and distribute this software and
- * its documentation for any purpose and without fee is hereby granted,
- * provided that the above copyright notice appears in all copies and
- * that both the copyright notice and this permission notice appear in
- * supporting documentation.
- *
- * OSF DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE
- * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
- * FOR A PARTICULAR PURPOSE.
- *
- * IN NO EVENT SHALL OSF BE LIABLE FOR ANY SPECIAL, INDIRECT, OR
- * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
- * LOSS OF USE, DATA OR PROFITS, WHETHER IN ACTION OF CONTRACT,
- * NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
- * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
- *
- */
-/*
- * MkLinux
- */
-
-/*
- * POSIX Threads - IEEE 1003.1c
- */
-
-#ifndef _PTHREAD_H
-#define _PTHREAD_H
-
-#include <_types.h>
-#ifndef __POSIX_LIB__
-#include <pthread/pthread_impl.h>
-#endif
-#include <pthread/sched.h>
-#include <time.h>
-#include <sys/_pthread/_pthread_types.h>
-#include <sys/_pthread/_pthread_attr_t.h>
-#include <sys/_pthread/_pthread_cond_t.h>
-#include <sys/_pthread/_pthread_condattr_t.h>
-#include <sys/_pthread/_pthread_key_t.h>
-#include <sys/_pthread/_pthread_mutex_t.h>
-#include <sys/_pthread/_pthread_mutexattr_t.h>
-#include <sys/_pthread/_pthread_once_t.h>
-#include <sys/_pthread/_pthread_rwlock_t.h>
-#include <sys/_pthread/_pthread_rwlockattr_t.h>
-#include <sys/_pthread/_pthread_t.h>
-
-#include <pthread/qos.h>
-
-#if (!defined(_POSIX_C_SOURCE) && !defined(_XOPEN_SOURCE)) || defined(_DARWIN_C_SOURCE) || defined(__cplusplus)
-
-#include <sys/_types/_mach_port_t.h>
-#include <sys/_types/_sigset_t.h>
-
-#endif /* (!_POSIX_C_SOURCE && !_XOPEN_SOURCE) || _DARWIN_C_SOURCE || __cplusplus */
-
-/*
- * These symbols indicate which [optional] features are available
- * They can be tested at compile time via '#ifdef XXX'
- * The way to check for pthreads is like so:
-
- * #include <unistd.h>
- * #ifdef _POSIX_THREADS
- * #include <pthread.h>
- * #endif
-
- */
-
-/* These will be moved to unistd.h */
-
-/*
- * Note: These data structures are meant to be opaque.  Only enough
- * structure is exposed to support initializers.
- * All of the typedefs will be moved to <sys/types.h>
- */
-
-#include <sys/cdefs.h>
-#include <Availability.h>
-
-#if __has_feature(assume_nonnull)
-_Pragma("clang assume_nonnull begin")
-#endif
-__BEGIN_DECLS
-/*
- * Threads
- */
-
-
-/*
- * Cancel cleanup handler management.  Note, since these are implemented as macros,
- * they *MUST* occur in matched pairs!
- */
-
-#define pthread_cleanup_push(func, val) \
-   { \
-	     struct __darwin_pthread_handler_rec __handler; \
-	     pthread_t __self = pthread_self(); \
-	     __handler.__routine = func; \
-	     __handler.__arg = val; \
-	     __handler.__next = __self->__cleanup_stack; \
-	     __self->__cleanup_stack = &__handler;
-
-#define pthread_cleanup_pop(execute) \
-	     /* Note: 'handler' must be in this same lexical context! */ \
-	     __self->__cleanup_stack = __handler.__next; \
-	     if (execute) (__handler.__routine)(__handler.__arg); \
-   }
-
-/*
- * Thread attributes
- */
-
-#define PTHREAD_CREATE_JOINABLE      1
-#define PTHREAD_CREATE_DETACHED      2
-
-#define PTHREAD_INHERIT_SCHED        1
-#define PTHREAD_EXPLICIT_SCHED       2
-
-#define PTHREAD_CANCEL_ENABLE        0x01  /* Cancel takes place at next cancellation point */
-#define PTHREAD_CANCEL_DISABLE       0x00  /* Cancel postponed */
-#define PTHREAD_CANCEL_DEFERRED      0x02  /* Cancel waits until cancellation point */
-#define PTHREAD_CANCEL_ASYNCHRONOUS  0x00  /* Cancel occurs immediately */
-
-/* Value returned from pthread_join() when a thread is canceled */
-#define PTHREAD_CANCELED	     ((void *) 1)
-
-/* We only support PTHREAD_SCOPE_SYSTEM */
-#define PTHREAD_SCOPE_SYSTEM         1
-#define PTHREAD_SCOPE_PROCESS        2
-
-#define PTHREAD_PROCESS_SHARED         1
-#define PTHREAD_PROCESS_PRIVATE        2
-
-/*
- * Mutex protocol attributes
- */
-#define PTHREAD_PRIO_NONE            0
-#define PTHREAD_PRIO_INHERIT         1
-#define PTHREAD_PRIO_PROTECT         2
-
-/*
- * Mutex type attributes
- */
-#define PTHREAD_MUTEX_NORMAL		0
-#define PTHREAD_MUTEX_ERRORCHECK	1
-#define PTHREAD_MUTEX_RECURSIVE		2
-#define PTHREAD_MUTEX_DEFAULT		PTHREAD_MUTEX_NORMAL
-
-/*
- * Mutex policy attributes
- */
-#define PTHREAD_MUTEX_POLICY_FAIRSHARE_NP   1
-#define PTHREAD_MUTEX_POLICY_FIRSTFIT_NP    3
-
-/*
- * RWLock variables
- */
-#define PTHREAD_RWLOCK_INITIALIZER {_PTHREAD_RWLOCK_SIG_init, {0}}
-
-/*
- * Mutex variables
- */
-#define PTHREAD_MUTEX_INITIALIZER {_PTHREAD_MUTEX_SIG_init, {0}}
-
-/* <rdar://problem/10854763> */
-#if ((__MAC_OS_X_VERSION_MIN_REQUIRED && __MAC_OS_X_VERSION_MIN_REQUIRED >= 1070) || (__IPHONE_OS_VERSION_MIN_REQUIRED && __IPHONE_OS_VERSION_MIN_REQUIRED >= 50000)) || defined(__DRIVERKIT_VERSION_MIN_REQUIRED)
-#	if (!defined(_POSIX_C_SOURCE) && !defined(_XOPEN_SOURCE)) || defined(_DARWIN_C_SOURCE)
-#		define PTHREAD_ERRORCHECK_MUTEX_INITIALIZER {_PTHREAD_ERRORCHECK_MUTEX_SIG_init, {0}}
-#		define PTHREAD_RECURSIVE_MUTEX_INITIALIZER {_PTHREAD_RECURSIVE_MUTEX_SIG_init, {0}}
-#	endif /* (!_POSIX_C_SOURCE && !_XOPEN_SOURCE) || _DARWIN_C_SOURCE */
-#endif
-
-/* <rdar://problem/25944576> */
-#define _PTHREAD_SWIFT_IMPORTER_NULLABILITY_COMPAT \
-	defined(SWIFT_CLASS_EXTRA) && (!defined(SWIFT_SDK_OVERLAY_PTHREAD_EPOCH) || (SWIFT_SDK_OVERLAY_PTHREAD_EPOCH < 1))
-
-/*
- * Condition variable attributes
- */
-
-/*
- * Condition variables
- */
-
-#define PTHREAD_COND_INITIALIZER {_PTHREAD_COND_SIG_init, {0}}
-
-/*
- * Initialization control (once) variables
- */
-
-#define PTHREAD_ONCE_INIT {_PTHREAD_ONCE_SIG_init, {0}}
-
-/*
- * Prototypes for all PTHREAD interfaces
- */
-__API_AVAILABLE(macos(10.4), ios(2.0))
-int pthread_atfork(void (* _Nullable)(void), void (* _Nullable)(void),
-		void (* _Nullable)(void));
-
-__API_AVAILABLE(macos(10.4), ios(2.0))
-int pthread_attr_destroy(pthread_attr_t *);
-
-__API_AVAILABLE(macos(10.4), ios(2.0))
-int pthread_attr_getdetachstate(const pthread_attr_t *, int *);
-
-__API_AVAILABLE(macos(10.4), ios(2.0))
-int pthread_attr_getguardsize(const pthread_attr_t * __restrict, size_t * __restrict);
-
-__API_AVAILABLE(macos(10.4), ios(2.0))
-int pthread_attr_getinheritsched(const pthread_attr_t * __restrict, int * __restrict);
-
-__API_AVAILABLE(macos(10.4), ios(2.0))
-int pthread_attr_getschedparam(const pthread_attr_t * __restrict,
-		struct sched_param * __restrict);
-
-__API_AVAILABLE(macos(10.4), ios(2.0))
-int pthread_attr_getschedpolicy(const pthread_attr_t * __restrict, int * __restrict);
-
-__API_AVAILABLE(macos(10.4), ios(2.0))
-int pthread_attr_getscope(const pthread_attr_t * __restrict, int * __restrict);
-
-__API_AVAILABLE(macos(10.4), ios(2.0))
-int pthread_attr_getstack(const pthread_attr_t * __restrict,
-		void * _Nullable * _Nonnull __restrict, size_t * __restrict);
-
-__API_AVAILABLE(macos(10.4), ios(2.0))
-int pthread_attr_getstackaddr(const pthread_attr_t * __restrict,
-		void * _Nullable * _Nonnull __restrict);
-
-__API_AVAILABLE(macos(10.4), ios(2.0))
-int pthread_attr_getstacksize(const pthread_attr_t * __restrict, size_t * __restrict);
-
-__API_AVAILABLE(macos(10.4), ios(2.0))
-int pthread_attr_init(pthread_attr_t *);
-
-__API_AVAILABLE(macos(10.4), ios(2.0))
-int pthread_attr_setdetachstate(pthread_attr_t *, int);
-
-__API_AVAILABLE(macos(10.4), ios(2.0))
-int pthread_attr_setguardsize(pthread_attr_t *, size_t);
-
-__API_AVAILABLE(macos(10.4), ios(2.0))
-int pthread_attr_setinheritsched(pthread_attr_t *, int);
-
-__API_AVAILABLE(macos(10.4), ios(2.0))
-int pthread_attr_setschedparam(pthread_attr_t * __restrict,
-		const struct sched_param * __restrict);
-
-__API_AVAILABLE(macos(10.4), ios(2.0))
-int pthread_attr_setschedpolicy(pthread_attr_t *, int);
-
-__API_AVAILABLE(macos(10.4), ios(2.0))
-int pthread_attr_setscope(pthread_attr_t *, int);
-
-__API_AVAILABLE(macos(10.4), ios(2.0))
-int pthread_attr_setstack(pthread_attr_t *, void *, size_t);
-
-__API_AVAILABLE(macos(10.4), ios(2.0))
-int pthread_attr_setstackaddr(pthread_attr_t *, void *);
-
-__API_AVAILABLE(macos(10.4), ios(2.0))
-int pthread_attr_setstacksize(pthread_attr_t *, size_t);
-
-__API_AVAILABLE(macos(10.4), ios(2.0))
-int pthread_cancel(pthread_t) __DARWIN_ALIAS(pthread_cancel);
-
-__API_AVAILABLE(macos(10.4), ios(2.0))
-int pthread_cond_broadcast(pthread_cond_t *);
-
-__API_AVAILABLE(macos(10.4), ios(2.0))
-int pthread_cond_destroy(pthread_cond_t *);
-
-__API_AVAILABLE(macos(10.4), ios(2.0))
-int pthread_cond_init(
-		pthread_cond_t * __restrict,
-		const pthread_condattr_t * _Nullable __restrict)
-		__DARWIN_ALIAS(pthread_cond_init);
-
-__API_AVAILABLE(macos(10.4), ios(2.0))
-int pthread_cond_signal(pthread_cond_t *);
-
-__API_AVAILABLE(macos(10.4), ios(2.0))
-int pthread_cond_timedwait(
-		pthread_cond_t * __restrict, pthread_mutex_t * __restrict,
-		const struct timespec * _Nullable __restrict)
-		__DARWIN_ALIAS_C(pthread_cond_timedwait);
-
-__API_AVAILABLE(macos(10.4), ios(2.0))
-int pthread_cond_wait(pthread_cond_t * __restrict,
-		pthread_mutex_t * __restrict) __DARWIN_ALIAS_C(pthread_cond_wait);
-
-__API_AVAILABLE(macos(10.4), ios(2.0))
-int pthread_condattr_destroy(pthread_condattr_t *);
-
-__API_AVAILABLE(macos(10.4), ios(2.0))
-int pthread_condattr_init(pthread_condattr_t *);
-
-__API_AVAILABLE(macos(10.4), ios(2.0))
-int pthread_condattr_getpshared(const pthread_condattr_t * __restrict,
-		int * __restrict);
-
-__API_AVAILABLE(macos(10.4), ios(2.0))
-int pthread_condattr_setpshared(pthread_condattr_t *, int);
-
-__API_AVAILABLE(macos(10.4), ios(2.0))
-#if !_PTHREAD_SWIFT_IMPORTER_NULLABILITY_COMPAT
-int pthread_create(pthread_t _Nullable * _Nonnull __restrict,
-		const pthread_attr_t * _Nullable __restrict,
-		void * _Nullable (* _Nonnull)(void * _Nullable),
-		void * _Nullable __restrict);
-#else
-int pthread_create(pthread_t * __restrict,
-		const pthread_attr_t * _Nullable __restrict,
-		void *(* _Nonnull)(void *), void * _Nullable __restrict);
-#endif // _PTHREAD_SWIFT_IMPORTER_NULLABILITY_COMPAT
-
-__API_AVAILABLE(macos(10.4), ios(2.0))
-int pthread_detach(pthread_t);
-
-__API_AVAILABLE(macos(10.4), ios(2.0))
-int pthread_equal(pthread_t _Nullable, pthread_t _Nullable);
-
-__API_AVAILABLE(macos(10.4), ios(2.0))
-void pthread_exit(void * _Nullable) __dead2;
-
-__API_AVAILABLE(macos(10.4), ios(2.0))
-int pthread_getconcurrency(void);
-
-__API_AVAILABLE(macos(10.4), ios(2.0))
-int pthread_getschedparam(pthread_t , int * _Nullable __restrict,
-		struct sched_param * _Nullable __restrict);
-
-__API_AVAILABLE(macos(10.4), ios(2.0))
-void* _Nullable pthread_getspecific(pthread_key_t);
-
-__API_AVAILABLE(macos(10.4), ios(2.0))
-int pthread_join(pthread_t , void * _Nullable * _Nullable)
-		__DARWIN_ALIAS_C(pthread_join);
-
-__API_AVAILABLE(macos(10.4), ios(2.0))
-int pthread_key_create(pthread_key_t *, void (* _Nullable)(void *));
-
-__API_AVAILABLE(macos(10.4), ios(2.0))
-int pthread_key_delete(pthread_key_t);
-
-__API_AVAILABLE(macos(10.4), ios(2.0))
-int pthread_mutex_destroy(pthread_mutex_t *);
-
-__API_AVAILABLE(macos(10.4), ios(2.0))
-int pthread_mutex_getprioceiling(const pthread_mutex_t * __restrict,
-		int * __restrict);
-
-__API_AVAILABLE(macos(10.4), ios(2.0))
-int pthread_mutex_init(pthread_mutex_t * __restrict,
-		const pthread_mutexattr_t * _Nullable __restrict);
-
-__API_AVAILABLE(macos(10.4), ios(2.0))
-int pthread_mutex_lock(pthread_mutex_t *);
-
-__API_AVAILABLE(macos(10.4), ios(2.0))
-int pthread_mutex_setprioceiling(pthread_mutex_t * __restrict, int,
-		int * __restrict);
-
-__API_AVAILABLE(macos(10.4), ios(2.0))
-int pthread_mutex_trylock(pthread_mutex_t *);
-
-__API_AVAILABLE(macos(10.4), ios(2.0))
-int pthread_mutex_unlock(pthread_mutex_t *);
-
-__API_AVAILABLE(macos(10.4), ios(2.0))
-int pthread_mutexattr_destroy(pthread_mutexattr_t *) __DARWIN_ALIAS(pthread_mutexattr_destroy);
-
-__API_AVAILABLE(macos(10.4), ios(2.0))
-int pthread_mutexattr_getprioceiling(const pthread_mutexattr_t * __restrict,
-		int * __restrict);
-
-__API_AVAILABLE(macos(10.4), ios(2.0))
-int pthread_mutexattr_getprotocol(const pthread_mutexattr_t * __restrict,
-		int * __restrict);
-
-__API_AVAILABLE(macos(10.4), ios(2.0))
-int pthread_mutexattr_getpshared(const pthread_mutexattr_t * __restrict,
-		int * __restrict);
-
-__API_AVAILABLE(macos(10.4), ios(2.0))
-int pthread_mutexattr_gettype(const pthread_mutexattr_t * __restrict,
-		int * __restrict);
-
-__API_AVAILABLE(macos(10.13.4), ios(11.3), watchos(4.3), tvos(11.3))
-int pthread_mutexattr_getpolicy_np(const pthread_mutexattr_t * __restrict,
-		int * __restrict);
-
-__API_AVAILABLE(macos(10.4), ios(2.0))
-int pthread_mutexattr_init(pthread_mutexattr_t *);
-
-__API_AVAILABLE(macos(10.4), ios(2.0))
-int pthread_mutexattr_setprioceiling(pthread_mutexattr_t *, int);
-
-__API_AVAILABLE(macos(10.4), ios(2.0))
-int pthread_mutexattr_setprotocol(pthread_mutexattr_t *, int);
-
-__API_AVAILABLE(macos(10.4), ios(2.0))
-int pthread_mutexattr_setpshared(pthread_mutexattr_t *, int);
-
-__API_AVAILABLE(macos(10.4), ios(2.0))
-int pthread_mutexattr_settype(pthread_mutexattr_t *, int);
-
-__API_AVAILABLE(macos(10.7), ios(5.0))
-int pthread_mutexattr_setpolicy_np(pthread_mutexattr_t *, int);
-
-__SWIFT_UNAVAILABLE_MSG("Use lazily initialized globals instead")
-__API_AVAILABLE(macos(10.4), ios(2.0))
-int pthread_once(pthread_once_t *, void (* _Nonnull)(void));
-
-__API_AVAILABLE(macos(10.4), ios(2.0))
-int pthread_rwlock_destroy(pthread_rwlock_t * ) __DARWIN_ALIAS(pthread_rwlock_destroy);
-
-__API_AVAILABLE(macos(10.4), ios(2.0))
-int pthread_rwlock_init(pthread_rwlock_t * __restrict,
-		const pthread_rwlockattr_t * _Nullable __restrict)
-		__DARWIN_ALIAS(pthread_rwlock_init);
-
-__API_AVAILABLE(macos(10.4), ios(2.0))
-int pthread_rwlock_rdlock(pthread_rwlock_t *) __DARWIN_ALIAS(pthread_rwlock_rdlock);
-
-__API_AVAILABLE(macos(10.4), ios(2.0))
-int pthread_rwlock_tryrdlock(pthread_rwlock_t *) __DARWIN_ALIAS(pthread_rwlock_tryrdlock);
-
-__API_AVAILABLE(macos(10.4), ios(2.0))
-int pthread_rwlock_trywrlock(pthread_rwlock_t *) __DARWIN_ALIAS(pthread_rwlock_trywrlock);
-
-__API_AVAILABLE(macos(10.4), ios(2.0))
-int pthread_rwlock_wrlock(pthread_rwlock_t *) __DARWIN_ALIAS(pthread_rwlock_wrlock);
-
-__API_AVAILABLE(macos(10.4), ios(2.0))
-int pthread_rwlock_unlock(pthread_rwlock_t *) __DARWIN_ALIAS(pthread_rwlock_unlock);
-
-__API_AVAILABLE(macos(10.4), ios(2.0))
-int pthread_rwlockattr_destroy(pthread_rwlockattr_t *);
-
-__API_AVAILABLE(macos(10.4), ios(2.0))
-int pthread_rwlockattr_getpshared(const pthread_rwlockattr_t * __restrict,
-		int * __restrict);
-
-__API_AVAILABLE(macos(10.4), ios(2.0))
-int pthread_rwlockattr_init(pthread_rwlockattr_t *);
-
-__API_AVAILABLE(macos(10.4), ios(2.0))
-int pthread_rwlockattr_setpshared(pthread_rwlockattr_t *, int);
-
-__API_AVAILABLE(macos(10.4), ios(2.0))
-pthread_t pthread_self(void);
-
-__API_AVAILABLE(macos(10.4), ios(2.0))
-int pthread_setcancelstate(int , int * _Nullable)
-		__DARWIN_ALIAS(pthread_setcancelstate);
-
-__API_AVAILABLE(macos(10.4), ios(2.0))
-int pthread_setcanceltype(int , int * _Nullable)
-		__DARWIN_ALIAS(pthread_setcanceltype);
-
-__API_AVAILABLE(macos(10.4), ios(2.0))
-int pthread_setconcurrency(int);
-
-__API_AVAILABLE(macos(10.4), ios(2.0))
-int pthread_setschedparam(pthread_t, int, const struct sched_param *);
-
-__API_AVAILABLE(macos(10.4), ios(2.0))
-int pthread_setspecific(pthread_key_t , const void * _Nullable);
-
-__API_AVAILABLE(macos(10.4), ios(2.0))
-void pthread_testcancel(void) __DARWIN_ALIAS(pthread_testcancel);
-
-#if (!defined(_POSIX_C_SOURCE) && !defined(_XOPEN_SOURCE)) || defined(_DARWIN_C_SOURCE) || defined(__cplusplus)
-
-/* returns non-zero if pthread_create or cthread_fork have been called */
-__API_AVAILABLE(macos(10.4), ios(2.0))
-int pthread_is_threaded_np(void);
-
-__API_AVAILABLE(macos(10.6), ios(3.2))
-int pthread_threadid_np(pthread_t _Nullable,__uint64_t* _Nullable);
-
-/*SPI to set and get pthread name*/
-__API_AVAILABLE(macos(10.6), ios(3.2))
-int	pthread_getname_np(pthread_t,char*,size_t);
-
-__API_AVAILABLE(macos(10.6), ios(3.2))
-int	pthread_setname_np(const char*);
-
-/* returns non-zero if the current thread is the main thread */
-__API_AVAILABLE(macos(10.4), ios(2.0))
-int	pthread_main_np(void);
-
-/* return the mach thread bound to the pthread */
-__API_AVAILABLE(macos(10.4), ios(2.0))
-mach_port_t pthread_mach_thread_np(pthread_t);
-
-__API_AVAILABLE(macos(10.4), ios(2.0))
-size_t pthread_get_stacksize_np(pthread_t);
-
-__API_AVAILABLE(macos(10.4), ios(2.0))
-void* pthread_get_stackaddr_np(pthread_t);
-
-/* Like pthread_cond_signal(), but only wake up the specified pthread */
-__API_AVAILABLE(macos(10.4), ios(2.0))
-int pthread_cond_signal_thread_np(pthread_cond_t *, pthread_t _Nullable);
-
-/* Like pthread_cond_timedwait, but use a relative timeout */
-__API_AVAILABLE(macos(10.4), ios(2.0))
-int pthread_cond_timedwait_relative_np(pthread_cond_t *, pthread_mutex_t *,
-		const struct timespec * _Nullable);
-
-/* Like pthread_create(), but leaves the thread suspended */
-__API_AVAILABLE(macos(10.4), ios(2.0))
-#if !_PTHREAD_SWIFT_IMPORTER_NULLABILITY_COMPAT
-int pthread_create_suspended_np(
-		pthread_t _Nullable * _Nonnull, const pthread_attr_t * _Nullable,
-		void * _Nullable (* _Nonnull)(void * _Nullable), void * _Nullable);
-#else
-int pthread_create_suspended_np(pthread_t *, const pthread_attr_t * _Nullable,
-		void *(* _Nonnull)(void *), void * _Nullable);
-#endif
-
-__API_AVAILABLE(macos(10.4), ios(2.0))
-int pthread_kill(pthread_t, int);
-
-__API_AVAILABLE(macos(10.5), ios(2.0))
-_Nullable pthread_t pthread_from_mach_thread_np(mach_port_t);
-
-__API_AVAILABLE(macos(10.4), ios(2.0))
-int pthread_sigmask(int, const sigset_t * _Nullable, sigset_t * _Nullable)
-		__DARWIN_ALIAS(pthread_sigmask);
-
-__API_AVAILABLE(macos(10.4), ios(2.0))
-void pthread_yield_np(void);
-
-#endif /* (!_POSIX_C_SOURCE && !_XOPEN_SOURCE) || _DARWIN_C_SOURCE || __cplusplus */
-__END_DECLS
-#if __has_feature(assume_nonnull)
-_Pragma("clang assume_nonnull end")
-#endif
-
-#endif /* _PTHREAD_H */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/pthread/sched.h b/lib/libc/include/x86_64-macos-gnu/pthread/sched.h
deleted file mode 100644
index 3c49e7980d..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/pthread/sched.h
+++ /dev/null
@@ -1,43 +0,0 @@
-/*
- * Copyright (c) 2000-2003 Apple Computer, Inc. All rights reserved.
- *
- * @APPLE_LICENSE_HEADER_START@
- * 
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this
- * file.
- * 
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- * 
- * @APPLE_LICENSE_HEADER_END@
- */
-
-#ifndef _SCHED_H_
-#define _SCHED_H_
-
-#include <sys/cdefs.h>
-#include <pthread_impl.h>
-
-__BEGIN_DECLS
-/*
- * Scheduling paramters
- */
-#ifndef __POSIX_LIB__
-struct sched_param { int sched_priority;  char __opaque[__SCHED_PARAM_SIZE__]; };
-#endif
-
-extern int sched_yield(void);
-extern int sched_get_priority_min(int);
-extern int sched_get_priority_max(int);
-__END_DECLS
-
-#endif /* _SCHED_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/pthread_impl.h b/lib/libc/include/x86_64-macos-gnu/pthread_impl.h
deleted file mode 100644
index aae74c2c03..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/pthread_impl.h
+++ /dev/null
@@ -1,66 +0,0 @@
-/*
- * Copyright (c) 2000-2003 Apple Computer, Inc. All rights reserved.
- *
- * @APPLE_LICENSE_HEADER_START@
- * 
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this
- * file.
- * 
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- * 
- * @APPLE_LICENSE_HEADER_END@
- */
-
-#ifndef _PTHREAD_IMPL_H_
-#define _PTHREAD_IMPL_H_
-/*
- * Internal implementation details
- */
-
-/* This whole header file will disappear, so don't depend on it... */
-
-#if __has_feature(assume_nonnull)
-_Pragma("clang assume_nonnull begin")
-#endif
-
-#ifndef __POSIX_LIB__
-
-/*
- * [Internal] data structure signatures
- */
-#define _PTHREAD_MUTEX_SIG_init		0x32AAABA7
-
-#define _PTHREAD_ERRORCHECK_MUTEX_SIG_init      0x32AAABA1
-#define _PTHREAD_RECURSIVE_MUTEX_SIG_init       0x32AAABA2
-#define _PTHREAD_FIRSTFIT_MUTEX_SIG_init       0x32AAABA3
-
-#define _PTHREAD_COND_SIG_init		0x3CB0B1BB
-#define _PTHREAD_ONCE_SIG_init		0x30B1BCBA
-#define _PTHREAD_RWLOCK_SIG_init    0x2DA8B3B4
-
-/*
- * POSIX scheduling policies
- */
-#define SCHED_OTHER                1
-#define SCHED_FIFO                 4
-#define SCHED_RR                   2
-
-#define __SCHED_PARAM_SIZE__       4
-
-#endif /* __POSIX_LIB__ */
-
-#if __has_feature(assume_nonnull)
-_Pragma("clang assume_nonnull end")
-#endif
-
-#endif /* _PTHREAD_IMPL_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/sched.h b/lib/libc/include/x86_64-macos-gnu/sched.h
deleted file mode 100644
index 3c49e7980d..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/sched.h
+++ /dev/null
@@ -1,43 +0,0 @@
-/*
- * Copyright (c) 2000-2003 Apple Computer, Inc. All rights reserved.
- *
- * @APPLE_LICENSE_HEADER_START@
- * 
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this
- * file.
- * 
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- * 
- * @APPLE_LICENSE_HEADER_END@
- */
-
-#ifndef _SCHED_H_
-#define _SCHED_H_
-
-#include <sys/cdefs.h>
-#include <pthread_impl.h>
-
-__BEGIN_DECLS
-/*
- * Scheduling paramters
- */
-#ifndef __POSIX_LIB__
-struct sched_param { int sched_priority;  char __opaque[__SCHED_PARAM_SIZE__]; };
-#endif
-
-extern int sched_yield(void);
-extern int sched_get_priority_min(int);
-extern int sched_get_priority_max(int);
-__END_DECLS
-
-#endif /* _SCHED_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/signal.h b/lib/libc/include/x86_64-macos-gnu/signal.h
deleted file mode 100644
index dbc5b35f2b..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/signal.h
+++ /dev/null
@@ -1,129 +0,0 @@
-/*
- * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
- *
- * @APPLE_LICENSE_HEADER_START@
- * 
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this
- * file.
- * 
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- * 
- * @APPLE_LICENSE_HEADER_END@
- */
-/*-
- * Copyright (c) 1991, 1993
- *	The Regents of the University of California.  All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *	This product includes software developed by the University of
- *	California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *	@(#)signal.h	8.3 (Berkeley) 3/30/94
- */
-
-#ifndef _USER_SIGNAL_H
-#define _USER_SIGNAL_H
-
-#include <sys/cdefs.h>
-#include <_types.h>
-#include <sys/signal.h>
-
-#include <sys/_pthread/_pthread_types.h>
-#include <sys/_pthread/_pthread_t.h>
-
-#if !defined(_ANSI_SOURCE) && (!defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE))
-extern __const char *__const sys_signame[NSIG];
-extern __const char *__const sys_siglist[NSIG];
-#endif
-
-__BEGIN_DECLS
-int	raise(int);
-__END_DECLS
-
-#ifndef	_ANSI_SOURCE
-__BEGIN_DECLS
-void	(* _Nullable bsd_signal(int, void (* _Nullable)(int)))(int);
-int	kill(pid_t, int) __DARWIN_ALIAS(kill);
-int	killpg(pid_t, int) __DARWIN_ALIAS(killpg);
-int	pthread_kill(pthread_t, int);
-int	pthread_sigmask(int, const sigset_t *, sigset_t *) __DARWIN_ALIAS(pthread_sigmask);
-int	sigaction(int, const struct sigaction * __restrict,
-	    struct sigaction * __restrict);
-int	sigaddset(sigset_t *, int);
-int	sigaltstack(const stack_t * __restrict, stack_t * __restrict)  __DARWIN_ALIAS(sigaltstack) __WATCHOS_PROHIBITED __TVOS_PROHIBITED;
-int	sigdelset(sigset_t *, int);
-int	sigemptyset(sigset_t *);
-int	sigfillset(sigset_t *);
-int	sighold(int);
-int	sigignore(int);
-int	siginterrupt(int, int);
-int	sigismember(const sigset_t *, int);
-int	sigpause(int) __DARWIN_ALIAS_C(sigpause);
-int	sigpending(sigset_t *);
-int	sigprocmask(int, const sigset_t * __restrict, sigset_t * __restrict);
-int	sigrelse(int);
-void    (* _Nullable sigset(int, void (* _Nullable)(int)))(int);
-int	sigsuspend(const sigset_t *) __DARWIN_ALIAS_C(sigsuspend);
-int	sigwait(const sigset_t * __restrict, int * __restrict) __DARWIN_ALIAS_C(sigwait);
-#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-void	psignal(unsigned int, const char *);
-int	sigblock(int);
-int	sigsetmask(int);
-int	sigvec(int, struct sigvec *, struct sigvec *);
-#endif	/* (!_POSIX_C_SOURCE || _DARWIN_C_SOURCE) */
-__END_DECLS
-
-/* List definitions after function declarations, or Reiser cpp gets upset. */
-#if defined(__i386__) || defined(__x86_64__)
-/* The left shift operator on intel is modulo 32 */
-__header_always_inline int
-__sigbits(int __signo)
-{
-    return __signo > __DARWIN_NSIG ? 0 : (1 << (__signo - 1));
-}
-#else /* !__i386__ && !__x86_64__ */
-#define __sigbits(signo)	(1 << ((signo) - 1))
-#endif /* __i386__ || __x86_64__ */
-
-#define	sigaddset(set, signo)	(*(set) |= __sigbits(signo), 0)
-#define	sigdelset(set, signo)	(*(set) &= ~__sigbits(signo), 0)
-#define	sigismember(set, signo)	((*(set) & __sigbits(signo)) != 0)
-#define	sigemptyset(set)	(*(set) = 0, 0)
-#define	sigfillset(set)		(*(set) = ~(sigset_t)0, 0)
-#endif	/* !_ANSI_SOURCE */
-
-#endif	/* !_USER_SIGNAL_H */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/simd/common.h b/lib/libc/include/x86_64-macos-gnu/simd/common.h
deleted file mode 100644
index 4c2f4d0760..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/simd/common.h
+++ /dev/null
@@ -1,4458 +0,0 @@
-/*! @header
- *  The interfaces declared in this header provide "common" elementwise
- *  operations that are neither math nor logic functions.  These are available
- *  only for floating-point vectors and scalars, except for min, max, abs,
- *  clamp, and the reduce operations, which also support integer vectors.
- *
- *      simd_abs(x)             Absolute value of x.  Also available as fabs
- *                              for floating-point vectors.  If x is the
- *                              smallest signed integer, x is returned.
- *
- *      simd_max(x,y)           Returns the maximum of x and y.  Also available
- *                              as fmax for floating-point vectors.
- *
- *      simd_min(x,y)           Returns the minimum of x and y.  Also available
- *                              as fmin for floating-point vectors.
- *
- *      simd_clamp(x,min,max)   x clamped to the range [min, max].
- *
- *      simd_sign(x)            -1 if x is less than zero, 0 if x is zero or
- *                              NaN, and +1 if x is greater than zero.
- *
- *      simd_mix(x,y,t)         If t is not in the range [0,1], the result is
- *                              undefined.  Otherwise the result is x+(y-x)*t,
- *                              which linearly interpolates between x and y.
- *
- *      simd_recip(x)           An approximation to 1/x.  If x is very near the
- *                              limits of representable values, or is infinity
- *                              or NaN, the result is undefined.  There are
- *                              two variants of this function:
- *
- *                                  simd_precise_recip(x)
- *
- *                              and
- *
- *                                  simd_fast_recip(x).
- *
- *                              The "precise" variant is accurate to a few ULPs,
- *                              whereas the "fast" variant may have as little
- *                              as 11 bits of accuracy in float and about 22
- *                              bits in double.
- *
- *                              The function simd_recip(x) resolves to
- *                              simd_precise_recip(x) ordinarily, but to
- *                              simd_fast_recip(x) when used in a translation
- *                              unit compiled with -ffast-math (when
- *                              -ffast-math is in effect, you may still use the
- *                              precise version of this function by calling it
- *                              explicitly by name).
- *
- *      simd_rsqrt(x)           An approximation to 1/sqrt(x).  If x is
- *                              infinity or NaN, the result is undefined.
- *                              There are two variants of this function:
- *
- *                                  simd_precise_rsqrt(x)
- *
- *                              and
- *
- *                                  simd_fast_rsqrt(x).
- *
- *                              The "precise" variant is accurate to a few ULPs,
- *                              whereas the "fast" variant may have as little
- *                              as 11 bits of accuracy in float and about 22
- *                              bits in double.
- *
- *                              The function simd_rsqrt(x) resolves to
- *                              simd_precise_rsqrt(x) ordinarily, but to
- *                              simd_fast_rsqrt(x) when used in a translation
- *                              unit compiled with -ffast-math (when
- *                              -ffast-math is in effect, you may still use the
- *                              precise version of this function by calling it
- *                              explicitly by name).
- *
- *      simd_fract(x)           The "fractional part" of x, which lies strictly
- *                              in the range [0, 0x1.fffffep-1].
- *
- *      simd_step(edge,x)       0 if x < edge, and 1 otherwise.
- *
- *      simd_smoothstep(edge0,edge1,x) 0 if x <= edge0, 1 if x >= edge1, and
- *                              a Hermite interpolation between 0 and 1 if
- *                              edge0 < x < edge1.
- *
- *      simd_reduce_add(x)      Sum of the elements of x.
- *
- *      simd_reduce_min(x)      Minimum of the elements of x.
- *
- *      simd_reduce_max(x)      Maximum of the elements of x.
- *
- *      simd_equal(x,y)         True if and only if every lane of x is equal
- *                              to the corresponding lane of y.
- *
- *  The following common functions are available in the simd:: namespace:
- *
- *      C++ Function                    Equivalent C Function
- *      --------------------------------------------------------------------
- *      simd::abs(x)                    simd_abs(x)
- *      simd::max(x,y)                  simd_max(x,y)
- *      simd::min(x,y)                  simd_min(x,y)
- *      simd::clamp(x,min,max)          simd_clamp(x,min,max)
- *      simd::sign(x)                   simd_sign(x)
- *      simd::mix(x,y,t)                simd_mix(x,y,t)
- *      simd::recip(x)                  simd_recip(x)
- *      simd::rsqrt(x)                  simd_rsqrt(x)
- *      simd::fract(x)                  simd_fract(x)
- *      simd::step(edge,x)              simd_step(edge,x)
- *      simd::smoothstep(e0,e1,x)       simd_smoothstep(e0,e1,x)
- *      simd::reduce_add(x)             simd_reduce_add(x)
- *      simd::reduce_max(x)             simd_reduce_max(x)
- *      simd::reduce_min(x)             simd_reduce_min(x)
- *      simd::equal(x,y)                simd_equal(x,y)
- *
- *      simd::precise::recip(x)         simd_precise_recip(x)
- *      simd::precise::rsqrt(x)         simd_precise_rsqrt(x)
- *
- *      simd::fast::recip(x)            simd_fast_recip(x)
- *      simd::fast::rsqrt(x)            simd_fast_rsqrt(x)
- *
- *  @copyright 2014-2017 Apple, Inc. All rights reserved.
- *  @unsorted                                                                 */
-
-#ifndef SIMD_COMMON_HEADER
-#define SIMD_COMMON_HEADER
-
-#include <simd/base.h>
-#if SIMD_COMPILER_HAS_REQUIRED_FEATURES
-#include <simd/vector_make.h>
-#include <simd/logic.h>
-#include <simd/math.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/*! @abstract The elementwise absolute value of x.                            */
-static inline SIMD_CFUNC simd_char2 simd_abs(simd_char2 x);
-/*! @abstract The elementwise absolute value of x.                            */
-static inline SIMD_CFUNC simd_char3 simd_abs(simd_char3 x);
-/*! @abstract The elementwise absolute value of x.                            */
-static inline SIMD_CFUNC simd_char4 simd_abs(simd_char4 x);
-/*! @abstract The elementwise absolute value of x.                            */
-static inline SIMD_CFUNC simd_char8 simd_abs(simd_char8 x);
-/*! @abstract The elementwise absolute value of x.                            */
-static inline SIMD_CFUNC simd_char16 simd_abs(simd_char16 x);
-/*! @abstract The elementwise absolute value of x.                            */
-static inline SIMD_CFUNC simd_char32 simd_abs(simd_char32 x);
-/*! @abstract The elementwise absolute value of x.                            */
-static inline SIMD_CFUNC simd_char64 simd_abs(simd_char64 x);
-/*! @abstract The elementwise absolute value of x.                            */
-static inline SIMD_CFUNC simd_short2 simd_abs(simd_short2 x);
-/*! @abstract The elementwise absolute value of x.                            */
-static inline SIMD_CFUNC simd_short3 simd_abs(simd_short3 x);
-/*! @abstract The elementwise absolute value of x.                            */
-static inline SIMD_CFUNC simd_short4 simd_abs(simd_short4 x);
-/*! @abstract The elementwise absolute value of x.                            */
-static inline SIMD_CFUNC simd_short8 simd_abs(simd_short8 x);
-/*! @abstract The elementwise absolute value of x.                            */
-static inline SIMD_CFUNC simd_short16 simd_abs(simd_short16 x);
-/*! @abstract The elementwise absolute value of x.                            */
-static inline SIMD_CFUNC simd_short32 simd_abs(simd_short32 x);
-/*! @abstract The elementwise absolute value of x.                            */
-static inline SIMD_CFUNC simd_int2 simd_abs(simd_int2 x);
-/*! @abstract The elementwise absolute value of x.                            */
-static inline SIMD_CFUNC simd_int3 simd_abs(simd_int3 x);
-/*! @abstract The elementwise absolute value of x.                            */
-static inline SIMD_CFUNC simd_int4 simd_abs(simd_int4 x);
-/*! @abstract The elementwise absolute value of x.                            */
-static inline SIMD_CFUNC simd_int8 simd_abs(simd_int8 x);
-/*! @abstract The elementwise absolute value of x.                            */
-static inline SIMD_CFUNC simd_int16 simd_abs(simd_int16 x);
-/*! @abstract The elementwise absolute value of x.                            */
-static inline SIMD_CFUNC simd_float2 simd_abs(simd_float2 x);
-/*! @abstract The elementwise absolute value of x.                            */
-static inline SIMD_CFUNC simd_float3 simd_abs(simd_float3 x);
-/*! @abstract The elementwise absolute value of x.                            */
-static inline SIMD_CFUNC simd_float4 simd_abs(simd_float4 x);
-/*! @abstract The elementwise absolute value of x.                            */
-static inline SIMD_CFUNC simd_float8 simd_abs(simd_float8 x);
-/*! @abstract The elementwise absolute value of x.                            */
-static inline SIMD_CFUNC simd_float16 simd_abs(simd_float16 x);
-/*! @abstract The elementwise absolute value of x.                            */
-static inline SIMD_CFUNC simd_long2 simd_abs(simd_long2 x);
-/*! @abstract The elementwise absolute value of x.                            */
-static inline SIMD_CFUNC simd_long3 simd_abs(simd_long3 x);
-/*! @abstract The elementwise absolute value of x.                            */
-static inline SIMD_CFUNC simd_long4 simd_abs(simd_long4 x);
-/*! @abstract The elementwise absolute value of x.                            */
-static inline SIMD_CFUNC simd_long8 simd_abs(simd_long8 x);
-/*! @abstract The elementwise absolute value of x.                            */
-static inline SIMD_CFUNC simd_double2 simd_abs(simd_double2 x);
-/*! @abstract The elementwise absolute value of x.                            */
-static inline SIMD_CFUNC simd_double3 simd_abs(simd_double3 x);
-/*! @abstract The elementwise absolute value of x.                            */
-static inline SIMD_CFUNC simd_double4 simd_abs(simd_double4 x);
-/*! @abstract The elementwise absolute value of x.                            */
-static inline SIMD_CFUNC simd_double8 simd_abs(simd_double8 x);
-/*! @abstract The elementwise absolute value of x.
- *  @discussion Deprecated. Use simd_abs(x) instead.                          */
-#define vector_abs simd_abs
-  
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_char2 simd_max(simd_char2 x, simd_char2 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_char3 simd_max(simd_char3 x, simd_char3 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_char4 simd_max(simd_char4 x, simd_char4 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_char8 simd_max(simd_char8 x, simd_char8 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_char16 simd_max(simd_char16 x, simd_char16 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_char32 simd_max(simd_char32 x, simd_char32 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_char64 simd_max(simd_char64 x, simd_char64 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_uchar2 simd_max(simd_uchar2 x, simd_uchar2 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_uchar3 simd_max(simd_uchar3 x, simd_uchar3 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_uchar4 simd_max(simd_uchar4 x, simd_uchar4 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_uchar8 simd_max(simd_uchar8 x, simd_uchar8 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_uchar16 simd_max(simd_uchar16 x, simd_uchar16 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_uchar32 simd_max(simd_uchar32 x, simd_uchar32 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_uchar64 simd_max(simd_uchar64 x, simd_uchar64 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_short2 simd_max(simd_short2 x, simd_short2 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_short3 simd_max(simd_short3 x, simd_short3 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_short4 simd_max(simd_short4 x, simd_short4 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_short8 simd_max(simd_short8 x, simd_short8 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_short16 simd_max(simd_short16 x, simd_short16 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_short32 simd_max(simd_short32 x, simd_short32 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_ushort2 simd_max(simd_ushort2 x, simd_ushort2 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_ushort3 simd_max(simd_ushort3 x, simd_ushort3 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_ushort4 simd_max(simd_ushort4 x, simd_ushort4 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_ushort8 simd_max(simd_ushort8 x, simd_ushort8 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_ushort16 simd_max(simd_ushort16 x, simd_ushort16 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_ushort32 simd_max(simd_ushort32 x, simd_ushort32 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_int2 simd_max(simd_int2 x, simd_int2 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_int3 simd_max(simd_int3 x, simd_int3 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_int4 simd_max(simd_int4 x, simd_int4 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_int8 simd_max(simd_int8 x, simd_int8 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_int16 simd_max(simd_int16 x, simd_int16 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_uint2 simd_max(simd_uint2 x, simd_uint2 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_uint3 simd_max(simd_uint3 x, simd_uint3 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_uint4 simd_max(simd_uint4 x, simd_uint4 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_uint8 simd_max(simd_uint8 x, simd_uint8 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_uint16 simd_max(simd_uint16 x, simd_uint16 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC float simd_max(float x, float y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_float2 simd_max(simd_float2 x, simd_float2 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_float3 simd_max(simd_float3 x, simd_float3 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_float4 simd_max(simd_float4 x, simd_float4 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_float8 simd_max(simd_float8 x, simd_float8 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_float16 simd_max(simd_float16 x, simd_float16 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_long2 simd_max(simd_long2 x, simd_long2 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_long3 simd_max(simd_long3 x, simd_long3 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_long4 simd_max(simd_long4 x, simd_long4 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_long8 simd_max(simd_long8 x, simd_long8 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_ulong2 simd_max(simd_ulong2 x, simd_ulong2 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_ulong3 simd_max(simd_ulong3 x, simd_ulong3 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_ulong4 simd_max(simd_ulong4 x, simd_ulong4 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_ulong8 simd_max(simd_ulong8 x, simd_ulong8 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC double simd_max(double x, double y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_double2 simd_max(simd_double2 x, simd_double2 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_double3 simd_max(simd_double3 x, simd_double3 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_double4 simd_max(simd_double4 x, simd_double4 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_double8 simd_max(simd_double8 x, simd_double8 y);
-/*! @abstract The elementwise maximum of x and y.
- *  @discussion Deprecated. Use simd_max(x,y) instead.                        */
-#define vector_max simd_max
-
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_char2 simd_min(simd_char2 x, simd_char2 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_char3 simd_min(simd_char3 x, simd_char3 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_char4 simd_min(simd_char4 x, simd_char4 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_char8 simd_min(simd_char8 x, simd_char8 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_char16 simd_min(simd_char16 x, simd_char16 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_char32 simd_min(simd_char32 x, simd_char32 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_char64 simd_min(simd_char64 x, simd_char64 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_uchar2 simd_min(simd_uchar2 x, simd_uchar2 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_uchar3 simd_min(simd_uchar3 x, simd_uchar3 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_uchar4 simd_min(simd_uchar4 x, simd_uchar4 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_uchar8 simd_min(simd_uchar8 x, simd_uchar8 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_uchar16 simd_min(simd_uchar16 x, simd_uchar16 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_uchar32 simd_min(simd_uchar32 x, simd_uchar32 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_uchar64 simd_min(simd_uchar64 x, simd_uchar64 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_short2 simd_min(simd_short2 x, simd_short2 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_short3 simd_min(simd_short3 x, simd_short3 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_short4 simd_min(simd_short4 x, simd_short4 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_short8 simd_min(simd_short8 x, simd_short8 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_short16 simd_min(simd_short16 x, simd_short16 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_short32 simd_min(simd_short32 x, simd_short32 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_ushort2 simd_min(simd_ushort2 x, simd_ushort2 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_ushort3 simd_min(simd_ushort3 x, simd_ushort3 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_ushort4 simd_min(simd_ushort4 x, simd_ushort4 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_ushort8 simd_min(simd_ushort8 x, simd_ushort8 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_ushort16 simd_min(simd_ushort16 x, simd_ushort16 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_ushort32 simd_min(simd_ushort32 x, simd_ushort32 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_int2 simd_min(simd_int2 x, simd_int2 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_int3 simd_min(simd_int3 x, simd_int3 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_int4 simd_min(simd_int4 x, simd_int4 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_int8 simd_min(simd_int8 x, simd_int8 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_int16 simd_min(simd_int16 x, simd_int16 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_uint2 simd_min(simd_uint2 x, simd_uint2 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_uint3 simd_min(simd_uint3 x, simd_uint3 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_uint4 simd_min(simd_uint4 x, simd_uint4 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_uint8 simd_min(simd_uint8 x, simd_uint8 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_uint16 simd_min(simd_uint16 x, simd_uint16 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC float simd_min(float x, float y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_float2 simd_min(simd_float2 x, simd_float2 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_float3 simd_min(simd_float3 x, simd_float3 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_float4 simd_min(simd_float4 x, simd_float4 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_float8 simd_min(simd_float8 x, simd_float8 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_float16 simd_min(simd_float16 x, simd_float16 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_long2 simd_min(simd_long2 x, simd_long2 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_long3 simd_min(simd_long3 x, simd_long3 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_long4 simd_min(simd_long4 x, simd_long4 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_long8 simd_min(simd_long8 x, simd_long8 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_ulong2 simd_min(simd_ulong2 x, simd_ulong2 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_ulong3 simd_min(simd_ulong3 x, simd_ulong3 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_ulong4 simd_min(simd_ulong4 x, simd_ulong4 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_ulong8 simd_min(simd_ulong8 x, simd_ulong8 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC double simd_min(double x, double y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_double2 simd_min(simd_double2 x, simd_double2 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_double3 simd_min(simd_double3 x, simd_double3 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_double4 simd_min(simd_double4 x, simd_double4 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_double8 simd_min(simd_double8 x, simd_double8 y);
-/*! @abstract The elementwise minimum of x and y.
- *  @discussion Deprecated. Use simd_min(x,y) instead.                        */
-#define vector_min simd_min
-
-  
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_char2 simd_clamp(simd_char2 x, simd_char2 min, simd_char2 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_char3 simd_clamp(simd_char3 x, simd_char3 min, simd_char3 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_char4 simd_clamp(simd_char4 x, simd_char4 min, simd_char4 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_char8 simd_clamp(simd_char8 x, simd_char8 min, simd_char8 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_char16 simd_clamp(simd_char16 x, simd_char16 min, simd_char16 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_char32 simd_clamp(simd_char32 x, simd_char32 min, simd_char32 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_char64 simd_clamp(simd_char64 x, simd_char64 min, simd_char64 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_uchar2 simd_clamp(simd_uchar2 x, simd_uchar2 min, simd_uchar2 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_uchar3 simd_clamp(simd_uchar3 x, simd_uchar3 min, simd_uchar3 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_uchar4 simd_clamp(simd_uchar4 x, simd_uchar4 min, simd_uchar4 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_uchar8 simd_clamp(simd_uchar8 x, simd_uchar8 min, simd_uchar8 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_uchar16 simd_clamp(simd_uchar16 x, simd_uchar16 min, simd_uchar16 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_uchar32 simd_clamp(simd_uchar32 x, simd_uchar32 min, simd_uchar32 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_uchar64 simd_clamp(simd_uchar64 x, simd_uchar64 min, simd_uchar64 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_short2 simd_clamp(simd_short2 x, simd_short2 min, simd_short2 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_short3 simd_clamp(simd_short3 x, simd_short3 min, simd_short3 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_short4 simd_clamp(simd_short4 x, simd_short4 min, simd_short4 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_short8 simd_clamp(simd_short8 x, simd_short8 min, simd_short8 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_short16 simd_clamp(simd_short16 x, simd_short16 min, simd_short16 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_short32 simd_clamp(simd_short32 x, simd_short32 min, simd_short32 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_ushort2 simd_clamp(simd_ushort2 x, simd_ushort2 min, simd_ushort2 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_ushort3 simd_clamp(simd_ushort3 x, simd_ushort3 min, simd_ushort3 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_ushort4 simd_clamp(simd_ushort4 x, simd_ushort4 min, simd_ushort4 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_ushort8 simd_clamp(simd_ushort8 x, simd_ushort8 min, simd_ushort8 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_ushort16 simd_clamp(simd_ushort16 x, simd_ushort16 min, simd_ushort16 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_ushort32 simd_clamp(simd_ushort32 x, simd_ushort32 min, simd_ushort32 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_int2 simd_clamp(simd_int2 x, simd_int2 min, simd_int2 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_int3 simd_clamp(simd_int3 x, simd_int3 min, simd_int3 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_int4 simd_clamp(simd_int4 x, simd_int4 min, simd_int4 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_int8 simd_clamp(simd_int8 x, simd_int8 min, simd_int8 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_int16 simd_clamp(simd_int16 x, simd_int16 min, simd_int16 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_uint2 simd_clamp(simd_uint2 x, simd_uint2 min, simd_uint2 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_uint3 simd_clamp(simd_uint3 x, simd_uint3 min, simd_uint3 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_uint4 simd_clamp(simd_uint4 x, simd_uint4 min, simd_uint4 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_uint8 simd_clamp(simd_uint8 x, simd_uint8 min, simd_uint8 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_uint16 simd_clamp(simd_uint16 x, simd_uint16 min, simd_uint16 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC float simd_clamp(float x, float min, float max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_float2 simd_clamp(simd_float2 x, simd_float2 min, simd_float2 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_float3 simd_clamp(simd_float3 x, simd_float3 min, simd_float3 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_float4 simd_clamp(simd_float4 x, simd_float4 min, simd_float4 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_float8 simd_clamp(simd_float8 x, simd_float8 min, simd_float8 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_float16 simd_clamp(simd_float16 x, simd_float16 min, simd_float16 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_long2 simd_clamp(simd_long2 x, simd_long2 min, simd_long2 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_long3 simd_clamp(simd_long3 x, simd_long3 min, simd_long3 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_long4 simd_clamp(simd_long4 x, simd_long4 min, simd_long4 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_long8 simd_clamp(simd_long8 x, simd_long8 min, simd_long8 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_ulong2 simd_clamp(simd_ulong2 x, simd_ulong2 min, simd_ulong2 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_ulong3 simd_clamp(simd_ulong3 x, simd_ulong3 min, simd_ulong3 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_ulong4 simd_clamp(simd_ulong4 x, simd_ulong4 min, simd_ulong4 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_ulong8 simd_clamp(simd_ulong8 x, simd_ulong8 min, simd_ulong8 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC double simd_clamp(double x, double min, double max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_double2 simd_clamp(simd_double2 x, simd_double2 min, simd_double2 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_double3 simd_clamp(simd_double3 x, simd_double3 min, simd_double3 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_double4 simd_clamp(simd_double4 x, simd_double4 min, simd_double4 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_double8 simd_clamp(simd_double8 x, simd_double8 min, simd_double8 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Deprecated. Use simd_clamp(x,min,max) instead.                */
-#define vector_clamp simd_clamp
-  
-/*! @abstract -1 if x is negative, +1 if x is positive, and 0 otherwise.      */
-static inline SIMD_CFUNC float simd_sign(float x);
-/*! @abstract -1 if x is negative, +1 if x is positive, and 0 otherwise.      */
-static inline SIMD_CFUNC simd_float2 simd_sign(simd_float2 x);
-/*! @abstract -1 if x is negative, +1 if x is positive, and 0 otherwise.      */
-static inline SIMD_CFUNC simd_float3 simd_sign(simd_float3 x);
-/*! @abstract -1 if x is negative, +1 if x is positive, and 0 otherwise.      */
-static inline SIMD_CFUNC simd_float4 simd_sign(simd_float4 x);
-/*! @abstract -1 if x is negative, +1 if x is positive, and 0 otherwise.      */
-static inline SIMD_CFUNC simd_float8 simd_sign(simd_float8 x);
-/*! @abstract -1 if x is negative, +1 if x is positive, and 0 otherwise.      */
-static inline SIMD_CFUNC simd_float16 simd_sign(simd_float16 x);
-/*! @abstract -1 if x is negative, +1 if x is positive, and 0 otherwise.      */
-static inline SIMD_CFUNC double simd_sign(double x);
-/*! @abstract -1 if x is negative, +1 if x is positive, and 0 otherwise.      */
-static inline SIMD_CFUNC simd_double2 simd_sign(simd_double2 x);
-/*! @abstract -1 if x is negative, +1 if x is positive, and 0 otherwise.      */
-static inline SIMD_CFUNC simd_double3 simd_sign(simd_double3 x);
-/*! @abstract -1 if x is negative, +1 if x is positive, and 0 otherwise.      */
-static inline SIMD_CFUNC simd_double4 simd_sign(simd_double4 x);
-/*! @abstract -1 if x is negative, +1 if x is positive, and 0 otherwise.      */
-static inline SIMD_CFUNC simd_double8 simd_sign(simd_double8 x);
-/*! @abstract -1 if x is negative, +1 if x is positive, and 0 otherwise.
- *  @discussion Deprecated. Use simd_sign(x) instead.                         */
-#define vector_sign simd_sign
-
-/*! @abstract Linearly interpolates between x and y, taking the value x when
- *  t=0 and y when t=1                                                        */
-static inline SIMD_CFUNC float simd_mix(float x, float y, float t);
-/*! @abstract Linearly interpolates between x and y, taking the value x when
- *  t=0 and y when t=1                                                        */
-static inline SIMD_CFUNC simd_float2 simd_mix(simd_float2 x, simd_float2 y, simd_float2 t);
-/*! @abstract Linearly interpolates between x and y, taking the value x when
- *  t=0 and y when t=1                                                        */
-static inline SIMD_CFUNC simd_float3 simd_mix(simd_float3 x, simd_float3 y, simd_float3 t);
-/*! @abstract Linearly interpolates between x and y, taking the value x when
- *  t=0 and y when t=1                                                        */
-static inline SIMD_CFUNC simd_float4 simd_mix(simd_float4 x, simd_float4 y, simd_float4 t);
-/*! @abstract Linearly interpolates between x and y, taking the value x when
- *  t=0 and y when t=1                                                        */
-static inline SIMD_CFUNC simd_float8 simd_mix(simd_float8 x, simd_float8 y, simd_float8 t);
-/*! @abstract Linearly interpolates between x and y, taking the value x when
- *  t=0 and y when t=1                                                        */
-static inline SIMD_CFUNC simd_float16 simd_mix(simd_float16 x, simd_float16 y, simd_float16 t);
-/*! @abstract Linearly interpolates between x and y, taking the value x when
- *  t=0 and y when t=1                                                        */
-static inline SIMD_CFUNC double simd_mix(double x, double y, double t);
-/*! @abstract Linearly interpolates between x and y, taking the value x when
- *  t=0 and y when t=1                                                        */
-static inline SIMD_CFUNC simd_double2 simd_mix(simd_double2 x, simd_double2 y, simd_double2 t);
-/*! @abstract Linearly interpolates between x and y, taking the value x when
- *  t=0 and y when t=1                                                        */
-static inline SIMD_CFUNC simd_double3 simd_mix(simd_double3 x, simd_double3 y, simd_double3 t);
-/*! @abstract Linearly interpolates between x and y, taking the value x when
- *  t=0 and y when t=1                                                        */
-static inline SIMD_CFUNC simd_double4 simd_mix(simd_double4 x, simd_double4 y, simd_double4 t);
-/*! @abstract Linearly interpolates between x and y, taking the value x when
- *  t=0 and y when t=1                                                        */
-static inline SIMD_CFUNC simd_double8 simd_mix(simd_double8 x, simd_double8 y, simd_double8 t);
-/*! @abstract Linearly interpolates between x and y, taking the value x when
- *  t=0 and y when t=1
- *  @discussion Deprecated. Use simd_mix(x, y, t) instead.                    */
-#define vector_mix simd_mix
-
-/*! @abstract A good approximation to 1/x.
- *  @discussion If x is very close to the limits of representation, the
- *  result may overflow or underflow; otherwise this function is accurate to
- *  a few units in the last place (ULPs).                                     */
-static inline SIMD_CFUNC float simd_precise_recip(float x);
-/*! @abstract A good approximation to 1/x.
- *  @discussion If x is very close to the limits of representation, the
- *  result may overflow or underflow; otherwise this function is accurate to
- *  a few units in the last place (ULPs).                                     */
-static inline SIMD_CFUNC simd_float2 simd_precise_recip(simd_float2 x);
-/*! @abstract A good approximation to 1/x.
- *  @discussion If x is very close to the limits of representation, the
- *  result may overflow or underflow; otherwise this function is accurate to
- *  a few units in the last place (ULPs).                                     */
-static inline SIMD_CFUNC simd_float3 simd_precise_recip(simd_float3 x);
-/*! @abstract A good approximation to 1/x.
- *  @discussion If x is very close to the limits of representation, the
- *  result may overflow or underflow; otherwise this function is accurate to
- *  a few units in the last place (ULPs).                                     */
-static inline SIMD_CFUNC simd_float4 simd_precise_recip(simd_float4 x);
-/*! @abstract A good approximation to 1/x.
- *  @discussion If x is very close to the limits of representation, the
- *  result may overflow or underflow; otherwise this function is accurate to
- *  a few units in the last place (ULPs).                                     */
-static inline SIMD_CFUNC simd_float8 simd_precise_recip(simd_float8 x);
-/*! @abstract A good approximation to 1/x.
- *  @discussion If x is very close to the limits of representation, the
- *  result may overflow or underflow; otherwise this function is accurate to
- *  a few units in the last place (ULPs).                                     */
-static inline SIMD_CFUNC simd_float16 simd_precise_recip(simd_float16 x);
-/*! @abstract A good approximation to 1/x.
- *  @discussion If x is very close to the limits of representation, the
- *  result may overflow or underflow; otherwise this function is accurate to
- *  a few units in the last place (ULPs).                                     */
-static inline SIMD_CFUNC double simd_precise_recip(double x);
-/*! @abstract A good approximation to 1/x.
- *  @discussion If x is very close to the limits of representation, the
- *  result may overflow or underflow; otherwise this function is accurate to
- *  a few units in the last place (ULPs).                                     */
-static inline SIMD_CFUNC simd_double2 simd_precise_recip(simd_double2 x);
-/*! @abstract A good approximation to 1/x.
- *  @discussion If x is very close to the limits of representation, the
- *  result may overflow or underflow; otherwise this function is accurate to
- *  a few units in the last place (ULPs).                                     */
-static inline SIMD_CFUNC simd_double3 simd_precise_recip(simd_double3 x);
-/*! @abstract A good approximation to 1/x.
- *  @discussion If x is very close to the limits of representation, the
- *  result may overflow or underflow; otherwise this function is accurate to
- *  a few units in the last place (ULPs).                                     */
-static inline SIMD_CFUNC simd_double4 simd_precise_recip(simd_double4 x);
-/*! @abstract A good approximation to 1/x.
- *  @discussion If x is very close to the limits of representation, the
- *  result may overflow or underflow; otherwise this function is accurate to
- *  a few units in the last place (ULPs).                                     */
-static inline SIMD_CFUNC simd_double8 simd_precise_recip(simd_double8 x);
-/*! @abstract A good approximation to 1/x.
- *  @discussion Deprecated. Use simd_precise_recip(x) instead.                */
-#define vector_precise_recip simd_precise_recip
-
-/*! @abstract A fast approximation to 1/x.
- *  @discussion If x is very close to the limits of representation, the
- *  result may overflow or underflow; otherwise this function is accurate to
- *  at least 11 bits for float and 22 bits for double.                        */
-static inline SIMD_CFUNC float simd_fast_recip(float x);
-/*! @abstract A fast approximation to 1/x.
- *  @discussion If x is very close to the limits of representation, the
- *  result may overflow or underflow; otherwise this function is accurate to
- *  at least 11 bits for float and 22 bits for double.                        */
-static inline SIMD_CFUNC simd_float2 simd_fast_recip(simd_float2 x);
-/*! @abstract A fast approximation to 1/x.
- *  @discussion If x is very close to the limits of representation, the
- *  result may overflow or underflow; otherwise this function is accurate to
- *  at least 11 bits for float and 22 bits for double.                        */
-static inline SIMD_CFUNC simd_float3 simd_fast_recip(simd_float3 x);
-/*! @abstract A fast approximation to 1/x.
- *  @discussion If x is very close to the limits of representation, the
- *  result may overflow or underflow; otherwise this function is accurate to
- *  at least 11 bits for float and 22 bits for double.                        */
-static inline SIMD_CFUNC simd_float4 simd_fast_recip(simd_float4 x);
-/*! @abstract A fast approximation to 1/x.
- *  @discussion If x is very close to the limits of representation, the
- *  result may overflow or underflow; otherwise this function is accurate to
- *  at least 11 bits for float and 22 bits for double.                        */
-static inline SIMD_CFUNC simd_float8 simd_fast_recip(simd_float8 x);
-/*! @abstract A fast approximation to 1/x.
- *  @discussion If x is very close to the limits of representation, the
- *  result may overflow or underflow; otherwise this function is accurate to
- *  at least 11 bits for float and 22 bits for double.                        */
-static inline SIMD_CFUNC simd_float16 simd_fast_recip(simd_float16 x);
-/*! @abstract A fast approximation to 1/x.
- *  @discussion If x is very close to the limits of representation, the
- *  result may overflow or underflow; otherwise this function is accurate to
- *  at least 11 bits for float and 22 bits for double.                        */
-static inline SIMD_CFUNC double simd_fast_recip(double x);
-/*! @abstract A fast approximation to 1/x.
- *  @discussion If x is very close to the limits of representation, the
- *  result may overflow or underflow; otherwise this function is accurate to
- *  at least 11 bits for float and 22 bits for double.                        */
-static inline SIMD_CFUNC simd_double2 simd_fast_recip(simd_double2 x);
-/*! @abstract A fast approximation to 1/x.
- *  @discussion If x is very close to the limits of representation, the
- *  result may overflow or underflow; otherwise this function is accurate to
- *  at least 11 bits for float and 22 bits for double.                        */
-static inline SIMD_CFUNC simd_double3 simd_fast_recip(simd_double3 x);
-/*! @abstract A fast approximation to 1/x.
- *  @discussion If x is very close to the limits of representation, the
- *  result may overflow or underflow; otherwise this function is accurate to
- *  at least 11 bits for float and 22 bits for double.                        */
-static inline SIMD_CFUNC simd_double4 simd_fast_recip(simd_double4 x);
-/*! @abstract A fast approximation to 1/x.
- *  @discussion If x is very close to the limits of representation, the
- *  result may overflow or underflow; otherwise this function is accurate to
- *  at least 11 bits for float and 22 bits for double.                        */
-static inline SIMD_CFUNC simd_double8 simd_fast_recip(simd_double8 x);
-/*! @abstract A fast approximation to 1/x.
- *  @discussion Deprecated. Use simd_fast_recip(x) instead.                   */
-#define vector_fast_recip simd_fast_recip
-
-/*! @abstract An approximation to 1/x.
- *  @discussion If x is very close to the limits of representation, the
- *  result may overflow or underflow. This function maps to
- *  simd_fast_recip(x) if -ffast-math is specified, and to
- *  simd_precise_recip(x) otherwise.                                          */
-static inline SIMD_CFUNC float simd_recip(float x);
-/*! @abstract An approximation to 1/x.
- *  @discussion If x is very close to the limits of representation, the
- *  result may overflow or underflow. This function maps to
- *  simd_fast_recip(x) if -ffast-math is specified, and to
- *  simd_precise_recip(x) otherwise.                                          */
-static inline SIMD_CFUNC simd_float2 simd_recip(simd_float2 x);
-/*! @abstract An approximation to 1/x.
- *  @discussion If x is very close to the limits of representation, the
- *  result may overflow or underflow. This function maps to
- *  simd_fast_recip(x) if -ffast-math is specified, and to
- *  simd_precise_recip(x) otherwise.                                          */
-static inline SIMD_CFUNC simd_float3 simd_recip(simd_float3 x);
-/*! @abstract An approximation to 1/x.
- *  @discussion If x is very close to the limits of representation, the
- *  result may overflow or underflow. This function maps to
- *  simd_fast_recip(x) if -ffast-math is specified, and to
- *  simd_precise_recip(x) otherwise.                                          */
-static inline SIMD_CFUNC simd_float4 simd_recip(simd_float4 x);
-/*! @abstract An approximation to 1/x.
- *  @discussion If x is very close to the limits of representation, the
- *  result may overflow or underflow. This function maps to
- *  simd_fast_recip(x) if -ffast-math is specified, and to
- *  simd_precise_recip(x) otherwise.                                          */
-static inline SIMD_CFUNC simd_float8 simd_recip(simd_float8 x);
-/*! @abstract An approximation to 1/x.
- *  @discussion If x is very close to the limits of representation, the
- *  result may overflow or underflow. This function maps to
- *  simd_fast_recip(x) if -ffast-math is specified, and to
- *  simd_precise_recip(x) otherwise.                                          */
-static inline SIMD_CFUNC simd_float16 simd_recip(simd_float16 x);
-/*! @abstract An approximation to 1/x.
- *  @discussion If x is very close to the limits of representation, the
- *  result may overflow or underflow. This function maps to
- *  simd_fast_recip(x) if -ffast-math is specified, and to
- *  simd_precise_recip(x) otherwise.                                          */
-static inline SIMD_CFUNC double simd_recip(double x);
-/*! @abstract An approximation to 1/x.
- *  @discussion If x is very close to the limits of representation, the
- *  result may overflow or underflow. This function maps to
- *  simd_fast_recip(x) if -ffast-math is specified, and to
- *  simd_precise_recip(x) otherwise.                                          */
-static inline SIMD_CFUNC simd_double2 simd_recip(simd_double2 x);
-/*! @abstract An approximation to 1/x.
- *  @discussion If x is very close to the limits of representation, the
- *  result may overflow or underflow. This function maps to
- *  simd_fast_recip(x) if -ffast-math is specified, and to
- *  simd_precise_recip(x) otherwise.                                          */
-static inline SIMD_CFUNC simd_double3 simd_recip(simd_double3 x);
-/*! @abstract An approximation to 1/x.
- *  @discussion If x is very close to the limits of representation, the
- *  result may overflow or underflow. This function maps to
- *  simd_fast_recip(x) if -ffast-math is specified, and to
- *  simd_precise_recip(x) otherwise.                                          */
-static inline SIMD_CFUNC simd_double4 simd_recip(simd_double4 x);
-/*! @abstract An approximation to 1/x.
- *  @discussion If x is very close to the limits of representation, the
- *  result may overflow or underflow. This function maps to
- *  simd_fast_recip(x) if -ffast-math is specified, and to
- *  simd_precise_recip(x) otherwise.                                          */
-static inline SIMD_CFUNC simd_double8 simd_recip(simd_double8 x);
-/*! @abstract An approximation to 1/x.
- *  @discussion Deprecated. Use simd_recip(x) instead.                        */
-#define vector_recip simd_recip
-
-/*! @abstract A good approximation to 1/sqrt(x).
- *  @discussion This function is accurate to a few units in the last place
- *  (ULPs).                                                                   */
-static inline SIMD_CFUNC float simd_precise_rsqrt(float x);
-/*! @abstract A good approximation to 1/sqrt(x).
- *  @discussion This function is accurate to a few units in the last place
- *  (ULPs).                                                                   */
-static inline SIMD_CFUNC simd_float2 simd_precise_rsqrt(simd_float2 x);
-/*! @abstract A good approximation to 1/sqrt(x).
- *  @discussion This function is accurate to a few units in the last place
- *  (ULPs).                                                                   */
-static inline SIMD_CFUNC simd_float3 simd_precise_rsqrt(simd_float3 x);
-/*! @abstract A good approximation to 1/sqrt(x).
- *  @discussion This function is accurate to a few units in the last place
- *  (ULPs).                                                                   */
-static inline SIMD_CFUNC simd_float4 simd_precise_rsqrt(simd_float4 x);
-/*! @abstract A good approximation to 1/sqrt(x).
- *  @discussion This function is accurate to a few units in the last place
- *  (ULPs).                                                                   */
-static inline SIMD_CFUNC simd_float8 simd_precise_rsqrt(simd_float8 x);
-/*! @abstract A good approximation to 1/sqrt(x).
- *  @discussion This function is accurate to a few units in the last place
- *  (ULPs).                                                                   */
-static inline SIMD_CFUNC simd_float16 simd_precise_rsqrt(simd_float16 x);
-/*! @abstract A good approximation to 1/sqrt(x).
- *  @discussion This function is accurate to a few units in the last place
- *  (ULPs).                                                                   */
-static inline SIMD_CFUNC double simd_precise_rsqrt(double x);
-/*! @abstract A good approximation to 1/sqrt(x).
- *  @discussion This function is accurate to a few units in the last place
- *  (ULPs).                                                                   */
-static inline SIMD_CFUNC simd_double2 simd_precise_rsqrt(simd_double2 x);
-/*! @abstract A good approximation to 1/sqrt(x).
- *  @discussion This function is accurate to a few units in the last place
- *  (ULPs).                                                                   */
-static inline SIMD_CFUNC simd_double3 simd_precise_rsqrt(simd_double3 x);
-/*! @abstract A good approximation to 1/sqrt(x).
- *  @discussion This function is accurate to a few units in the last place
- *  (ULPs).                                                                   */
-static inline SIMD_CFUNC simd_double4 simd_precise_rsqrt(simd_double4 x);
-/*! @abstract A good approximation to 1/sqrt(x).
- *  @discussion This function is accurate to a few units in the last place
- *  (ULPs).                                                                   */
-static inline SIMD_CFUNC simd_double8 simd_precise_rsqrt(simd_double8 x);
-/*! @abstract A good approximation to 1/sqrt(x).
- *  @discussion Deprecated. Use simd_precise_rsqrt(x) instead.                */
-#define vector_precise_rsqrt simd_precise_rsqrt
-
-/*! @abstract A fast approximation to 1/sqrt(x).
- *  @discussion This function is accurate to at least 11 bits for float and
- *  22 bits for double.                                                       */
-static inline SIMD_CFUNC float simd_fast_rsqrt(float x);
-/*! @abstract A fast approximation to 1/sqrt(x).
- *  @discussion This function is accurate to at least 11 bits for float and
- *  22 bits for double.                                                       */
-static inline SIMD_CFUNC simd_float2 simd_fast_rsqrt(simd_float2 x);
-/*! @abstract A fast approximation to 1/sqrt(x).
- *  @discussion This function is accurate to at least 11 bits for float and
- *  22 bits for double.                                                       */
-static inline SIMD_CFUNC simd_float3 simd_fast_rsqrt(simd_float3 x);
-/*! @abstract A fast approximation to 1/sqrt(x).
- *  @discussion This function is accurate to at least 11 bits for float and
- *  22 bits for double.                                                       */
-static inline SIMD_CFUNC simd_float4 simd_fast_rsqrt(simd_float4 x);
-/*! @abstract A fast approximation to 1/sqrt(x).
- *  @discussion This function is accurate to at least 11 bits for float and
- *  22 bits for double.                                                       */
-static inline SIMD_CFUNC simd_float8 simd_fast_rsqrt(simd_float8 x);
-/*! @abstract A fast approximation to 1/sqrt(x).
- *  @discussion This function is accurate to at least 11 bits for float and
- *  22 bits for double.                                                       */
-static inline SIMD_CFUNC simd_float16 simd_fast_rsqrt(simd_float16 x);
-/*! @abstract A fast approximation to 1/sqrt(x).
- *  @discussion This function is accurate to at least 11 bits for float and
- *  22 bits for double.                                                       */
-static inline SIMD_CFUNC double simd_fast_rsqrt(double x);
-/*! @abstract A fast approximation to 1/sqrt(x).
- *  @discussion This function is accurate to at least 11 bits for float and
- *  22 bits for double.                                                       */
-static inline SIMD_CFUNC simd_double2 simd_fast_rsqrt(simd_double2 x);
-/*! @abstract A fast approximation to 1/sqrt(x).
- *  @discussion This function is accurate to at least 11 bits for float and
- *  22 bits for double.                                                       */
-static inline SIMD_CFUNC simd_double3 simd_fast_rsqrt(simd_double3 x);
-/*! @abstract A fast approximation to 1/sqrt(x).
- *  @discussion This function is accurate to at least 11 bits for float and
- *  22 bits for double.                                                       */
-static inline SIMD_CFUNC simd_double4 simd_fast_rsqrt(simd_double4 x);
-/*! @abstract A fast approximation to 1/sqrt(x).
- *  @discussion This function is accurate to at least 11 bits for float and
- *  22 bits for double.                                                       */
-static inline SIMD_CFUNC simd_double8 simd_fast_rsqrt(simd_double8 x);
-/*! @abstract A fast approximation to 1/sqrt(x).
- *  @discussion Deprecated. Use simd_fast_rsqrt(x) instead.                   */
-#define vector_fast_rsqrt simd_fast_rsqrt
-
-/*! @abstract An approximation to 1/sqrt(x).
- *  @discussion This function maps to simd_fast_recip(x) if -ffast-math is
- *  specified, and to simd_precise_recip(x) otherwise.                        */
-static inline SIMD_CFUNC float simd_rsqrt(float x);
-/*! @abstract An approximation to 1/sqrt(x).
- *  @discussion This function maps to simd_fast_recip(x) if -ffast-math is
- *  specified, and to simd_precise_recip(x) otherwise.                        */
-static inline SIMD_CFUNC simd_float2 simd_rsqrt(simd_float2 x);
-/*! @abstract An approximation to 1/sqrt(x).
- *  @discussion This function maps to simd_fast_recip(x) if -ffast-math is
- *  specified, and to simd_precise_recip(x) otherwise.                        */
-static inline SIMD_CFUNC simd_float3 simd_rsqrt(simd_float3 x);
-/*! @abstract An approximation to 1/sqrt(x).
- *  @discussion This function maps to simd_fast_recip(x) if -ffast-math is
- *  specified, and to simd_precise_recip(x) otherwise.                        */
-static inline SIMD_CFUNC simd_float4 simd_rsqrt(simd_float4 x);
-/*! @abstract An approximation to 1/sqrt(x).
- *  @discussion This function maps to simd_fast_recip(x) if -ffast-math is
- *  specified, and to simd_precise_recip(x) otherwise.                        */
-static inline SIMD_CFUNC simd_float8 simd_rsqrt(simd_float8 x);
-/*! @abstract An approximation to 1/sqrt(x).
- *  @discussion This function maps to simd_fast_recip(x) if -ffast-math is
- *  specified, and to simd_precise_recip(x) otherwise.                        */
-static inline SIMD_CFUNC simd_float16 simd_rsqrt(simd_float16 x);
-/*! @abstract An approximation to 1/sqrt(x).
- *  @discussion This function maps to simd_fast_recip(x) if -ffast-math is
- *  specified, and to simd_precise_recip(x) otherwise.                        */
-static inline SIMD_CFUNC double simd_rsqrt(double x);
-/*! @abstract An approximation to 1/sqrt(x).
- *  @discussion This function maps to simd_fast_recip(x) if -ffast-math is
- *  specified, and to simd_precise_recip(x) otherwise.                        */
-static inline SIMD_CFUNC simd_double2 simd_rsqrt(simd_double2 x);
-/*! @abstract An approximation to 1/sqrt(x).
- *  @discussion This function maps to simd_fast_recip(x) if -ffast-math is
- *  specified, and to simd_precise_recip(x) otherwise.                        */
-static inline SIMD_CFUNC simd_double3 simd_rsqrt(simd_double3 x);
-/*! @abstract An approximation to 1/sqrt(x).
- *  @discussion This function maps to simd_fast_recip(x) if -ffast-math is
- *  specified, and to simd_precise_recip(x) otherwise.                        */
-static inline SIMD_CFUNC simd_double4 simd_rsqrt(simd_double4 x);
-/*! @abstract An approximation to 1/sqrt(x).
- *  @discussion This function maps to simd_fast_recip(x) if -ffast-math is
- *  specified, and to simd_precise_recip(x) otherwise.                        */
-static inline SIMD_CFUNC simd_double8 simd_rsqrt(simd_double8 x);
-/*! @abstract An approximation to 1/sqrt(x).
- *  @discussion Deprecated. Use simd_rsqrt(x) instead.                        */
-#define vector_rsqrt simd_rsqrt
-
-/*! @abstract The "fractional part" of x, lying in the range [0, 1).
- *  @discussion floor(x) + fract(x) is *approximately* equal to x. If x is
- *  positive and finite, then the two values are exactly equal.               */
-static inline SIMD_CFUNC float simd_fract(float x);
-/*! @abstract The "fractional part" of x, lying in the range [0, 1).
- *  @discussion floor(x) + fract(x) is *approximately* equal to x. If x is
- *  positive and finite, then the two values are exactly equal.               */
-static inline SIMD_CFUNC simd_float2 simd_fract(simd_float2 x);
-/*! @abstract The "fractional part" of x, lying in the range [0, 1).
- *  @discussion floor(x) + fract(x) is *approximately* equal to x. If x is
- *  positive and finite, then the two values are exactly equal.               */
-static inline SIMD_CFUNC simd_float3 simd_fract(simd_float3 x);
-/*! @abstract The "fractional part" of x, lying in the range [0, 1).
- *  @discussion floor(x) + fract(x) is *approximately* equal to x. If x is
- *  positive and finite, then the two values are exactly equal.               */
-static inline SIMD_CFUNC simd_float4 simd_fract(simd_float4 x);
-/*! @abstract The "fractional part" of x, lying in the range [0, 1).
- *  @discussion floor(x) + fract(x) is *approximately* equal to x. If x is
- *  positive and finite, then the two values are exactly equal.               */
-static inline SIMD_CFUNC simd_float8 simd_fract(simd_float8 x);
-/*! @abstract The "fractional part" of x, lying in the range [0, 1).
- *  @discussion floor(x) + fract(x) is *approximately* equal to x. If x is
- *  positive and finite, then the two values are exactly equal.               */
-static inline SIMD_CFUNC simd_float16 simd_fract(simd_float16 x);
-/*! @abstract The "fractional part" of x, lying in the range [0, 1).
- *  @discussion floor(x) + fract(x) is *approximately* equal to x. If x is
- *  positive and finite, then the two values are exactly equal.               */
-static inline SIMD_CFUNC double simd_fract(double x);
-/*! @abstract The "fractional part" of x, lying in the range [0, 1).
- *  @discussion floor(x) + fract(x) is *approximately* equal to x. If x is
- *  positive and finite, then the two values are exactly equal.               */
-static inline SIMD_CFUNC simd_double2 simd_fract(simd_double2 x);
-/*! @abstract The "fractional part" of x, lying in the range [0, 1).
- *  @discussion floor(x) + fract(x) is *approximately* equal to x. If x is
- *  positive and finite, then the two values are exactly equal.               */
-static inline SIMD_CFUNC simd_double3 simd_fract(simd_double3 x);
-/*! @abstract The "fractional part" of x, lying in the range [0, 1).
- *  @discussion floor(x) + fract(x) is *approximately* equal to x. If x is
- *  positive and finite, then the two values are exactly equal.               */
-static inline SIMD_CFUNC simd_double4 simd_fract(simd_double4 x);
-/*! @abstract The "fractional part" of x, lying in the range [0, 1).
- *  @discussion floor(x) + fract(x) is *approximately* equal to x. If x is
- *  positive and finite, then the two values are exactly equal.               */
-static inline SIMD_CFUNC simd_double8 simd_fract(simd_double8 x);
-/*! @abstract The "fractional part" of x, lying in the range [0, 1).
- *  @discussion Deprecated. Use simd_fract(x) instead.                        */
-#define vector_fract simd_fract
-
-/*! @abstract 0 if x < edge, and 1 otherwise.
- *  @discussion Use a scalar value for edge if you want to apply the same
- *  threshold to all lanes.                                                   */
-static inline SIMD_CFUNC float simd_step(float edge, float x);
-/*! @abstract 0 if x < edge, and 1 otherwise.
- *  @discussion Use a scalar value for edge if you want to apply the same
- *  threshold to all lanes.                                                   */
-static inline SIMD_CFUNC simd_float2 simd_step(simd_float2 edge, simd_float2 x);
-/*! @abstract 0 if x < edge, and 1 otherwise.
- *  @discussion Use a scalar value for edge if you want to apply the same
- *  threshold to all lanes.                                                   */
-static inline SIMD_CFUNC simd_float3 simd_step(simd_float3 edge, simd_float3 x);
-/*! @abstract 0 if x < edge, and 1 otherwise.
- *  @discussion Use a scalar value for edge if you want to apply the same
- *  threshold to all lanes.                                                   */
-static inline SIMD_CFUNC simd_float4 simd_step(simd_float4 edge, simd_float4 x);
-/*! @abstract 0 if x < edge, and 1 otherwise.
- *  @discussion Use a scalar value for edge if you want to apply the same
- *  threshold to all lanes.                                                   */
-static inline SIMD_CFUNC simd_float8 simd_step(simd_float8 edge, simd_float8 x);
-/*! @abstract 0 if x < edge, and 1 otherwise.
- *  @discussion Use a scalar value for edge if you want to apply the same
- *  threshold to all lanes.                                                   */
-static inline SIMD_CFUNC simd_float16 simd_step(simd_float16 edge, simd_float16 x);
-/*! @abstract 0 if x < edge, and 1 otherwise.
- *  @discussion Use a scalar value for edge if you want to apply the same
- *  threshold to all lanes.                                                   */
-static inline SIMD_CFUNC double simd_step(double edge, double x);
-/*! @abstract 0 if x < edge, and 1 otherwise.
- *  @discussion Use a scalar value for edge if you want to apply the same
- *  threshold to all lanes.                                                   */
-static inline SIMD_CFUNC simd_double2 simd_step(simd_double2 edge, simd_double2 x);
-/*! @abstract 0 if x < edge, and 1 otherwise.
- *  @discussion Use a scalar value for edge if you want to apply the same
- *  threshold to all lanes.                                                   */
-static inline SIMD_CFUNC simd_double3 simd_step(simd_double3 edge, simd_double3 x);
-/*! @abstract 0 if x < edge, and 1 otherwise.
- *  @discussion Use a scalar value for edge if you want to apply the same
- *  threshold to all lanes.                                                   */
-static inline SIMD_CFUNC simd_double4 simd_step(simd_double4 edge, simd_double4 x);
-/*! @abstract 0 if x < edge, and 1 otherwise.
- *  @discussion Use a scalar value for edge if you want to apply the same
- *  threshold to all lanes.                                                   */
-static inline SIMD_CFUNC simd_double8 simd_step(simd_double8 edge, simd_double8 x);
-/*! @abstract 0 if x < edge, and 1 otherwise.
- *  @discussion Deprecated. Use simd_step(edge, x) instead.                   */
-#define vector_step simd_step
-
-/*! @abstract Interpolates smoothly between 0 at edge0 and 1 at edge1
- *  @discussion You can use a scalar value for edge0 and edge1 if you want
- *  to clamp all lanes at the same points.                                    */
-static inline SIMD_CFUNC float simd_smoothstep(float edge0, float edge1, float x);
-/*! @abstract Interpolates smoothly between 0 at edge0 and 1 at edge1
- *  @discussion You can use a scalar value for edge0 and edge1 if you want
- *  to clamp all lanes at the same points.                                    */
-static inline SIMD_CFUNC simd_float2 simd_smoothstep(simd_float2 edge0, simd_float2 edge1, simd_float2 x);
-/*! @abstract Interpolates smoothly between 0 at edge0 and 1 at edge1
- *  @discussion You can use a scalar value for edge0 and edge1 if you want
- *  to clamp all lanes at the same points.                                    */
-static inline SIMD_CFUNC simd_float3 simd_smoothstep(simd_float3 edge0, simd_float3 edge1, simd_float3 x);
-/*! @abstract Interpolates smoothly between 0 at edge0 and 1 at edge1
- *  @discussion You can use a scalar value for edge0 and edge1 if you want
- *  to clamp all lanes at the same points.                                    */
-static inline SIMD_CFUNC simd_float4 simd_smoothstep(simd_float4 edge0, simd_float4 edge1, simd_float4 x);
-/*! @abstract Interpolates smoothly between 0 at edge0 and 1 at edge1
- *  @discussion You can use a scalar value for edge0 and edge1 if you want
- *  to clamp all lanes at the same points.                                    */
-static inline SIMD_CFUNC simd_float8 simd_smoothstep(simd_float8 edge0, simd_float8 edge1, simd_float8 x);
-/*! @abstract Interpolates smoothly between 0 at edge0 and 1 at edge1
- *  @discussion You can use a scalar value for edge0 and edge1 if you want
- *  to clamp all lanes at the same points.                                    */
-static inline SIMD_CFUNC simd_float16 simd_smoothstep(simd_float16 edge0, simd_float16 edge1, simd_float16 x);
-/*! @abstract Interpolates smoothly between 0 at edge0 and 1 at edge1
- *  @discussion You can use a scalar value for edge0 and edge1 if you want
- *  to clamp all lanes at the same points.                                    */
-static inline SIMD_CFUNC double simd_smoothstep(double edge0, double edge1, double x);
-/*! @abstract Interpolates smoothly between 0 at edge0 and 1 at edge1
- *  @discussion You can use a scalar value for edge0 and edge1 if you want
- *  to clamp all lanes at the same points.                                    */
-static inline SIMD_CFUNC simd_double2 simd_smoothstep(simd_double2 edge0, simd_double2 edge1, simd_double2 x);
-/*! @abstract Interpolates smoothly between 0 at edge0 and 1 at edge1
- *  @discussion You can use a scalar value for edge0 and edge1 if you want
- *  to clamp all lanes at the same points.                                    */
-static inline SIMD_CFUNC simd_double3 simd_smoothstep(simd_double3 edge0, simd_double3 edge1, simd_double3 x);
-/*! @abstract Interpolates smoothly between 0 at edge0 and 1 at edge1
- *  @discussion You can use a scalar value for edge0 and edge1 if you want
- *  to clamp all lanes at the same points.                                    */
-static inline SIMD_CFUNC simd_double4 simd_smoothstep(simd_double4 edge0, simd_double4 edge1, simd_double4 x);
-/*! @abstract Interpolates smoothly between 0 at edge0 and 1 at edge1
- *  @discussion You can use a scalar value for edge0 and edge1 if you want
- *  to clamp all lanes at the same points.                                    */
-static inline SIMD_CFUNC simd_double8 simd_smoothstep(simd_double8 edge0, simd_double8 edge1, simd_double8 x);
-/*! @abstract Interpolates smoothly between 0 at edge0 and 1 at edge1
- *  @discussion Deprecated. Use simd_smoothstep(edge0, edge1, x) instead.     */
-#define vector_smoothstep simd_smoothstep
-
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC char simd_reduce_add(simd_char2 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC char simd_reduce_add(simd_char3 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC char simd_reduce_add(simd_char4 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC char simd_reduce_add(simd_char8 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC char simd_reduce_add(simd_char16 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC char simd_reduce_add(simd_char32 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC char simd_reduce_add(simd_char64 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC unsigned char simd_reduce_add(simd_uchar2 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC unsigned char simd_reduce_add(simd_uchar3 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC unsigned char simd_reduce_add(simd_uchar4 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC unsigned char simd_reduce_add(simd_uchar8 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC unsigned char simd_reduce_add(simd_uchar16 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC unsigned char simd_reduce_add(simd_uchar32 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC unsigned char simd_reduce_add(simd_uchar64 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC short simd_reduce_add(simd_short2 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC short simd_reduce_add(simd_short3 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC short simd_reduce_add(simd_short4 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC short simd_reduce_add(simd_short8 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC short simd_reduce_add(simd_short16 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC short simd_reduce_add(simd_short32 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC unsigned short simd_reduce_add(simd_ushort2 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC unsigned short simd_reduce_add(simd_ushort3 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC unsigned short simd_reduce_add(simd_ushort4 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC unsigned short simd_reduce_add(simd_ushort8 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC unsigned short simd_reduce_add(simd_ushort16 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC unsigned short simd_reduce_add(simd_ushort32 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC int simd_reduce_add(simd_int2 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC int simd_reduce_add(simd_int3 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC int simd_reduce_add(simd_int4 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC int simd_reduce_add(simd_int8 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC int simd_reduce_add(simd_int16 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC unsigned int simd_reduce_add(simd_uint2 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC unsigned int simd_reduce_add(simd_uint3 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC unsigned int simd_reduce_add(simd_uint4 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC unsigned int simd_reduce_add(simd_uint8 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC unsigned int simd_reduce_add(simd_uint16 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC float simd_reduce_add(simd_float2 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC float simd_reduce_add(simd_float3 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC float simd_reduce_add(simd_float4 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC float simd_reduce_add(simd_float8 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC float simd_reduce_add(simd_float16 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC simd_long1 simd_reduce_add(simd_long2 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC simd_long1 simd_reduce_add(simd_long3 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC simd_long1 simd_reduce_add(simd_long4 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC simd_long1 simd_reduce_add(simd_long8 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC simd_ulong1 simd_reduce_add(simd_ulong2 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC simd_ulong1 simd_reduce_add(simd_ulong3 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC simd_ulong1 simd_reduce_add(simd_ulong4 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC simd_ulong1 simd_reduce_add(simd_ulong8 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC double simd_reduce_add(simd_double2 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC double simd_reduce_add(simd_double3 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC double simd_reduce_add(simd_double4 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC double simd_reduce_add(simd_double8 x);
-/*! @abstract Sum of elements in x.
- *  @discussion Deprecated. Use simd_add(x) instead.                          */
-#define vector_reduce_add simd_reduce_add
-  
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC char simd_reduce_min(simd_char2 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC char simd_reduce_min(simd_char3 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC char simd_reduce_min(simd_char4 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC char simd_reduce_min(simd_char8 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC char simd_reduce_min(simd_char16 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC char simd_reduce_min(simd_char32 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC char simd_reduce_min(simd_char64 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC unsigned char simd_reduce_min(simd_uchar2 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC unsigned char simd_reduce_min(simd_uchar3 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC unsigned char simd_reduce_min(simd_uchar4 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC unsigned char simd_reduce_min(simd_uchar8 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC unsigned char simd_reduce_min(simd_uchar16 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC unsigned char simd_reduce_min(simd_uchar32 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC unsigned char simd_reduce_min(simd_uchar64 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC short simd_reduce_min(simd_short2 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC short simd_reduce_min(simd_short3 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC short simd_reduce_min(simd_short4 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC short simd_reduce_min(simd_short8 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC short simd_reduce_min(simd_short16 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC short simd_reduce_min(simd_short32 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC unsigned short simd_reduce_min(simd_ushort2 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC unsigned short simd_reduce_min(simd_ushort3 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC unsigned short simd_reduce_min(simd_ushort4 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC unsigned short simd_reduce_min(simd_ushort8 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC unsigned short simd_reduce_min(simd_ushort16 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC unsigned short simd_reduce_min(simd_ushort32 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC int simd_reduce_min(simd_int2 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC int simd_reduce_min(simd_int3 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC int simd_reduce_min(simd_int4 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC int simd_reduce_min(simd_int8 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC int simd_reduce_min(simd_int16 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC unsigned int simd_reduce_min(simd_uint2 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC unsigned int simd_reduce_min(simd_uint3 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC unsigned int simd_reduce_min(simd_uint4 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC unsigned int simd_reduce_min(simd_uint8 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC unsigned int simd_reduce_min(simd_uint16 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC float simd_reduce_min(simd_float2 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC float simd_reduce_min(simd_float3 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC float simd_reduce_min(simd_float4 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC float simd_reduce_min(simd_float8 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC float simd_reduce_min(simd_float16 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC simd_long1 simd_reduce_min(simd_long2 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC simd_long1 simd_reduce_min(simd_long3 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC simd_long1 simd_reduce_min(simd_long4 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC simd_long1 simd_reduce_min(simd_long8 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC simd_ulong1 simd_reduce_min(simd_ulong2 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC simd_ulong1 simd_reduce_min(simd_ulong3 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC simd_ulong1 simd_reduce_min(simd_ulong4 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC simd_ulong1 simd_reduce_min(simd_ulong8 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC double simd_reduce_min(simd_double2 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC double simd_reduce_min(simd_double3 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC double simd_reduce_min(simd_double4 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC double simd_reduce_min(simd_double8 x);
-/*! @abstract Minimum of elements in x.
- *  @discussion Deprecated. Use simd_min(x) instead.                          */
-#define vector_reduce_min simd_reduce_min
-  
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC char simd_reduce_max(simd_char2 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC char simd_reduce_max(simd_char3 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC char simd_reduce_max(simd_char4 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC char simd_reduce_max(simd_char8 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC char simd_reduce_max(simd_char16 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC char simd_reduce_max(simd_char32 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC char simd_reduce_max(simd_char64 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC unsigned char simd_reduce_max(simd_uchar2 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC unsigned char simd_reduce_max(simd_uchar3 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC unsigned char simd_reduce_max(simd_uchar4 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC unsigned char simd_reduce_max(simd_uchar8 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC unsigned char simd_reduce_max(simd_uchar16 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC unsigned char simd_reduce_max(simd_uchar32 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC unsigned char simd_reduce_max(simd_uchar64 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC short simd_reduce_max(simd_short2 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC short simd_reduce_max(simd_short3 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC short simd_reduce_max(simd_short4 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC short simd_reduce_max(simd_short8 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC short simd_reduce_max(simd_short16 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC short simd_reduce_max(simd_short32 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC unsigned short simd_reduce_max(simd_ushort2 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC unsigned short simd_reduce_max(simd_ushort3 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC unsigned short simd_reduce_max(simd_ushort4 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC unsigned short simd_reduce_max(simd_ushort8 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC unsigned short simd_reduce_max(simd_ushort16 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC unsigned short simd_reduce_max(simd_ushort32 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC int simd_reduce_max(simd_int2 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC int simd_reduce_max(simd_int3 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC int simd_reduce_max(simd_int4 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC int simd_reduce_max(simd_int8 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC int simd_reduce_max(simd_int16 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC unsigned int simd_reduce_max(simd_uint2 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC unsigned int simd_reduce_max(simd_uint3 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC unsigned int simd_reduce_max(simd_uint4 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC unsigned int simd_reduce_max(simd_uint8 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC unsigned int simd_reduce_max(simd_uint16 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC float simd_reduce_max(simd_float2 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC float simd_reduce_max(simd_float3 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC float simd_reduce_max(simd_float4 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC float simd_reduce_max(simd_float8 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC float simd_reduce_max(simd_float16 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC simd_long1 simd_reduce_max(simd_long2 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC simd_long1 simd_reduce_max(simd_long3 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC simd_long1 simd_reduce_max(simd_long4 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC simd_long1 simd_reduce_max(simd_long8 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC simd_ulong1 simd_reduce_max(simd_ulong2 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC simd_ulong1 simd_reduce_max(simd_ulong3 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC simd_ulong1 simd_reduce_max(simd_ulong4 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC simd_ulong1 simd_reduce_max(simd_ulong8 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC double simd_reduce_max(simd_double2 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC double simd_reduce_max(simd_double3 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC double simd_reduce_max(simd_double4 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC double simd_reduce_max(simd_double8 x);
-/*! @abstract Maximum of elements in x.
- *  @discussion Deprecated. Use simd_max(x) instead.                          */
-#define vector_reduce_max simd_reduce_max
-  
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_char2 x, simd_char2 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_char3 x, simd_char3 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_char4 x, simd_char4 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_char8 x, simd_char8 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_char16 x, simd_char16 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_char32 x, simd_char32 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_char64 x, simd_char64 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_uchar2 x, simd_uchar2 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_uchar3 x, simd_uchar3 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_uchar4 x, simd_uchar4 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_uchar8 x, simd_uchar8 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_uchar16 x, simd_uchar16 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_uchar32 x, simd_uchar32 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_uchar64 x, simd_uchar64 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_short2 x, simd_short2 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_short3 x, simd_short3 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_short4 x, simd_short4 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_short8 x, simd_short8 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_short16 x, simd_short16 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_short32 x, simd_short32 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_ushort2 x, simd_ushort2 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_ushort3 x, simd_ushort3 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_ushort4 x, simd_ushort4 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_ushort8 x, simd_ushort8 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_ushort16 x, simd_ushort16 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_ushort32 x, simd_ushort32 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_int2 x, simd_int2 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_int3 x, simd_int3 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_int4 x, simd_int4 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_int8 x, simd_int8 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_int16 x, simd_int16 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_uint2 x, simd_uint2 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_uint3 x, simd_uint3 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_uint4 x, simd_uint4 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_uint8 x, simd_uint8 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_uint16 x, simd_uint16 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_float2 x, simd_float2 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_float3 x, simd_float3 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_float4 x, simd_float4 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_float8 x, simd_float8 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_float16 x, simd_float16 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_long2 x, simd_long2 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_long3 x, simd_long3 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_long4 x, simd_long4 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_long8 x, simd_long8 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_ulong2 x, simd_ulong2 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_ulong3 x, simd_ulong3 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_ulong4 x, simd_ulong4 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_ulong8 x, simd_ulong8 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_double2 x, simd_double2 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_double3 x, simd_double3 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_double4 x, simd_double4 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_double8 x, simd_double8 y) {
-  return simd_all(x == y);
-}
-  
-#ifdef __cplusplus
-} /* extern "C" */
-
-namespace simd {
-  /*! @abstract The lanewise absolute value of x.                             */
-  template <typename typeN> static SIMD_CPPFUNC typeN abs(const typeN x) { return ::simd_abs(x); }
-  /*! @abstract The lanewise maximum of x and y.                              */
-  template <typename typeN> static SIMD_CPPFUNC typeN max(const typeN x, const typeN y) { return ::simd_max(x,y); }
-  /*! @abstract The lanewise minimum of x and y.                              */
-  template <typename typeN> static SIMD_CPPFUNC typeN min(const typeN x, const typeN y) { return ::simd_min(x,y); }
-  /*! @abstract x clamped to the interval [min, max].                         */
-  template <typename typeN> static SIMD_CPPFUNC typeN clamp(const typeN x, const typeN min, const typeN max) { return ::simd_clamp(x,min,max); }
-  /*! @abstract -1 if x < 0, +1 if x > 0, and 0 otherwise.                    */
-  template <typename fptypeN> static SIMD_CPPFUNC fptypeN sign(const fptypeN x) { return ::simd_sign(x); }
-  /*! @abstract Linearly interpolates between x and y, taking the value x when t=0 and y when t=1 */
-  template <typename fptypeN> static SIMD_CPPFUNC fptypeN mix(const fptypeN x, const fptypeN y, const fptypeN t) { return ::simd_mix(x,y,t); }
-  /*! @abstract An approximation to 1/x.                                      */
-  template <typename fptypeN> static SIMD_CPPFUNC fptypeN recip(const fptypeN x) { return simd_recip(x); }
-  /*! @abstract An approximation to 1/sqrt(x).                                */
-  template <typename fptypeN> static SIMD_CPPFUNC fptypeN rsqrt(const fptypeN x) { return simd_rsqrt(x); }
-  /*! @abstract The "fracional part" of x, in the range [0,1).                */
-  template <typename fptypeN> static SIMD_CPPFUNC fptypeN fract(const fptypeN x) { return ::simd_fract(x); }
-  /*! @abstract 0 if x < edge, 1 otherwise.                                   */
-  template <typename fptypeN> static SIMD_CPPFUNC fptypeN step(const fptypeN edge, const fptypeN x) { return ::simd_step(edge,x); }
-  /*! @abstract smoothly interpolates from 0 at edge0 to 1 at edge1.          */
-  template <typename fptypeN> static SIMD_CPPFUNC fptypeN smoothstep(const fptypeN edge0, const fptypeN edge1, const fptypeN x) { return ::simd_smoothstep(edge0,edge1,x); }
-  /*! @abstract True if and only if each lane of x is equal to the
-   *  corresponding lane of y.
-   *
-   *  @discussion This isn't operator== because that's already defined by
-   *  the compiler to return a lane mask.                                     */
-  template <typename fptypeN> static SIMD_CPPFUNC simd_bool equal(const fptypeN x, const fptypeN y) { return ::simd_equal(x, y); }
-#if __cpp_decltype_auto
-  /*  If you are targeting an earlier version of the C++ standard that lacks
-   decltype_auto support, you may use the C-style simd_reduce_* functions
-   instead.                                                                   */
-  /*! @abstract The sum of the elements in x. May overflow.                   */
-  template <typename typeN> static SIMD_CPPFUNC auto reduce_add(typeN x) { return ::simd_reduce_add(x); }
-  /*! @abstract The least element in x.                                       */
-  template <typename typeN> static SIMD_CPPFUNC auto reduce_min(typeN x) { return ::simd_reduce_min(x); }
-  /*! @abstract The greatest element in x.                                    */
-  template <typename typeN> static SIMD_CPPFUNC auto reduce_max(typeN x) { return ::simd_reduce_max(x); }
-#endif
-  namespace precise {
-    /*! @abstract An approximation to 1/x.                                      */
-    template <typename fptypeN> static SIMD_CPPFUNC fptypeN recip(const fptypeN x) { return ::simd_precise_recip(x); }
-    /*! @abstract An approximation to 1/sqrt(x).                                */
-    template <typename fptypeN> static SIMD_CPPFUNC fptypeN rsqrt(const fptypeN x) { return ::simd_precise_rsqrt(x); }
-  }
-  namespace fast {
-    /*! @abstract An approximation to 1/x.                                      */
-    template <typename fptypeN> static SIMD_CPPFUNC fptypeN recip(const fptypeN x) { return ::simd_fast_recip(x); }
-    /*! @abstract An approximation to 1/sqrt(x).                                */
-    template <typename fptypeN> static SIMD_CPPFUNC fptypeN rsqrt(const fptypeN x) { return ::simd_fast_rsqrt(x); }
-  }
-}
-
-extern "C" {
-#endif /* __cplusplus */
-
-#pragma mark - Implementation
-
-static inline SIMD_CFUNC simd_char2 simd_abs(simd_char2 x) {
-  return simd_make_char2(simd_abs(simd_make_char8_undef(x)));
-}
-
-static inline SIMD_CFUNC simd_char3 simd_abs(simd_char3 x) {
-  return simd_make_char3(simd_abs(simd_make_char8_undef(x)));
-}
-
-static inline SIMD_CFUNC simd_char4 simd_abs(simd_char4 x) {
-  return simd_make_char4(simd_abs(simd_make_char8_undef(x)));
-}
-
-static inline SIMD_CFUNC simd_char8 simd_abs(simd_char8 x) {
-#if defined __arm__ || defined __arm64__
-  return vabs_s8(x);
-#else
-  return simd_make_char8(simd_abs(simd_make_char16_undef(x)));
-#endif
-}
-
-static inline SIMD_CFUNC simd_char16 simd_abs(simd_char16 x) {
-#if defined __arm__ || defined __arm64__
-  return vabsq_s8(x);
-#elif defined __SSE4_1__
-  return _mm_abs_epi8(x);
-#else
-  simd_char16 mask = x >> 7; return (x ^ mask) - mask;
-#endif
-}
-
-static inline SIMD_CFUNC simd_char32 simd_abs(simd_char32 x) {
-#if defined __AVX2__
-  return _mm256_abs_epi8(x);
-#else
-  return simd_make_char32(simd_abs(x.lo), simd_abs(x.hi));
-#endif
-}
-
-static inline SIMD_CFUNC simd_char64 simd_abs(simd_char64 x) {
-#if defined __AVX512BW__
-  return _mm512_abs_epi8(x);
-#else
-  return simd_make_char64(simd_abs(x.lo), simd_abs(x.hi));
-#endif
-}
-
-static inline SIMD_CFUNC simd_short2 simd_abs(simd_short2 x) {
-  return simd_make_short2(simd_abs(simd_make_short4_undef(x)));
-}
-
-static inline SIMD_CFUNC simd_short3 simd_abs(simd_short3 x) {
-  return simd_make_short3(simd_abs(simd_make_short4_undef(x)));
-}
-
-static inline SIMD_CFUNC simd_short4 simd_abs(simd_short4 x) {
-#if defined __arm__ || defined __arm64__
-  return vabs_s16(x);
-#else
-  return simd_make_short4(simd_abs(simd_make_short8_undef(x)));
-#endif
-}
-
-static inline SIMD_CFUNC simd_short8 simd_abs(simd_short8 x) {
-#if defined __arm__ || defined __arm64__
-  return vabsq_s16(x);
-#elif defined __SSE4_1__
-  return _mm_abs_epi16(x);
-#else
-  simd_short8 mask = x >> 15; return (x ^ mask) - mask;
-#endif
-}
-
-static inline SIMD_CFUNC simd_short16 simd_abs(simd_short16 x) {
-#if defined __AVX2__
-  return _mm256_abs_epi16(x);
-#else
-  return simd_make_short16(simd_abs(x.lo), simd_abs(x.hi));
-#endif
-}
-
-static inline SIMD_CFUNC simd_short32 simd_abs(simd_short32 x) {
-#if defined __AVX512BW__
-  return _mm512_abs_epi16(x);
-#else
-  return simd_make_short32(simd_abs(x.lo), simd_abs(x.hi));
-#endif
-}
-
-static inline SIMD_CFUNC simd_int2 simd_abs(simd_int2 x) {
-#if defined __arm__ || defined __arm64__
-  return vabs_s32(x);
-#else
-  return simd_make_int2(simd_abs(simd_make_int4_undef(x)));
-#endif
-}
-
-static inline SIMD_CFUNC simd_int3 simd_abs(simd_int3 x) {
-  return simd_make_int3(simd_abs(simd_make_int4_undef(x)));
-}
-
-static inline SIMD_CFUNC simd_int4 simd_abs(simd_int4 x) {
-#if defined __arm__ || defined __arm64__
-  return vabsq_s32(x);
-#elif defined __SSE4_1__
-  return _mm_abs_epi32(x);
-#else
-  simd_int4 mask = x >> 31; return (x ^ mask) - mask;
-#endif
-}
-
-static inline SIMD_CFUNC simd_int8 simd_abs(simd_int8 x) {
-#if defined __AVX2__
-  return _mm256_abs_epi32(x);
-#else
-  return simd_make_int8(simd_abs(x.lo), simd_abs(x.hi));
-#endif
-}
-
-static inline SIMD_CFUNC simd_int16 simd_abs(simd_int16 x) {
-#if defined __AVX512F__
-  return _mm512_abs_epi32(x);
-#else
-  return simd_make_int16(simd_abs(x.lo), simd_abs(x.hi));
-#endif
-}
-
-static inline SIMD_CFUNC simd_float2 simd_abs(simd_float2 x) {
-  return __tg_fabs(x);
-}
-
-static inline SIMD_CFUNC simd_float3 simd_abs(simd_float3 x) {
-  return __tg_fabs(x);
-}
-
-static inline SIMD_CFUNC simd_float4 simd_abs(simd_float4 x) {
-  return __tg_fabs(x);
-}
-
-static inline SIMD_CFUNC simd_float8 simd_abs(simd_float8 x) {
-  return __tg_fabs(x);
-}
-
-static inline SIMD_CFUNC simd_float16 simd_abs(simd_float16 x) {
-  return __tg_fabs(x);
-}
-
-static inline SIMD_CFUNC simd_long2 simd_abs(simd_long2 x) {
-#if defined __arm64__
-  return vabsq_s64(x);
-#elif defined __SSE4_1__
-  return _mm_abs_epi64(x);
-#else
-  simd_long2 mask = x >> 63; return (x ^ mask) - mask;
-#endif
-}
-
-static inline SIMD_CFUNC simd_long3 simd_abs(simd_long3 x) {
-  return simd_make_long3(simd_abs(simd_make_long4_undef(x)));
-}
-
-static inline SIMD_CFUNC simd_long4 simd_abs(simd_long4 x) {
-#if defined __AVX2__
-  return _mm256_abs_epi64(x);
-#else
-  return simd_make_long4(simd_abs(x.lo), simd_abs(x.hi));
-#endif
-}
-
-static inline SIMD_CFUNC simd_long8 simd_abs(simd_long8 x) {
-#if defined __AVX512F__
-  return _mm512_abs_epi64(x);
-#else
-  return simd_make_long8(simd_abs(x.lo), simd_abs(x.hi));
-#endif
-}
-
-static inline SIMD_CFUNC simd_double2 simd_abs(simd_double2 x) {
-  return __tg_fabs(x);
-}
-
-static inline SIMD_CFUNC simd_double3 simd_abs(simd_double3 x) {
-  return __tg_fabs(x);
-}
-
-static inline SIMD_CFUNC simd_double4 simd_abs(simd_double4 x) {
-  return __tg_fabs(x);
-}
-
-static inline SIMD_CFUNC simd_double8 simd_abs(simd_double8 x) {
-  return __tg_fabs(x);
-}
-
-static inline SIMD_CFUNC simd_char2 simd_min(simd_char2 x, simd_char2 y) {
-  return simd_make_char2(simd_min(simd_make_char8_undef(x), simd_make_char8_undef(y)));
-}
-
-static inline SIMD_CFUNC simd_char3 simd_min(simd_char3 x, simd_char3 y) {
-  return simd_make_char3(simd_min(simd_make_char8_undef(x), simd_make_char8_undef(y)));
-}
-
-static inline SIMD_CFUNC simd_char4 simd_min(simd_char4 x, simd_char4 y) {
-  return simd_make_char4(simd_min(simd_make_char8_undef(x), simd_make_char8_undef(y)));
-}
-
-static inline SIMD_CFUNC simd_char8 simd_min(simd_char8 x, simd_char8 y) {
-#if defined __arm__ || defined __arm64__
-  return vmin_s8(x, y);
-#else
-  return simd_make_char8(simd_min(simd_make_char16_undef(x), simd_make_char16_undef(y)));
-#endif
-
-}
-
-static inline SIMD_CFUNC simd_char16 simd_min(simd_char16 x, simd_char16 y) {
-#if defined __arm__ || defined __arm64__
-  return vminq_s8(x, y);
-#elif defined __SSE4_1__
-  return _mm_min_epi8(x, y);
-#else
-  return simd_bitselect(x, y, y < x);
-#endif
-}
-
-static inline SIMD_CFUNC simd_char32 simd_min(simd_char32 x, simd_char32 y) {
-#if defined __AVX2__
-  return _mm256_min_epi8(x, y);
-#else
-  return simd_bitselect(x, y, y < x);
-#endif
-}
-
-static inline SIMD_CFUNC simd_char64 simd_min(simd_char64 x, simd_char64 y) {
-#if defined __AVX512BW__
-  return _mm512_min_epi8(x, y);
-#else
-  return simd_bitselect(x, y, y < x);
-#endif
-}
-
-static inline SIMD_CFUNC simd_uchar2 simd_min(simd_uchar2 x, simd_uchar2 y) {
-  return simd_make_uchar2(simd_min(simd_make_uchar8_undef(x), simd_make_uchar8_undef(y)));
-}
-
-static inline SIMD_CFUNC simd_uchar3 simd_min(simd_uchar3 x, simd_uchar3 y) {
-  return simd_make_uchar3(simd_min(simd_make_uchar8_undef(x), simd_make_uchar8_undef(y)));
-}
-
-static inline SIMD_CFUNC simd_uchar4 simd_min(simd_uchar4 x, simd_uchar4 y) {
-  return simd_make_uchar4(simd_min(simd_make_uchar8_undef(x), simd_make_uchar8_undef(y)));
-}
-
-static inline SIMD_CFUNC simd_uchar8 simd_min(simd_uchar8 x, simd_uchar8 y) {
-#if defined __arm__ || defined __arm64__
-  return vmin_u8(x, y);
-#else
-  return simd_make_uchar8(simd_min(simd_make_uchar16_undef(x), simd_make_uchar16_undef(y)));
-#endif
-
-}
-
-static inline SIMD_CFUNC simd_uchar16 simd_min(simd_uchar16 x, simd_uchar16 y) {
-#if defined __arm__ || defined __arm64__
-  return vminq_u8(x, y);
-#elif defined __SSE4_1__
-  return _mm_min_epu8(x, y);
-#else
-  return simd_bitselect(x, y, y < x);
-#endif
-}
-
-static inline SIMD_CFUNC simd_uchar32 simd_min(simd_uchar32 x, simd_uchar32 y) {
-#if defined __AVX2__
-  return _mm256_min_epu8(x, y);
-#else
-  return simd_bitselect(x, y, y < x);
-#endif
-}
-
-static inline SIMD_CFUNC simd_uchar64 simd_min(simd_uchar64 x, simd_uchar64 y) {
-#if defined __AVX512BW__
-  return _mm512_min_epu8(x, y);
-#else
-  return simd_bitselect(x, y, y < x);
-#endif
-}
-
-static inline SIMD_CFUNC simd_short2 simd_min(simd_short2 x, simd_short2 y) {
-  return simd_make_short2(simd_min(simd_make_short4_undef(x), simd_make_short4_undef(y)));
-}
-
-static inline SIMD_CFUNC simd_short3 simd_min(simd_short3 x, simd_short3 y) {
-  return simd_make_short3(simd_min(simd_make_short4_undef(x), simd_make_short4_undef(y)));
-}
-
-static inline SIMD_CFUNC simd_short4 simd_min(simd_short4 x, simd_short4 y) {
-#if defined __arm__ || defined __arm64__
-  return vmin_s16(x, y);
-#else
-  return simd_make_short4(simd_min(simd_make_short8_undef(x), simd_make_short8_undef(y)));
-#endif
-
-}
-
-static inline SIMD_CFUNC simd_short8 simd_min(simd_short8 x, simd_short8 y) {
-#if defined __arm__ || defined __arm64__
-  return vminq_s16(x, y);
-#elif defined __SSE4_1__
-  return _mm_min_epi16(x, y);
-#else
-  return simd_bitselect(x, y, y < x);
-#endif
-}
-
-static inline SIMD_CFUNC simd_short16 simd_min(simd_short16 x, simd_short16 y) {
-#if defined __AVX2__
-  return _mm256_min_epi16(x, y);
-#else
-  return simd_bitselect(x, y, y < x);
-#endif
-}
-
-static inline SIMD_CFUNC simd_short32 simd_min(simd_short32 x, simd_short32 y) {
-#if defined __AVX512BW__
-  return _mm512_min_epi16(x, y);
-#else
-  return simd_bitselect(x, y, y < x);
-#endif
-}
-
-static inline SIMD_CFUNC simd_ushort2 simd_min(simd_ushort2 x, simd_ushort2 y) {
-  return simd_make_ushort2(simd_min(simd_make_ushort4_undef(x), simd_make_ushort4_undef(y)));
-}
-
-static inline SIMD_CFUNC simd_ushort3 simd_min(simd_ushort3 x, simd_ushort3 y) {
-  return simd_make_ushort3(simd_min(simd_make_ushort4_undef(x), simd_make_ushort4_undef(y)));
-}
-
-static inline SIMD_CFUNC simd_ushort4 simd_min(simd_ushort4 x, simd_ushort4 y) {
-#if defined __arm__ || defined __arm64__
-  return vmin_u16(x, y);
-#else
-  return simd_make_ushort4(simd_min(simd_make_ushort8_undef(x), simd_make_ushort8_undef(y)));
-#endif
-
-}
-
-static inline SIMD_CFUNC simd_ushort8 simd_min(simd_ushort8 x, simd_ushort8 y) {
-#if defined __arm__ || defined __arm64__
-  return vminq_u16(x, y);
-#elif defined __SSE4_1__
-  return _mm_min_epu16(x, y);
-#else
-  return simd_bitselect(x, y, y < x);
-#endif
-}
-
-static inline SIMD_CFUNC simd_ushort16 simd_min(simd_ushort16 x, simd_ushort16 y) {
-#if defined __AVX2__
-  return _mm256_min_epu16(x, y);
-#else
-  return simd_bitselect(x, y, y < x);
-#endif
-}
-
-static inline SIMD_CFUNC simd_ushort32 simd_min(simd_ushort32 x, simd_ushort32 y) {
-#if defined __AVX512BW__
-  return _mm512_min_epu16(x, y);
-#else
-  return simd_bitselect(x, y, y < x);
-#endif
-}
-
-static inline SIMD_CFUNC simd_int2 simd_min(simd_int2 x, simd_int2 y) {
-#if defined __arm__ || defined __arm64__
-  return vmin_s32(x, y);
-#else
-  return simd_make_int2(simd_min(simd_make_int4_undef(x), simd_make_int4_undef(y)));
-#endif
-
-}
-
-static inline SIMD_CFUNC simd_int3 simd_min(simd_int3 x, simd_int3 y) {
-  return simd_make_int3(simd_min(simd_make_int4_undef(x), simd_make_int4_undef(y)));
-}
-
-static inline SIMD_CFUNC simd_int4 simd_min(simd_int4 x, simd_int4 y) {
-#if defined __arm__ || defined __arm64__
-  return vminq_s32(x, y);
-#elif defined __SSE4_1__
-  return _mm_min_epi32(x, y);
-#else
-  return simd_bitselect(x, y, y < x);
-#endif
-}
-
-static inline SIMD_CFUNC simd_int8 simd_min(simd_int8 x, simd_int8 y) {
-#if defined __AVX2__
-  return _mm256_min_epi32(x, y);
-#else
-  return simd_bitselect(x, y, y < x);
-#endif
-}
-
-static inline SIMD_CFUNC simd_int16 simd_min(simd_int16 x, simd_int16 y) {
-#if defined __AVX512F__
-  return _mm512_min_epi32(x, y);
-#else
-  return simd_bitselect(x, y, y < x);
-#endif
-}
-
-static inline SIMD_CFUNC simd_uint2 simd_min(simd_uint2 x, simd_uint2 y) {
-#if defined __arm__ || defined __arm64__
-  return vmin_u32(x, y);
-#else
-  return simd_make_uint2(simd_min(simd_make_uint4_undef(x), simd_make_uint4_undef(y)));
-#endif
-
-}
-
-static inline SIMD_CFUNC simd_uint3 simd_min(simd_uint3 x, simd_uint3 y) {
-  return simd_make_uint3(simd_min(simd_make_uint4_undef(x), simd_make_uint4_undef(y)));
-}
-
-static inline SIMD_CFUNC simd_uint4 simd_min(simd_uint4 x, simd_uint4 y) {
-#if defined __arm__ || defined __arm64__
-  return vminq_u32(x, y);
-#elif defined __SSE4_1__
-  return _mm_min_epu32(x, y);
-#else
-  return simd_bitselect(x, y, y < x);
-#endif
-}
-
-static inline SIMD_CFUNC simd_uint8 simd_min(simd_uint8 x, simd_uint8 y) {
-#if defined __AVX2__
-  return _mm256_min_epu32(x, y);
-#else
-  return simd_bitselect(x, y, y < x);
-#endif
-}
-
-static inline SIMD_CFUNC simd_uint16 simd_min(simd_uint16 x, simd_uint16 y) {
-#if defined __AVX512F__
-  return _mm512_min_epu32(x, y);
-#else
-  return simd_bitselect(x, y, y < x);
-#endif
-}
-
-static inline SIMD_CFUNC float simd_min(float x, float y) {
-  return __tg_fmin(x,y);
-}
-
-static inline SIMD_CFUNC simd_float2 simd_min(simd_float2 x, simd_float2 y) {
-  return __tg_fmin(x,y);
-}
-
-static inline SIMD_CFUNC simd_float3 simd_min(simd_float3 x, simd_float3 y) {
-  return __tg_fmin(x,y);
-}
-
-static inline SIMD_CFUNC simd_float4 simd_min(simd_float4 x, simd_float4 y) {
-  return __tg_fmin(x,y);
-}
-
-static inline SIMD_CFUNC simd_float8 simd_min(simd_float8 x, simd_float8 y) {
-  return __tg_fmin(x,y);
-}
-
-static inline SIMD_CFUNC simd_float16 simd_min(simd_float16 x, simd_float16 y) {
-  return __tg_fmin(x,y);
-}
-
-static inline SIMD_CFUNC simd_long2 simd_min(simd_long2 x, simd_long2 y) {
-#if defined __AVX512VL__
-  return _mm_min_epi64(x, y);
-#else
-  return simd_bitselect(x, y, y < x);
-#endif
-}
-
-static inline SIMD_CFUNC simd_long3 simd_min(simd_long3 x, simd_long3 y) {
-  return simd_make_long3(simd_min(simd_make_long4_undef(x), simd_make_long4_undef(y)));
-}
-
-static inline SIMD_CFUNC simd_long4 simd_min(simd_long4 x, simd_long4 y) {
-#if defined __AVX512VL__
-  return _mm256_min_epi64(x, y);
-#else
-  return simd_bitselect(x, y, y < x);
-#endif
-}
-
-static inline SIMD_CFUNC simd_long8 simd_min(simd_long8 x, simd_long8 y) {
-#if defined __AVX512F__
-  return _mm512_min_epi64(x, y);
-#else
-  return simd_bitselect(x, y, y < x);
-#endif
-}
-
-static inline SIMD_CFUNC simd_ulong2 simd_min(simd_ulong2 x, simd_ulong2 y) {
-#if defined __AVX512VL__
-  return _mm_min_epu64(x, y);
-#else
-  return simd_bitselect(x, y, y < x);
-#endif
-}
-
-static inline SIMD_CFUNC simd_ulong3 simd_min(simd_ulong3 x, simd_ulong3 y) {
-  return simd_make_ulong3(simd_min(simd_make_ulong4_undef(x), simd_make_ulong4_undef(y)));
-}
-
-static inline SIMD_CFUNC simd_ulong4 simd_min(simd_ulong4 x, simd_ulong4 y) {
-#if defined __AVX512VL__
-  return _mm256_min_epu64(x, y);
-#else
-  return simd_bitselect(x, y, y < x);
-#endif
-}
-
-static inline SIMD_CFUNC simd_ulong8 simd_min(simd_ulong8 x, simd_ulong8 y) {
-#if defined __AVX512F__
-  return _mm512_min_epu64(x, y);
-#else
-  return simd_bitselect(x, y, y < x);
-#endif
-}
-
-static inline SIMD_CFUNC double simd_min(double x, double y) {
-  return __tg_fmin(x,y);
-}
-
-static inline SIMD_CFUNC simd_double2 simd_min(simd_double2 x, simd_double2 y) {
-  return __tg_fmin(x,y);
-}
-
-static inline SIMD_CFUNC simd_double3 simd_min(simd_double3 x, simd_double3 y) {
-  return __tg_fmin(x,y);
-}
-
-static inline SIMD_CFUNC simd_double4 simd_min(simd_double4 x, simd_double4 y) {
-  return __tg_fmin(x,y);
-}
-
-static inline SIMD_CFUNC simd_double8 simd_min(simd_double8 x, simd_double8 y) {
-  return __tg_fmin(x,y);
-}
-
-static inline SIMD_CFUNC simd_char2 simd_max(simd_char2 x, simd_char2 y) {
-  return simd_make_char2(simd_max(simd_make_char8_undef(x), simd_make_char8_undef(y)));
-}
-
-static inline SIMD_CFUNC simd_char3 simd_max(simd_char3 x, simd_char3 y) {
-  return simd_make_char3(simd_max(simd_make_char8_undef(x), simd_make_char8_undef(y)));
-}
-
-static inline SIMD_CFUNC simd_char4 simd_max(simd_char4 x, simd_char4 y) {
-  return simd_make_char4(simd_max(simd_make_char8_undef(x), simd_make_char8_undef(y)));
-}
-
-static inline SIMD_CFUNC simd_char8 simd_max(simd_char8 x, simd_char8 y) {
-#if defined __arm__ || defined __arm64__
-  return vmax_s8(x, y);
-#else
-  return simd_make_char8(simd_max(simd_make_char16_undef(x), simd_make_char16_undef(y)));
-#endif
-
-}
-
-static inline SIMD_CFUNC simd_char16 simd_max(simd_char16 x, simd_char16 y) {
-#if defined __arm__ || defined __arm64__
-  return vmaxq_s8(x, y);
-#elif defined __SSE4_1__
-  return _mm_max_epi8(x, y);
-#else
-  return simd_bitselect(x, y, x < y);
-#endif
-}
-
-static inline SIMD_CFUNC simd_char32 simd_max(simd_char32 x, simd_char32 y) {
-#if defined __AVX2__
-  return _mm256_max_epi8(x, y);
-#else
-  return simd_bitselect(x, y, x < y);
-#endif
-}
-
-static inline SIMD_CFUNC simd_char64 simd_max(simd_char64 x, simd_char64 y) {
-#if defined __AVX512BW__
-  return _mm512_max_epi8(x, y);
-#else
-  return simd_bitselect(x, y, x < y);
-#endif
-}
-
-static inline SIMD_CFUNC simd_uchar2 simd_max(simd_uchar2 x, simd_uchar2 y) {
-  return simd_make_uchar2(simd_max(simd_make_uchar8_undef(x), simd_make_uchar8_undef(y)));
-}
-
-static inline SIMD_CFUNC simd_uchar3 simd_max(simd_uchar3 x, simd_uchar3 y) {
-  return simd_make_uchar3(simd_max(simd_make_uchar8_undef(x), simd_make_uchar8_undef(y)));
-}
-
-static inline SIMD_CFUNC simd_uchar4 simd_max(simd_uchar4 x, simd_uchar4 y) {
-  return simd_make_uchar4(simd_max(simd_make_uchar8_undef(x), simd_make_uchar8_undef(y)));
-}
-
-static inline SIMD_CFUNC simd_uchar8 simd_max(simd_uchar8 x, simd_uchar8 y) {
-#if defined __arm__ || defined __arm64__
-  return vmax_u8(x, y);
-#else
-  return simd_make_uchar8(simd_max(simd_make_uchar16_undef(x), simd_make_uchar16_undef(y)));
-#endif
-
-}
-
-static inline SIMD_CFUNC simd_uchar16 simd_max(simd_uchar16 x, simd_uchar16 y) {
-#if defined __arm__ || defined __arm64__
-  return vmaxq_u8(x, y);
-#elif defined __SSE4_1__
-  return _mm_max_epu8(x, y);
-#else
-  return simd_bitselect(x, y, x < y);
-#endif
-}
-
-static inline SIMD_CFUNC simd_uchar32 simd_max(simd_uchar32 x, simd_uchar32 y) {
-#if defined __AVX2__
-  return _mm256_max_epu8(x, y);
-#else
-  return simd_bitselect(x, y, x < y);
-#endif
-}
-
-static inline SIMD_CFUNC simd_uchar64 simd_max(simd_uchar64 x, simd_uchar64 y) {
-#if defined __AVX512BW__
-  return _mm512_max_epu8(x, y);
-#else
-  return simd_bitselect(x, y, x < y);
-#endif
-}
-
-static inline SIMD_CFUNC simd_short2 simd_max(simd_short2 x, simd_short2 y) {
-  return simd_make_short2(simd_max(simd_make_short4_undef(x), simd_make_short4_undef(y)));
-}
-
-static inline SIMD_CFUNC simd_short3 simd_max(simd_short3 x, simd_short3 y) {
-  return simd_make_short3(simd_max(simd_make_short4_undef(x), simd_make_short4_undef(y)));
-}
-
-static inline SIMD_CFUNC simd_short4 simd_max(simd_short4 x, simd_short4 y) {
-#if defined __arm__ || defined __arm64__
-  return vmax_s16(x, y);
-#else
-  return simd_make_short4(simd_max(simd_make_short8_undef(x), simd_make_short8_undef(y)));
-#endif
-
-}
-
-static inline SIMD_CFUNC simd_short8 simd_max(simd_short8 x, simd_short8 y) {
-#if defined __arm__ || defined __arm64__
-  return vmaxq_s16(x, y);
-#elif defined __SSE4_1__
-  return _mm_max_epi16(x, y);
-#else
-  return simd_bitselect(x, y, x < y);
-#endif
-}
-
-static inline SIMD_CFUNC simd_short16 simd_max(simd_short16 x, simd_short16 y) {
-#if defined __AVX2__
-  return _mm256_max_epi16(x, y);
-#else
-  return simd_bitselect(x, y, x < y);
-#endif
-}
-
-static inline SIMD_CFUNC simd_short32 simd_max(simd_short32 x, simd_short32 y) {
-#if defined __AVX512BW__
-  return _mm512_max_epi16(x, y);
-#else
-  return simd_bitselect(x, y, x < y);
-#endif
-}
-
-static inline SIMD_CFUNC simd_ushort2 simd_max(simd_ushort2 x, simd_ushort2 y) {
-  return simd_make_ushort2(simd_max(simd_make_ushort4_undef(x), simd_make_ushort4_undef(y)));
-}
-
-static inline SIMD_CFUNC simd_ushort3 simd_max(simd_ushort3 x, simd_ushort3 y) {
-  return simd_make_ushort3(simd_max(simd_make_ushort4_undef(x), simd_make_ushort4_undef(y)));
-}
-
-static inline SIMD_CFUNC simd_ushort4 simd_max(simd_ushort4 x, simd_ushort4 y) {
-#if defined __arm__ || defined __arm64__
-  return vmax_u16(x, y);
-#else
-  return simd_make_ushort4(simd_max(simd_make_ushort8_undef(x), simd_make_ushort8_undef(y)));
-#endif
-
-}
-
-static inline SIMD_CFUNC simd_ushort8 simd_max(simd_ushort8 x, simd_ushort8 y) {
-#if defined __arm__ || defined __arm64__
-  return vmaxq_u16(x, y);
-#elif defined __SSE4_1__
-  return _mm_max_epu16(x, y);
-#else
-  return simd_bitselect(x, y, x < y);
-#endif
-}
-
-static inline SIMD_CFUNC simd_ushort16 simd_max(simd_ushort16 x, simd_ushort16 y) {
-#if defined __AVX2__
-  return _mm256_max_epu16(x, y);
-#else
-  return simd_bitselect(x, y, x < y);
-#endif
-}
-
-static inline SIMD_CFUNC simd_ushort32 simd_max(simd_ushort32 x, simd_ushort32 y) {
-#if defined __AVX512BW__
-  return _mm512_max_epu16(x, y);
-#else
-  return simd_bitselect(x, y, x < y);
-#endif
-}
-
-static inline SIMD_CFUNC simd_int2 simd_max(simd_int2 x, simd_int2 y) {
-#if defined __arm__ || defined __arm64__
-  return vmax_s32(x, y);
-#else
-  return simd_make_int2(simd_max(simd_make_int4_undef(x), simd_make_int4_undef(y)));
-#endif
-
-}
-
-static inline SIMD_CFUNC simd_int3 simd_max(simd_int3 x, simd_int3 y) {
-  return simd_make_int3(simd_max(simd_make_int4_undef(x), simd_make_int4_undef(y)));
-}
-
-static inline SIMD_CFUNC simd_int4 simd_max(simd_int4 x, simd_int4 y) {
-#if defined __arm__ || defined __arm64__
-  return vmaxq_s32(x, y);
-#elif defined __SSE4_1__
-  return _mm_max_epi32(x, y);
-#else
-  return simd_bitselect(x, y, x < y);
-#endif
-}
-
-static inline SIMD_CFUNC simd_int8 simd_max(simd_int8 x, simd_int8 y) {
-#if defined __AVX2__
-  return _mm256_max_epi32(x, y);
-#else
-  return simd_bitselect(x, y, x < y);
-#endif
-}
-
-static inline SIMD_CFUNC simd_int16 simd_max(simd_int16 x, simd_int16 y) {
-#if defined __AVX512F__
-  return _mm512_max_epi32(x, y);
-#else
-  return simd_bitselect(x, y, x < y);
-#endif
-}
-
-static inline SIMD_CFUNC simd_uint2 simd_max(simd_uint2 x, simd_uint2 y) {
-#if defined __arm__ || defined __arm64__
-  return vmax_u32(x, y);
-#else
-  return simd_make_uint2(simd_max(simd_make_uint4_undef(x), simd_make_uint4_undef(y)));
-#endif
-
-}
-
-static inline SIMD_CFUNC simd_uint3 simd_max(simd_uint3 x, simd_uint3 y) {
-  return simd_make_uint3(simd_max(simd_make_uint4_undef(x), simd_make_uint4_undef(y)));
-}
-
-static inline SIMD_CFUNC simd_uint4 simd_max(simd_uint4 x, simd_uint4 y) {
-#if defined __arm__ || defined __arm64__
-  return vmaxq_u32(x, y);
-#elif defined __SSE4_1__
-  return _mm_max_epu32(x, y);
-#else
-  return simd_bitselect(x, y, x < y);
-#endif
-}
-
-static inline SIMD_CFUNC simd_uint8 simd_max(simd_uint8 x, simd_uint8 y) {
-#if defined __AVX2__
-  return _mm256_max_epu32(x, y);
-#else
-  return simd_bitselect(x, y, x < y);
-#endif
-}
-
-static inline SIMD_CFUNC simd_uint16 simd_max(simd_uint16 x, simd_uint16 y) {
-#if defined __AVX512F__
-  return _mm512_max_epu32(x, y);
-#else
-  return simd_bitselect(x, y, x < y);
-#endif
-}
-
-static inline SIMD_CFUNC float simd_max(float x, float y) {
-  return __tg_fmax(x,y);
-}
-
-static inline SIMD_CFUNC simd_float2 simd_max(simd_float2 x, simd_float2 y) {
-  return __tg_fmax(x,y);
-}
-
-static inline SIMD_CFUNC simd_float3 simd_max(simd_float3 x, simd_float3 y) {
-  return __tg_fmax(x,y);
-}
-
-static inline SIMD_CFUNC simd_float4 simd_max(simd_float4 x, simd_float4 y) {
-  return __tg_fmax(x,y);
-}
-
-static inline SIMD_CFUNC simd_float8 simd_max(simd_float8 x, simd_float8 y) {
-  return __tg_fmax(x,y);
-}
-
-static inline SIMD_CFUNC simd_float16 simd_max(simd_float16 x, simd_float16 y) {
-  return __tg_fmax(x,y);
-}
-
-static inline SIMD_CFUNC simd_long2 simd_max(simd_long2 x, simd_long2 y) {
-#if defined __AVX512VL__
-  return _mm_max_epi64(x, y);
-#else
-  return simd_bitselect(x, y, x < y);
-#endif
-}
-
-static inline SIMD_CFUNC simd_long3 simd_max(simd_long3 x, simd_long3 y) {
-  return simd_make_long3(simd_max(simd_make_long4_undef(x), simd_make_long4_undef(y)));
-}
-
-static inline SIMD_CFUNC simd_long4 simd_max(simd_long4 x, simd_long4 y) {
-#if defined __AVX512VL__
-  return _mm256_max_epi64(x, y);
-#else
-  return simd_bitselect(x, y, x < y);
-#endif
-}
-
-static inline SIMD_CFUNC simd_long8 simd_max(simd_long8 x, simd_long8 y) {
-#if defined __AVX512F__
-  return _mm512_max_epi64(x, y);
-#else
-  return simd_bitselect(x, y, x < y);
-#endif
-}
-
-static inline SIMD_CFUNC simd_ulong2 simd_max(simd_ulong2 x, simd_ulong2 y) {
-#if defined __AVX512VL__
-  return _mm_max_epu64(x, y);
-#else
-  return simd_bitselect(x, y, x < y);
-#endif
-}
-
-static inline SIMD_CFUNC simd_ulong3 simd_max(simd_ulong3 x, simd_ulong3 y) {
-  return simd_make_ulong3(simd_max(simd_make_ulong4_undef(x), simd_make_ulong4_undef(y)));
-}
-
-static inline SIMD_CFUNC simd_ulong4 simd_max(simd_ulong4 x, simd_ulong4 y) {
-#if defined __AVX512VL__
-  return _mm256_max_epu64(x, y);
-#else
-  return simd_bitselect(x, y, x < y);
-#endif
-}
-
-static inline SIMD_CFUNC simd_ulong8 simd_max(simd_ulong8 x, simd_ulong8 y) {
-#if defined __AVX512F__
-  return _mm512_max_epu64(x, y);
-#else
-  return simd_bitselect(x, y, x < y);
-#endif
-}
-
-static inline SIMD_CFUNC double simd_max(double x, double y) {
-  return __tg_fmax(x,y);
-}
-
-static inline SIMD_CFUNC simd_double2 simd_max(simd_double2 x, simd_double2 y) {
-  return __tg_fmax(x,y);
-}
-
-static inline SIMD_CFUNC simd_double3 simd_max(simd_double3 x, simd_double3 y) {
-  return __tg_fmax(x,y);
-}
-
-static inline SIMD_CFUNC simd_double4 simd_max(simd_double4 x, simd_double4 y) {
-  return __tg_fmax(x,y);
-}
-
-static inline SIMD_CFUNC simd_double8 simd_max(simd_double8 x, simd_double8 y) {
-  return __tg_fmax(x,y);
-}
-
-static inline SIMD_CFUNC simd_char2 simd_clamp(simd_char2 x, simd_char2 min, simd_char2 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_char3 simd_clamp(simd_char3 x, simd_char3 min, simd_char3 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_char4 simd_clamp(simd_char4 x, simd_char4 min, simd_char4 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_char8 simd_clamp(simd_char8 x, simd_char8 min, simd_char8 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_char16 simd_clamp(simd_char16 x, simd_char16 min, simd_char16 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_char32 simd_clamp(simd_char32 x, simd_char32 min, simd_char32 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_char64 simd_clamp(simd_char64 x, simd_char64 min, simd_char64 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_uchar2 simd_clamp(simd_uchar2 x, simd_uchar2 min, simd_uchar2 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_uchar3 simd_clamp(simd_uchar3 x, simd_uchar3 min, simd_uchar3 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_uchar4 simd_clamp(simd_uchar4 x, simd_uchar4 min, simd_uchar4 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_uchar8 simd_clamp(simd_uchar8 x, simd_uchar8 min, simd_uchar8 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_uchar16 simd_clamp(simd_uchar16 x, simd_uchar16 min, simd_uchar16 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_uchar32 simd_clamp(simd_uchar32 x, simd_uchar32 min, simd_uchar32 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_uchar64 simd_clamp(simd_uchar64 x, simd_uchar64 min, simd_uchar64 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_short2 simd_clamp(simd_short2 x, simd_short2 min, simd_short2 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_short3 simd_clamp(simd_short3 x, simd_short3 min, simd_short3 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_short4 simd_clamp(simd_short4 x, simd_short4 min, simd_short4 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_short8 simd_clamp(simd_short8 x, simd_short8 min, simd_short8 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_short16 simd_clamp(simd_short16 x, simd_short16 min, simd_short16 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_short32 simd_clamp(simd_short32 x, simd_short32 min, simd_short32 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_ushort2 simd_clamp(simd_ushort2 x, simd_ushort2 min, simd_ushort2 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_ushort3 simd_clamp(simd_ushort3 x, simd_ushort3 min, simd_ushort3 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_ushort4 simd_clamp(simd_ushort4 x, simd_ushort4 min, simd_ushort4 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_ushort8 simd_clamp(simd_ushort8 x, simd_ushort8 min, simd_ushort8 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_ushort16 simd_clamp(simd_ushort16 x, simd_ushort16 min, simd_ushort16 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_ushort32 simd_clamp(simd_ushort32 x, simd_ushort32 min, simd_ushort32 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_int2 simd_clamp(simd_int2 x, simd_int2 min, simd_int2 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_int3 simd_clamp(simd_int3 x, simd_int3 min, simd_int3 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_int4 simd_clamp(simd_int4 x, simd_int4 min, simd_int4 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_int8 simd_clamp(simd_int8 x, simd_int8 min, simd_int8 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_int16 simd_clamp(simd_int16 x, simd_int16 min, simd_int16 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_uint2 simd_clamp(simd_uint2 x, simd_uint2 min, simd_uint2 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_uint3 simd_clamp(simd_uint3 x, simd_uint3 min, simd_uint3 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_uint4 simd_clamp(simd_uint4 x, simd_uint4 min, simd_uint4 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_uint8 simd_clamp(simd_uint8 x, simd_uint8 min, simd_uint8 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_uint16 simd_clamp(simd_uint16 x, simd_uint16 min, simd_uint16 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC float simd_clamp(float x, float min, float max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_float2 simd_clamp(simd_float2 x, simd_float2 min, simd_float2 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_float3 simd_clamp(simd_float3 x, simd_float3 min, simd_float3 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_float4 simd_clamp(simd_float4 x, simd_float4 min, simd_float4 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_float8 simd_clamp(simd_float8 x, simd_float8 min, simd_float8 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_float16 simd_clamp(simd_float16 x, simd_float16 min, simd_float16 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_long2 simd_clamp(simd_long2 x, simd_long2 min, simd_long2 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_long3 simd_clamp(simd_long3 x, simd_long3 min, simd_long3 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_long4 simd_clamp(simd_long4 x, simd_long4 min, simd_long4 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_long8 simd_clamp(simd_long8 x, simd_long8 min, simd_long8 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_ulong2 simd_clamp(simd_ulong2 x, simd_ulong2 min, simd_ulong2 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_ulong3 simd_clamp(simd_ulong3 x, simd_ulong3 min, simd_ulong3 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_ulong4 simd_clamp(simd_ulong4 x, simd_ulong4 min, simd_ulong4 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_ulong8 simd_clamp(simd_ulong8 x, simd_ulong8 min, simd_ulong8 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC double simd_clamp(double x, double min, double max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_double2 simd_clamp(simd_double2 x, simd_double2 min, simd_double2 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_double3 simd_clamp(simd_double3 x, simd_double3 min, simd_double3 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_double4 simd_clamp(simd_double4 x, simd_double4 min, simd_double4 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_double8 simd_clamp(simd_double8 x, simd_double8 min, simd_double8 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-  
-static inline SIMD_CFUNC float simd_sign(float x) {
-  return x == 0 | x != x ? 0 : copysign(1,x);
-}
-
-static inline SIMD_CFUNC simd_float2 simd_sign(simd_float2 x) {
-  return simd_bitselect(__tg_copysign(1,x), 0, x == 0 | x != x);
-}
-
-static inline SIMD_CFUNC simd_float3 simd_sign(simd_float3 x) {
-  return simd_bitselect(__tg_copysign(1,x), 0, x == 0 | x != x);
-}
-
-static inline SIMD_CFUNC simd_float4 simd_sign(simd_float4 x) {
-  return simd_bitselect(__tg_copysign(1,x), 0, x == 0 | x != x);
-}
-
-static inline SIMD_CFUNC simd_float8 simd_sign(simd_float8 x) {
-  return simd_bitselect(__tg_copysign(1,x), 0, x == 0 | x != x);
-}
-
-static inline SIMD_CFUNC simd_float16 simd_sign(simd_float16 x) {
-  return simd_bitselect(__tg_copysign(1,x), 0, x == 0 | x != x);
-}
-
-static inline SIMD_CFUNC double simd_sign(double x) {
-  return x == 0 | x != x ? 0 : copysign(1,x);
-}
-
-static inline SIMD_CFUNC simd_double2 simd_sign(simd_double2 x) {
-  return simd_bitselect(__tg_copysign(1,x), 0, x == 0 | x != x);
-}
-
-static inline SIMD_CFUNC simd_double3 simd_sign(simd_double3 x) {
-  return simd_bitselect(__tg_copysign(1,x), 0, x == 0 | x != x);
-}
-
-static inline SIMD_CFUNC simd_double4 simd_sign(simd_double4 x) {
-  return simd_bitselect(__tg_copysign(1,x), 0, x == 0 | x != x);
-}
-
-static inline SIMD_CFUNC simd_double8 simd_sign(simd_double8 x) {
-  return simd_bitselect(__tg_copysign(1,x), 0, x == 0 | x != x);
-}
-
-static inline SIMD_CFUNC float simd_mix(float x, float y, float t) {
-  return x + t*(y - x);
-}
-  
-static inline SIMD_CFUNC simd_float2 simd_mix(simd_float2 x, simd_float2 y, simd_float2 t) {
-  return x + t*(y - x);
-}
-  
-static inline SIMD_CFUNC simd_float3 simd_mix(simd_float3 x, simd_float3 y, simd_float3 t) {
-  return x + t*(y - x);
-}
-  
-static inline SIMD_CFUNC simd_float4 simd_mix(simd_float4 x, simd_float4 y, simd_float4 t) {
-  return x + t*(y - x);
-}
-  
-static inline SIMD_CFUNC simd_float8 simd_mix(simd_float8 x, simd_float8 y, simd_float8 t) {
-  return x + t*(y - x);
-}
-  
-static inline SIMD_CFUNC simd_float16 simd_mix(simd_float16 x, simd_float16 y, simd_float16 t) {
-  return x + t*(y - x);
-}
-  
-static inline SIMD_CFUNC double simd_mix(double x, double y, double t) {
-  return x + t*(y - x);
-}
-  
-static inline SIMD_CFUNC simd_double2 simd_mix(simd_double2 x, simd_double2 y, simd_double2 t) {
-  return x + t*(y - x);
-}
-  
-static inline SIMD_CFUNC simd_double3 simd_mix(simd_double3 x, simd_double3 y, simd_double3 t) {
-  return x + t*(y - x);
-}
-  
-static inline SIMD_CFUNC simd_double4 simd_mix(simd_double4 x, simd_double4 y, simd_double4 t) {
-  return x + t*(y - x);
-}
-  
-static inline SIMD_CFUNC simd_double8 simd_mix(simd_double8 x, simd_double8 y, simd_double8 t) {
-  return x + t*(y - x);
-}
-  
-static inline SIMD_CFUNC float simd_recip(float x) {
-#if __FAST_MATH__
-  return simd_fast_recip(x);
-#else
-  return simd_precise_recip(x);
-#endif
-}
-
-static inline SIMD_CFUNC simd_float2 simd_recip(simd_float2 x) {
-#if __FAST_MATH__
-  return simd_fast_recip(x);
-#else
-  return simd_precise_recip(x);
-#endif
-}
-
-static inline SIMD_CFUNC simd_float3 simd_recip(simd_float3 x) {
-#if __FAST_MATH__
-  return simd_fast_recip(x);
-#else
-  return simd_precise_recip(x);
-#endif
-}
-
-static inline SIMD_CFUNC simd_float4 simd_recip(simd_float4 x) {
-#if __FAST_MATH__
-  return simd_fast_recip(x);
-#else
-  return simd_precise_recip(x);
-#endif
-}
-
-static inline SIMD_CFUNC simd_float8 simd_recip(simd_float8 x) {
-#if __FAST_MATH__
-  return simd_fast_recip(x);
-#else
-  return simd_precise_recip(x);
-#endif
-}
-
-static inline SIMD_CFUNC simd_float16 simd_recip(simd_float16 x) {
-#if __FAST_MATH__
-  return simd_fast_recip(x);
-#else
-  return simd_precise_recip(x);
-#endif
-}
-
-static inline SIMD_CFUNC double simd_recip(double x) {
-#if __FAST_MATH__
-  return simd_fast_recip(x);
-#else
-  return simd_precise_recip(x);
-#endif
-}
-
-static inline SIMD_CFUNC simd_double2 simd_recip(simd_double2 x) {
-#if __FAST_MATH__
-  return simd_fast_recip(x);
-#else
-  return simd_precise_recip(x);
-#endif
-}
-
-static inline SIMD_CFUNC simd_double3 simd_recip(simd_double3 x) {
-#if __FAST_MATH__
-  return simd_fast_recip(x);
-#else
-  return simd_precise_recip(x);
-#endif
-}
-
-static inline SIMD_CFUNC simd_double4 simd_recip(simd_double4 x) {
-#if __FAST_MATH__
-  return simd_fast_recip(x);
-#else
-  return simd_precise_recip(x);
-#endif
-}
-
-static inline SIMD_CFUNC simd_double8 simd_recip(simd_double8 x) {
-#if __FAST_MATH__
-  return simd_fast_recip(x);
-#else
-  return simd_precise_recip(x);
-#endif
-}
-
-static inline SIMD_CFUNC float simd_fast_recip(float x) {
-#if defined __AVX512VL__
-  simd_float4 x4 = simd_make_float4(x);
-  return ((simd_float4)_mm_rcp14_ss(x4, x4)).x;
-#elif defined __SSE__
-  return ((simd_float4)_mm_rcp_ss(simd_make_float4(x))).x;
-#elif defined __ARM_NEON__
-  return simd_fast_recip(simd_make_float2_undef(x)).x;
-#else
-  return simd_precise_recip(x);
-#endif
-}
-
-static inline SIMD_CFUNC simd_float2 simd_fast_recip(simd_float2 x) {
-#if defined __SSE__
-  return simd_make_float2(simd_fast_recip(simd_make_float4_undef(x)));
-#elif defined __ARM_NEON__
-  simd_float2 r = vrecpe_f32(x);
-  return r * vrecps_f32(x, r);
-#else
-  return simd_precise_recip(x);
-#endif
-}
-
-static inline SIMD_CFUNC simd_float3 simd_fast_recip(simd_float3 x) {
-  return simd_make_float3(simd_fast_recip(simd_make_float4_undef(x)));
-}
-
-static inline SIMD_CFUNC simd_float4 simd_fast_recip(simd_float4 x) {
-#if defined __AVX512VL__
-  return _mm_rcp14_ps(x);
-#elif defined __SSE__
-  return _mm_rcp_ps(x);
-#elif defined __ARM_NEON__
-  simd_float4 r = vrecpeq_f32(x);
-  return r * vrecpsq_f32(x, r);
-#else
-  return simd_precise_recip(x);
-#endif
-}
-
-static inline SIMD_CFUNC simd_float8 simd_fast_recip(simd_float8 x) {
-#if defined __AVX512VL__
-  return _mm256_rcp14_ps(x);
-#elif defined __AVX__
-  return _mm256_rcp_ps(x);
-#else
-  return simd_make_float8(simd_fast_recip(x.lo), simd_fast_recip(x.hi));
-#endif
-}
-
-static inline SIMD_CFUNC simd_float16 simd_fast_recip(simd_float16 x) {
-#if defined __AVX512F__
-  return _mm512_rcp14_ps(x);
-#else
-  return simd_make_float16(simd_fast_recip(x.lo), simd_fast_recip(x.hi));
-#endif
-}
-
-static inline SIMD_CFUNC double simd_fast_recip(double x) {
-  return simd_precise_recip(x);
-}
-
-static inline SIMD_CFUNC simd_double2 simd_fast_recip(simd_double2 x) {
-  return simd_precise_recip(x);
-}
-
-static inline SIMD_CFUNC simd_double3 simd_fast_recip(simd_double3 x) {
-  return simd_precise_recip(x);
-}
-
-static inline SIMD_CFUNC simd_double4 simd_fast_recip(simd_double4 x) {
-  return simd_precise_recip(x);
-}
-
-static inline SIMD_CFUNC simd_double8 simd_fast_recip(simd_double8 x) {
-  return simd_precise_recip(x);
-}
-
-static inline SIMD_CFUNC float simd_precise_recip(float x) {
-#if defined __SSE__
-  float r = simd_fast_recip(x);
-  return r*(2 - (x == 0 ? -INFINITY : x)*r);
-#elif defined __ARM_NEON__
-  return simd_precise_recip(simd_make_float2_undef(x)).x;
-#else
-  return 1/x;
-#endif
-}
-
-static inline SIMD_CFUNC simd_float2 simd_precise_recip(simd_float2 x) {
-#if defined __SSE__
-  return simd_make_float2(simd_precise_recip(simd_make_float4_undef(x)));
-#elif defined __ARM_NEON__
-  simd_float2 r = simd_fast_recip(x);
-  return r*vrecps_f32(x, r);
-#else
-  return 1/x;
-#endif
-}
-
-static inline SIMD_CFUNC simd_float3 simd_precise_recip(simd_float3 x) {
-  return simd_make_float3(simd_precise_recip(simd_make_float4_undef(x)));
-}
-
-static inline SIMD_CFUNC simd_float4 simd_precise_recip(simd_float4 x) {
-#if defined __SSE__
-  simd_float4 r = simd_fast_recip(x);
-  return r*(2 - simd_bitselect(x, -INFINITY, x == 0)*r);
-#elif defined __ARM_NEON__
-  simd_float4 r = simd_fast_recip(x);
-  return r*vrecpsq_f32(x, r);
-#else
-  return 1/x;
-#endif
-}
-
-static inline SIMD_CFUNC simd_float8 simd_precise_recip(simd_float8 x) {
-#if defined __AVX__
-  simd_float8 r = simd_fast_recip(x);
-  return r*(2 - simd_bitselect(x, -INFINITY, x == 0)*r);
-#else
-  return simd_make_float8(simd_precise_recip(x.lo), simd_precise_recip(x.hi));
-#endif
-}
-
-static inline SIMD_CFUNC simd_float16 simd_precise_recip(simd_float16 x) {
-#if defined __AVX512F__
-  simd_float16 r = simd_fast_recip(x);
-  return r*(2 - simd_bitselect(x, -INFINITY, x == 0)*r);
-#else
-  return simd_make_float16(simd_precise_recip(x.lo), simd_precise_recip(x.hi));
-#endif
-}
-
-static inline SIMD_CFUNC double simd_precise_recip(double x) {
-  return 1/x;
-}
-
-static inline SIMD_CFUNC simd_double2 simd_precise_recip(simd_double2 x) {
-  return 1/x;
-}
-
-static inline SIMD_CFUNC simd_double3 simd_precise_recip(simd_double3 x) {
-  return 1/x;
-}
-
-static inline SIMD_CFUNC simd_double4 simd_precise_recip(simd_double4 x) {
-  return 1/x;
-}
-
-static inline SIMD_CFUNC simd_double8 simd_precise_recip(simd_double8 x) {
-  return 1/x;
-}
-
-static inline SIMD_CFUNC float simd_rsqrt(float x) {
-#if __FAST_MATH__
-  return simd_fast_rsqrt(x);
-#else
-  return simd_precise_rsqrt(x);
-#endif
-}
-  
-static inline SIMD_CFUNC simd_float2 simd_rsqrt(simd_float2 x) {
-#if __FAST_MATH__
-  return simd_fast_rsqrt(x);
-#else
-  return simd_precise_rsqrt(x);
-#endif
-}
-  
-static inline SIMD_CFUNC simd_float3 simd_rsqrt(simd_float3 x) {
-#if __FAST_MATH__
-  return simd_fast_rsqrt(x);
-#else
-  return simd_precise_rsqrt(x);
-#endif
-}
-  
-static inline SIMD_CFUNC simd_float4 simd_rsqrt(simd_float4 x) {
-#if __FAST_MATH__
-  return simd_fast_rsqrt(x);
-#else
-  return simd_precise_rsqrt(x);
-#endif
-}
-  
-static inline SIMD_CFUNC simd_float8 simd_rsqrt(simd_float8 x) {
-#if __FAST_MATH__
-  return simd_fast_rsqrt(x);
-#else
-  return simd_precise_rsqrt(x);
-#endif
-}
-  
-static inline SIMD_CFUNC simd_float16 simd_rsqrt(simd_float16 x) {
-#if __FAST_MATH__
-  return simd_fast_rsqrt(x);
-#else
-  return simd_precise_rsqrt(x);
-#endif
-}
-  
-static inline SIMD_CFUNC double simd_rsqrt(double x) {
-#if __FAST_MATH__
-  return simd_fast_rsqrt(x);
-#else
-  return simd_precise_rsqrt(x);
-#endif
-}
-  
-static inline SIMD_CFUNC simd_double2 simd_rsqrt(simd_double2 x) {
-#if __FAST_MATH__
-  return simd_fast_rsqrt(x);
-#else
-  return simd_precise_rsqrt(x);
-#endif
-}
-  
-static inline SIMD_CFUNC simd_double3 simd_rsqrt(simd_double3 x) {
-#if __FAST_MATH__
-  return simd_fast_rsqrt(x);
-#else
-  return simd_precise_rsqrt(x);
-#endif
-}
-  
-static inline SIMD_CFUNC simd_double4 simd_rsqrt(simd_double4 x) {
-#if __FAST_MATH__
-  return simd_fast_rsqrt(x);
-#else
-  return simd_precise_rsqrt(x);
-#endif
-}
-  
-static inline SIMD_CFUNC simd_double8 simd_rsqrt(simd_double8 x) {
-#if __FAST_MATH__
-  return simd_fast_rsqrt(x);
-#else
-  return simd_precise_rsqrt(x);
-#endif
-}
-  
-static inline SIMD_CFUNC float simd_fast_rsqrt(float x) {
-#if defined __AVX512VL__
-  simd_float4 x4 = simd_make_float4(x);
-  return ((simd_float4)_mm_rsqrt14_ss(x4, x4)).x;
-#elif defined __SSE__
-  return ((simd_float4)_mm_rsqrt_ss(simd_make_float4(x))).x;
-#elif defined __ARM_NEON__
-  return simd_fast_rsqrt(simd_make_float2_undef(x)).x;
-#else
-  return simd_precise_rsqrt(x);
-#endif
-}
-
-static inline SIMD_CFUNC simd_float2 simd_fast_rsqrt(simd_float2 x) {
-#if defined __SSE__
-  return simd_make_float2(simd_fast_rsqrt(simd_make_float4_undef(x)));
-#elif defined __ARM_NEON__
-  simd_float2 r = vrsqrte_f32(x);
-  return r * vrsqrts_f32(x, r*r);
-#else
-  return simd_precise_rsqrt(x);
-#endif
-}
-
-static inline SIMD_CFUNC simd_float3 simd_fast_rsqrt(simd_float3 x) {
-  return simd_make_float3(simd_fast_rsqrt(simd_make_float4_undef(x)));
-}
-
-static inline SIMD_CFUNC simd_float4 simd_fast_rsqrt(simd_float4 x) {
-#if defined __AVX512VL__
-  return _mm_rsqrt14_ps(x);
-#elif defined __SSE__
-  return _mm_rsqrt_ps(x);
-#elif defined __ARM_NEON__
-  simd_float4 r = vrsqrteq_f32(x);
-  return r * vrsqrtsq_f32(x, r*r);
-#else
-  return simd_precise_rsqrt(x);
-#endif
-}
-
-static inline SIMD_CFUNC simd_float8 simd_fast_rsqrt(simd_float8 x) {
-#if defined __AVX512VL__
-  return _mm256_rsqrt14_ps(x);
-#elif defined __AVX__
-  return _mm256_rsqrt_ps(x);
-#else
-  return simd_make_float8(simd_fast_rsqrt(x.lo), simd_fast_rsqrt(x.hi));
-#endif
-}
-
-static inline SIMD_CFUNC simd_float16 simd_fast_rsqrt(simd_float16 x) {
-#if defined __AVX512F__
-  return _mm512_rsqrt14_ps(x);
-#else
-  return simd_make_float16(simd_fast_rsqrt(x.lo), simd_fast_rsqrt(x.hi));
-#endif
-}
-
-static inline SIMD_CFUNC double simd_fast_rsqrt(double x) {
-  return simd_precise_rsqrt(x);
-}
-
-static inline SIMD_CFUNC simd_double2 simd_fast_rsqrt(simd_double2 x) {
-  return simd_precise_rsqrt(x);
-}
-
-static inline SIMD_CFUNC simd_double3 simd_fast_rsqrt(simd_double3 x) {
-  return simd_precise_rsqrt(x);
-}
-
-static inline SIMD_CFUNC simd_double4 simd_fast_rsqrt(simd_double4 x) {
-  return simd_precise_rsqrt(x);
-}
-
-static inline SIMD_CFUNC simd_double8 simd_fast_rsqrt(simd_double8 x) {
-  return simd_precise_rsqrt(x);
-}
-
-static inline SIMD_CFUNC float simd_precise_rsqrt(float x) {
-#if defined __SSE__
-  float r = simd_fast_rsqrt(x);
-  return r*(1.5f - 0.5f*(r == INFINITY ? -INFINITY : x)*r*r);
-#elif defined __ARM_NEON__
-  return simd_precise_rsqrt(simd_make_float2_undef(x)).x;
-#else
-  return 1/sqrt(x);
-#endif
-}
-  
-static inline SIMD_CFUNC simd_float2 simd_precise_rsqrt(simd_float2 x) {
-#if defined __SSE__
-  return simd_make_float2(simd_precise_rsqrt(simd_make_float4_undef(x)));
-#elif defined __ARM_NEON__
-  simd_float2 r = simd_fast_rsqrt(x);
-  return r*vrsqrts_f32(x, r*r);
-#else
-  return 1/__tg_sqrt(x);
-#endif
-}
-  
-static inline SIMD_CFUNC simd_float3 simd_precise_rsqrt(simd_float3 x) {
-  return simd_make_float3(simd_precise_rsqrt(simd_make_float4_undef(x)));
-}
-  
-static inline SIMD_CFUNC simd_float4 simd_precise_rsqrt(simd_float4 x) {
-#if defined __SSE__
-  simd_float4 r = simd_fast_rsqrt(x);
-  return r*(1.5 - 0.5*simd_bitselect(x, -INFINITY, r == INFINITY)*r*r);
-#elif defined __ARM_NEON__
-  simd_float4 r = simd_fast_rsqrt(x);
-  return r*vrsqrtsq_f32(x, r*r);
-#else
-  return 1/__tg_sqrt(x);
-#endif
-}
-  
-static inline SIMD_CFUNC simd_float8 simd_precise_rsqrt(simd_float8 x) {
-#if defined __AVX__
-  simd_float8 r = simd_fast_rsqrt(x);
-  return r*(1.5 - 0.5*simd_bitselect(x, -INFINITY, r == INFINITY)*r*r);
-#else
-  return simd_make_float8(simd_precise_rsqrt(x.lo), simd_precise_rsqrt(x.hi));
-#endif
-}
-  
-static inline SIMD_CFUNC simd_float16 simd_precise_rsqrt(simd_float16 x) {
-#if defined __AVX512F__
-  simd_float16 r = simd_fast_rsqrt(x);
-  return r*(1.5 - 0.5*simd_bitselect(x, -INFINITY, r == INFINITY)*r*r);
-#else
-  return simd_make_float16(simd_precise_rsqrt(x.lo), simd_precise_rsqrt(x.hi));
-#endif
-}
-  
-static inline SIMD_CFUNC double simd_precise_rsqrt(double x) {
-  return 1/sqrt(x);
-}
-  
-static inline SIMD_CFUNC simd_double2 simd_precise_rsqrt(simd_double2 x) {
-  return 1/__tg_sqrt(x);
-}
-  
-static inline SIMD_CFUNC simd_double3 simd_precise_rsqrt(simd_double3 x) {
-  return 1/__tg_sqrt(x);
-}
-  
-static inline SIMD_CFUNC simd_double4 simd_precise_rsqrt(simd_double4 x) {
-  return 1/__tg_sqrt(x);
-}
-  
-static inline SIMD_CFUNC simd_double8 simd_precise_rsqrt(simd_double8 x) {
-  return 1/__tg_sqrt(x);
-}
-  
-static inline SIMD_CFUNC float simd_fract(float x) {
-  return fmin(x - floor(x), 0x1.fffffep-1f);
-}
-
-static inline SIMD_CFUNC simd_float2 simd_fract(simd_float2 x) {
-  return __tg_fmin(x - __tg_floor(x), 0x1.fffffep-1f);
-}
-
-static inline SIMD_CFUNC simd_float3 simd_fract(simd_float3 x) {
-  return __tg_fmin(x - __tg_floor(x), 0x1.fffffep-1f);
-}
-
-static inline SIMD_CFUNC simd_float4 simd_fract(simd_float4 x) {
-  return __tg_fmin(x - __tg_floor(x), 0x1.fffffep-1f);
-}
-
-static inline SIMD_CFUNC simd_float8 simd_fract(simd_float8 x) {
-  return __tg_fmin(x - __tg_floor(x), 0x1.fffffep-1f);
-}
-
-static inline SIMD_CFUNC simd_float16 simd_fract(simd_float16 x) {
-  return __tg_fmin(x - __tg_floor(x), 0x1.fffffep-1f);
-}
-
-static inline SIMD_CFUNC double simd_fract(double x) {
-  return fmin(x - floor(x), 0x1.fffffffffffffp-1);
-}
-
-static inline SIMD_CFUNC simd_double2 simd_fract(simd_double2 x) {
-  return __tg_fmin(x - __tg_floor(x), 0x1.fffffffffffffp-1);
-}
-
-static inline SIMD_CFUNC simd_double3 simd_fract(simd_double3 x) {
-  return __tg_fmin(x - __tg_floor(x), 0x1.fffffffffffffp-1);
-}
-
-static inline SIMD_CFUNC simd_double4 simd_fract(simd_double4 x) {
-  return __tg_fmin(x - __tg_floor(x), 0x1.fffffffffffffp-1);
-}
-
-static inline SIMD_CFUNC simd_double8 simd_fract(simd_double8 x) {
-  return __tg_fmin(x - __tg_floor(x), 0x1.fffffffffffffp-1);
-}
-
-static inline SIMD_CFUNC float simd_step(float edge, float x) {
-  return !(x < edge);
-}
-
-static inline SIMD_CFUNC simd_float2 simd_step(simd_float2 edge, simd_float2 x) {
-  return simd_bitselect((simd_float2)1, 0, x < edge);
-}
-
-static inline SIMD_CFUNC simd_float3 simd_step(simd_float3 edge, simd_float3 x) {
-  return simd_bitselect((simd_float3)1, 0, x < edge);
-}
-
-static inline SIMD_CFUNC simd_float4 simd_step(simd_float4 edge, simd_float4 x) {
-  return simd_bitselect((simd_float4)1, 0, x < edge);
-}
-
-static inline SIMD_CFUNC simd_float8 simd_step(simd_float8 edge, simd_float8 x) {
-  return simd_bitselect((simd_float8)1, 0, x < edge);
-}
-
-static inline SIMD_CFUNC simd_float16 simd_step(simd_float16 edge, simd_float16 x) {
-  return simd_bitselect((simd_float16)1, 0, x < edge);
-}
-
-static inline SIMD_CFUNC double simd_step(double edge, double x) {
-  return !(x < edge);
-}
-
-static inline SIMD_CFUNC simd_double2 simd_step(simd_double2 edge, simd_double2 x) {
-  return simd_bitselect((simd_double2)1, 0, x < edge);
-}
-
-static inline SIMD_CFUNC simd_double3 simd_step(simd_double3 edge, simd_double3 x) {
-  return simd_bitselect((simd_double3)1, 0, x < edge);
-}
-
-static inline SIMD_CFUNC simd_double4 simd_step(simd_double4 edge, simd_double4 x) {
-  return simd_bitselect((simd_double4)1, 0, x < edge);
-}
-
-static inline SIMD_CFUNC simd_double8 simd_step(simd_double8 edge, simd_double8 x) {
-  return simd_bitselect((simd_double8)1, 0, x < edge);
-}
-
-static inline SIMD_CFUNC float simd_smoothstep(float edge0, float edge1, float x) {
-  float t = simd_clamp((x - edge0)/(edge1 - edge0), 0, 1);
-  return t*t*(3 - 2*t);
-}
-
-static inline SIMD_CFUNC simd_float2 simd_smoothstep(simd_float2 edge0, simd_float2 edge1, simd_float2 x) {
-  simd_float2 t = simd_clamp((x - edge0)/(edge1 - edge0), 0, 1);
-  return t*t*(3 - 2*t);
-}
-
-static inline SIMD_CFUNC simd_float3 simd_smoothstep(simd_float3 edge0, simd_float3 edge1, simd_float3 x) {
-  simd_float3 t = simd_clamp((x - edge0)/(edge1 - edge0), 0, 1);
-  return t*t*(3 - 2*t);
-}
-
-static inline SIMD_CFUNC simd_float4 simd_smoothstep(simd_float4 edge0, simd_float4 edge1, simd_float4 x) {
-  simd_float4 t = simd_clamp((x - edge0)/(edge1 - edge0), 0, 1);
-  return t*t*(3 - 2*t);
-}
-
-static inline SIMD_CFUNC simd_float8 simd_smoothstep(simd_float8 edge0, simd_float8 edge1, simd_float8 x) {
-  simd_float8 t = simd_clamp((x - edge0)/(edge1 - edge0), 0, 1);
-  return t*t*(3 - 2*t);
-}
-
-static inline SIMD_CFUNC simd_float16 simd_smoothstep(simd_float16 edge0, simd_float16 edge1, simd_float16 x) {
-  simd_float16 t = simd_clamp((x - edge0)/(edge1 - edge0), 0, 1);
-  return t*t*(3 - 2*t);
-}
-
-static inline SIMD_CFUNC double simd_smoothstep(double edge0, double edge1, double x) {
-  double t = simd_clamp((x - edge0)/(edge1 - edge0), 0, 1);
-  return t*t*(3 - 2*t);
-}
-
-static inline SIMD_CFUNC simd_double2 simd_smoothstep(simd_double2 edge0, simd_double2 edge1, simd_double2 x) {
-  simd_double2 t = simd_clamp((x - edge0)/(edge1 - edge0), 0, 1);
-  return t*t*(3 - 2*t);
-}
-
-static inline SIMD_CFUNC simd_double3 simd_smoothstep(simd_double3 edge0, simd_double3 edge1, simd_double3 x) {
-  simd_double3 t = simd_clamp((x - edge0)/(edge1 - edge0), 0, 1);
-  return t*t*(3 - 2*t);
-}
-
-static inline SIMD_CFUNC simd_double4 simd_smoothstep(simd_double4 edge0, simd_double4 edge1, simd_double4 x) {
-  simd_double4 t = simd_clamp((x - edge0)/(edge1 - edge0), 0, 1);
-  return t*t*(3 - 2*t);
-}
-
-static inline SIMD_CFUNC simd_double8 simd_smoothstep(simd_double8 edge0, simd_double8 edge1, simd_double8 x) {
-  simd_double8 t = simd_clamp((x - edge0)/(edge1 - edge0), 0, 1);
-  return t*t*(3 - 2*t);
-}
-
-static inline SIMD_CFUNC char simd_reduce_add(simd_char2 x) {
-  return x.x + x.y;
-}
-
-static inline SIMD_CFUNC char simd_reduce_add(simd_char3 x) {
-  return x.x + x.y + x.z;
-}
-
-static inline SIMD_CFUNC char simd_reduce_add(simd_char4 x) {
-  return simd_reduce_add(x.lo + x.hi);
-}
-
-static inline SIMD_CFUNC char simd_reduce_add(simd_char8 x) {
-  return simd_reduce_add(x.lo + x.hi);
-}
-
-static inline SIMD_CFUNC char simd_reduce_add(simd_char16 x) {
-  return simd_reduce_add(x.lo + x.hi);
-}
-
-static inline SIMD_CFUNC char simd_reduce_add(simd_char32 x) {
-  return simd_reduce_add(x.lo + x.hi);
-}
-
-static inline SIMD_CFUNC char simd_reduce_add(simd_char64 x) {
-  return simd_reduce_add(x.lo + x.hi);
-}
-
-static inline SIMD_CFUNC unsigned char simd_reduce_add(simd_uchar2 x) {
-  return x.x + x.y;
-}
-
-static inline SIMD_CFUNC unsigned char simd_reduce_add(simd_uchar3 x) {
-  return x.x + x.y + x.z;
-}
-
-static inline SIMD_CFUNC unsigned char simd_reduce_add(simd_uchar4 x) {
-  return simd_reduce_add(x.lo + x.hi);
-}
-
-static inline SIMD_CFUNC unsigned char simd_reduce_add(simd_uchar8 x) {
-  return simd_reduce_add(x.lo + x.hi);
-}
-
-static inline SIMD_CFUNC unsigned char simd_reduce_add(simd_uchar16 x) {
-  return simd_reduce_add(x.lo + x.hi);
-}
-
-static inline SIMD_CFUNC unsigned char simd_reduce_add(simd_uchar32 x) {
-  return simd_reduce_add(x.lo + x.hi);
-}
-
-static inline SIMD_CFUNC unsigned char simd_reduce_add(simd_uchar64 x) {
-  return simd_reduce_add(x.lo + x.hi);
-}
-
-static inline SIMD_CFUNC short simd_reduce_add(simd_short2 x) {
-  return x.x + x.y;
-}
-
-static inline SIMD_CFUNC short simd_reduce_add(simd_short3 x) {
-  return x.x + x.y + x.z;
-}
-
-static inline SIMD_CFUNC short simd_reduce_add(simd_short4 x) {
-  return simd_reduce_add(x.lo + x.hi);
-}
-
-static inline SIMD_CFUNC short simd_reduce_add(simd_short8 x) {
-  return simd_reduce_add(x.lo + x.hi);
-}
-
-static inline SIMD_CFUNC short simd_reduce_add(simd_short16 x) {
-  return simd_reduce_add(x.lo + x.hi);
-}
-
-static inline SIMD_CFUNC short simd_reduce_add(simd_short32 x) {
-  return simd_reduce_add(x.lo + x.hi);
-}
-
-static inline SIMD_CFUNC unsigned short simd_reduce_add(simd_ushort2 x) {
-  return x.x + x.y;
-}
-
-static inline SIMD_CFUNC unsigned short simd_reduce_add(simd_ushort3 x) {
-  return x.x + x.y + x.z;
-}
-
-static inline SIMD_CFUNC unsigned short simd_reduce_add(simd_ushort4 x) {
-  return simd_reduce_add(x.lo + x.hi);
-}
-
-static inline SIMD_CFUNC unsigned short simd_reduce_add(simd_ushort8 x) {
-  return simd_reduce_add(x.lo + x.hi);
-}
-
-static inline SIMD_CFUNC unsigned short simd_reduce_add(simd_ushort16 x) {
-  return simd_reduce_add(x.lo + x.hi);
-}
-
-static inline SIMD_CFUNC unsigned short simd_reduce_add(simd_ushort32 x) {
-  return simd_reduce_add(x.lo + x.hi);
-}
-
-static inline SIMD_CFUNC int simd_reduce_add(simd_int2 x) {
-  return x.x + x.y;
-}
-
-static inline SIMD_CFUNC int simd_reduce_add(simd_int3 x) {
-  return x.x + x.y + x.z;
-}
-
-static inline SIMD_CFUNC int simd_reduce_add(simd_int4 x) {
-  return simd_reduce_add(x.lo + x.hi);
-}
-
-static inline SIMD_CFUNC int simd_reduce_add(simd_int8 x) {
-  return simd_reduce_add(x.lo + x.hi);
-}
-
-static inline SIMD_CFUNC int simd_reduce_add(simd_int16 x) {
-  return simd_reduce_add(x.lo + x.hi);
-}
-
-static inline SIMD_CFUNC unsigned int simd_reduce_add(simd_uint2 x) {
-  return x.x + x.y;
-}
-
-static inline SIMD_CFUNC unsigned int simd_reduce_add(simd_uint3 x) {
-  return x.x + x.y + x.z;
-}
-
-static inline SIMD_CFUNC unsigned int simd_reduce_add(simd_uint4 x) {
-  return simd_reduce_add(x.lo + x.hi);
-}
-
-static inline SIMD_CFUNC unsigned int simd_reduce_add(simd_uint8 x) {
-  return simd_reduce_add(x.lo + x.hi);
-}
-
-static inline SIMD_CFUNC unsigned int simd_reduce_add(simd_uint16 x) {
-  return simd_reduce_add(x.lo + x.hi);
-}
-
-static inline SIMD_CFUNC float simd_reduce_add(simd_float2 x) {
-  return x.x + x.y;
-}
-
-static inline SIMD_CFUNC float simd_reduce_add(simd_float3 x) {
-  return x.x + x.y + x.z;
-}
-
-static inline SIMD_CFUNC float simd_reduce_add(simd_float4 x) {
-  return simd_reduce_add(x.lo + x.hi);
-}
-
-static inline SIMD_CFUNC float simd_reduce_add(simd_float8 x) {
-  return simd_reduce_add(x.lo + x.hi);
-}
-
-static inline SIMD_CFUNC float simd_reduce_add(simd_float16 x) {
-  return simd_reduce_add(x.lo + x.hi);
-}
-
-static inline SIMD_CFUNC simd_long1 simd_reduce_add(simd_long2 x) {
-  return x.x + x.y;
-}
-
-static inline SIMD_CFUNC simd_long1 simd_reduce_add(simd_long3 x) {
-  return x.x + x.y + x.z;
-}
-
-static inline SIMD_CFUNC simd_long1 simd_reduce_add(simd_long4 x) {
-  return simd_reduce_add(x.lo + x.hi);
-}
-
-static inline SIMD_CFUNC simd_long1 simd_reduce_add(simd_long8 x) {
-  return simd_reduce_add(x.lo + x.hi);
-}
-
-static inline SIMD_CFUNC simd_ulong1 simd_reduce_add(simd_ulong2 x) {
-  return x.x + x.y;
-}
-
-static inline SIMD_CFUNC simd_ulong1 simd_reduce_add(simd_ulong3 x) {
-  return x.x + x.y + x.z;
-}
-
-static inline SIMD_CFUNC simd_ulong1 simd_reduce_add(simd_ulong4 x) {
-  return simd_reduce_add(x.lo + x.hi);
-}
-
-static inline SIMD_CFUNC simd_ulong1 simd_reduce_add(simd_ulong8 x) {
-  return simd_reduce_add(x.lo + x.hi);
-}
-
-static inline SIMD_CFUNC double simd_reduce_add(simd_double2 x) {
-  return x.x + x.y;
-}
-
-static inline SIMD_CFUNC double simd_reduce_add(simd_double3 x) {
-  return x.x + x.y + x.z;
-}
-
-static inline SIMD_CFUNC double simd_reduce_add(simd_double4 x) {
-  return simd_reduce_add(x.lo + x.hi);
-}
-
-static inline SIMD_CFUNC double simd_reduce_add(simd_double8 x) {
-  return simd_reduce_add(x.lo + x.hi);
-}
-
-static inline SIMD_CFUNC char simd_reduce_min(simd_char2 x) {
-  return x.y < x.x ? x.y : x.x;
-}
-
-static inline SIMD_CFUNC char simd_reduce_min(simd_char3 x) {
-  char t = x.z < x.x ? x.z : x.x;
-  return x.y < t ? x.y : t;
-}
-
-static inline SIMD_CFUNC char simd_reduce_min(simd_char4 x) {
-  return simd_reduce_min(simd_min(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC char simd_reduce_min(simd_char8 x) {
-  return simd_reduce_min(simd_min(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC char simd_reduce_min(simd_char16 x) {
-  return simd_reduce_min(simd_min(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC char simd_reduce_min(simd_char32 x) {
-  return simd_reduce_min(simd_min(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC char simd_reduce_min(simd_char64 x) {
-  return simd_reduce_min(simd_min(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC unsigned char simd_reduce_min(simd_uchar2 x) {
-  return x.y < x.x ? x.y : x.x;
-}
-
-static inline SIMD_CFUNC unsigned char simd_reduce_min(simd_uchar3 x) {
-  unsigned char t = x.z < x.x ? x.z : x.x;
-  return x.y < t ? x.y : t;
-}
-
-static inline SIMD_CFUNC unsigned char simd_reduce_min(simd_uchar4 x) {
-  return simd_reduce_min(simd_min(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC unsigned char simd_reduce_min(simd_uchar8 x) {
-  return simd_reduce_min(simd_min(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC unsigned char simd_reduce_min(simd_uchar16 x) {
-  return simd_reduce_min(simd_min(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC unsigned char simd_reduce_min(simd_uchar32 x) {
-  return simd_reduce_min(simd_min(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC unsigned char simd_reduce_min(simd_uchar64 x) {
-  return simd_reduce_min(simd_min(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC short simd_reduce_min(simd_short2 x) {
-  return x.y < x.x ? x.y : x.x;
-}
-
-static inline SIMD_CFUNC short simd_reduce_min(simd_short3 x) {
-  short t = x.z < x.x ? x.z : x.x;
-  return x.y < t ? x.y : t;
-}
-
-static inline SIMD_CFUNC short simd_reduce_min(simd_short4 x) {
-  return simd_reduce_min(simd_min(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC short simd_reduce_min(simd_short8 x) {
-  return simd_reduce_min(simd_min(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC short simd_reduce_min(simd_short16 x) {
-  return simd_reduce_min(simd_min(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC short simd_reduce_min(simd_short32 x) {
-  return simd_reduce_min(simd_min(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC unsigned short simd_reduce_min(simd_ushort2 x) {
-  return x.y < x.x ? x.y : x.x;
-}
-
-static inline SIMD_CFUNC unsigned short simd_reduce_min(simd_ushort3 x) {
-  unsigned short t = x.z < x.x ? x.z : x.x;
-  return x.y < t ? x.y : t;
-}
-
-static inline SIMD_CFUNC unsigned short simd_reduce_min(simd_ushort4 x) {
-  return simd_reduce_min(simd_min(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC unsigned short simd_reduce_min(simd_ushort8 x) {
-  return simd_reduce_min(simd_min(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC unsigned short simd_reduce_min(simd_ushort16 x) {
-  return simd_reduce_min(simd_min(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC unsigned short simd_reduce_min(simd_ushort32 x) {
-  return simd_reduce_min(simd_min(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC int simd_reduce_min(simd_int2 x) {
-  return x.y < x.x ? x.y : x.x;
-}
-
-static inline SIMD_CFUNC int simd_reduce_min(simd_int3 x) {
-  int t = x.z < x.x ? x.z : x.x;
-  return x.y < t ? x.y : t;
-}
-
-static inline SIMD_CFUNC int simd_reduce_min(simd_int4 x) {
-  return simd_reduce_min(simd_min(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC int simd_reduce_min(simd_int8 x) {
-  return simd_reduce_min(simd_min(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC int simd_reduce_min(simd_int16 x) {
-  return simd_reduce_min(simd_min(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC unsigned int simd_reduce_min(simd_uint2 x) {
-  return x.y < x.x ? x.y : x.x;
-}
-
-static inline SIMD_CFUNC unsigned int simd_reduce_min(simd_uint3 x) {
-  unsigned int t = x.z < x.x ? x.z : x.x;
-  return x.y < t ? x.y : t;
-}
-
-static inline SIMD_CFUNC unsigned int simd_reduce_min(simd_uint4 x) {
-  return simd_reduce_min(simd_min(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC unsigned int simd_reduce_min(simd_uint8 x) {
-  return simd_reduce_min(simd_min(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC unsigned int simd_reduce_min(simd_uint16 x) {
-  return simd_reduce_min(simd_min(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC float simd_reduce_min(simd_float2 x) {
-  return fmin(x.x, x.y);
-}
-
-static inline SIMD_CFUNC float simd_reduce_min(simd_float3 x) {
-  return fmin(fmin(x.x, x.z), x.y);
-}
-
-static inline SIMD_CFUNC float simd_reduce_min(simd_float4 x) {
-  return simd_reduce_min(simd_min(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC float simd_reduce_min(simd_float8 x) {
-  return simd_reduce_min(simd_min(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC float simd_reduce_min(simd_float16 x) {
-  return simd_reduce_min(simd_min(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC simd_long1 simd_reduce_min(simd_long2 x) {
-  return x.y < x.x ? x.y : x.x;
-}
-
-static inline SIMD_CFUNC simd_long1 simd_reduce_min(simd_long3 x) {
-  simd_long1 t = x.z < x.x ? x.z : x.x;
-  return x.y < t ? x.y : t;
-}
-
-static inline SIMD_CFUNC simd_long1 simd_reduce_min(simd_long4 x) {
-  return simd_reduce_min(simd_min(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC simd_long1 simd_reduce_min(simd_long8 x) {
-  return simd_reduce_min(simd_min(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC simd_ulong1 simd_reduce_min(simd_ulong2 x) {
-  return x.y < x.x ? x.y : x.x;
-}
-
-static inline SIMD_CFUNC simd_ulong1 simd_reduce_min(simd_ulong3 x) {
-  simd_ulong1 t = x.z < x.x ? x.z : x.x;
-  return x.y < t ? x.y : t;
-}
-
-static inline SIMD_CFUNC simd_ulong1 simd_reduce_min(simd_ulong4 x) {
-  return simd_reduce_min(simd_min(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC simd_ulong1 simd_reduce_min(simd_ulong8 x) {
-  return simd_reduce_min(simd_min(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC double simd_reduce_min(simd_double2 x) {
-  return fmin(x.x, x.y);
-}
-
-static inline SIMD_CFUNC double simd_reduce_min(simd_double3 x) {
-  return fmin(fmin(x.x, x.z), x.y);
-}
-
-static inline SIMD_CFUNC double simd_reduce_min(simd_double4 x) {
-  return simd_reduce_min(simd_min(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC double simd_reduce_min(simd_double8 x) {
-  return simd_reduce_min(simd_min(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC char simd_reduce_max(simd_char2 x) {
-  return x.y > x.x ? x.y : x.x;
-}
-
-static inline SIMD_CFUNC char simd_reduce_max(simd_char3 x) {
-  char t = x.z > x.x ? x.z : x.x;
-  return x.y > t ? x.y : t;
-}
-
-static inline SIMD_CFUNC char simd_reduce_max(simd_char4 x) {
-  return simd_reduce_max(simd_max(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC char simd_reduce_max(simd_char8 x) {
-  return simd_reduce_max(simd_max(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC char simd_reduce_max(simd_char16 x) {
-  return simd_reduce_max(simd_max(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC char simd_reduce_max(simd_char32 x) {
-  return simd_reduce_max(simd_max(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC char simd_reduce_max(simd_char64 x) {
-  return simd_reduce_max(simd_max(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC unsigned char simd_reduce_max(simd_uchar2 x) {
-  return x.y > x.x ? x.y : x.x;
-}
-
-static inline SIMD_CFUNC unsigned char simd_reduce_max(simd_uchar3 x) {
-  unsigned char t = x.z > x.x ? x.z : x.x;
-  return x.y > t ? x.y : t;
-}
-
-static inline SIMD_CFUNC unsigned char simd_reduce_max(simd_uchar4 x) {
-  return simd_reduce_max(simd_max(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC unsigned char simd_reduce_max(simd_uchar8 x) {
-  return simd_reduce_max(simd_max(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC unsigned char simd_reduce_max(simd_uchar16 x) {
-  return simd_reduce_max(simd_max(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC unsigned char simd_reduce_max(simd_uchar32 x) {
-  return simd_reduce_max(simd_max(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC unsigned char simd_reduce_max(simd_uchar64 x) {
-  return simd_reduce_max(simd_max(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC short simd_reduce_max(simd_short2 x) {
-  return x.y > x.x ? x.y : x.x;
-}
-
-static inline SIMD_CFUNC short simd_reduce_max(simd_short3 x) {
-  short t = x.z > x.x ? x.z : x.x;
-  return x.y > t ? x.y : t;
-}
-
-static inline SIMD_CFUNC short simd_reduce_max(simd_short4 x) {
-  return simd_reduce_max(simd_max(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC short simd_reduce_max(simd_short8 x) {
-  return simd_reduce_max(simd_max(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC short simd_reduce_max(simd_short16 x) {
-  return simd_reduce_max(simd_max(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC short simd_reduce_max(simd_short32 x) {
-  return simd_reduce_max(simd_max(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC unsigned short simd_reduce_max(simd_ushort2 x) {
-  return x.y > x.x ? x.y : x.x;
-}
-
-static inline SIMD_CFUNC unsigned short simd_reduce_max(simd_ushort3 x) {
-  unsigned short t = x.z > x.x ? x.z : x.x;
-  return x.y > t ? x.y : t;
-}
-
-static inline SIMD_CFUNC unsigned short simd_reduce_max(simd_ushort4 x) {
-  return simd_reduce_max(simd_max(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC unsigned short simd_reduce_max(simd_ushort8 x) {
-  return simd_reduce_max(simd_max(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC unsigned short simd_reduce_max(simd_ushort16 x) {
-  return simd_reduce_max(simd_max(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC unsigned short simd_reduce_max(simd_ushort32 x) {
-  return simd_reduce_max(simd_max(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC int simd_reduce_max(simd_int2 x) {
-  return x.y > x.x ? x.y : x.x;
-}
-
-static inline SIMD_CFUNC int simd_reduce_max(simd_int3 x) {
-  int t = x.z > x.x ? x.z : x.x;
-  return x.y > t ? x.y : t;
-}
-
-static inline SIMD_CFUNC int simd_reduce_max(simd_int4 x) {
-  return simd_reduce_max(simd_max(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC int simd_reduce_max(simd_int8 x) {
-  return simd_reduce_max(simd_max(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC int simd_reduce_max(simd_int16 x) {
-  return simd_reduce_max(simd_max(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC unsigned int simd_reduce_max(simd_uint2 x) {
-  return x.y > x.x ? x.y : x.x;
-}
-
-static inline SIMD_CFUNC unsigned int simd_reduce_max(simd_uint3 x) {
-  unsigned int t = x.z > x.x ? x.z : x.x;
-  return x.y > t ? x.y : t;
-}
-
-static inline SIMD_CFUNC unsigned int simd_reduce_max(simd_uint4 x) {
-  return simd_reduce_max(simd_max(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC unsigned int simd_reduce_max(simd_uint8 x) {
-  return simd_reduce_max(simd_max(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC unsigned int simd_reduce_max(simd_uint16 x) {
-  return simd_reduce_max(simd_max(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC float simd_reduce_max(simd_float2 x) {
-  return fmax(x.x, x.y);
-}
-
-static inline SIMD_CFUNC float simd_reduce_max(simd_float3 x) {
-  return fmax(fmax(x.x, x.z), x.y);
-}
-
-static inline SIMD_CFUNC float simd_reduce_max(simd_float4 x) {
-  return simd_reduce_max(simd_max(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC float simd_reduce_max(simd_float8 x) {
-  return simd_reduce_max(simd_max(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC float simd_reduce_max(simd_float16 x) {
-  return simd_reduce_max(simd_max(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC simd_long1 simd_reduce_max(simd_long2 x) {
-  return x.y > x.x ? x.y : x.x;
-}
-
-static inline SIMD_CFUNC simd_long1 simd_reduce_max(simd_long3 x) {
-  simd_long1 t = x.z > x.x ? x.z : x.x;
-  return x.y > t ? x.y : t;
-}
-
-static inline SIMD_CFUNC simd_long1 simd_reduce_max(simd_long4 x) {
-  return simd_reduce_max(simd_max(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC simd_long1 simd_reduce_max(simd_long8 x) {
-  return simd_reduce_max(simd_max(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC simd_ulong1 simd_reduce_max(simd_ulong2 x) {
-  return x.y > x.x ? x.y : x.x;
-}
-
-static inline SIMD_CFUNC simd_ulong1 simd_reduce_max(simd_ulong3 x) {
-  simd_ulong1 t = x.z > x.x ? x.z : x.x;
-  return x.y > t ? x.y : t;
-}
-
-static inline SIMD_CFUNC simd_ulong1 simd_reduce_max(simd_ulong4 x) {
-  return simd_reduce_max(simd_max(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC simd_ulong1 simd_reduce_max(simd_ulong8 x) {
-  return simd_reduce_max(simd_max(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC double simd_reduce_max(simd_double2 x) {
-  return fmax(x.x, x.y);
-}
-
-static inline SIMD_CFUNC double simd_reduce_max(simd_double3 x) {
-  return fmax(fmax(x.x, x.z), x.y);
-}
-
-static inline SIMD_CFUNC double simd_reduce_max(simd_double4 x) {
-  return simd_reduce_max(simd_max(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC double simd_reduce_max(simd_double8 x) {
-  return simd_reduce_max(simd_max(x.lo, x.hi));
-}
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* SIMD_COMPILER_HAS_REQUIRED_FEATURES */
-#endif /* SIMD_COMMON_HEADER */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/simd/conversion.h b/lib/libc/include/x86_64-macos-gnu/simd/conversion.h
deleted file mode 100644
index cc6c533e8f..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/simd/conversion.h
+++ /dev/null
@@ -1,1876 +0,0 @@
-/*  Copyright (c) 2014-2017 Apple, Inc. All rights reserved.
- *
- *  The interfaces declared in this header provide conversions between vector
- *  types. The following functions are available:
- *
- *      simd_char(x)      simd_uchar(x)
- *      simd_short(x)     simd_ushort(x)
- *      simd_int(x)       simd_uint(x)
- *      simd_long(x)      simd_ulong(x)
- *      simd_float(x)
- *      simd_double(x)
- *
- *  Each of these functions converts x to a vector whose elements have the
- *  type named by the function, with the same number of elements as x. Unlike
- *  a vector cast, these functions convert the elements to the new element
- *  type. These conversions behave exactly as C scalar conversions, except
- *  that conversions from integer vector types to signed integer vector types
- *  are guaranteed to wrap modulo 2^N (where N is the number of bits in an
- *  element of the result type).
- *
- *  For integer vector types, saturating conversions are also available:
- *
- *      simd_char_sat(x)      simd_uchar_sat(x)
- *      simd_short_sat(x)     simd_ushort_sat(x)
- *      simd_int_sat(x)       simd_uint_sat(x)
- *      simd_long_sat(x)      simd_ulong_sat(x)
- *
- *  These conversions clamp x to the representable range of the result type
- *  before converting.
- *
- *  Unlike most vector operations in <simd/>, there are no abbreviated C++
- *  names for these functions in the simd:: namespace.
- */
-
-#ifndef __SIMD_CONVERSION_HEADER__
-#define __SIMD_CONVERSION_HEADER__
-
-#include <simd/base.h>
-#if SIMD_COMPILER_HAS_REQUIRED_FEATURES
-#include <simd/vector_types.h>
-#include <simd/common.h>
-#include <simd/logic.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-static simd_char2  SIMD_CFUNC simd_char(simd_char2    __x);
-static simd_char3  SIMD_CFUNC simd_char(simd_char3    __x);
-static simd_char4  SIMD_CFUNC simd_char(simd_char4    __x);
-static simd_char8  SIMD_CFUNC simd_char(simd_char8    __x);
-static simd_char16 SIMD_CFUNC simd_char(simd_char16   __x);
-static simd_char32 SIMD_CFUNC simd_char(simd_char32   __x);
-static simd_char2  SIMD_CFUNC simd_char(simd_uchar2   __x);
-static simd_char3  SIMD_CFUNC simd_char(simd_uchar3   __x);
-static simd_char4  SIMD_CFUNC simd_char(simd_uchar4   __x);
-static simd_char8  SIMD_CFUNC simd_char(simd_uchar8   __x);
-static simd_char16 SIMD_CFUNC simd_char(simd_uchar16  __x);
-static simd_char32 SIMD_CFUNC simd_char(simd_uchar32  __x);
-static simd_char2  SIMD_CFUNC simd_char(simd_short2   __x);
-static simd_char3  SIMD_CFUNC simd_char(simd_short3   __x);
-static simd_char4  SIMD_CFUNC simd_char(simd_short4   __x);
-static simd_char8  SIMD_CFUNC simd_char(simd_short8   __x);
-static simd_char16 SIMD_CFUNC simd_char(simd_short16  __x);
-static simd_char32 SIMD_CFUNC simd_char(simd_short32  __x);
-static simd_char2  SIMD_CFUNC simd_char(simd_ushort2  __x);
-static simd_char3  SIMD_CFUNC simd_char(simd_ushort3  __x);
-static simd_char4  SIMD_CFUNC simd_char(simd_ushort4  __x);
-static simd_char8  SIMD_CFUNC simd_char(simd_ushort8  __x);
-static simd_char16 SIMD_CFUNC simd_char(simd_ushort16 __x);
-static simd_char32 SIMD_CFUNC simd_char(simd_ushort32 __x);
-static simd_char2  SIMD_CFUNC simd_char(simd_int2     __x);
-static simd_char3  SIMD_CFUNC simd_char(simd_int3     __x);
-static simd_char4  SIMD_CFUNC simd_char(simd_int4     __x);
-static simd_char8  SIMD_CFUNC simd_char(simd_int8     __x);
-static simd_char16 SIMD_CFUNC simd_char(simd_int16    __x);
-static simd_char2  SIMD_CFUNC simd_char(simd_uint2    __x);
-static simd_char3  SIMD_CFUNC simd_char(simd_uint3    __x);
-static simd_char4  SIMD_CFUNC simd_char(simd_uint4    __x);
-static simd_char8  SIMD_CFUNC simd_char(simd_uint8    __x);
-static simd_char16 SIMD_CFUNC simd_char(simd_uint16   __x);
-static simd_char2  SIMD_CFUNC simd_char(simd_float2   __x);
-static simd_char3  SIMD_CFUNC simd_char(simd_float3   __x);
-static simd_char4  SIMD_CFUNC simd_char(simd_float4   __x);
-static simd_char8  SIMD_CFUNC simd_char(simd_float8   __x);
-static simd_char16 SIMD_CFUNC simd_char(simd_float16  __x);
-static simd_char2  SIMD_CFUNC simd_char(simd_long2    __x);
-static simd_char3  SIMD_CFUNC simd_char(simd_long3    __x);
-static simd_char4  SIMD_CFUNC simd_char(simd_long4    __x);
-static simd_char8  SIMD_CFUNC simd_char(simd_long8    __x);
-static simd_char2  SIMD_CFUNC simd_char(simd_ulong2   __x);
-static simd_char3  SIMD_CFUNC simd_char(simd_ulong3   __x);
-static simd_char4  SIMD_CFUNC simd_char(simd_ulong4   __x);
-static simd_char8  SIMD_CFUNC simd_char(simd_ulong8   __x);
-static simd_char2  SIMD_CFUNC simd_char(simd_double2  __x);
-static simd_char3  SIMD_CFUNC simd_char(simd_double3  __x);
-static simd_char4  SIMD_CFUNC simd_char(simd_double4  __x);
-static simd_char8  SIMD_CFUNC simd_char(simd_double8  __x);
-static simd_char2  SIMD_CFUNC simd_char_sat(simd_char2    __x);
-static simd_char3  SIMD_CFUNC simd_char_sat(simd_char3    __x);
-static simd_char4  SIMD_CFUNC simd_char_sat(simd_char4    __x);
-static simd_char8  SIMD_CFUNC simd_char_sat(simd_char8    __x);
-static simd_char16 SIMD_CFUNC simd_char_sat(simd_char16   __x);
-static simd_char32 SIMD_CFUNC simd_char_sat(simd_char32   __x);
-static simd_char2  SIMD_CFUNC simd_char_sat(simd_short2   __x);
-static simd_char3  SIMD_CFUNC simd_char_sat(simd_short3   __x);
-static simd_char4  SIMD_CFUNC simd_char_sat(simd_short4   __x);
-static simd_char8  SIMD_CFUNC simd_char_sat(simd_short8   __x);
-static simd_char16 SIMD_CFUNC simd_char_sat(simd_short16  __x);
-static simd_char32 SIMD_CFUNC simd_char_sat(simd_short32  __x);
-static simd_char2  SIMD_CFUNC simd_char_sat(simd_int2     __x);
-static simd_char3  SIMD_CFUNC simd_char_sat(simd_int3     __x);
-static simd_char4  SIMD_CFUNC simd_char_sat(simd_int4     __x);
-static simd_char8  SIMD_CFUNC simd_char_sat(simd_int8     __x);
-static simd_char16 SIMD_CFUNC simd_char_sat(simd_int16    __x);
-static simd_char2  SIMD_CFUNC simd_char_sat(simd_float2   __x);
-static simd_char3  SIMD_CFUNC simd_char_sat(simd_float3   __x);
-static simd_char4  SIMD_CFUNC simd_char_sat(simd_float4   __x);
-static simd_char8  SIMD_CFUNC simd_char_sat(simd_float8   __x);
-static simd_char16 SIMD_CFUNC simd_char_sat(simd_float16  __x);
-static simd_char2  SIMD_CFUNC simd_char_sat(simd_long2    __x);
-static simd_char3  SIMD_CFUNC simd_char_sat(simd_long3    __x);
-static simd_char4  SIMD_CFUNC simd_char_sat(simd_long4    __x);
-static simd_char8  SIMD_CFUNC simd_char_sat(simd_long8    __x);
-static simd_char2  SIMD_CFUNC simd_char_sat(simd_double2  __x);
-static simd_char3  SIMD_CFUNC simd_char_sat(simd_double3  __x);
-static simd_char4  SIMD_CFUNC simd_char_sat(simd_double4  __x);
-static simd_char8  SIMD_CFUNC simd_char_sat(simd_double8  __x);
-static simd_char2  SIMD_CFUNC simd_char_sat(simd_uchar2   __x);
-static simd_char3  SIMD_CFUNC simd_char_sat(simd_uchar3   __x);
-static simd_char4  SIMD_CFUNC simd_char_sat(simd_uchar4   __x);
-static simd_char8  SIMD_CFUNC simd_char_sat(simd_uchar8   __x);
-static simd_char16 SIMD_CFUNC simd_char_sat(simd_uchar16  __x);
-static simd_char32 SIMD_CFUNC simd_char_sat(simd_uchar32  __x);
-static simd_char2  SIMD_CFUNC simd_char_sat(simd_ushort2  __x);
-static simd_char3  SIMD_CFUNC simd_char_sat(simd_ushort3  __x);
-static simd_char4  SIMD_CFUNC simd_char_sat(simd_ushort4  __x);
-static simd_char8  SIMD_CFUNC simd_char_sat(simd_ushort8  __x);
-static simd_char16 SIMD_CFUNC simd_char_sat(simd_ushort16 __x);
-static simd_char32 SIMD_CFUNC simd_char_sat(simd_ushort32 __x);
-static simd_char2  SIMD_CFUNC simd_char_sat(simd_uint2    __x);
-static simd_char3  SIMD_CFUNC simd_char_sat(simd_uint3    __x);
-static simd_char4  SIMD_CFUNC simd_char_sat(simd_uint4    __x);
-static simd_char8  SIMD_CFUNC simd_char_sat(simd_uint8    __x);
-static simd_char16 SIMD_CFUNC simd_char_sat(simd_uint16   __x);
-static simd_char2  SIMD_CFUNC simd_char_sat(simd_ulong2   __x);
-static simd_char3  SIMD_CFUNC simd_char_sat(simd_ulong3   __x);
-static simd_char4  SIMD_CFUNC simd_char_sat(simd_ulong4   __x);
-static simd_char8  SIMD_CFUNC simd_char_sat(simd_ulong8   __x);
-#define vector_char simd_char
-#define vector_char_sat simd_char_sat
-
-static simd_uchar2  SIMD_CFUNC simd_uchar(simd_char2    __x);
-static simd_uchar3  SIMD_CFUNC simd_uchar(simd_char3    __x);
-static simd_uchar4  SIMD_CFUNC simd_uchar(simd_char4    __x);
-static simd_uchar8  SIMD_CFUNC simd_uchar(simd_char8    __x);
-static simd_uchar16 SIMD_CFUNC simd_uchar(simd_char16   __x);
-static simd_uchar32 SIMD_CFUNC simd_uchar(simd_char32   __x);
-static simd_uchar2  SIMD_CFUNC simd_uchar(simd_uchar2   __x);
-static simd_uchar3  SIMD_CFUNC simd_uchar(simd_uchar3   __x);
-static simd_uchar4  SIMD_CFUNC simd_uchar(simd_uchar4   __x);
-static simd_uchar8  SIMD_CFUNC simd_uchar(simd_uchar8   __x);
-static simd_uchar16 SIMD_CFUNC simd_uchar(simd_uchar16  __x);
-static simd_uchar32 SIMD_CFUNC simd_uchar(simd_uchar32  __x);
-static simd_uchar2  SIMD_CFUNC simd_uchar(simd_short2   __x);
-static simd_uchar3  SIMD_CFUNC simd_uchar(simd_short3   __x);
-static simd_uchar4  SIMD_CFUNC simd_uchar(simd_short4   __x);
-static simd_uchar8  SIMD_CFUNC simd_uchar(simd_short8   __x);
-static simd_uchar16 SIMD_CFUNC simd_uchar(simd_short16  __x);
-static simd_uchar32 SIMD_CFUNC simd_uchar(simd_short32  __x);
-static simd_uchar2  SIMD_CFUNC simd_uchar(simd_ushort2  __x);
-static simd_uchar3  SIMD_CFUNC simd_uchar(simd_ushort3  __x);
-static simd_uchar4  SIMD_CFUNC simd_uchar(simd_ushort4  __x);
-static simd_uchar8  SIMD_CFUNC simd_uchar(simd_ushort8  __x);
-static simd_uchar16 SIMD_CFUNC simd_uchar(simd_ushort16 __x);
-static simd_uchar32 SIMD_CFUNC simd_uchar(simd_ushort32 __x);
-static simd_uchar2  SIMD_CFUNC simd_uchar(simd_int2     __x);
-static simd_uchar3  SIMD_CFUNC simd_uchar(simd_int3     __x);
-static simd_uchar4  SIMD_CFUNC simd_uchar(simd_int4     __x);
-static simd_uchar8  SIMD_CFUNC simd_uchar(simd_int8     __x);
-static simd_uchar16 SIMD_CFUNC simd_uchar(simd_int16    __x);
-static simd_uchar2  SIMD_CFUNC simd_uchar(simd_uint2    __x);
-static simd_uchar3  SIMD_CFUNC simd_uchar(simd_uint3    __x);
-static simd_uchar4  SIMD_CFUNC simd_uchar(simd_uint4    __x);
-static simd_uchar8  SIMD_CFUNC simd_uchar(simd_uint8    __x);
-static simd_uchar16 SIMD_CFUNC simd_uchar(simd_uint16   __x);
-static simd_uchar2  SIMD_CFUNC simd_uchar(simd_float2   __x);
-static simd_uchar3  SIMD_CFUNC simd_uchar(simd_float3   __x);
-static simd_uchar4  SIMD_CFUNC simd_uchar(simd_float4   __x);
-static simd_uchar8  SIMD_CFUNC simd_uchar(simd_float8   __x);
-static simd_uchar16 SIMD_CFUNC simd_uchar(simd_float16  __x);
-static simd_uchar2  SIMD_CFUNC simd_uchar(simd_long2    __x);
-static simd_uchar3  SIMD_CFUNC simd_uchar(simd_long3    __x);
-static simd_uchar4  SIMD_CFUNC simd_uchar(simd_long4    __x);
-static simd_uchar8  SIMD_CFUNC simd_uchar(simd_long8    __x);
-static simd_uchar2  SIMD_CFUNC simd_uchar(simd_ulong2   __x);
-static simd_uchar3  SIMD_CFUNC simd_uchar(simd_ulong3   __x);
-static simd_uchar4  SIMD_CFUNC simd_uchar(simd_ulong4   __x);
-static simd_uchar8  SIMD_CFUNC simd_uchar(simd_ulong8   __x);
-static simd_uchar2  SIMD_CFUNC simd_uchar(simd_double2  __x);
-static simd_uchar3  SIMD_CFUNC simd_uchar(simd_double3  __x);
-static simd_uchar4  SIMD_CFUNC simd_uchar(simd_double4  __x);
-static simd_uchar8  SIMD_CFUNC simd_uchar(simd_double8  __x);
-static simd_uchar2  SIMD_CFUNC simd_uchar_sat(simd_char2    __x);
-static simd_uchar3  SIMD_CFUNC simd_uchar_sat(simd_char3    __x);
-static simd_uchar4  SIMD_CFUNC simd_uchar_sat(simd_char4    __x);
-static simd_uchar8  SIMD_CFUNC simd_uchar_sat(simd_char8    __x);
-static simd_uchar16 SIMD_CFUNC simd_uchar_sat(simd_char16   __x);
-static simd_uchar32 SIMD_CFUNC simd_uchar_sat(simd_char32   __x);
-static simd_uchar2  SIMD_CFUNC simd_uchar_sat(simd_short2   __x);
-static simd_uchar3  SIMD_CFUNC simd_uchar_sat(simd_short3   __x);
-static simd_uchar4  SIMD_CFUNC simd_uchar_sat(simd_short4   __x);
-static simd_uchar8  SIMD_CFUNC simd_uchar_sat(simd_short8   __x);
-static simd_uchar16 SIMD_CFUNC simd_uchar_sat(simd_short16  __x);
-static simd_uchar32 SIMD_CFUNC simd_uchar_sat(simd_short32  __x);
-static simd_uchar2  SIMD_CFUNC simd_uchar_sat(simd_int2     __x);
-static simd_uchar3  SIMD_CFUNC simd_uchar_sat(simd_int3     __x);
-static simd_uchar4  SIMD_CFUNC simd_uchar_sat(simd_int4     __x);
-static simd_uchar8  SIMD_CFUNC simd_uchar_sat(simd_int8     __x);
-static simd_uchar16 SIMD_CFUNC simd_uchar_sat(simd_int16    __x);
-static simd_uchar2  SIMD_CFUNC simd_uchar_sat(simd_float2   __x);
-static simd_uchar3  SIMD_CFUNC simd_uchar_sat(simd_float3   __x);
-static simd_uchar4  SIMD_CFUNC simd_uchar_sat(simd_float4   __x);
-static simd_uchar8  SIMD_CFUNC simd_uchar_sat(simd_float8   __x);
-static simd_uchar16 SIMD_CFUNC simd_uchar_sat(simd_float16  __x);
-static simd_uchar2  SIMD_CFUNC simd_uchar_sat(simd_long2    __x);
-static simd_uchar3  SIMD_CFUNC simd_uchar_sat(simd_long3    __x);
-static simd_uchar4  SIMD_CFUNC simd_uchar_sat(simd_long4    __x);
-static simd_uchar8  SIMD_CFUNC simd_uchar_sat(simd_long8    __x);
-static simd_uchar2  SIMD_CFUNC simd_uchar_sat(simd_double2  __x);
-static simd_uchar3  SIMD_CFUNC simd_uchar_sat(simd_double3  __x);
-static simd_uchar4  SIMD_CFUNC simd_uchar_sat(simd_double4  __x);
-static simd_uchar8  SIMD_CFUNC simd_uchar_sat(simd_double8  __x);
-static simd_uchar2  SIMD_CFUNC simd_uchar_sat(simd_uchar2   __x);
-static simd_uchar3  SIMD_CFUNC simd_uchar_sat(simd_uchar3   __x);
-static simd_uchar4  SIMD_CFUNC simd_uchar_sat(simd_uchar4   __x);
-static simd_uchar8  SIMD_CFUNC simd_uchar_sat(simd_uchar8   __x);
-static simd_uchar16 SIMD_CFUNC simd_uchar_sat(simd_uchar16  __x);
-static simd_uchar32 SIMD_CFUNC simd_uchar_sat(simd_uchar32  __x);
-static simd_uchar2  SIMD_CFUNC simd_uchar_sat(simd_ushort2  __x);
-static simd_uchar3  SIMD_CFUNC simd_uchar_sat(simd_ushort3  __x);
-static simd_uchar4  SIMD_CFUNC simd_uchar_sat(simd_ushort4  __x);
-static simd_uchar8  SIMD_CFUNC simd_uchar_sat(simd_ushort8  __x);
-static simd_uchar16 SIMD_CFUNC simd_uchar_sat(simd_ushort16 __x);
-static simd_uchar32 SIMD_CFUNC simd_uchar_sat(simd_ushort32 __x);
-static simd_uchar2  SIMD_CFUNC simd_uchar_sat(simd_uint2    __x);
-static simd_uchar3  SIMD_CFUNC simd_uchar_sat(simd_uint3    __x);
-static simd_uchar4  SIMD_CFUNC simd_uchar_sat(simd_uint4    __x);
-static simd_uchar8  SIMD_CFUNC simd_uchar_sat(simd_uint8    __x);
-static simd_uchar16 SIMD_CFUNC simd_uchar_sat(simd_uint16   __x);
-static simd_uchar2  SIMD_CFUNC simd_uchar_sat(simd_ulong2   __x);
-static simd_uchar3  SIMD_CFUNC simd_uchar_sat(simd_ulong3   __x);
-static simd_uchar4  SIMD_CFUNC simd_uchar_sat(simd_ulong4   __x);
-static simd_uchar8  SIMD_CFUNC simd_uchar_sat(simd_ulong8   __x);
-#define vector_uchar simd_uchar
-#define vector_uchar_sat simd_uchar_sat
-
-static simd_short2  SIMD_CFUNC simd_short(simd_char2    __x);
-static simd_short3  SIMD_CFUNC simd_short(simd_char3    __x);
-static simd_short4  SIMD_CFUNC simd_short(simd_char4    __x);
-static simd_short8  SIMD_CFUNC simd_short(simd_char8    __x);
-static simd_short16 SIMD_CFUNC simd_short(simd_char16   __x);
-static simd_short32 SIMD_CFUNC simd_short(simd_char32   __x);
-static simd_short2  SIMD_CFUNC simd_short(simd_uchar2   __x);
-static simd_short3  SIMD_CFUNC simd_short(simd_uchar3   __x);
-static simd_short4  SIMD_CFUNC simd_short(simd_uchar4   __x);
-static simd_short8  SIMD_CFUNC simd_short(simd_uchar8   __x);
-static simd_short16 SIMD_CFUNC simd_short(simd_uchar16  __x);
-static simd_short32 SIMD_CFUNC simd_short(simd_uchar32  __x);
-static simd_short2  SIMD_CFUNC simd_short(simd_short2   __x);
-static simd_short3  SIMD_CFUNC simd_short(simd_short3   __x);
-static simd_short4  SIMD_CFUNC simd_short(simd_short4   __x);
-static simd_short8  SIMD_CFUNC simd_short(simd_short8   __x);
-static simd_short16 SIMD_CFUNC simd_short(simd_short16  __x);
-static simd_short32 SIMD_CFUNC simd_short(simd_short32  __x);
-static simd_short2  SIMD_CFUNC simd_short(simd_ushort2  __x);
-static simd_short3  SIMD_CFUNC simd_short(simd_ushort3  __x);
-static simd_short4  SIMD_CFUNC simd_short(simd_ushort4  __x);
-static simd_short8  SIMD_CFUNC simd_short(simd_ushort8  __x);
-static simd_short16 SIMD_CFUNC simd_short(simd_ushort16 __x);
-static simd_short32 SIMD_CFUNC simd_short(simd_ushort32 __x);
-static simd_short2  SIMD_CFUNC simd_short(simd_int2     __x);
-static simd_short3  SIMD_CFUNC simd_short(simd_int3     __x);
-static simd_short4  SIMD_CFUNC simd_short(simd_int4     __x);
-static simd_short8  SIMD_CFUNC simd_short(simd_int8     __x);
-static simd_short16 SIMD_CFUNC simd_short(simd_int16    __x);
-static simd_short2  SIMD_CFUNC simd_short(simd_uint2    __x);
-static simd_short3  SIMD_CFUNC simd_short(simd_uint3    __x);
-static simd_short4  SIMD_CFUNC simd_short(simd_uint4    __x);
-static simd_short8  SIMD_CFUNC simd_short(simd_uint8    __x);
-static simd_short16 SIMD_CFUNC simd_short(simd_uint16   __x);
-static simd_short2  SIMD_CFUNC simd_short(simd_float2   __x);
-static simd_short3  SIMD_CFUNC simd_short(simd_float3   __x);
-static simd_short4  SIMD_CFUNC simd_short(simd_float4   __x);
-static simd_short8  SIMD_CFUNC simd_short(simd_float8   __x);
-static simd_short16 SIMD_CFUNC simd_short(simd_float16  __x);
-static simd_short2  SIMD_CFUNC simd_short(simd_long2    __x);
-static simd_short3  SIMD_CFUNC simd_short(simd_long3    __x);
-static simd_short4  SIMD_CFUNC simd_short(simd_long4    __x);
-static simd_short8  SIMD_CFUNC simd_short(simd_long8    __x);
-static simd_short2  SIMD_CFUNC simd_short(simd_ulong2   __x);
-static simd_short3  SIMD_CFUNC simd_short(simd_ulong3   __x);
-static simd_short4  SIMD_CFUNC simd_short(simd_ulong4   __x);
-static simd_short8  SIMD_CFUNC simd_short(simd_ulong8   __x);
-static simd_short2  SIMD_CFUNC simd_short(simd_double2  __x);
-static simd_short3  SIMD_CFUNC simd_short(simd_double3  __x);
-static simd_short4  SIMD_CFUNC simd_short(simd_double4  __x);
-static simd_short8  SIMD_CFUNC simd_short(simd_double8  __x);
-static simd_short2  SIMD_CFUNC simd_short_sat(simd_char2    __x);
-static simd_short3  SIMD_CFUNC simd_short_sat(simd_char3    __x);
-static simd_short4  SIMD_CFUNC simd_short_sat(simd_char4    __x);
-static simd_short8  SIMD_CFUNC simd_short_sat(simd_char8    __x);
-static simd_short16 SIMD_CFUNC simd_short_sat(simd_char16   __x);
-static simd_short32 SIMD_CFUNC simd_short_sat(simd_char32   __x);
-static simd_short2  SIMD_CFUNC simd_short_sat(simd_short2   __x);
-static simd_short3  SIMD_CFUNC simd_short_sat(simd_short3   __x);
-static simd_short4  SIMD_CFUNC simd_short_sat(simd_short4   __x);
-static simd_short8  SIMD_CFUNC simd_short_sat(simd_short8   __x);
-static simd_short16 SIMD_CFUNC simd_short_sat(simd_short16  __x);
-static simd_short32 SIMD_CFUNC simd_short_sat(simd_short32  __x);
-static simd_short2  SIMD_CFUNC simd_short_sat(simd_int2     __x);
-static simd_short3  SIMD_CFUNC simd_short_sat(simd_int3     __x);
-static simd_short4  SIMD_CFUNC simd_short_sat(simd_int4     __x);
-static simd_short8  SIMD_CFUNC simd_short_sat(simd_int8     __x);
-static simd_short16 SIMD_CFUNC simd_short_sat(simd_int16    __x);
-static simd_short2  SIMD_CFUNC simd_short_sat(simd_float2   __x);
-static simd_short3  SIMD_CFUNC simd_short_sat(simd_float3   __x);
-static simd_short4  SIMD_CFUNC simd_short_sat(simd_float4   __x);
-static simd_short8  SIMD_CFUNC simd_short_sat(simd_float8   __x);
-static simd_short16 SIMD_CFUNC simd_short_sat(simd_float16  __x);
-static simd_short2  SIMD_CFUNC simd_short_sat(simd_long2    __x);
-static simd_short3  SIMD_CFUNC simd_short_sat(simd_long3    __x);
-static simd_short4  SIMD_CFUNC simd_short_sat(simd_long4    __x);
-static simd_short8  SIMD_CFUNC simd_short_sat(simd_long8    __x);
-static simd_short2  SIMD_CFUNC simd_short_sat(simd_double2  __x);
-static simd_short3  SIMD_CFUNC simd_short_sat(simd_double3  __x);
-static simd_short4  SIMD_CFUNC simd_short_sat(simd_double4  __x);
-static simd_short8  SIMD_CFUNC simd_short_sat(simd_double8  __x);
-static simd_short2  SIMD_CFUNC simd_short_sat(simd_uchar2   __x);
-static simd_short3  SIMD_CFUNC simd_short_sat(simd_uchar3   __x);
-static simd_short4  SIMD_CFUNC simd_short_sat(simd_uchar4   __x);
-static simd_short8  SIMD_CFUNC simd_short_sat(simd_uchar8   __x);
-static simd_short16 SIMD_CFUNC simd_short_sat(simd_uchar16  __x);
-static simd_short32 SIMD_CFUNC simd_short_sat(simd_uchar32  __x);
-static simd_short2  SIMD_CFUNC simd_short_sat(simd_ushort2  __x);
-static simd_short3  SIMD_CFUNC simd_short_sat(simd_ushort3  __x);
-static simd_short4  SIMD_CFUNC simd_short_sat(simd_ushort4  __x);
-static simd_short8  SIMD_CFUNC simd_short_sat(simd_ushort8  __x);
-static simd_short16 SIMD_CFUNC simd_short_sat(simd_ushort16 __x);
-static simd_short32 SIMD_CFUNC simd_short_sat(simd_ushort32 __x);
-static simd_short2  SIMD_CFUNC simd_short_sat(simd_uint2    __x);
-static simd_short3  SIMD_CFUNC simd_short_sat(simd_uint3    __x);
-static simd_short4  SIMD_CFUNC simd_short_sat(simd_uint4    __x);
-static simd_short8  SIMD_CFUNC simd_short_sat(simd_uint8    __x);
-static simd_short16 SIMD_CFUNC simd_short_sat(simd_uint16   __x);
-static simd_short2  SIMD_CFUNC simd_short_sat(simd_ulong2   __x);
-static simd_short3  SIMD_CFUNC simd_short_sat(simd_ulong3   __x);
-static simd_short4  SIMD_CFUNC simd_short_sat(simd_ulong4   __x);
-static simd_short8  SIMD_CFUNC simd_short_sat(simd_ulong8   __x);
-#define vector_short simd_short
-#define vector_short_sat simd_short_sat
-
-static simd_ushort2  SIMD_CFUNC simd_ushort(simd_char2    __x);
-static simd_ushort3  SIMD_CFUNC simd_ushort(simd_char3    __x);
-static simd_ushort4  SIMD_CFUNC simd_ushort(simd_char4    __x);
-static simd_ushort8  SIMD_CFUNC simd_ushort(simd_char8    __x);
-static simd_ushort16 SIMD_CFUNC simd_ushort(simd_char16   __x);
-static simd_ushort32 SIMD_CFUNC simd_ushort(simd_char32   __x);
-static simd_ushort2  SIMD_CFUNC simd_ushort(simd_uchar2   __x);
-static simd_ushort3  SIMD_CFUNC simd_ushort(simd_uchar3   __x);
-static simd_ushort4  SIMD_CFUNC simd_ushort(simd_uchar4   __x);
-static simd_ushort8  SIMD_CFUNC simd_ushort(simd_uchar8   __x);
-static simd_ushort16 SIMD_CFUNC simd_ushort(simd_uchar16  __x);
-static simd_ushort32 SIMD_CFUNC simd_ushort(simd_uchar32  __x);
-static simd_ushort2  SIMD_CFUNC simd_ushort(simd_short2   __x);
-static simd_ushort3  SIMD_CFUNC simd_ushort(simd_short3   __x);
-static simd_ushort4  SIMD_CFUNC simd_ushort(simd_short4   __x);
-static simd_ushort8  SIMD_CFUNC simd_ushort(simd_short8   __x);
-static simd_ushort16 SIMD_CFUNC simd_ushort(simd_short16  __x);
-static simd_ushort32 SIMD_CFUNC simd_ushort(simd_short32  __x);
-static simd_ushort2  SIMD_CFUNC simd_ushort(simd_ushort2  __x);
-static simd_ushort3  SIMD_CFUNC simd_ushort(simd_ushort3  __x);
-static simd_ushort4  SIMD_CFUNC simd_ushort(simd_ushort4  __x);
-static simd_ushort8  SIMD_CFUNC simd_ushort(simd_ushort8  __x);
-static simd_ushort16 SIMD_CFUNC simd_ushort(simd_ushort16 __x);
-static simd_ushort32 SIMD_CFUNC simd_ushort(simd_ushort32 __x);
-static simd_ushort2  SIMD_CFUNC simd_ushort(simd_int2     __x);
-static simd_ushort3  SIMD_CFUNC simd_ushort(simd_int3     __x);
-static simd_ushort4  SIMD_CFUNC simd_ushort(simd_int4     __x);
-static simd_ushort8  SIMD_CFUNC simd_ushort(simd_int8     __x);
-static simd_ushort16 SIMD_CFUNC simd_ushort(simd_int16    __x);
-static simd_ushort2  SIMD_CFUNC simd_ushort(simd_uint2    __x);
-static simd_ushort3  SIMD_CFUNC simd_ushort(simd_uint3    __x);
-static simd_ushort4  SIMD_CFUNC simd_ushort(simd_uint4    __x);
-static simd_ushort8  SIMD_CFUNC simd_ushort(simd_uint8    __x);
-static simd_ushort16 SIMD_CFUNC simd_ushort(simd_uint16   __x);
-static simd_ushort2  SIMD_CFUNC simd_ushort(simd_float2   __x);
-static simd_ushort3  SIMD_CFUNC simd_ushort(simd_float3   __x);
-static simd_ushort4  SIMD_CFUNC simd_ushort(simd_float4   __x);
-static simd_ushort8  SIMD_CFUNC simd_ushort(simd_float8   __x);
-static simd_ushort16 SIMD_CFUNC simd_ushort(simd_float16  __x);
-static simd_ushort2  SIMD_CFUNC simd_ushort(simd_long2    __x);
-static simd_ushort3  SIMD_CFUNC simd_ushort(simd_long3    __x);
-static simd_ushort4  SIMD_CFUNC simd_ushort(simd_long4    __x);
-static simd_ushort8  SIMD_CFUNC simd_ushort(simd_long8    __x);
-static simd_ushort2  SIMD_CFUNC simd_ushort(simd_ulong2   __x);
-static simd_ushort3  SIMD_CFUNC simd_ushort(simd_ulong3   __x);
-static simd_ushort4  SIMD_CFUNC simd_ushort(simd_ulong4   __x);
-static simd_ushort8  SIMD_CFUNC simd_ushort(simd_ulong8   __x);
-static simd_ushort2  SIMD_CFUNC simd_ushort(simd_double2  __x);
-static simd_ushort3  SIMD_CFUNC simd_ushort(simd_double3  __x);
-static simd_ushort4  SIMD_CFUNC simd_ushort(simd_double4  __x);
-static simd_ushort8  SIMD_CFUNC simd_ushort(simd_double8  __x);
-static simd_ushort2  SIMD_CFUNC simd_ushort_sat(simd_char2    __x);
-static simd_ushort3  SIMD_CFUNC simd_ushort_sat(simd_char3    __x);
-static simd_ushort4  SIMD_CFUNC simd_ushort_sat(simd_char4    __x);
-static simd_ushort8  SIMD_CFUNC simd_ushort_sat(simd_char8    __x);
-static simd_ushort16 SIMD_CFUNC simd_ushort_sat(simd_char16   __x);
-static simd_ushort32 SIMD_CFUNC simd_ushort_sat(simd_char32   __x);
-static simd_ushort2  SIMD_CFUNC simd_ushort_sat(simd_short2   __x);
-static simd_ushort3  SIMD_CFUNC simd_ushort_sat(simd_short3   __x);
-static simd_ushort4  SIMD_CFUNC simd_ushort_sat(simd_short4   __x);
-static simd_ushort8  SIMD_CFUNC simd_ushort_sat(simd_short8   __x);
-static simd_ushort16 SIMD_CFUNC simd_ushort_sat(simd_short16  __x);
-static simd_ushort32 SIMD_CFUNC simd_ushort_sat(simd_short32  __x);
-static simd_ushort2  SIMD_CFUNC simd_ushort_sat(simd_int2     __x);
-static simd_ushort3  SIMD_CFUNC simd_ushort_sat(simd_int3     __x);
-static simd_ushort4  SIMD_CFUNC simd_ushort_sat(simd_int4     __x);
-static simd_ushort8  SIMD_CFUNC simd_ushort_sat(simd_int8     __x);
-static simd_ushort16 SIMD_CFUNC simd_ushort_sat(simd_int16    __x);
-static simd_ushort2  SIMD_CFUNC simd_ushort_sat(simd_float2   __x);
-static simd_ushort3  SIMD_CFUNC simd_ushort_sat(simd_float3   __x);
-static simd_ushort4  SIMD_CFUNC simd_ushort_sat(simd_float4   __x);
-static simd_ushort8  SIMD_CFUNC simd_ushort_sat(simd_float8   __x);
-static simd_ushort16 SIMD_CFUNC simd_ushort_sat(simd_float16  __x);
-static simd_ushort2  SIMD_CFUNC simd_ushort_sat(simd_long2    __x);
-static simd_ushort3  SIMD_CFUNC simd_ushort_sat(simd_long3    __x);
-static simd_ushort4  SIMD_CFUNC simd_ushort_sat(simd_long4    __x);
-static simd_ushort8  SIMD_CFUNC simd_ushort_sat(simd_long8    __x);
-static simd_ushort2  SIMD_CFUNC simd_ushort_sat(simd_double2  __x);
-static simd_ushort3  SIMD_CFUNC simd_ushort_sat(simd_double3  __x);
-static simd_ushort4  SIMD_CFUNC simd_ushort_sat(simd_double4  __x);
-static simd_ushort8  SIMD_CFUNC simd_ushort_sat(simd_double8  __x);
-static simd_ushort2  SIMD_CFUNC simd_ushort_sat(simd_uchar2   __x);
-static simd_ushort3  SIMD_CFUNC simd_ushort_sat(simd_uchar3   __x);
-static simd_ushort4  SIMD_CFUNC simd_ushort_sat(simd_uchar4   __x);
-static simd_ushort8  SIMD_CFUNC simd_ushort_sat(simd_uchar8   __x);
-static simd_ushort16 SIMD_CFUNC simd_ushort_sat(simd_uchar16  __x);
-static simd_ushort32 SIMD_CFUNC simd_ushort_sat(simd_uchar32  __x);
-static simd_ushort2  SIMD_CFUNC simd_ushort_sat(simd_ushort2  __x);
-static simd_ushort3  SIMD_CFUNC simd_ushort_sat(simd_ushort3  __x);
-static simd_ushort4  SIMD_CFUNC simd_ushort_sat(simd_ushort4  __x);
-static simd_ushort8  SIMD_CFUNC simd_ushort_sat(simd_ushort8  __x);
-static simd_ushort16 SIMD_CFUNC simd_ushort_sat(simd_ushort16 __x);
-static simd_ushort32 SIMD_CFUNC simd_ushort_sat(simd_ushort32 __x);
-static simd_ushort2  SIMD_CFUNC simd_ushort_sat(simd_uint2    __x);
-static simd_ushort3  SIMD_CFUNC simd_ushort_sat(simd_uint3    __x);
-static simd_ushort4  SIMD_CFUNC simd_ushort_sat(simd_uint4    __x);
-static simd_ushort8  SIMD_CFUNC simd_ushort_sat(simd_uint8    __x);
-static simd_ushort16 SIMD_CFUNC simd_ushort_sat(simd_uint16   __x);
-static simd_ushort2  SIMD_CFUNC simd_ushort_sat(simd_ulong2   __x);
-static simd_ushort3  SIMD_CFUNC simd_ushort_sat(simd_ulong3   __x);
-static simd_ushort4  SIMD_CFUNC simd_ushort_sat(simd_ulong4   __x);
-static simd_ushort8  SIMD_CFUNC simd_ushort_sat(simd_ulong8   __x);
-#define vector_ushort simd_ushort
-#define vector_ushort_sat simd_ushort_sat
-
-static simd_int2  SIMD_CFUNC simd_int(simd_char2    __x);
-static simd_int3  SIMD_CFUNC simd_int(simd_char3    __x);
-static simd_int4  SIMD_CFUNC simd_int(simd_char4    __x);
-static simd_int8  SIMD_CFUNC simd_int(simd_char8    __x);
-static simd_int16 SIMD_CFUNC simd_int(simd_char16   __x);
-static simd_int2  SIMD_CFUNC simd_int(simd_uchar2   __x);
-static simd_int3  SIMD_CFUNC simd_int(simd_uchar3   __x);
-static simd_int4  SIMD_CFUNC simd_int(simd_uchar4   __x);
-static simd_int8  SIMD_CFUNC simd_int(simd_uchar8   __x);
-static simd_int16 SIMD_CFUNC simd_int(simd_uchar16  __x);
-static simd_int2  SIMD_CFUNC simd_int(simd_short2   __x);
-static simd_int3  SIMD_CFUNC simd_int(simd_short3   __x);
-static simd_int4  SIMD_CFUNC simd_int(simd_short4   __x);
-static simd_int8  SIMD_CFUNC simd_int(simd_short8   __x);
-static simd_int16 SIMD_CFUNC simd_int(simd_short16  __x);
-static simd_int2  SIMD_CFUNC simd_int(simd_ushort2  __x);
-static simd_int3  SIMD_CFUNC simd_int(simd_ushort3  __x);
-static simd_int4  SIMD_CFUNC simd_int(simd_ushort4  __x);
-static simd_int8  SIMD_CFUNC simd_int(simd_ushort8  __x);
-static simd_int16 SIMD_CFUNC simd_int(simd_ushort16 __x);
-static simd_int2  SIMD_CFUNC simd_int(simd_int2     __x);
-static simd_int3  SIMD_CFUNC simd_int(simd_int3     __x);
-static simd_int4  SIMD_CFUNC simd_int(simd_int4     __x);
-static simd_int8  SIMD_CFUNC simd_int(simd_int8     __x);
-static simd_int16 SIMD_CFUNC simd_int(simd_int16    __x);
-static simd_int2  SIMD_CFUNC simd_int(simd_uint2    __x);
-static simd_int3  SIMD_CFUNC simd_int(simd_uint3    __x);
-static simd_int4  SIMD_CFUNC simd_int(simd_uint4    __x);
-static simd_int8  SIMD_CFUNC simd_int(simd_uint8    __x);
-static simd_int16 SIMD_CFUNC simd_int(simd_uint16   __x);
-static simd_int2  SIMD_CFUNC simd_int(simd_float2   __x);
-static simd_int3  SIMD_CFUNC simd_int(simd_float3   __x);
-static simd_int4  SIMD_CFUNC simd_int(simd_float4   __x);
-static simd_int8  SIMD_CFUNC simd_int(simd_float8   __x);
-static simd_int16 SIMD_CFUNC simd_int(simd_float16  __x);
-static simd_int2  SIMD_CFUNC simd_int(simd_long2    __x);
-static simd_int3  SIMD_CFUNC simd_int(simd_long3    __x);
-static simd_int4  SIMD_CFUNC simd_int(simd_long4    __x);
-static simd_int8  SIMD_CFUNC simd_int(simd_long8    __x);
-static simd_int2  SIMD_CFUNC simd_int(simd_ulong2   __x);
-static simd_int3  SIMD_CFUNC simd_int(simd_ulong3   __x);
-static simd_int4  SIMD_CFUNC simd_int(simd_ulong4   __x);
-static simd_int8  SIMD_CFUNC simd_int(simd_ulong8   __x);
-static simd_int2  SIMD_CFUNC simd_int(simd_double2  __x);
-static simd_int3  SIMD_CFUNC simd_int(simd_double3  __x);
-static simd_int4  SIMD_CFUNC simd_int(simd_double4  __x);
-static simd_int8  SIMD_CFUNC simd_int(simd_double8  __x);
-static simd_int2  SIMD_CFUNC simd_int_sat(simd_char2    __x);
-static simd_int3  SIMD_CFUNC simd_int_sat(simd_char3    __x);
-static simd_int4  SIMD_CFUNC simd_int_sat(simd_char4    __x);
-static simd_int8  SIMD_CFUNC simd_int_sat(simd_char8    __x);
-static simd_int16 SIMD_CFUNC simd_int_sat(simd_char16   __x);
-static simd_int2  SIMD_CFUNC simd_int_sat(simd_short2   __x);
-static simd_int3  SIMD_CFUNC simd_int_sat(simd_short3   __x);
-static simd_int4  SIMD_CFUNC simd_int_sat(simd_short4   __x);
-static simd_int8  SIMD_CFUNC simd_int_sat(simd_short8   __x);
-static simd_int16 SIMD_CFUNC simd_int_sat(simd_short16  __x);
-static simd_int2  SIMD_CFUNC simd_int_sat(simd_int2     __x);
-static simd_int3  SIMD_CFUNC simd_int_sat(simd_int3     __x);
-static simd_int4  SIMD_CFUNC simd_int_sat(simd_int4     __x);
-static simd_int8  SIMD_CFUNC simd_int_sat(simd_int8     __x);
-static simd_int16 SIMD_CFUNC simd_int_sat(simd_int16    __x);
-static simd_int2  SIMD_CFUNC simd_int_sat(simd_float2   __x);
-static simd_int3  SIMD_CFUNC simd_int_sat(simd_float3   __x);
-static simd_int4  SIMD_CFUNC simd_int_sat(simd_float4   __x);
-static simd_int8  SIMD_CFUNC simd_int_sat(simd_float8   __x);
-static simd_int16 SIMD_CFUNC simd_int_sat(simd_float16  __x);
-static simd_int2  SIMD_CFUNC simd_int_sat(simd_long2    __x);
-static simd_int3  SIMD_CFUNC simd_int_sat(simd_long3    __x);
-static simd_int4  SIMD_CFUNC simd_int_sat(simd_long4    __x);
-static simd_int8  SIMD_CFUNC simd_int_sat(simd_long8    __x);
-static simd_int2  SIMD_CFUNC simd_int_sat(simd_double2  __x);
-static simd_int3  SIMD_CFUNC simd_int_sat(simd_double3  __x);
-static simd_int4  SIMD_CFUNC simd_int_sat(simd_double4  __x);
-static simd_int8  SIMD_CFUNC simd_int_sat(simd_double8  __x);
-static simd_int2  SIMD_CFUNC simd_int_sat(simd_uchar2   __x);
-static simd_int3  SIMD_CFUNC simd_int_sat(simd_uchar3   __x);
-static simd_int4  SIMD_CFUNC simd_int_sat(simd_uchar4   __x);
-static simd_int8  SIMD_CFUNC simd_int_sat(simd_uchar8   __x);
-static simd_int16 SIMD_CFUNC simd_int_sat(simd_uchar16  __x);
-static simd_int2  SIMD_CFUNC simd_int_sat(simd_ushort2  __x);
-static simd_int3  SIMD_CFUNC simd_int_sat(simd_ushort3  __x);
-static simd_int4  SIMD_CFUNC simd_int_sat(simd_ushort4  __x);
-static simd_int8  SIMD_CFUNC simd_int_sat(simd_ushort8  __x);
-static simd_int16 SIMD_CFUNC simd_int_sat(simd_ushort16 __x);
-static simd_int2  SIMD_CFUNC simd_int_sat(simd_uint2    __x);
-static simd_int3  SIMD_CFUNC simd_int_sat(simd_uint3    __x);
-static simd_int4  SIMD_CFUNC simd_int_sat(simd_uint4    __x);
-static simd_int8  SIMD_CFUNC simd_int_sat(simd_uint8    __x);
-static simd_int16 SIMD_CFUNC simd_int_sat(simd_uint16   __x);
-static simd_int2  SIMD_CFUNC simd_int_sat(simd_ulong2   __x);
-static simd_int3  SIMD_CFUNC simd_int_sat(simd_ulong3   __x);
-static simd_int4  SIMD_CFUNC simd_int_sat(simd_ulong4   __x);
-static simd_int8  SIMD_CFUNC simd_int_sat(simd_ulong8   __x);
-#define vector_int simd_int
-#define vector_int_sat simd_int_sat
-
-static simd_uint2  SIMD_CFUNC simd_uint(simd_char2    __x);
-static simd_uint3  SIMD_CFUNC simd_uint(simd_char3    __x);
-static simd_uint4  SIMD_CFUNC simd_uint(simd_char4    __x);
-static simd_uint8  SIMD_CFUNC simd_uint(simd_char8    __x);
-static simd_uint16 SIMD_CFUNC simd_uint(simd_char16   __x);
-static simd_uint2  SIMD_CFUNC simd_uint(simd_uchar2   __x);
-static simd_uint3  SIMD_CFUNC simd_uint(simd_uchar3   __x);
-static simd_uint4  SIMD_CFUNC simd_uint(simd_uchar4   __x);
-static simd_uint8  SIMD_CFUNC simd_uint(simd_uchar8   __x);
-static simd_uint16 SIMD_CFUNC simd_uint(simd_uchar16  __x);
-static simd_uint2  SIMD_CFUNC simd_uint(simd_short2   __x);
-static simd_uint3  SIMD_CFUNC simd_uint(simd_short3   __x);
-static simd_uint4  SIMD_CFUNC simd_uint(simd_short4   __x);
-static simd_uint8  SIMD_CFUNC simd_uint(simd_short8   __x);
-static simd_uint16 SIMD_CFUNC simd_uint(simd_short16  __x);
-static simd_uint2  SIMD_CFUNC simd_uint(simd_ushort2  __x);
-static simd_uint3  SIMD_CFUNC simd_uint(simd_ushort3  __x);
-static simd_uint4  SIMD_CFUNC simd_uint(simd_ushort4  __x);
-static simd_uint8  SIMD_CFUNC simd_uint(simd_ushort8  __x);
-static simd_uint16 SIMD_CFUNC simd_uint(simd_ushort16 __x);
-static simd_uint2  SIMD_CFUNC simd_uint(simd_int2     __x);
-static simd_uint3  SIMD_CFUNC simd_uint(simd_int3     __x);
-static simd_uint4  SIMD_CFUNC simd_uint(simd_int4     __x);
-static simd_uint8  SIMD_CFUNC simd_uint(simd_int8     __x);
-static simd_uint16 SIMD_CFUNC simd_uint(simd_int16    __x);
-static simd_uint2  SIMD_CFUNC simd_uint(simd_uint2    __x);
-static simd_uint3  SIMD_CFUNC simd_uint(simd_uint3    __x);
-static simd_uint4  SIMD_CFUNC simd_uint(simd_uint4    __x);
-static simd_uint8  SIMD_CFUNC simd_uint(simd_uint8    __x);
-static simd_uint16 SIMD_CFUNC simd_uint(simd_uint16   __x);
-static simd_uint2  SIMD_CFUNC simd_uint(simd_float2   __x);
-static simd_uint3  SIMD_CFUNC simd_uint(simd_float3   __x);
-static simd_uint4  SIMD_CFUNC simd_uint(simd_float4   __x);
-static simd_uint8  SIMD_CFUNC simd_uint(simd_float8   __x);
-static simd_uint16 SIMD_CFUNC simd_uint(simd_float16  __x);
-static simd_uint2  SIMD_CFUNC simd_uint(simd_long2    __x);
-static simd_uint3  SIMD_CFUNC simd_uint(simd_long3    __x);
-static simd_uint4  SIMD_CFUNC simd_uint(simd_long4    __x);
-static simd_uint8  SIMD_CFUNC simd_uint(simd_long8    __x);
-static simd_uint2  SIMD_CFUNC simd_uint(simd_ulong2   __x);
-static simd_uint3  SIMD_CFUNC simd_uint(simd_ulong3   __x);
-static simd_uint4  SIMD_CFUNC simd_uint(simd_ulong4   __x);
-static simd_uint8  SIMD_CFUNC simd_uint(simd_ulong8   __x);
-static simd_uint2  SIMD_CFUNC simd_uint(simd_double2  __x);
-static simd_uint3  SIMD_CFUNC simd_uint(simd_double3  __x);
-static simd_uint4  SIMD_CFUNC simd_uint(simd_double4  __x);
-static simd_uint8  SIMD_CFUNC simd_uint(simd_double8  __x);
-static simd_uint2  SIMD_CFUNC simd_uint_sat(simd_char2    __x);
-static simd_uint3  SIMD_CFUNC simd_uint_sat(simd_char3    __x);
-static simd_uint4  SIMD_CFUNC simd_uint_sat(simd_char4    __x);
-static simd_uint8  SIMD_CFUNC simd_uint_sat(simd_char8    __x);
-static simd_uint16 SIMD_CFUNC simd_uint_sat(simd_char16   __x);
-static simd_uint2  SIMD_CFUNC simd_uint_sat(simd_short2   __x);
-static simd_uint3  SIMD_CFUNC simd_uint_sat(simd_short3   __x);
-static simd_uint4  SIMD_CFUNC simd_uint_sat(simd_short4   __x);
-static simd_uint8  SIMD_CFUNC simd_uint_sat(simd_short8   __x);
-static simd_uint16 SIMD_CFUNC simd_uint_sat(simd_short16  __x);
-static simd_uint2  SIMD_CFUNC simd_uint_sat(simd_int2     __x);
-static simd_uint3  SIMD_CFUNC simd_uint_sat(simd_int3     __x);
-static simd_uint4  SIMD_CFUNC simd_uint_sat(simd_int4     __x);
-static simd_uint8  SIMD_CFUNC simd_uint_sat(simd_int8     __x);
-static simd_uint16 SIMD_CFUNC simd_uint_sat(simd_int16    __x);
-static simd_uint2  SIMD_CFUNC simd_uint_sat(simd_float2   __x);
-static simd_uint3  SIMD_CFUNC simd_uint_sat(simd_float3   __x);
-static simd_uint4  SIMD_CFUNC simd_uint_sat(simd_float4   __x);
-static simd_uint8  SIMD_CFUNC simd_uint_sat(simd_float8   __x);
-static simd_uint16 SIMD_CFUNC simd_uint_sat(simd_float16  __x);
-static simd_uint2  SIMD_CFUNC simd_uint_sat(simd_long2    __x);
-static simd_uint3  SIMD_CFUNC simd_uint_sat(simd_long3    __x);
-static simd_uint4  SIMD_CFUNC simd_uint_sat(simd_long4    __x);
-static simd_uint8  SIMD_CFUNC simd_uint_sat(simd_long8    __x);
-static simd_uint2  SIMD_CFUNC simd_uint_sat(simd_double2  __x);
-static simd_uint3  SIMD_CFUNC simd_uint_sat(simd_double3  __x);
-static simd_uint4  SIMD_CFUNC simd_uint_sat(simd_double4  __x);
-static simd_uint8  SIMD_CFUNC simd_uint_sat(simd_double8  __x);
-static simd_uint2  SIMD_CFUNC simd_uint_sat(simd_uchar2   __x);
-static simd_uint3  SIMD_CFUNC simd_uint_sat(simd_uchar3   __x);
-static simd_uint4  SIMD_CFUNC simd_uint_sat(simd_uchar4   __x);
-static simd_uint8  SIMD_CFUNC simd_uint_sat(simd_uchar8   __x);
-static simd_uint16 SIMD_CFUNC simd_uint_sat(simd_uchar16  __x);
-static simd_uint2  SIMD_CFUNC simd_uint_sat(simd_ushort2  __x);
-static simd_uint3  SIMD_CFUNC simd_uint_sat(simd_ushort3  __x);
-static simd_uint4  SIMD_CFUNC simd_uint_sat(simd_ushort4  __x);
-static simd_uint8  SIMD_CFUNC simd_uint_sat(simd_ushort8  __x);
-static simd_uint16 SIMD_CFUNC simd_uint_sat(simd_ushort16 __x);
-static simd_uint2  SIMD_CFUNC simd_uint_sat(simd_uint2    __x);
-static simd_uint3  SIMD_CFUNC simd_uint_sat(simd_uint3    __x);
-static simd_uint4  SIMD_CFUNC simd_uint_sat(simd_uint4    __x);
-static simd_uint8  SIMD_CFUNC simd_uint_sat(simd_uint8    __x);
-static simd_uint16 SIMD_CFUNC simd_uint_sat(simd_uint16   __x);
-static simd_uint2  SIMD_CFUNC simd_uint_sat(simd_ulong2   __x);
-static simd_uint3  SIMD_CFUNC simd_uint_sat(simd_ulong3   __x);
-static simd_uint4  SIMD_CFUNC simd_uint_sat(simd_ulong4   __x);
-static simd_uint8  SIMD_CFUNC simd_uint_sat(simd_ulong8   __x);
-#define vector_uint simd_uint
-#define vector_uint_sat simd_uint_sat
-
-static simd_float2  SIMD_CFUNC simd_float(simd_char2    __x);
-static simd_float3  SIMD_CFUNC simd_float(simd_char3    __x);
-static simd_float4  SIMD_CFUNC simd_float(simd_char4    __x);
-static simd_float8  SIMD_CFUNC simd_float(simd_char8    __x);
-static simd_float16 SIMD_CFUNC simd_float(simd_char16   __x);
-static simd_float2  SIMD_CFUNC simd_float(simd_uchar2   __x);
-static simd_float3  SIMD_CFUNC simd_float(simd_uchar3   __x);
-static simd_float4  SIMD_CFUNC simd_float(simd_uchar4   __x);
-static simd_float8  SIMD_CFUNC simd_float(simd_uchar8   __x);
-static simd_float16 SIMD_CFUNC simd_float(simd_uchar16  __x);
-static simd_float2  SIMD_CFUNC simd_float(simd_short2   __x);
-static simd_float3  SIMD_CFUNC simd_float(simd_short3   __x);
-static simd_float4  SIMD_CFUNC simd_float(simd_short4   __x);
-static simd_float8  SIMD_CFUNC simd_float(simd_short8   __x);
-static simd_float16 SIMD_CFUNC simd_float(simd_short16  __x);
-static simd_float2  SIMD_CFUNC simd_float(simd_ushort2  __x);
-static simd_float3  SIMD_CFUNC simd_float(simd_ushort3  __x);
-static simd_float4  SIMD_CFUNC simd_float(simd_ushort4  __x);
-static simd_float8  SIMD_CFUNC simd_float(simd_ushort8  __x);
-static simd_float16 SIMD_CFUNC simd_float(simd_ushort16 __x);
-static simd_float2  SIMD_CFUNC simd_float(simd_int2     __x);
-static simd_float3  SIMD_CFUNC simd_float(simd_int3     __x);
-static simd_float4  SIMD_CFUNC simd_float(simd_int4     __x);
-static simd_float8  SIMD_CFUNC simd_float(simd_int8     __x);
-static simd_float16 SIMD_CFUNC simd_float(simd_int16    __x);
-static simd_float2  SIMD_CFUNC simd_float(simd_uint2    __x);
-static simd_float3  SIMD_CFUNC simd_float(simd_uint3    __x);
-static simd_float4  SIMD_CFUNC simd_float(simd_uint4    __x);
-static simd_float8  SIMD_CFUNC simd_float(simd_uint8    __x);
-static simd_float16 SIMD_CFUNC simd_float(simd_uint16   __x);
-static simd_float2  SIMD_CFUNC simd_float(simd_float2   __x);
-static simd_float3  SIMD_CFUNC simd_float(simd_float3   __x);
-static simd_float4  SIMD_CFUNC simd_float(simd_float4   __x);
-static simd_float8  SIMD_CFUNC simd_float(simd_float8   __x);
-static simd_float16 SIMD_CFUNC simd_float(simd_float16  __x);
-static simd_float2  SIMD_CFUNC simd_float(simd_long2    __x);
-static simd_float3  SIMD_CFUNC simd_float(simd_long3    __x);
-static simd_float4  SIMD_CFUNC simd_float(simd_long4    __x);
-static simd_float8  SIMD_CFUNC simd_float(simd_long8    __x);
-static simd_float2  SIMD_CFUNC simd_float(simd_ulong2   __x);
-static simd_float3  SIMD_CFUNC simd_float(simd_ulong3   __x);
-static simd_float4  SIMD_CFUNC simd_float(simd_ulong4   __x);
-static simd_float8  SIMD_CFUNC simd_float(simd_ulong8   __x);
-static simd_float2  SIMD_CFUNC simd_float(simd_double2  __x);
-static simd_float3  SIMD_CFUNC simd_float(simd_double3  __x);
-static simd_float4  SIMD_CFUNC simd_float(simd_double4  __x);
-static simd_float8  SIMD_CFUNC simd_float(simd_double8  __x);
-#define vector_float simd_float
-
-static simd_long2  SIMD_CFUNC simd_long(simd_char2    __x);
-static simd_long3  SIMD_CFUNC simd_long(simd_char3    __x);
-static simd_long4  SIMD_CFUNC simd_long(simd_char4    __x);
-static simd_long8  SIMD_CFUNC simd_long(simd_char8    __x);
-static simd_long2  SIMD_CFUNC simd_long(simd_uchar2   __x);
-static simd_long3  SIMD_CFUNC simd_long(simd_uchar3   __x);
-static simd_long4  SIMD_CFUNC simd_long(simd_uchar4   __x);
-static simd_long8  SIMD_CFUNC simd_long(simd_uchar8   __x);
-static simd_long2  SIMD_CFUNC simd_long(simd_short2   __x);
-static simd_long3  SIMD_CFUNC simd_long(simd_short3   __x);
-static simd_long4  SIMD_CFUNC simd_long(simd_short4   __x);
-static simd_long8  SIMD_CFUNC simd_long(simd_short8   __x);
-static simd_long2  SIMD_CFUNC simd_long(simd_ushort2  __x);
-static simd_long3  SIMD_CFUNC simd_long(simd_ushort3  __x);
-static simd_long4  SIMD_CFUNC simd_long(simd_ushort4  __x);
-static simd_long8  SIMD_CFUNC simd_long(simd_ushort8  __x);
-static simd_long2  SIMD_CFUNC simd_long(simd_int2     __x);
-static simd_long3  SIMD_CFUNC simd_long(simd_int3     __x);
-static simd_long4  SIMD_CFUNC simd_long(simd_int4     __x);
-static simd_long8  SIMD_CFUNC simd_long(simd_int8     __x);
-static simd_long2  SIMD_CFUNC simd_long(simd_uint2    __x);
-static simd_long3  SIMD_CFUNC simd_long(simd_uint3    __x);
-static simd_long4  SIMD_CFUNC simd_long(simd_uint4    __x);
-static simd_long8  SIMD_CFUNC simd_long(simd_uint8    __x);
-static simd_long2  SIMD_CFUNC simd_long(simd_float2   __x);
-static simd_long3  SIMD_CFUNC simd_long(simd_float3   __x);
-static simd_long4  SIMD_CFUNC simd_long(simd_float4   __x);
-static simd_long8  SIMD_CFUNC simd_long(simd_float8   __x);
-static simd_long2  SIMD_CFUNC simd_long(simd_long2    __x);
-static simd_long3  SIMD_CFUNC simd_long(simd_long3    __x);
-static simd_long4  SIMD_CFUNC simd_long(simd_long4    __x);
-static simd_long8  SIMD_CFUNC simd_long(simd_long8    __x);
-static simd_long2  SIMD_CFUNC simd_long(simd_ulong2   __x);
-static simd_long3  SIMD_CFUNC simd_long(simd_ulong3   __x);
-static simd_long4  SIMD_CFUNC simd_long(simd_ulong4   __x);
-static simd_long8  SIMD_CFUNC simd_long(simd_ulong8   __x);
-static simd_long2  SIMD_CFUNC simd_long(simd_double2  __x);
-static simd_long3  SIMD_CFUNC simd_long(simd_double3  __x);
-static simd_long4  SIMD_CFUNC simd_long(simd_double4  __x);
-static simd_long8  SIMD_CFUNC simd_long(simd_double8  __x);
-static simd_long2  SIMD_CFUNC simd_long_sat(simd_char2    __x);
-static simd_long3  SIMD_CFUNC simd_long_sat(simd_char3    __x);
-static simd_long4  SIMD_CFUNC simd_long_sat(simd_char4    __x);
-static simd_long8  SIMD_CFUNC simd_long_sat(simd_char8    __x);
-static simd_long2  SIMD_CFUNC simd_long_sat(simd_short2   __x);
-static simd_long3  SIMD_CFUNC simd_long_sat(simd_short3   __x);
-static simd_long4  SIMD_CFUNC simd_long_sat(simd_short4   __x);
-static simd_long8  SIMD_CFUNC simd_long_sat(simd_short8   __x);
-static simd_long2  SIMD_CFUNC simd_long_sat(simd_int2     __x);
-static simd_long3  SIMD_CFUNC simd_long_sat(simd_int3     __x);
-static simd_long4  SIMD_CFUNC simd_long_sat(simd_int4     __x);
-static simd_long8  SIMD_CFUNC simd_long_sat(simd_int8     __x);
-static simd_long2  SIMD_CFUNC simd_long_sat(simd_float2   __x);
-static simd_long3  SIMD_CFUNC simd_long_sat(simd_float3   __x);
-static simd_long4  SIMD_CFUNC simd_long_sat(simd_float4   __x);
-static simd_long8  SIMD_CFUNC simd_long_sat(simd_float8   __x);
-static simd_long2  SIMD_CFUNC simd_long_sat(simd_long2    __x);
-static simd_long3  SIMD_CFUNC simd_long_sat(simd_long3    __x);
-static simd_long4  SIMD_CFUNC simd_long_sat(simd_long4    __x);
-static simd_long8  SIMD_CFUNC simd_long_sat(simd_long8    __x);
-static simd_long2  SIMD_CFUNC simd_long_sat(simd_double2  __x);
-static simd_long3  SIMD_CFUNC simd_long_sat(simd_double3  __x);
-static simd_long4  SIMD_CFUNC simd_long_sat(simd_double4  __x);
-static simd_long8  SIMD_CFUNC simd_long_sat(simd_double8  __x);
-static simd_long2  SIMD_CFUNC simd_long_sat(simd_uchar2   __x);
-static simd_long3  SIMD_CFUNC simd_long_sat(simd_uchar3   __x);
-static simd_long4  SIMD_CFUNC simd_long_sat(simd_uchar4   __x);
-static simd_long8  SIMD_CFUNC simd_long_sat(simd_uchar8   __x);
-static simd_long2  SIMD_CFUNC simd_long_sat(simd_ushort2  __x);
-static simd_long3  SIMD_CFUNC simd_long_sat(simd_ushort3  __x);
-static simd_long4  SIMD_CFUNC simd_long_sat(simd_ushort4  __x);
-static simd_long8  SIMD_CFUNC simd_long_sat(simd_ushort8  __x);
-static simd_long2  SIMD_CFUNC simd_long_sat(simd_uint2    __x);
-static simd_long3  SIMD_CFUNC simd_long_sat(simd_uint3    __x);
-static simd_long4  SIMD_CFUNC simd_long_sat(simd_uint4    __x);
-static simd_long8  SIMD_CFUNC simd_long_sat(simd_uint8    __x);
-static simd_long2  SIMD_CFUNC simd_long_sat(simd_ulong2   __x);
-static simd_long3  SIMD_CFUNC simd_long_sat(simd_ulong3   __x);
-static simd_long4  SIMD_CFUNC simd_long_sat(simd_ulong4   __x);
-static simd_long8  SIMD_CFUNC simd_long_sat(simd_ulong8   __x);
-#define vector_long simd_long
-#define vector_long_sat simd_long_sat
-
-static simd_ulong2  SIMD_CFUNC simd_ulong(simd_char2    __x);
-static simd_ulong3  SIMD_CFUNC simd_ulong(simd_char3    __x);
-static simd_ulong4  SIMD_CFUNC simd_ulong(simd_char4    __x);
-static simd_ulong8  SIMD_CFUNC simd_ulong(simd_char8    __x);
-static simd_ulong2  SIMD_CFUNC simd_ulong(simd_uchar2   __x);
-static simd_ulong3  SIMD_CFUNC simd_ulong(simd_uchar3   __x);
-static simd_ulong4  SIMD_CFUNC simd_ulong(simd_uchar4   __x);
-static simd_ulong8  SIMD_CFUNC simd_ulong(simd_uchar8   __x);
-static simd_ulong2  SIMD_CFUNC simd_ulong(simd_short2   __x);
-static simd_ulong3  SIMD_CFUNC simd_ulong(simd_short3   __x);
-static simd_ulong4  SIMD_CFUNC simd_ulong(simd_short4   __x);
-static simd_ulong8  SIMD_CFUNC simd_ulong(simd_short8   __x);
-static simd_ulong2  SIMD_CFUNC simd_ulong(simd_ushort2  __x);
-static simd_ulong3  SIMD_CFUNC simd_ulong(simd_ushort3  __x);
-static simd_ulong4  SIMD_CFUNC simd_ulong(simd_ushort4  __x);
-static simd_ulong8  SIMD_CFUNC simd_ulong(simd_ushort8  __x);
-static simd_ulong2  SIMD_CFUNC simd_ulong(simd_int2     __x);
-static simd_ulong3  SIMD_CFUNC simd_ulong(simd_int3     __x);
-static simd_ulong4  SIMD_CFUNC simd_ulong(simd_int4     __x);
-static simd_ulong8  SIMD_CFUNC simd_ulong(simd_int8     __x);
-static simd_ulong2  SIMD_CFUNC simd_ulong(simd_uint2    __x);
-static simd_ulong3  SIMD_CFUNC simd_ulong(simd_uint3    __x);
-static simd_ulong4  SIMD_CFUNC simd_ulong(simd_uint4    __x);
-static simd_ulong8  SIMD_CFUNC simd_ulong(simd_uint8    __x);
-static simd_ulong2  SIMD_CFUNC simd_ulong(simd_float2   __x);
-static simd_ulong3  SIMD_CFUNC simd_ulong(simd_float3   __x);
-static simd_ulong4  SIMD_CFUNC simd_ulong(simd_float4   __x);
-static simd_ulong8  SIMD_CFUNC simd_ulong(simd_float8   __x);
-static simd_ulong2  SIMD_CFUNC simd_ulong(simd_long2    __x);
-static simd_ulong3  SIMD_CFUNC simd_ulong(simd_long3    __x);
-static simd_ulong4  SIMD_CFUNC simd_ulong(simd_long4    __x);
-static simd_ulong8  SIMD_CFUNC simd_ulong(simd_long8    __x);
-static simd_ulong2  SIMD_CFUNC simd_ulong(simd_ulong2   __x);
-static simd_ulong3  SIMD_CFUNC simd_ulong(simd_ulong3   __x);
-static simd_ulong4  SIMD_CFUNC simd_ulong(simd_ulong4   __x);
-static simd_ulong8  SIMD_CFUNC simd_ulong(simd_ulong8   __x);
-static simd_ulong2  SIMD_CFUNC simd_ulong(simd_double2  __x);
-static simd_ulong3  SIMD_CFUNC simd_ulong(simd_double3  __x);
-static simd_ulong4  SIMD_CFUNC simd_ulong(simd_double4  __x);
-static simd_ulong8  SIMD_CFUNC simd_ulong(simd_double8  __x);
-static simd_ulong2  SIMD_CFUNC simd_ulong_sat(simd_char2    __x);
-static simd_ulong3  SIMD_CFUNC simd_ulong_sat(simd_char3    __x);
-static simd_ulong4  SIMD_CFUNC simd_ulong_sat(simd_char4    __x);
-static simd_ulong8  SIMD_CFUNC simd_ulong_sat(simd_char8    __x);
-static simd_ulong2  SIMD_CFUNC simd_ulong_sat(simd_short2   __x);
-static simd_ulong3  SIMD_CFUNC simd_ulong_sat(simd_short3   __x);
-static simd_ulong4  SIMD_CFUNC simd_ulong_sat(simd_short4   __x);
-static simd_ulong8  SIMD_CFUNC simd_ulong_sat(simd_short8   __x);
-static simd_ulong2  SIMD_CFUNC simd_ulong_sat(simd_int2     __x);
-static simd_ulong3  SIMD_CFUNC simd_ulong_sat(simd_int3     __x);
-static simd_ulong4  SIMD_CFUNC simd_ulong_sat(simd_int4     __x);
-static simd_ulong8  SIMD_CFUNC simd_ulong_sat(simd_int8     __x);
-static simd_ulong2  SIMD_CFUNC simd_ulong_sat(simd_float2   __x);
-static simd_ulong3  SIMD_CFUNC simd_ulong_sat(simd_float3   __x);
-static simd_ulong4  SIMD_CFUNC simd_ulong_sat(simd_float4   __x);
-static simd_ulong8  SIMD_CFUNC simd_ulong_sat(simd_float8   __x);
-static simd_ulong2  SIMD_CFUNC simd_ulong_sat(simd_long2    __x);
-static simd_ulong3  SIMD_CFUNC simd_ulong_sat(simd_long3    __x);
-static simd_ulong4  SIMD_CFUNC simd_ulong_sat(simd_long4    __x);
-static simd_ulong8  SIMD_CFUNC simd_ulong_sat(simd_long8    __x);
-static simd_ulong2  SIMD_CFUNC simd_ulong_sat(simd_double2  __x);
-static simd_ulong3  SIMD_CFUNC simd_ulong_sat(simd_double3  __x);
-static simd_ulong4  SIMD_CFUNC simd_ulong_sat(simd_double4  __x);
-static simd_ulong8  SIMD_CFUNC simd_ulong_sat(simd_double8  __x);
-static simd_ulong2  SIMD_CFUNC simd_ulong_sat(simd_uchar2   __x);
-static simd_ulong3  SIMD_CFUNC simd_ulong_sat(simd_uchar3   __x);
-static simd_ulong4  SIMD_CFUNC simd_ulong_sat(simd_uchar4   __x);
-static simd_ulong8  SIMD_CFUNC simd_ulong_sat(simd_uchar8   __x);
-static simd_ulong2  SIMD_CFUNC simd_ulong_sat(simd_ushort2  __x);
-static simd_ulong3  SIMD_CFUNC simd_ulong_sat(simd_ushort3  __x);
-static simd_ulong4  SIMD_CFUNC simd_ulong_sat(simd_ushort4  __x);
-static simd_ulong8  SIMD_CFUNC simd_ulong_sat(simd_ushort8  __x);
-static simd_ulong2  SIMD_CFUNC simd_ulong_sat(simd_uint2    __x);
-static simd_ulong3  SIMD_CFUNC simd_ulong_sat(simd_uint3    __x);
-static simd_ulong4  SIMD_CFUNC simd_ulong_sat(simd_uint4    __x);
-static simd_ulong8  SIMD_CFUNC simd_ulong_sat(simd_uint8    __x);
-static simd_ulong2  SIMD_CFUNC simd_ulong_sat(simd_ulong2   __x);
-static simd_ulong3  SIMD_CFUNC simd_ulong_sat(simd_ulong3   __x);
-static simd_ulong4  SIMD_CFUNC simd_ulong_sat(simd_ulong4   __x);
-static simd_ulong8  SIMD_CFUNC simd_ulong_sat(simd_ulong8   __x);
-#define vector_ulong simd_ulong
-#define vector_ulong_sat simd_ulong_sat
-
-static simd_double2  SIMD_CFUNC simd_double(simd_char2    __x);
-static simd_double3  SIMD_CFUNC simd_double(simd_char3    __x);
-static simd_double4  SIMD_CFUNC simd_double(simd_char4    __x);
-static simd_double8  SIMD_CFUNC simd_double(simd_char8    __x);
-static simd_double2  SIMD_CFUNC simd_double(simd_uchar2   __x);
-static simd_double3  SIMD_CFUNC simd_double(simd_uchar3   __x);
-static simd_double4  SIMD_CFUNC simd_double(simd_uchar4   __x);
-static simd_double8  SIMD_CFUNC simd_double(simd_uchar8   __x);
-static simd_double2  SIMD_CFUNC simd_double(simd_short2   __x);
-static simd_double3  SIMD_CFUNC simd_double(simd_short3   __x);
-static simd_double4  SIMD_CFUNC simd_double(simd_short4   __x);
-static simd_double8  SIMD_CFUNC simd_double(simd_short8   __x);
-static simd_double2  SIMD_CFUNC simd_double(simd_ushort2  __x);
-static simd_double3  SIMD_CFUNC simd_double(simd_ushort3  __x);
-static simd_double4  SIMD_CFUNC simd_double(simd_ushort4  __x);
-static simd_double8  SIMD_CFUNC simd_double(simd_ushort8  __x);
-static simd_double2  SIMD_CFUNC simd_double(simd_int2     __x);
-static simd_double3  SIMD_CFUNC simd_double(simd_int3     __x);
-static simd_double4  SIMD_CFUNC simd_double(simd_int4     __x);
-static simd_double8  SIMD_CFUNC simd_double(simd_int8     __x);
-static simd_double2  SIMD_CFUNC simd_double(simd_uint2    __x);
-static simd_double3  SIMD_CFUNC simd_double(simd_uint3    __x);
-static simd_double4  SIMD_CFUNC simd_double(simd_uint4    __x);
-static simd_double8  SIMD_CFUNC simd_double(simd_uint8    __x);
-static simd_double2  SIMD_CFUNC simd_double(simd_float2   __x);
-static simd_double3  SIMD_CFUNC simd_double(simd_float3   __x);
-static simd_double4  SIMD_CFUNC simd_double(simd_float4   __x);
-static simd_double8  SIMD_CFUNC simd_double(simd_float8   __x);
-static simd_double2  SIMD_CFUNC simd_double(simd_long2    __x);
-static simd_double3  SIMD_CFUNC simd_double(simd_long3    __x);
-static simd_double4  SIMD_CFUNC simd_double(simd_long4    __x);
-static simd_double8  SIMD_CFUNC simd_double(simd_long8    __x);
-static simd_double2  SIMD_CFUNC simd_double(simd_ulong2   __x);
-static simd_double3  SIMD_CFUNC simd_double(simd_ulong3   __x);
-static simd_double4  SIMD_CFUNC simd_double(simd_ulong4   __x);
-static simd_double8  SIMD_CFUNC simd_double(simd_ulong8   __x);
-static simd_double2  SIMD_CFUNC simd_double(simd_double2  __x);
-static simd_double3  SIMD_CFUNC simd_double(simd_double3  __x);
-static simd_double4  SIMD_CFUNC simd_double(simd_double4  __x);
-static simd_double8  SIMD_CFUNC simd_double(simd_double8  __x);
-#define vector_double simd_double
-
-static simd_char2   SIMD_CFUNC vector2(char           __x, char           __y) { return (  simd_char2){__x, __y}; }
-static simd_uchar2  SIMD_CFUNC vector2(unsigned char  __x, unsigned char  __y) { return ( simd_uchar2){__x, __y}; }
-static simd_short2  SIMD_CFUNC vector2(short          __x, short          __y) { return ( simd_short2){__x, __y}; }
-static simd_ushort2 SIMD_CFUNC vector2(unsigned short __x, unsigned short __y) { return (simd_ushort2){__x, __y}; }
-static simd_int2    SIMD_CFUNC vector2(int            __x, int            __y) { return (   simd_int2){__x, __y}; }
-static simd_uint2   SIMD_CFUNC vector2(unsigned int   __x, unsigned int   __y) { return (  simd_uint2){__x, __y}; }
-static simd_float2  SIMD_CFUNC vector2(float          __x, float          __y) { return ( simd_float2){__x, __y}; }
-static simd_long2   SIMD_CFUNC vector2(simd_long1   __x, simd_long1   __y) { return (  simd_long2){__x, __y}; }
-static simd_ulong2  SIMD_CFUNC vector2(simd_ulong1  __x, simd_ulong1  __y) { return ( simd_ulong2){__x, __y}; }
-static simd_double2 SIMD_CFUNC vector2(double         __x, double         __y) { return (simd_double2){__x, __y}; }
-
-static simd_char3   SIMD_CFUNC vector3(char           __x, char           __y, char           __z) { return (  simd_char3){__x, __y, __z}; }
-static simd_uchar3  SIMD_CFUNC vector3(unsigned char  __x, unsigned char  __y, unsigned char  __z) { return ( simd_uchar3){__x, __y, __z}; }
-static simd_short3  SIMD_CFUNC vector3(short          __x, short          __y, short          __z) { return ( simd_short3){__x, __y, __z}; }
-static simd_ushort3 SIMD_CFUNC vector3(unsigned short __x, unsigned short __y, unsigned short __z) { return (simd_ushort3){__x, __y, __z}; }
-static simd_int3    SIMD_CFUNC vector3(int            __x, int            __y, int            __z) { return (   simd_int3){__x, __y, __z}; }
-static simd_uint3   SIMD_CFUNC vector3(unsigned int   __x, unsigned int   __y, unsigned int   __z) { return (  simd_uint3){__x, __y, __z}; }
-static simd_float3  SIMD_CFUNC vector3(float          __x, float          __y, float          __z) { return ( simd_float3){__x, __y, __z}; }
-static simd_long3   SIMD_CFUNC vector3(simd_long1   __x, simd_long1   __y, simd_long1   __z) { return (  simd_long3){__x, __y, __z}; }
-static simd_ulong3  SIMD_CFUNC vector3(simd_ulong1  __x, simd_ulong1  __y, simd_ulong1  __z) { return ( simd_ulong3){__x, __y, __z}; }
-static simd_double3 SIMD_CFUNC vector3(double         __x, double         __y, double         __z) { return (simd_double3){__x, __y, __z}; }
-
-static simd_char3   SIMD_CFUNC vector3(simd_char2   __xy, char           __z) { simd_char3   __r; __r.xy = __xy; __r.z = __z; return __r; }
-static simd_uchar3  SIMD_CFUNC vector3(simd_uchar2  __xy, unsigned char  __z) { simd_uchar3  __r; __r.xy = __xy; __r.z = __z; return __r; }
-static simd_short3  SIMD_CFUNC vector3(simd_short2  __xy, short          __z) { simd_short3  __r; __r.xy = __xy; __r.z = __z; return __r; }
-static simd_ushort3 SIMD_CFUNC vector3(simd_ushort2 __xy, unsigned short __z) { simd_ushort3 __r; __r.xy = __xy; __r.z = __z; return __r; }
-static simd_int3    SIMD_CFUNC vector3(simd_int2    __xy, int            __z) { simd_int3    __r; __r.xy = __xy; __r.z = __z; return __r; }
-static simd_uint3   SIMD_CFUNC vector3(simd_uint2   __xy, unsigned int   __z) { simd_uint3   __r; __r.xy = __xy; __r.z = __z; return __r; }
-static simd_float3  SIMD_CFUNC vector3(simd_float2  __xy, float          __z) { simd_float3  __r; __r.xy = __xy; __r.z = __z; return __r; }
-static simd_long3   SIMD_CFUNC vector3(simd_long2   __xy, simd_long1   __z) { simd_long3   __r; __r.xy = __xy; __r.z = __z; return __r; }
-static simd_ulong3  SIMD_CFUNC vector3(simd_ulong2  __xy, simd_ulong1  __z) { simd_ulong3  __r; __r.xy = __xy; __r.z = __z; return __r; }
-static simd_double3 SIMD_CFUNC vector3(simd_double2 __xy, double         __z) { simd_double3 __r; __r.xy = __xy; __r.z = __z; return __r; }
-
-static simd_char4   SIMD_CFUNC vector4(char           __x, char           __y, char           __z, char           __w) { return (  simd_char4){__x, __y, __z, __w}; }
-static simd_uchar4  SIMD_CFUNC vector4(unsigned char  __x, unsigned char  __y, unsigned char  __z, unsigned char  __w) { return ( simd_uchar4){__x, __y, __z, __w}; }
-static simd_short4  SIMD_CFUNC vector4(short          __x, short          __y, short          __z, short          __w) { return ( simd_short4){__x, __y, __z, __w}; }
-static simd_ushort4 SIMD_CFUNC vector4(unsigned short __x, unsigned short __y, unsigned short __z, unsigned short __w) { return (simd_ushort4){__x, __y, __z, __w}; }
-static simd_int4    SIMD_CFUNC vector4(int            __x, int            __y, int            __z, int            __w) { return (   simd_int4){__x, __y, __z, __w}; }
-static simd_uint4   SIMD_CFUNC vector4(unsigned int   __x, unsigned int   __y, unsigned int   __z, unsigned int   __w) { return (  simd_uint4){__x, __y, __z, __w}; }
-static simd_float4  SIMD_CFUNC vector4(float          __x, float          __y, float          __z, float          __w) { return ( simd_float4){__x, __y, __z, __w}; }
-static simd_long4   SIMD_CFUNC vector4(simd_long1   __x, simd_long1   __y, simd_long1   __z, simd_long1   __w) { return (  simd_long4){__x, __y, __z, __w}; }
-static simd_ulong4  SIMD_CFUNC vector4(simd_ulong1  __x, simd_ulong1  __y, simd_ulong1  __z, simd_ulong1  __w) { return ( simd_ulong4){__x, __y, __z, __w}; }
-static simd_double4 SIMD_CFUNC vector4(double         __x, double         __y, double         __z, double         __w) { return (simd_double4){__x, __y, __z, __w}; }
-
-static simd_char4   SIMD_CFUNC vector4(simd_char2   __xy, simd_char2   __zw) { simd_char4   __r; __r.xy = __xy; __r.zw = __zw; return __r; }
-static simd_uchar4  SIMD_CFUNC vector4(simd_uchar2  __xy, simd_uchar2  __zw) { simd_uchar4  __r; __r.xy = __xy; __r.zw = __zw; return __r; }
-static simd_short4  SIMD_CFUNC vector4(simd_short2  __xy, simd_short2  __zw) { simd_short4  __r; __r.xy = __xy; __r.zw = __zw; return __r; }
-static simd_ushort4 SIMD_CFUNC vector4(simd_ushort2 __xy, simd_ushort2 __zw) { simd_ushort4 __r; __r.xy = __xy; __r.zw = __zw; return __r; }
-static simd_int4    SIMD_CFUNC vector4(simd_int2    __xy, simd_int2    __zw) { simd_int4    __r; __r.xy = __xy; __r.zw = __zw; return __r; }
-static simd_uint4   SIMD_CFUNC vector4(simd_uint2   __xy, simd_uint2   __zw) { simd_uint4   __r; __r.xy = __xy; __r.zw = __zw; return __r; }
-static simd_float4  SIMD_CFUNC vector4(simd_float2  __xy, simd_float2  __zw) { simd_float4  __r; __r.xy = __xy; __r.zw = __zw; return __r; }
-static simd_long4   SIMD_CFUNC vector4(simd_long2   __xy, simd_long2   __zw) { simd_long4   __r; __r.xy = __xy; __r.zw = __zw; return __r; }
-static simd_ulong4  SIMD_CFUNC vector4(simd_ulong2  __xy, simd_ulong2  __zw) { simd_ulong4  __r; __r.xy = __xy; __r.zw = __zw; return __r; }
-static simd_double4 SIMD_CFUNC vector4(simd_double2 __xy, simd_double2 __zw) { simd_double4 __r; __r.xy = __xy; __r.zw = __zw; return __r; }
-
-static simd_char4   SIMD_CFUNC vector4(simd_char3   __xyz, char           __w) { simd_char4   __r; __r.xyz = __xyz; __r.w = __w; return __r; }
-static simd_uchar4  SIMD_CFUNC vector4(simd_uchar3  __xyz, unsigned char  __w) { simd_uchar4  __r; __r.xyz = __xyz; __r.w = __w; return __r; }
-static simd_short4  SIMD_CFUNC vector4(simd_short3  __xyz, short          __w) { simd_short4  __r; __r.xyz = __xyz; __r.w = __w; return __r; }
-static simd_ushort4 SIMD_CFUNC vector4(simd_ushort3 __xyz, unsigned short __w) { simd_ushort4 __r; __r.xyz = __xyz; __r.w = __w; return __r; }
-static simd_int4    SIMD_CFUNC vector4(simd_int3    __xyz, int            __w) { simd_int4    __r; __r.xyz = __xyz; __r.w = __w; return __r; }
-static simd_uint4   SIMD_CFUNC vector4(simd_uint3   __xyz, unsigned int   __w) { simd_uint4   __r; __r.xyz = __xyz; __r.w = __w; return __r; }
-static simd_float4  SIMD_CFUNC vector4(simd_float3  __xyz, float          __w) { simd_float4  __r; __r.xyz = __xyz; __r.w = __w; return __r; }
-static simd_long4   SIMD_CFUNC vector4(simd_long3   __xyz, simd_long1   __w) { simd_long4   __r; __r.xyz = __xyz; __r.w = __w; return __r; }
-static simd_ulong4  SIMD_CFUNC vector4(simd_ulong3  __xyz, simd_ulong1  __w) { simd_ulong4  __r; __r.xyz = __xyz; __r.w = __w; return __r; }
-static simd_double4 SIMD_CFUNC vector4(simd_double3 __xyz, double         __w) { simd_double4 __r; __r.xyz = __xyz; __r.w = __w; return __r; }
-
-static simd_char8   SIMD_CFUNC vector8(simd_char4   __lo, simd_char4   __hi) { simd_char8   __r; __r.lo = __lo; __r.hi = __hi; return __r; }
-static simd_uchar8  SIMD_CFUNC vector8(simd_uchar4  __lo, simd_uchar4  __hi) { simd_uchar8  __r; __r.lo = __lo; __r.hi = __hi; return __r; }
-static simd_short8  SIMD_CFUNC vector8(simd_short4  __lo, simd_short4  __hi) { simd_short8  __r; __r.lo = __lo; __r.hi = __hi; return __r; }
-static simd_ushort8 SIMD_CFUNC vector8(simd_ushort4 __lo, simd_ushort4 __hi) { simd_ushort8 __r; __r.lo = __lo; __r.hi = __hi; return __r; }
-static simd_int8    SIMD_CFUNC vector8(simd_int4    __lo, simd_int4    __hi) { simd_int8    __r; __r.lo = __lo; __r.hi = __hi; return __r; }
-static simd_uint8   SIMD_CFUNC vector8(simd_uint4   __lo, simd_uint4   __hi) { simd_uint8   __r; __r.lo = __lo; __r.hi = __hi; return __r; }
-static simd_float8  SIMD_CFUNC vector8(simd_float4  __lo, simd_float4  __hi) { simd_float8  __r; __r.lo = __lo; __r.hi = __hi; return __r; }
-static simd_long8   SIMD_CFUNC vector8(simd_long4   __lo, simd_long4   __hi) { simd_long8   __r; __r.lo = __lo; __r.hi = __hi; return __r; }
-static simd_ulong8  SIMD_CFUNC vector8(simd_ulong4  __lo, simd_ulong4  __hi) { simd_ulong8  __r; __r.lo = __lo; __r.hi = __hi; return __r; }
-static simd_double8 SIMD_CFUNC vector8(simd_double4 __lo, simd_double4 __hi) { simd_double8 __r; __r.lo = __lo; __r.hi = __hi; return __r; }
-
-static simd_char16   SIMD_CFUNC vector16(simd_char8   __lo, simd_char8   __hi) { simd_char16   __r; __r.lo = __lo; __r.hi = __hi; return __r; }
-static simd_uchar16  SIMD_CFUNC vector16(simd_uchar8  __lo, simd_uchar8  __hi) { simd_uchar16  __r; __r.lo = __lo; __r.hi = __hi; return __r; }
-static simd_short16  SIMD_CFUNC vector16(simd_short8  __lo, simd_short8  __hi) { simd_short16  __r; __r.lo = __lo; __r.hi = __hi; return __r; }
-static simd_ushort16 SIMD_CFUNC vector16(simd_ushort8 __lo, simd_ushort8 __hi) { simd_ushort16 __r; __r.lo = __lo; __r.hi = __hi; return __r; }
-static simd_int16    SIMD_CFUNC vector16(simd_int8    __lo, simd_int8    __hi) { simd_int16    __r; __r.lo = __lo; __r.hi = __hi; return __r; }
-static simd_uint16   SIMD_CFUNC vector16(simd_uint8   __lo, simd_uint8   __hi) { simd_uint16   __r; __r.lo = __lo; __r.hi = __hi; return __r; }
-static simd_float16  SIMD_CFUNC vector16(simd_float8  __lo, simd_float8  __hi) { simd_float16  __r; __r.lo = __lo; __r.hi = __hi; return __r; }
-
-static simd_char32   SIMD_CFUNC vector32(simd_char16   __lo, simd_char16   __hi) { simd_char32   __r; __r.lo = __lo; __r.hi = __hi; return __r; }
-static simd_uchar32  SIMD_CFUNC vector32(simd_uchar16  __lo, simd_uchar16  __hi) { simd_uchar32  __r; __r.lo = __lo; __r.hi = __hi; return __r; }
-static simd_short32  SIMD_CFUNC vector32(simd_short16  __lo, simd_short16  __hi) { simd_short32  __r; __r.lo = __lo; __r.hi = __hi; return __r; }
-static simd_ushort32 SIMD_CFUNC vector32(simd_ushort16 __lo, simd_ushort16 __hi) { simd_ushort32 __r; __r.lo = __lo; __r.hi = __hi; return __r; }
-
-#pragma mark - Implementation
-
-static simd_char2  SIMD_CFUNC simd_char(simd_char2    __x) { return __x; }
-static simd_char3  SIMD_CFUNC simd_char(simd_char3    __x) { return __x; }
-static simd_char4  SIMD_CFUNC simd_char(simd_char4    __x) { return __x; }
-static simd_char8  SIMD_CFUNC simd_char(simd_char8    __x) { return __x; }
-static simd_char16 SIMD_CFUNC simd_char(simd_char16   __x) { return __x; }
-static simd_char32 SIMD_CFUNC simd_char(simd_char32   __x) { return __x; }
-static simd_char2  SIMD_CFUNC simd_char(simd_uchar2   __x) { return (simd_char2)__x; }
-static simd_char3  SIMD_CFUNC simd_char(simd_uchar3   __x) { return (simd_char3)__x; }
-static simd_char4  SIMD_CFUNC simd_char(simd_uchar4   __x) { return (simd_char4)__x; }
-static simd_char8  SIMD_CFUNC simd_char(simd_uchar8   __x) { return (simd_char8)__x; }
-static simd_char16 SIMD_CFUNC simd_char(simd_uchar16  __x) { return (simd_char16)__x; }
-static simd_char32 SIMD_CFUNC simd_char(simd_uchar32  __x) { return (simd_char32)__x; }
-static simd_char2  SIMD_CFUNC simd_char(simd_short2   __x) { return __builtin_convertvector(__x & 0xff, simd_char2); }
-static simd_char3  SIMD_CFUNC simd_char(simd_short3   __x) { return __builtin_convertvector(__x & 0xff, simd_char3); }
-static simd_char4  SIMD_CFUNC simd_char(simd_short4   __x) { return __builtin_convertvector(__x & 0xff, simd_char4); }
-static simd_char8  SIMD_CFUNC simd_char(simd_short8   __x) { return __builtin_convertvector(__x & 0xff, simd_char8); }
-static simd_char16 SIMD_CFUNC simd_char(simd_short16  __x) { return __builtin_convertvector(__x & 0xff, simd_char16); }
-static simd_char32 SIMD_CFUNC simd_char(simd_short32  __x) { return __builtin_convertvector(__x & 0xff, simd_char32); }
-static simd_char2  SIMD_CFUNC simd_char(simd_ushort2  __x) { return simd_char(simd_short(__x)); }
-static simd_char3  SIMD_CFUNC simd_char(simd_ushort3  __x) { return simd_char(simd_short(__x)); }
-static simd_char4  SIMD_CFUNC simd_char(simd_ushort4  __x) { return simd_char(simd_short(__x)); }
-static simd_char8  SIMD_CFUNC simd_char(simd_ushort8  __x) { return simd_char(simd_short(__x)); }
-static simd_char16 SIMD_CFUNC simd_char(simd_ushort16 __x) { return simd_char(simd_short(__x)); }
-static simd_char32 SIMD_CFUNC simd_char(simd_ushort32 __x) { return simd_char(simd_short(__x)); }
-static simd_char2  SIMD_CFUNC simd_char(simd_int2     __x) { return simd_char(simd_short(__x)); }
-static simd_char3  SIMD_CFUNC simd_char(simd_int3     __x) { return simd_char(simd_short(__x)); }
-static simd_char4  SIMD_CFUNC simd_char(simd_int4     __x) { return simd_char(simd_short(__x)); }
-static simd_char8  SIMD_CFUNC simd_char(simd_int8     __x) { return simd_char(simd_short(__x)); }
-static simd_char16 SIMD_CFUNC simd_char(simd_int16    __x) { return simd_char(simd_short(__x)); }
-static simd_char2  SIMD_CFUNC simd_char(simd_uint2    __x) { return simd_char(simd_short(__x)); }
-static simd_char3  SIMD_CFUNC simd_char(simd_uint3    __x) { return simd_char(simd_short(__x)); }
-static simd_char4  SIMD_CFUNC simd_char(simd_uint4    __x) { return simd_char(simd_short(__x)); }
-static simd_char8  SIMD_CFUNC simd_char(simd_uint8    __x) { return simd_char(simd_short(__x)); }
-static simd_char16 SIMD_CFUNC simd_char(simd_uint16   __x) { return simd_char(simd_short(__x)); }
-static simd_char2  SIMD_CFUNC simd_char(simd_float2   __x) { return simd_char(simd_short(__x)); }
-static simd_char3  SIMD_CFUNC simd_char(simd_float3   __x) { return simd_char(simd_short(__x)); }
-static simd_char4  SIMD_CFUNC simd_char(simd_float4   __x) { return simd_char(simd_short(__x)); }
-static simd_char8  SIMD_CFUNC simd_char(simd_float8   __x) { return simd_char(simd_short(__x)); }
-static simd_char16 SIMD_CFUNC simd_char(simd_float16  __x) { return simd_char(simd_short(__x)); }
-static simd_char2  SIMD_CFUNC simd_char(simd_long2    __x) { return simd_char(simd_short(__x)); }
-static simd_char3  SIMD_CFUNC simd_char(simd_long3    __x) { return simd_char(simd_short(__x)); }
-static simd_char4  SIMD_CFUNC simd_char(simd_long4    __x) { return simd_char(simd_short(__x)); }
-static simd_char8  SIMD_CFUNC simd_char(simd_long8    __x) { return simd_char(simd_short(__x)); }
-static simd_char2  SIMD_CFUNC simd_char(simd_ulong2   __x) { return simd_char(simd_short(__x)); }
-static simd_char3  SIMD_CFUNC simd_char(simd_ulong3   __x) { return simd_char(simd_short(__x)); }
-static simd_char4  SIMD_CFUNC simd_char(simd_ulong4   __x) { return simd_char(simd_short(__x)); }
-static simd_char8  SIMD_CFUNC simd_char(simd_ulong8   __x) { return simd_char(simd_short(__x)); }
-static simd_char2  SIMD_CFUNC simd_char(simd_double2  __x) { return simd_char(simd_short(__x)); }
-static simd_char3  SIMD_CFUNC simd_char(simd_double3  __x) { return simd_char(simd_short(__x)); }
-static simd_char4  SIMD_CFUNC simd_char(simd_double4  __x) { return simd_char(simd_short(__x)); }
-static simd_char8  SIMD_CFUNC simd_char(simd_double8  __x) { return simd_char(simd_short(__x)); }
-    
-static simd_char2  SIMD_CFUNC simd_char_sat(simd_char2    __x) { return __x; }
-static simd_char3  SIMD_CFUNC simd_char_sat(simd_char3    __x) { return __x; }
-static simd_char4  SIMD_CFUNC simd_char_sat(simd_char4    __x) { return __x; }
-static simd_char8  SIMD_CFUNC simd_char_sat(simd_char8    __x) { return __x; }
-static simd_char16 SIMD_CFUNC simd_char_sat(simd_char16   __x) { return __x; }
-static simd_char32 SIMD_CFUNC simd_char_sat(simd_char32   __x) { return __x; }
-static simd_char2  SIMD_CFUNC simd_char_sat(simd_short2   __x) { return simd_char(simd_clamp(__x,-0x80,0x7f)); }
-static simd_char3  SIMD_CFUNC simd_char_sat(simd_short3   __x) { return simd_char(simd_clamp(__x,-0x80,0x7f)); }
-static simd_char4  SIMD_CFUNC simd_char_sat(simd_short4   __x) { return simd_char(simd_clamp(__x,-0x80,0x7f)); }
-static simd_char8  SIMD_CFUNC simd_char_sat(simd_short8   __x) { return simd_char(simd_clamp(__x,-0x80,0x7f)); }
-static simd_char16 SIMD_CFUNC simd_char_sat(simd_short16  __x) { return simd_char(simd_clamp(__x,-0x80,0x7f)); }
-static simd_char32 SIMD_CFUNC simd_char_sat(simd_short32  __x) { return simd_char(simd_clamp(__x,-0x80,0x7f)); }
-static simd_char2  SIMD_CFUNC simd_char_sat(simd_int2     __x) { return simd_char(simd_clamp(__x,-0x80,0x7f)); }
-static simd_char3  SIMD_CFUNC simd_char_sat(simd_int3     __x) { return simd_char(simd_clamp(__x,-0x80,0x7f)); }
-static simd_char4  SIMD_CFUNC simd_char_sat(simd_int4     __x) { return simd_char(simd_clamp(__x,-0x80,0x7f)); }
-static simd_char8  SIMD_CFUNC simd_char_sat(simd_int8     __x) { return simd_char(simd_clamp(__x,-0x80,0x7f)); }
-static simd_char16 SIMD_CFUNC simd_char_sat(simd_int16    __x) { return simd_char(simd_clamp(__x,-0x80,0x7f)); }
-static simd_char2  SIMD_CFUNC simd_char_sat(simd_float2   __x) { return simd_char(simd_clamp(__x,-0x80,0x7f)); }
-static simd_char3  SIMD_CFUNC simd_char_sat(simd_float3   __x) { return simd_char(simd_clamp(__x,-0x80,0x7f)); }
-static simd_char4  SIMD_CFUNC simd_char_sat(simd_float4   __x) { return simd_char(simd_clamp(__x,-0x80,0x7f)); }
-static simd_char8  SIMD_CFUNC simd_char_sat(simd_float8   __x) { return simd_char(simd_clamp(__x,-0x80,0x7f)); }
-static simd_char16 SIMD_CFUNC simd_char_sat(simd_float16  __x) { return simd_char(simd_clamp(__x,-0x80,0x7f)); }
-static simd_char2  SIMD_CFUNC simd_char_sat(simd_long2    __x) { return simd_char(simd_clamp(__x,-0x80,0x7f)); }
-static simd_char3  SIMD_CFUNC simd_char_sat(simd_long3    __x) { return simd_char(simd_clamp(__x,-0x80,0x7f)); }
-static simd_char4  SIMD_CFUNC simd_char_sat(simd_long4    __x) { return simd_char(simd_clamp(__x,-0x80,0x7f)); }
-static simd_char8  SIMD_CFUNC simd_char_sat(simd_long8    __x) { return simd_char(simd_clamp(__x,-0x80,0x7f)); }
-static simd_char2  SIMD_CFUNC simd_char_sat(simd_double2  __x) { return simd_char(simd_clamp(__x,-0x80,0x7f)); }
-static simd_char3  SIMD_CFUNC simd_char_sat(simd_double3  __x) { return simd_char(simd_clamp(__x,-0x80,0x7f)); }
-static simd_char4  SIMD_CFUNC simd_char_sat(simd_double4  __x) { return simd_char(simd_clamp(__x,-0x80,0x7f)); }
-static simd_char8  SIMD_CFUNC simd_char_sat(simd_double8  __x) { return simd_char(simd_clamp(__x,-0x80,0x7f)); }
-static simd_char2  SIMD_CFUNC simd_char_sat(simd_uchar2   __x) { return simd_char(simd_min(__x,0x7f)); }
-static simd_char3  SIMD_CFUNC simd_char_sat(simd_uchar3   __x) { return simd_char(simd_min(__x,0x7f)); }
-static simd_char4  SIMD_CFUNC simd_char_sat(simd_uchar4   __x) { return simd_char(simd_min(__x,0x7f)); }
-static simd_char8  SIMD_CFUNC simd_char_sat(simd_uchar8   __x) { return simd_char(simd_min(__x,0x7f)); }
-static simd_char16 SIMD_CFUNC simd_char_sat(simd_uchar16  __x) { return simd_char(simd_min(__x,0x7f)); }
-static simd_char32 SIMD_CFUNC simd_char_sat(simd_uchar32  __x) { return simd_char(simd_min(__x,0x7f)); }
-static simd_char2  SIMD_CFUNC simd_char_sat(simd_ushort2  __x) { return simd_char(simd_min(__x,0x7f)); }
-static simd_char3  SIMD_CFUNC simd_char_sat(simd_ushort3  __x) { return simd_char(simd_min(__x,0x7f)); }
-static simd_char4  SIMD_CFUNC simd_char_sat(simd_ushort4  __x) { return simd_char(simd_min(__x,0x7f)); }
-static simd_char8  SIMD_CFUNC simd_char_sat(simd_ushort8  __x) { return simd_char(simd_min(__x,0x7f)); }
-static simd_char16 SIMD_CFUNC simd_char_sat(simd_ushort16 __x) { return simd_char(simd_min(__x,0x7f)); }
-static simd_char32 SIMD_CFUNC simd_char_sat(simd_ushort32 __x) { return simd_char(simd_min(__x,0x7f)); }
-static simd_char2  SIMD_CFUNC simd_char_sat(simd_uint2    __x) { return simd_char(simd_min(__x,0x7f)); }
-static simd_char3  SIMD_CFUNC simd_char_sat(simd_uint3    __x) { return simd_char(simd_min(__x,0x7f)); }
-static simd_char4  SIMD_CFUNC simd_char_sat(simd_uint4    __x) { return simd_char(simd_min(__x,0x7f)); }
-static simd_char8  SIMD_CFUNC simd_char_sat(simd_uint8    __x) { return simd_char(simd_min(__x,0x7f)); }
-static simd_char16 SIMD_CFUNC simd_char_sat(simd_uint16   __x) { return simd_char(simd_min(__x,0x7f)); }
-static simd_char2  SIMD_CFUNC simd_char_sat(simd_ulong2   __x) { return simd_char(simd_min(__x,0x7f)); }
-static simd_char3  SIMD_CFUNC simd_char_sat(simd_ulong3   __x) { return simd_char(simd_min(__x,0x7f)); }
-static simd_char4  SIMD_CFUNC simd_char_sat(simd_ulong4   __x) { return simd_char(simd_min(__x,0x7f)); }
-static simd_char8  SIMD_CFUNC simd_char_sat(simd_ulong8   __x) { return simd_char(simd_min(__x,0x7f)); }
-
-static simd_uchar2  SIMD_CFUNC simd_uchar(simd_char2    __x) { return (simd_uchar2)__x; }
-static simd_uchar3  SIMD_CFUNC simd_uchar(simd_char3    __x) { return (simd_uchar3)__x; }
-static simd_uchar4  SIMD_CFUNC simd_uchar(simd_char4    __x) { return (simd_uchar4)__x; }
-static simd_uchar8  SIMD_CFUNC simd_uchar(simd_char8    __x) { return (simd_uchar8)__x; }
-static simd_uchar16 SIMD_CFUNC simd_uchar(simd_char16   __x) { return (simd_uchar16)__x; }
-static simd_uchar32 SIMD_CFUNC simd_uchar(simd_char32   __x) { return (simd_uchar32)__x; }
-static simd_uchar2  SIMD_CFUNC simd_uchar(simd_uchar2   __x) { return __x; }
-static simd_uchar3  SIMD_CFUNC simd_uchar(simd_uchar3   __x) { return __x; }
-static simd_uchar4  SIMD_CFUNC simd_uchar(simd_uchar4   __x) { return __x; }
-static simd_uchar8  SIMD_CFUNC simd_uchar(simd_uchar8   __x) { return __x; }
-static simd_uchar16 SIMD_CFUNC simd_uchar(simd_uchar16  __x) { return __x; }
-static simd_uchar32 SIMD_CFUNC simd_uchar(simd_uchar32  __x) { return __x; }
-static simd_uchar2  SIMD_CFUNC simd_uchar(simd_short2   __x) { return simd_uchar(simd_char(__x)); }
-static simd_uchar3  SIMD_CFUNC simd_uchar(simd_short3   __x) { return simd_uchar(simd_char(__x)); }
-static simd_uchar4  SIMD_CFUNC simd_uchar(simd_short4   __x) { return simd_uchar(simd_char(__x)); }
-static simd_uchar8  SIMD_CFUNC simd_uchar(simd_short8   __x) { return simd_uchar(simd_char(__x)); }
-static simd_uchar16 SIMD_CFUNC simd_uchar(simd_short16  __x) { return simd_uchar(simd_char(__x)); }
-static simd_uchar32 SIMD_CFUNC simd_uchar(simd_short32  __x) { return simd_uchar(simd_char(__x)); }
-static simd_uchar2  SIMD_CFUNC simd_uchar(simd_ushort2  __x) { return simd_uchar(simd_char(__x)); }
-static simd_uchar3  SIMD_CFUNC simd_uchar(simd_ushort3  __x) { return simd_uchar(simd_char(__x)); }
-static simd_uchar4  SIMD_CFUNC simd_uchar(simd_ushort4  __x) { return simd_uchar(simd_char(__x)); }
-static simd_uchar8  SIMD_CFUNC simd_uchar(simd_ushort8  __x) { return simd_uchar(simd_char(__x)); }
-static simd_uchar16 SIMD_CFUNC simd_uchar(simd_ushort16 __x) { return simd_uchar(simd_char(__x)); }
-static simd_uchar32 SIMD_CFUNC simd_uchar(simd_ushort32 __x) { return simd_uchar(simd_char(__x)); }
-static simd_uchar2  SIMD_CFUNC simd_uchar(simd_int2     __x) { return simd_uchar(simd_char(__x)); }
-static simd_uchar3  SIMD_CFUNC simd_uchar(simd_int3     __x) { return simd_uchar(simd_char(__x)); }
-static simd_uchar4  SIMD_CFUNC simd_uchar(simd_int4     __x) { return simd_uchar(simd_char(__x)); }
-static simd_uchar8  SIMD_CFUNC simd_uchar(simd_int8     __x) { return simd_uchar(simd_char(__x)); }
-static simd_uchar16 SIMD_CFUNC simd_uchar(simd_int16    __x) { return simd_uchar(simd_char(__x)); }
-static simd_uchar2  SIMD_CFUNC simd_uchar(simd_uint2    __x) { return simd_uchar(simd_char(__x)); }
-static simd_uchar3  SIMD_CFUNC simd_uchar(simd_uint3    __x) { return simd_uchar(simd_char(__x)); }
-static simd_uchar4  SIMD_CFUNC simd_uchar(simd_uint4    __x) { return simd_uchar(simd_char(__x)); }
-static simd_uchar8  SIMD_CFUNC simd_uchar(simd_uint8    __x) { return simd_uchar(simd_char(__x)); }
-static simd_uchar16 SIMD_CFUNC simd_uchar(simd_uint16   __x) { return simd_uchar(simd_char(__x)); }
-static simd_uchar2  SIMD_CFUNC simd_uchar(simd_float2   __x) { return simd_uchar(simd_char(__x)); }
-static simd_uchar3  SIMD_CFUNC simd_uchar(simd_float3   __x) { return simd_uchar(simd_char(__x)); }
-static simd_uchar4  SIMD_CFUNC simd_uchar(simd_float4   __x) { return simd_uchar(simd_char(__x)); }
-static simd_uchar8  SIMD_CFUNC simd_uchar(simd_float8   __x) { return simd_uchar(simd_char(__x)); }
-static simd_uchar16 SIMD_CFUNC simd_uchar(simd_float16  __x) { return simd_uchar(simd_char(__x)); }
-static simd_uchar2  SIMD_CFUNC simd_uchar(simd_long2    __x) { return simd_uchar(simd_char(__x)); }
-static simd_uchar3  SIMD_CFUNC simd_uchar(simd_long3    __x) { return simd_uchar(simd_char(__x)); }
-static simd_uchar4  SIMD_CFUNC simd_uchar(simd_long4    __x) { return simd_uchar(simd_char(__x)); }
-static simd_uchar8  SIMD_CFUNC simd_uchar(simd_long8    __x) { return simd_uchar(simd_char(__x)); }
-static simd_uchar2  SIMD_CFUNC simd_uchar(simd_ulong2   __x) { return simd_uchar(simd_char(__x)); }
-static simd_uchar3  SIMD_CFUNC simd_uchar(simd_ulong3   __x) { return simd_uchar(simd_char(__x)); }
-static simd_uchar4  SIMD_CFUNC simd_uchar(simd_ulong4   __x) { return simd_uchar(simd_char(__x)); }
-static simd_uchar8  SIMD_CFUNC simd_uchar(simd_ulong8   __x) { return simd_uchar(simd_char(__x)); }
-static simd_uchar2  SIMD_CFUNC simd_uchar(simd_double2  __x) { return simd_uchar(simd_char(__x)); }
-static simd_uchar3  SIMD_CFUNC simd_uchar(simd_double3  __x) { return simd_uchar(simd_char(__x)); }
-static simd_uchar4  SIMD_CFUNC simd_uchar(simd_double4  __x) { return simd_uchar(simd_char(__x)); }
-static simd_uchar8  SIMD_CFUNC simd_uchar(simd_double8  __x) { return simd_uchar(simd_char(__x)); }
-    
-static simd_uchar2  SIMD_CFUNC simd_uchar_sat(simd_char2    __x) { return simd_uchar(simd_max(0,__x)); }
-static simd_uchar3  SIMD_CFUNC simd_uchar_sat(simd_char3    __x) { return simd_uchar(simd_max(0,__x)); }
-static simd_uchar4  SIMD_CFUNC simd_uchar_sat(simd_char4    __x) { return simd_uchar(simd_max(0,__x)); }
-static simd_uchar8  SIMD_CFUNC simd_uchar_sat(simd_char8    __x) { return simd_uchar(simd_max(0,__x)); }
-static simd_uchar16 SIMD_CFUNC simd_uchar_sat(simd_char16   __x) { return simd_uchar(simd_max(0,__x)); }
-static simd_uchar32 SIMD_CFUNC simd_uchar_sat(simd_char32   __x) { return simd_uchar(simd_max(0,__x)); }
-static simd_uchar2  SIMD_CFUNC simd_uchar_sat(simd_short2   __x) { return simd_uchar(simd_clamp(__x,0,0xff)); }
-static simd_uchar3  SIMD_CFUNC simd_uchar_sat(simd_short3   __x) { return simd_uchar(simd_clamp(__x,0,0xff)); }
-static simd_uchar4  SIMD_CFUNC simd_uchar_sat(simd_short4   __x) { return simd_uchar(simd_clamp(__x,0,0xff)); }
-static simd_uchar8  SIMD_CFUNC simd_uchar_sat(simd_short8   __x) { return simd_uchar(simd_clamp(__x,0,0xff)); }
-static simd_uchar16 SIMD_CFUNC simd_uchar_sat(simd_short16  __x) { return simd_uchar(simd_clamp(__x,0,0xff)); }
-static simd_uchar32 SIMD_CFUNC simd_uchar_sat(simd_short32  __x) { return simd_uchar(simd_clamp(__x,0,0xff)); }
-static simd_uchar2  SIMD_CFUNC simd_uchar_sat(simd_int2     __x) { return simd_uchar(simd_clamp(__x,0,0xff)); }
-static simd_uchar3  SIMD_CFUNC simd_uchar_sat(simd_int3     __x) { return simd_uchar(simd_clamp(__x,0,0xff)); }
-static simd_uchar4  SIMD_CFUNC simd_uchar_sat(simd_int4     __x) { return simd_uchar(simd_clamp(__x,0,0xff)); }
-static simd_uchar8  SIMD_CFUNC simd_uchar_sat(simd_int8     __x) { return simd_uchar(simd_clamp(__x,0,0xff)); }
-static simd_uchar16 SIMD_CFUNC simd_uchar_sat(simd_int16    __x) { return simd_uchar(simd_clamp(__x,0,0xff)); }
-static simd_uchar2  SIMD_CFUNC simd_uchar_sat(simd_float2   __x) { return simd_uchar(simd_clamp(__x,0,0xff)); }
-static simd_uchar3  SIMD_CFUNC simd_uchar_sat(simd_float3   __x) { return simd_uchar(simd_clamp(__x,0,0xff)); }
-static simd_uchar4  SIMD_CFUNC simd_uchar_sat(simd_float4   __x) { return simd_uchar(simd_clamp(__x,0,0xff)); }
-static simd_uchar8  SIMD_CFUNC simd_uchar_sat(simd_float8   __x) { return simd_uchar(simd_clamp(__x,0,0xff)); }
-static simd_uchar16 SIMD_CFUNC simd_uchar_sat(simd_float16  __x) { return simd_uchar(simd_clamp(__x,0,0xff)); }
-static simd_uchar2  SIMD_CFUNC simd_uchar_sat(simd_long2    __x) { return simd_uchar(simd_clamp(__x,0,0xff)); }
-static simd_uchar3  SIMD_CFUNC simd_uchar_sat(simd_long3    __x) { return simd_uchar(simd_clamp(__x,0,0xff)); }
-static simd_uchar4  SIMD_CFUNC simd_uchar_sat(simd_long4    __x) { return simd_uchar(simd_clamp(__x,0,0xff)); }
-static simd_uchar8  SIMD_CFUNC simd_uchar_sat(simd_long8    __x) { return simd_uchar(simd_clamp(__x,0,0xff)); }
-static simd_uchar2  SIMD_CFUNC simd_uchar_sat(simd_double2  __x) { return simd_uchar(simd_clamp(__x,0,0xff)); }
-static simd_uchar3  SIMD_CFUNC simd_uchar_sat(simd_double3  __x) { return simd_uchar(simd_clamp(__x,0,0xff)); }
-static simd_uchar4  SIMD_CFUNC simd_uchar_sat(simd_double4  __x) { return simd_uchar(simd_clamp(__x,0,0xff)); }
-static simd_uchar8  SIMD_CFUNC simd_uchar_sat(simd_double8  __x) { return simd_uchar(simd_clamp(__x,0,0xff)); }
-static simd_uchar2  SIMD_CFUNC simd_uchar_sat(simd_uchar2   __x) { return __x; }
-static simd_uchar3  SIMD_CFUNC simd_uchar_sat(simd_uchar3   __x) { return __x; }
-static simd_uchar4  SIMD_CFUNC simd_uchar_sat(simd_uchar4   __x) { return __x; }
-static simd_uchar8  SIMD_CFUNC simd_uchar_sat(simd_uchar8   __x) { return __x; }
-static simd_uchar16 SIMD_CFUNC simd_uchar_sat(simd_uchar16  __x) { return __x; }
-static simd_uchar32 SIMD_CFUNC simd_uchar_sat(simd_uchar32  __x) { return __x; }
-static simd_uchar2  SIMD_CFUNC simd_uchar_sat(simd_ushort2  __x) { return simd_uchar(simd_min(__x,0xff)); }
-static simd_uchar3  SIMD_CFUNC simd_uchar_sat(simd_ushort3  __x) { return simd_uchar(simd_min(__x,0xff)); }
-static simd_uchar4  SIMD_CFUNC simd_uchar_sat(simd_ushort4  __x) { return simd_uchar(simd_min(__x,0xff)); }
-static simd_uchar8  SIMD_CFUNC simd_uchar_sat(simd_ushort8  __x) { return simd_uchar(simd_min(__x,0xff)); }
-static simd_uchar16 SIMD_CFUNC simd_uchar_sat(simd_ushort16 __x) { return simd_uchar(simd_min(__x,0xff)); }
-static simd_uchar32 SIMD_CFUNC simd_uchar_sat(simd_ushort32 __x) { return simd_uchar(simd_min(__x,0xff)); }
-static simd_uchar2  SIMD_CFUNC simd_uchar_sat(simd_uint2    __x) { return simd_uchar(simd_min(__x,0xff)); }
-static simd_uchar3  SIMD_CFUNC simd_uchar_sat(simd_uint3    __x) { return simd_uchar(simd_min(__x,0xff)); }
-static simd_uchar4  SIMD_CFUNC simd_uchar_sat(simd_uint4    __x) { return simd_uchar(simd_min(__x,0xff)); }
-static simd_uchar8  SIMD_CFUNC simd_uchar_sat(simd_uint8    __x) { return simd_uchar(simd_min(__x,0xff)); }
-static simd_uchar16 SIMD_CFUNC simd_uchar_sat(simd_uint16   __x) { return simd_uchar(simd_min(__x,0xff)); }
-static simd_uchar2  SIMD_CFUNC simd_uchar_sat(simd_ulong2   __x) { return simd_uchar(simd_min(__x,0xff)); }
-static simd_uchar3  SIMD_CFUNC simd_uchar_sat(simd_ulong3   __x) { return simd_uchar(simd_min(__x,0xff)); }
-static simd_uchar4  SIMD_CFUNC simd_uchar_sat(simd_ulong4   __x) { return simd_uchar(simd_min(__x,0xff)); }
-static simd_uchar8  SIMD_CFUNC simd_uchar_sat(simd_ulong8   __x) { return simd_uchar(simd_min(__x,0xff)); }
-
-static simd_short2  SIMD_CFUNC simd_short(simd_char2    __x) { return __builtin_convertvector(__x, simd_short2); }
-static simd_short3  SIMD_CFUNC simd_short(simd_char3    __x) { return __builtin_convertvector(__x, simd_short3); }
-static simd_short4  SIMD_CFUNC simd_short(simd_char4    __x) { return __builtin_convertvector(__x, simd_short4); }
-static simd_short8  SIMD_CFUNC simd_short(simd_char8    __x) { return __builtin_convertvector(__x, simd_short8); }
-static simd_short16 SIMD_CFUNC simd_short(simd_char16   __x) { return __builtin_convertvector(__x, simd_short16); }
-static simd_short32 SIMD_CFUNC simd_short(simd_char32   __x) { return __builtin_convertvector(__x, simd_short32); }
-static simd_short2  SIMD_CFUNC simd_short(simd_uchar2   __x) { return __builtin_convertvector(__x, simd_short2); }
-static simd_short3  SIMD_CFUNC simd_short(simd_uchar3   __x) { return __builtin_convertvector(__x, simd_short3); }
-static simd_short4  SIMD_CFUNC simd_short(simd_uchar4   __x) { return __builtin_convertvector(__x, simd_short4); }
-static simd_short8  SIMD_CFUNC simd_short(simd_uchar8   __x) { return __builtin_convertvector(__x, simd_short8); }
-static simd_short16 SIMD_CFUNC simd_short(simd_uchar16  __x) { return __builtin_convertvector(__x, simd_short16); }
-static simd_short32 SIMD_CFUNC simd_short(simd_uchar32  __x) { return __builtin_convertvector(__x, simd_short32); }
-static simd_short2  SIMD_CFUNC simd_short(simd_short2   __x) { return __x; }
-static simd_short3  SIMD_CFUNC simd_short(simd_short3   __x) { return __x; }
-static simd_short4  SIMD_CFUNC simd_short(simd_short4   __x) { return __x; }
-static simd_short8  SIMD_CFUNC simd_short(simd_short8   __x) { return __x; }
-static simd_short16 SIMD_CFUNC simd_short(simd_short16  __x) { return __x; }
-static simd_short32 SIMD_CFUNC simd_short(simd_short32  __x) { return __x; }
-static simd_short2  SIMD_CFUNC simd_short(simd_ushort2  __x) { return (simd_short2)__x; }
-static simd_short3  SIMD_CFUNC simd_short(simd_ushort3  __x) { return (simd_short3)__x; }
-static simd_short4  SIMD_CFUNC simd_short(simd_ushort4  __x) { return (simd_short4)__x; }
-static simd_short8  SIMD_CFUNC simd_short(simd_ushort8  __x) { return (simd_short8)__x; }
-static simd_short16 SIMD_CFUNC simd_short(simd_ushort16 __x) { return (simd_short16)__x; }
-static simd_short32 SIMD_CFUNC simd_short(simd_ushort32 __x) { return (simd_short32)__x; }
-static simd_short2  SIMD_CFUNC simd_short(simd_int2     __x) { return __builtin_convertvector(__x & 0xffff, simd_short2); }
-static simd_short3  SIMD_CFUNC simd_short(simd_int3     __x) { return __builtin_convertvector(__x & 0xffff, simd_short3); }
-static simd_short4  SIMD_CFUNC simd_short(simd_int4     __x) { return __builtin_convertvector(__x & 0xffff, simd_short4); }
-static simd_short8  SIMD_CFUNC simd_short(simd_int8     __x) { return __builtin_convertvector(__x & 0xffff, simd_short8); }
-static simd_short16 SIMD_CFUNC simd_short(simd_int16    __x) { return __builtin_convertvector(__x & 0xffff, simd_short16); }
-static simd_short2  SIMD_CFUNC simd_short(simd_uint2    __x) { return simd_short(simd_int(__x)); }
-static simd_short3  SIMD_CFUNC simd_short(simd_uint3    __x) { return simd_short(simd_int(__x)); }
-static simd_short4  SIMD_CFUNC simd_short(simd_uint4    __x) { return simd_short(simd_int(__x)); }
-static simd_short8  SIMD_CFUNC simd_short(simd_uint8    __x) { return simd_short(simd_int(__x)); }
-static simd_short16 SIMD_CFUNC simd_short(simd_uint16   __x) { return simd_short(simd_int(__x)); }
-static simd_short2  SIMD_CFUNC simd_short(simd_float2   __x) { return simd_short(simd_int(__x)); }
-static simd_short3  SIMD_CFUNC simd_short(simd_float3   __x) { return simd_short(simd_int(__x)); }
-static simd_short4  SIMD_CFUNC simd_short(simd_float4   __x) { return simd_short(simd_int(__x)); }
-static simd_short8  SIMD_CFUNC simd_short(simd_float8   __x) { return simd_short(simd_int(__x)); }
-static simd_short16 SIMD_CFUNC simd_short(simd_float16  __x) { return simd_short(simd_int(__x)); }
-static simd_short2  SIMD_CFUNC simd_short(simd_long2    __x) { return simd_short(simd_int(__x)); }
-static simd_short3  SIMD_CFUNC simd_short(simd_long3    __x) { return simd_short(simd_int(__x)); }
-static simd_short4  SIMD_CFUNC simd_short(simd_long4    __x) { return simd_short(simd_int(__x)); }
-static simd_short8  SIMD_CFUNC simd_short(simd_long8    __x) { return simd_short(simd_int(__x)); }
-static simd_short2  SIMD_CFUNC simd_short(simd_ulong2   __x) { return simd_short(simd_int(__x)); }
-static simd_short3  SIMD_CFUNC simd_short(simd_ulong3   __x) { return simd_short(simd_int(__x)); }
-static simd_short4  SIMD_CFUNC simd_short(simd_ulong4   __x) { return simd_short(simd_int(__x)); }
-static simd_short8  SIMD_CFUNC simd_short(simd_ulong8   __x) { return simd_short(simd_int(__x)); }
-static simd_short2  SIMD_CFUNC simd_short(simd_double2  __x) { return simd_short(simd_int(__x)); }
-static simd_short3  SIMD_CFUNC simd_short(simd_double3  __x) { return simd_short(simd_int(__x)); }
-static simd_short4  SIMD_CFUNC simd_short(simd_double4  __x) { return simd_short(simd_int(__x)); }
-static simd_short8  SIMD_CFUNC simd_short(simd_double8  __x) { return simd_short(simd_int(__x)); }
-    
-static simd_short2  SIMD_CFUNC simd_short_sat(simd_char2    __x) { return simd_short(__x); }
-static simd_short3  SIMD_CFUNC simd_short_sat(simd_char3    __x) { return simd_short(__x); }
-static simd_short4  SIMD_CFUNC simd_short_sat(simd_char4    __x) { return simd_short(__x); }
-static simd_short8  SIMD_CFUNC simd_short_sat(simd_char8    __x) { return simd_short(__x); }
-static simd_short16 SIMD_CFUNC simd_short_sat(simd_char16   __x) { return simd_short(__x); }
-static simd_short32 SIMD_CFUNC simd_short_sat(simd_char32   __x) { return simd_short(__x); }
-static simd_short2  SIMD_CFUNC simd_short_sat(simd_short2   __x) { return __x; }
-static simd_short3  SIMD_CFUNC simd_short_sat(simd_short3   __x) { return __x; }
-static simd_short4  SIMD_CFUNC simd_short_sat(simd_short4   __x) { return __x; }
-static simd_short8  SIMD_CFUNC simd_short_sat(simd_short8   __x) { return __x; }
-static simd_short16 SIMD_CFUNC simd_short_sat(simd_short16  __x) { return __x; }
-static simd_short32 SIMD_CFUNC simd_short_sat(simd_short32  __x) { return __x; }
-static simd_short2  SIMD_CFUNC simd_short_sat(simd_int2     __x) { return simd_short(simd_clamp(__x,-0x8000,0x7fff)); }
-static simd_short3  SIMD_CFUNC simd_short_sat(simd_int3     __x) { return simd_short(simd_clamp(__x,-0x8000,0x7fff)); }
-static simd_short4  SIMD_CFUNC simd_short_sat(simd_int4     __x) { return simd_short(simd_clamp(__x,-0x8000,0x7fff)); }
-static simd_short8  SIMD_CFUNC simd_short_sat(simd_int8     __x) { return simd_short(simd_clamp(__x,-0x8000,0x7fff)); }
-static simd_short16 SIMD_CFUNC simd_short_sat(simd_int16    __x) { return simd_short(simd_clamp(__x,-0x8000,0x7fff)); }
-static simd_short2  SIMD_CFUNC simd_short_sat(simd_float2   __x) { return simd_short(simd_clamp(__x,-0x8000,0x7fff)); }
-static simd_short3  SIMD_CFUNC simd_short_sat(simd_float3   __x) { return simd_short(simd_clamp(__x,-0x8000,0x7fff)); }
-static simd_short4  SIMD_CFUNC simd_short_sat(simd_float4   __x) { return simd_short(simd_clamp(__x,-0x8000,0x7fff)); }
-static simd_short8  SIMD_CFUNC simd_short_sat(simd_float8   __x) { return simd_short(simd_clamp(__x,-0x8000,0x7fff)); }
-static simd_short16 SIMD_CFUNC simd_short_sat(simd_float16  __x) { return simd_short(simd_clamp(__x,-0x8000,0x7fff)); }
-static simd_short2  SIMD_CFUNC simd_short_sat(simd_long2    __x) { return simd_short(simd_clamp(__x,-0x8000,0x7fff)); }
-static simd_short3  SIMD_CFUNC simd_short_sat(simd_long3    __x) { return simd_short(simd_clamp(__x,-0x8000,0x7fff)); }
-static simd_short4  SIMD_CFUNC simd_short_sat(simd_long4    __x) { return simd_short(simd_clamp(__x,-0x8000,0x7fff)); }
-static simd_short8  SIMD_CFUNC simd_short_sat(simd_long8    __x) { return simd_short(simd_clamp(__x,-0x8000,0x7fff)); }
-static simd_short2  SIMD_CFUNC simd_short_sat(simd_double2  __x) { return simd_short(simd_clamp(__x,-0x8000,0x7fff)); }
-static simd_short3  SIMD_CFUNC simd_short_sat(simd_double3  __x) { return simd_short(simd_clamp(__x,-0x8000,0x7fff)); }
-static simd_short4  SIMD_CFUNC simd_short_sat(simd_double4  __x) { return simd_short(simd_clamp(__x,-0x8000,0x7fff)); }
-static simd_short8  SIMD_CFUNC simd_short_sat(simd_double8  __x) { return simd_short(simd_clamp(__x,-0x8000,0x7fff)); }
-static simd_short2  SIMD_CFUNC simd_short_sat(simd_uchar2   __x) { return simd_short(__x); }
-static simd_short3  SIMD_CFUNC simd_short_sat(simd_uchar3   __x) { return simd_short(__x); }
-static simd_short4  SIMD_CFUNC simd_short_sat(simd_uchar4   __x) { return simd_short(__x); }
-static simd_short8  SIMD_CFUNC simd_short_sat(simd_uchar8   __x) { return simd_short(__x); }
-static simd_short16 SIMD_CFUNC simd_short_sat(simd_uchar16  __x) { return simd_short(__x); }
-static simd_short32 SIMD_CFUNC simd_short_sat(simd_uchar32  __x) { return simd_short(__x); }
-static simd_short2  SIMD_CFUNC simd_short_sat(simd_ushort2  __x) { return simd_short(simd_min(__x,0x7fff)); }
-static simd_short3  SIMD_CFUNC simd_short_sat(simd_ushort3  __x) { return simd_short(simd_min(__x,0x7fff)); }
-static simd_short4  SIMD_CFUNC simd_short_sat(simd_ushort4  __x) { return simd_short(simd_min(__x,0x7fff)); }
-static simd_short8  SIMD_CFUNC simd_short_sat(simd_ushort8  __x) { return simd_short(simd_min(__x,0x7fff)); }
-static simd_short16 SIMD_CFUNC simd_short_sat(simd_ushort16 __x) { return simd_short(simd_min(__x,0x7fff)); }
-static simd_short32 SIMD_CFUNC simd_short_sat(simd_ushort32 __x) { return simd_short(simd_min(__x,0x7fff)); }
-static simd_short2  SIMD_CFUNC simd_short_sat(simd_uint2    __x) { return simd_short(simd_min(__x,0x7fff)); }
-static simd_short3  SIMD_CFUNC simd_short_sat(simd_uint3    __x) { return simd_short(simd_min(__x,0x7fff)); }
-static simd_short4  SIMD_CFUNC simd_short_sat(simd_uint4    __x) { return simd_short(simd_min(__x,0x7fff)); }
-static simd_short8  SIMD_CFUNC simd_short_sat(simd_uint8    __x) { return simd_short(simd_min(__x,0x7fff)); }
-static simd_short16 SIMD_CFUNC simd_short_sat(simd_uint16   __x) { return simd_short(simd_min(__x,0x7fff)); }
-static simd_short2  SIMD_CFUNC simd_short_sat(simd_ulong2   __x) { return simd_short(simd_min(__x,0x7fff)); }
-static simd_short3  SIMD_CFUNC simd_short_sat(simd_ulong3   __x) { return simd_short(simd_min(__x,0x7fff)); }
-static simd_short4  SIMD_CFUNC simd_short_sat(simd_ulong4   __x) { return simd_short(simd_min(__x,0x7fff)); }
-static simd_short8  SIMD_CFUNC simd_short_sat(simd_ulong8   __x) { return simd_short(simd_min(__x,0x7fff)); }
-
-static simd_ushort2  SIMD_CFUNC simd_ushort(simd_char2    __x) { return simd_ushort(simd_short(__x)); }
-static simd_ushort3  SIMD_CFUNC simd_ushort(simd_char3    __x) { return simd_ushort(simd_short(__x)); }
-static simd_ushort4  SIMD_CFUNC simd_ushort(simd_char4    __x) { return simd_ushort(simd_short(__x)); }
-static simd_ushort8  SIMD_CFUNC simd_ushort(simd_char8    __x) { return simd_ushort(simd_short(__x)); }
-static simd_ushort16 SIMD_CFUNC simd_ushort(simd_char16   __x) { return simd_ushort(simd_short(__x)); }
-static simd_ushort32 SIMD_CFUNC simd_ushort(simd_char32   __x) { return simd_ushort(simd_short(__x)); }
-static simd_ushort2  SIMD_CFUNC simd_ushort(simd_uchar2   __x) { return simd_ushort(simd_short(__x)); }
-static simd_ushort3  SIMD_CFUNC simd_ushort(simd_uchar3   __x) { return simd_ushort(simd_short(__x)); }
-static simd_ushort4  SIMD_CFUNC simd_ushort(simd_uchar4   __x) { return simd_ushort(simd_short(__x)); }
-static simd_ushort8  SIMD_CFUNC simd_ushort(simd_uchar8   __x) { return simd_ushort(simd_short(__x)); }
-static simd_ushort16 SIMD_CFUNC simd_ushort(simd_uchar16  __x) { return simd_ushort(simd_short(__x)); }
-static simd_ushort32 SIMD_CFUNC simd_ushort(simd_uchar32  __x) { return simd_ushort(simd_short(__x)); }
-static simd_ushort2  SIMD_CFUNC simd_ushort(simd_short2   __x) { return (simd_ushort2)__x; }
-static simd_ushort3  SIMD_CFUNC simd_ushort(simd_short3   __x) { return (simd_ushort3)__x; }
-static simd_ushort4  SIMD_CFUNC simd_ushort(simd_short4   __x) { return (simd_ushort4)__x; }
-static simd_ushort8  SIMD_CFUNC simd_ushort(simd_short8   __x) { return (simd_ushort8)__x; }
-static simd_ushort16 SIMD_CFUNC simd_ushort(simd_short16  __x) { return (simd_ushort16)__x; }
-static simd_ushort32 SIMD_CFUNC simd_ushort(simd_short32  __x) { return (simd_ushort32)__x; }
-static simd_ushort2  SIMD_CFUNC simd_ushort(simd_ushort2  __x) { return __x; }
-static simd_ushort3  SIMD_CFUNC simd_ushort(simd_ushort3  __x) { return __x; }
-static simd_ushort4  SIMD_CFUNC simd_ushort(simd_ushort4  __x) { return __x; }
-static simd_ushort8  SIMD_CFUNC simd_ushort(simd_ushort8  __x) { return __x; }
-static simd_ushort16 SIMD_CFUNC simd_ushort(simd_ushort16 __x) { return __x; }
-static simd_ushort32 SIMD_CFUNC simd_ushort(simd_ushort32 __x) { return __x; }
-static simd_ushort2  SIMD_CFUNC simd_ushort(simd_int2     __x) { return simd_ushort(simd_short(__x)); }
-static simd_ushort3  SIMD_CFUNC simd_ushort(simd_int3     __x) { return simd_ushort(simd_short(__x)); }
-static simd_ushort4  SIMD_CFUNC simd_ushort(simd_int4     __x) { return simd_ushort(simd_short(__x)); }
-static simd_ushort8  SIMD_CFUNC simd_ushort(simd_int8     __x) { return simd_ushort(simd_short(__x)); }
-static simd_ushort16 SIMD_CFUNC simd_ushort(simd_int16    __x) { return simd_ushort(simd_short(__x)); }
-static simd_ushort2  SIMD_CFUNC simd_ushort(simd_uint2    __x) { return simd_ushort(simd_short(__x)); }
-static simd_ushort3  SIMD_CFUNC simd_ushort(simd_uint3    __x) { return simd_ushort(simd_short(__x)); }
-static simd_ushort4  SIMD_CFUNC simd_ushort(simd_uint4    __x) { return simd_ushort(simd_short(__x)); }
-static simd_ushort8  SIMD_CFUNC simd_ushort(simd_uint8    __x) { return simd_ushort(simd_short(__x)); }
-static simd_ushort16 SIMD_CFUNC simd_ushort(simd_uint16   __x) { return simd_ushort(simd_short(__x)); }
-static simd_ushort2  SIMD_CFUNC simd_ushort(simd_float2   __x) { return simd_ushort(simd_short(__x)); }
-static simd_ushort3  SIMD_CFUNC simd_ushort(simd_float3   __x) { return simd_ushort(simd_short(__x)); }
-static simd_ushort4  SIMD_CFUNC simd_ushort(simd_float4   __x) { return simd_ushort(simd_short(__x)); }
-static simd_ushort8  SIMD_CFUNC simd_ushort(simd_float8   __x) { return simd_ushort(simd_short(__x)); }
-static simd_ushort16 SIMD_CFUNC simd_ushort(simd_float16  __x) { return simd_ushort(simd_short(__x)); }
-static simd_ushort2  SIMD_CFUNC simd_ushort(simd_long2    __x) { return simd_ushort(simd_short(__x)); }
-static simd_ushort3  SIMD_CFUNC simd_ushort(simd_long3    __x) { return simd_ushort(simd_short(__x)); }
-static simd_ushort4  SIMD_CFUNC simd_ushort(simd_long4    __x) { return simd_ushort(simd_short(__x)); }
-static simd_ushort8  SIMD_CFUNC simd_ushort(simd_long8    __x) { return simd_ushort(simd_short(__x)); }
-static simd_ushort2  SIMD_CFUNC simd_ushort(simd_ulong2   __x) { return simd_ushort(simd_short(__x)); }
-static simd_ushort3  SIMD_CFUNC simd_ushort(simd_ulong3   __x) { return simd_ushort(simd_short(__x)); }
-static simd_ushort4  SIMD_CFUNC simd_ushort(simd_ulong4   __x) { return simd_ushort(simd_short(__x)); }
-static simd_ushort8  SIMD_CFUNC simd_ushort(simd_ulong8   __x) { return simd_ushort(simd_short(__x)); }
-static simd_ushort2  SIMD_CFUNC simd_ushort(simd_double2  __x) { return simd_ushort(simd_short(__x)); }
-static simd_ushort3  SIMD_CFUNC simd_ushort(simd_double3  __x) { return simd_ushort(simd_short(__x)); }
-static simd_ushort4  SIMD_CFUNC simd_ushort(simd_double4  __x) { return simd_ushort(simd_short(__x)); }
-static simd_ushort8  SIMD_CFUNC simd_ushort(simd_double8  __x) { return simd_ushort(simd_short(__x)); }
-    
-static simd_ushort2  SIMD_CFUNC simd_ushort_sat(simd_char2    __x) { return simd_ushort(simd_max(__x, 0)); }
-static simd_ushort3  SIMD_CFUNC simd_ushort_sat(simd_char3    __x) { return simd_ushort(simd_max(__x, 0)); }
-static simd_ushort4  SIMD_CFUNC simd_ushort_sat(simd_char4    __x) { return simd_ushort(simd_max(__x, 0)); }
-static simd_ushort8  SIMD_CFUNC simd_ushort_sat(simd_char8    __x) { return simd_ushort(simd_max(__x, 0)); }
-static simd_ushort16 SIMD_CFUNC simd_ushort_sat(simd_char16   __x) { return simd_ushort(simd_max(__x, 0)); }
-static simd_ushort32 SIMD_CFUNC simd_ushort_sat(simd_char32   __x) { return simd_ushort(simd_max(__x, 0)); }
-static simd_ushort2  SIMD_CFUNC simd_ushort_sat(simd_short2   __x) { return simd_ushort(simd_max(__x, 0)); }
-static simd_ushort3  SIMD_CFUNC simd_ushort_sat(simd_short3   __x) { return simd_ushort(simd_max(__x, 0)); }
-static simd_ushort4  SIMD_CFUNC simd_ushort_sat(simd_short4   __x) { return simd_ushort(simd_max(__x, 0)); }
-static simd_ushort8  SIMD_CFUNC simd_ushort_sat(simd_short8   __x) { return simd_ushort(simd_max(__x, 0)); }
-static simd_ushort16 SIMD_CFUNC simd_ushort_sat(simd_short16  __x) { return simd_ushort(simd_max(__x, 0)); }
-static simd_ushort32 SIMD_CFUNC simd_ushort_sat(simd_short32  __x) { return simd_ushort(simd_max(__x, 0)); }
-static simd_ushort2  SIMD_CFUNC simd_ushort_sat(simd_int2     __x) { return simd_ushort(simd_clamp(__x, 0, 0xffff)); }
-static simd_ushort3  SIMD_CFUNC simd_ushort_sat(simd_int3     __x) { return simd_ushort(simd_clamp(__x, 0, 0xffff)); }
-static simd_ushort4  SIMD_CFUNC simd_ushort_sat(simd_int4     __x) { return simd_ushort(simd_clamp(__x, 0, 0xffff)); }
-static simd_ushort8  SIMD_CFUNC simd_ushort_sat(simd_int8     __x) { return simd_ushort(simd_clamp(__x, 0, 0xffff)); }
-static simd_ushort16 SIMD_CFUNC simd_ushort_sat(simd_int16    __x) { return simd_ushort(simd_clamp(__x, 0, 0xffff)); }
-static simd_ushort2  SIMD_CFUNC simd_ushort_sat(simd_float2   __x) { return simd_ushort(simd_clamp(__x, 0, 0xffff)); }
-static simd_ushort3  SIMD_CFUNC simd_ushort_sat(simd_float3   __x) { return simd_ushort(simd_clamp(__x, 0, 0xffff)); }
-static simd_ushort4  SIMD_CFUNC simd_ushort_sat(simd_float4   __x) { return simd_ushort(simd_clamp(__x, 0, 0xffff)); }
-static simd_ushort8  SIMD_CFUNC simd_ushort_sat(simd_float8   __x) { return simd_ushort(simd_clamp(__x, 0, 0xffff)); }
-static simd_ushort16 SIMD_CFUNC simd_ushort_sat(simd_float16  __x) { return simd_ushort(simd_clamp(__x, 0, 0xffff)); }
-static simd_ushort2  SIMD_CFUNC simd_ushort_sat(simd_long2    __x) { return simd_ushort(simd_clamp(__x, 0, 0xffff)); }
-static simd_ushort3  SIMD_CFUNC simd_ushort_sat(simd_long3    __x) { return simd_ushort(simd_clamp(__x, 0, 0xffff)); }
-static simd_ushort4  SIMD_CFUNC simd_ushort_sat(simd_long4    __x) { return simd_ushort(simd_clamp(__x, 0, 0xffff)); }
-static simd_ushort8  SIMD_CFUNC simd_ushort_sat(simd_long8    __x) { return simd_ushort(simd_clamp(__x, 0, 0xffff)); }
-static simd_ushort2  SIMD_CFUNC simd_ushort_sat(simd_double2  __x) { return simd_ushort(simd_clamp(__x, 0, 0xffff)); }
-static simd_ushort3  SIMD_CFUNC simd_ushort_sat(simd_double3  __x) { return simd_ushort(simd_clamp(__x, 0, 0xffff)); }
-static simd_ushort4  SIMD_CFUNC simd_ushort_sat(simd_double4  __x) { return simd_ushort(simd_clamp(__x, 0, 0xffff)); }
-static simd_ushort8  SIMD_CFUNC simd_ushort_sat(simd_double8  __x) { return simd_ushort(simd_clamp(__x, 0, 0xffff)); }
-static simd_ushort2  SIMD_CFUNC simd_ushort_sat(simd_uchar2   __x) { return simd_ushort(__x); }
-static simd_ushort3  SIMD_CFUNC simd_ushort_sat(simd_uchar3   __x) { return simd_ushort(__x); }
-static simd_ushort4  SIMD_CFUNC simd_ushort_sat(simd_uchar4   __x) { return simd_ushort(__x); }
-static simd_ushort8  SIMD_CFUNC simd_ushort_sat(simd_uchar8   __x) { return simd_ushort(__x); }
-static simd_ushort16 SIMD_CFUNC simd_ushort_sat(simd_uchar16  __x) { return simd_ushort(__x); }
-static simd_ushort32 SIMD_CFUNC simd_ushort_sat(simd_uchar32  __x) { return simd_ushort(__x); }
-static simd_ushort2  SIMD_CFUNC simd_ushort_sat(simd_ushort2  __x) { return __x; }
-static simd_ushort3  SIMD_CFUNC simd_ushort_sat(simd_ushort3  __x) { return __x; }
-static simd_ushort4  SIMD_CFUNC simd_ushort_sat(simd_ushort4  __x) { return __x; }
-static simd_ushort8  SIMD_CFUNC simd_ushort_sat(simd_ushort8  __x) { return __x; }
-static simd_ushort16 SIMD_CFUNC simd_ushort_sat(simd_ushort16 __x) { return __x; }
-static simd_ushort32 SIMD_CFUNC simd_ushort_sat(simd_ushort32 __x) { return __x; }
-static simd_ushort2  SIMD_CFUNC simd_ushort_sat(simd_uint2    __x) { return simd_ushort(simd_min(__x, 0xffff)); }
-static simd_ushort3  SIMD_CFUNC simd_ushort_sat(simd_uint3    __x) { return simd_ushort(simd_min(__x, 0xffff)); }
-static simd_ushort4  SIMD_CFUNC simd_ushort_sat(simd_uint4    __x) { return simd_ushort(simd_min(__x, 0xffff)); }
-static simd_ushort8  SIMD_CFUNC simd_ushort_sat(simd_uint8    __x) { return simd_ushort(simd_min(__x, 0xffff)); }
-static simd_ushort16 SIMD_CFUNC simd_ushort_sat(simd_uint16   __x) { return simd_ushort(simd_min(__x, 0xffff)); }
-static simd_ushort2  SIMD_CFUNC simd_ushort_sat(simd_ulong2   __x) { return simd_ushort(simd_min(__x, 0xffff)); }
-static simd_ushort3  SIMD_CFUNC simd_ushort_sat(simd_ulong3   __x) { return simd_ushort(simd_min(__x, 0xffff)); }
-static simd_ushort4  SIMD_CFUNC simd_ushort_sat(simd_ulong4   __x) { return simd_ushort(simd_min(__x, 0xffff)); }
-static simd_ushort8  SIMD_CFUNC simd_ushort_sat(simd_ulong8   __x) { return simd_ushort(simd_min(__x, 0xffff)); }
-
-static simd_int2  SIMD_CFUNC simd_int(simd_char2    __x) { return __builtin_convertvector(__x, simd_int2); }
-static simd_int3  SIMD_CFUNC simd_int(simd_char3    __x) { return __builtin_convertvector(__x, simd_int3); }
-static simd_int4  SIMD_CFUNC simd_int(simd_char4    __x) { return __builtin_convertvector(__x, simd_int4); }
-static simd_int8  SIMD_CFUNC simd_int(simd_char8    __x) { return __builtin_convertvector(__x, simd_int8); }
-static simd_int16 SIMD_CFUNC simd_int(simd_char16   __x) { return __builtin_convertvector(__x, simd_int16); }
-static simd_int2  SIMD_CFUNC simd_int(simd_uchar2   __x) { return __builtin_convertvector(__x, simd_int2); }
-static simd_int3  SIMD_CFUNC simd_int(simd_uchar3   __x) { return __builtin_convertvector(__x, simd_int3); }
-static simd_int4  SIMD_CFUNC simd_int(simd_uchar4   __x) { return __builtin_convertvector(__x, simd_int4); }
-static simd_int8  SIMD_CFUNC simd_int(simd_uchar8   __x) { return __builtin_convertvector(__x, simd_int8); }
-static simd_int16 SIMD_CFUNC simd_int(simd_uchar16  __x) { return __builtin_convertvector(__x, simd_int16); }
-static simd_int2  SIMD_CFUNC simd_int(simd_short2   __x) { return __builtin_convertvector(__x, simd_int2); }
-static simd_int3  SIMD_CFUNC simd_int(simd_short3   __x) { return __builtin_convertvector(__x, simd_int3); }
-static simd_int4  SIMD_CFUNC simd_int(simd_short4   __x) { return __builtin_convertvector(__x, simd_int4); }
-static simd_int8  SIMD_CFUNC simd_int(simd_short8   __x) { return __builtin_convertvector(__x, simd_int8); }
-static simd_int16 SIMD_CFUNC simd_int(simd_short16  __x) { return __builtin_convertvector(__x, simd_int16); }
-static simd_int2  SIMD_CFUNC simd_int(simd_ushort2  __x) { return __builtin_convertvector(__x, simd_int2); }
-static simd_int3  SIMD_CFUNC simd_int(simd_ushort3  __x) { return __builtin_convertvector(__x, simd_int3); }
-static simd_int4  SIMD_CFUNC simd_int(simd_ushort4  __x) { return __builtin_convertvector(__x, simd_int4); }
-static simd_int8  SIMD_CFUNC simd_int(simd_ushort8  __x) { return __builtin_convertvector(__x, simd_int8); }
-static simd_int16 SIMD_CFUNC simd_int(simd_ushort16 __x) { return __builtin_convertvector(__x, simd_int16); }
-static simd_int2  SIMD_CFUNC simd_int(simd_int2     __x) { return __x; }
-static simd_int3  SIMD_CFUNC simd_int(simd_int3     __x) { return __x; }
-static simd_int4  SIMD_CFUNC simd_int(simd_int4     __x) { return __x; }
-static simd_int8  SIMD_CFUNC simd_int(simd_int8     __x) { return __x; }
-static simd_int16 SIMD_CFUNC simd_int(simd_int16    __x) { return __x; }
-static simd_int2  SIMD_CFUNC simd_int(simd_uint2    __x) { return (simd_int2)__x; }
-static simd_int3  SIMD_CFUNC simd_int(simd_uint3    __x) { return (simd_int3)__x; }
-static simd_int4  SIMD_CFUNC simd_int(simd_uint4    __x) { return (simd_int4)__x; }
-static simd_int8  SIMD_CFUNC simd_int(simd_uint8    __x) { return (simd_int8)__x; }
-static simd_int16 SIMD_CFUNC simd_int(simd_uint16   __x) { return (simd_int16)__x; }
-static simd_int2  SIMD_CFUNC simd_int(simd_float2   __x) { return __builtin_convertvector(__x, simd_int2); }
-static simd_int3  SIMD_CFUNC simd_int(simd_float3   __x) { return __builtin_convertvector(__x, simd_int3); }
-static simd_int4  SIMD_CFUNC simd_int(simd_float4   __x) { return __builtin_convertvector(__x, simd_int4); }
-static simd_int8  SIMD_CFUNC simd_int(simd_float8   __x) { return __builtin_convertvector(__x, simd_int8); }
-static simd_int16 SIMD_CFUNC simd_int(simd_float16  __x) { return __builtin_convertvector(__x, simd_int16); }
-static simd_int2  SIMD_CFUNC simd_int(simd_long2    __x) { return __builtin_convertvector(__x & 0xffffffff, simd_int2); }
-static simd_int3  SIMD_CFUNC simd_int(simd_long3    __x) { return __builtin_convertvector(__x & 0xffffffff, simd_int3); }
-static simd_int4  SIMD_CFUNC simd_int(simd_long4    __x) { return __builtin_convertvector(__x & 0xffffffff, simd_int4); }
-static simd_int8  SIMD_CFUNC simd_int(simd_long8    __x) { return __builtin_convertvector(__x & 0xffffffff, simd_int8); }
-static simd_int2  SIMD_CFUNC simd_int(simd_ulong2   __x) { return simd_int(simd_long(__x)); }
-static simd_int3  SIMD_CFUNC simd_int(simd_ulong3   __x) { return simd_int(simd_long(__x)); }
-static simd_int4  SIMD_CFUNC simd_int(simd_ulong4   __x) { return simd_int(simd_long(__x)); }
-static simd_int8  SIMD_CFUNC simd_int(simd_ulong8   __x) { return simd_int(simd_long(__x)); }
-static simd_int2  SIMD_CFUNC simd_int(simd_double2  __x) { return __builtin_convertvector(__x, simd_int2); }
-static simd_int3  SIMD_CFUNC simd_int(simd_double3  __x) { return __builtin_convertvector(__x, simd_int3); }
-static simd_int4  SIMD_CFUNC simd_int(simd_double4  __x) { return __builtin_convertvector(__x, simd_int4); }
-static simd_int8  SIMD_CFUNC simd_int(simd_double8  __x) { return __builtin_convertvector(__x, simd_int8); }
-    
-static simd_int2  SIMD_CFUNC simd_int_sat(simd_char2    __x) { return simd_int(__x); }
-static simd_int3  SIMD_CFUNC simd_int_sat(simd_char3    __x) { return simd_int(__x); }
-static simd_int4  SIMD_CFUNC simd_int_sat(simd_char4    __x) { return simd_int(__x); }
-static simd_int8  SIMD_CFUNC simd_int_sat(simd_char8    __x) { return simd_int(__x); }
-static simd_int16 SIMD_CFUNC simd_int_sat(simd_char16   __x) { return simd_int(__x); }
-static simd_int2  SIMD_CFUNC simd_int_sat(simd_short2   __x) { return simd_int(__x); }
-static simd_int3  SIMD_CFUNC simd_int_sat(simd_short3   __x) { return simd_int(__x); }
-static simd_int4  SIMD_CFUNC simd_int_sat(simd_short4   __x) { return simd_int(__x); }
-static simd_int8  SIMD_CFUNC simd_int_sat(simd_short8   __x) { return simd_int(__x); }
-static simd_int16 SIMD_CFUNC simd_int_sat(simd_short16  __x) { return simd_int(__x); }
-static simd_int2  SIMD_CFUNC simd_int_sat(simd_int2     __x) { return __x; }
-static simd_int3  SIMD_CFUNC simd_int_sat(simd_int3     __x) { return __x; }
-static simd_int4  SIMD_CFUNC simd_int_sat(simd_int4     __x) { return __x; }
-static simd_int8  SIMD_CFUNC simd_int_sat(simd_int8     __x) { return __x; }
-static simd_int16 SIMD_CFUNC simd_int_sat(simd_int16    __x) { return __x; }
-static simd_int2  SIMD_CFUNC simd_int_sat(simd_float2   __x) { return simd_bitselect(simd_int(simd_max(__x,-0x1.0p31f)), 0x7fffffff, __x >= 0x1.0p31f); }
-static simd_int3  SIMD_CFUNC simd_int_sat(simd_float3   __x) { return simd_bitselect(simd_int(simd_max(__x,-0x1.0p31f)), 0x7fffffff, __x >= 0x1.0p31f); }
-static simd_int4  SIMD_CFUNC simd_int_sat(simd_float4   __x) { return simd_bitselect(simd_int(simd_max(__x,-0x1.0p31f)), 0x7fffffff, __x >= 0x1.0p31f); }
-static simd_int8  SIMD_CFUNC simd_int_sat(simd_float8   __x) { return simd_bitselect(simd_int(simd_max(__x,-0x1.0p31f)), 0x7fffffff, __x >= 0x1.0p31f); }
-static simd_int16 SIMD_CFUNC simd_int_sat(simd_float16  __x) { return simd_bitselect(simd_int(simd_max(__x,-0x1.0p31f)), 0x7fffffff, __x >= 0x1.0p31f); }
-static simd_int2  SIMD_CFUNC simd_int_sat(simd_long2    __x) { return simd_int(simd_clamp(__x,-0x80000000LL,0x7fffffffLL)); }
-static simd_int3  SIMD_CFUNC simd_int_sat(simd_long3    __x) { return simd_int(simd_clamp(__x,-0x80000000LL,0x7fffffffLL)); }
-static simd_int4  SIMD_CFUNC simd_int_sat(simd_long4    __x) { return simd_int(simd_clamp(__x,-0x80000000LL,0x7fffffffLL)); }
-static simd_int8  SIMD_CFUNC simd_int_sat(simd_long8    __x) { return simd_int(simd_clamp(__x,-0x80000000LL,0x7fffffffLL)); }
-static simd_int2  SIMD_CFUNC simd_int_sat(simd_double2  __x) { return simd_int(simd_clamp(__x,-0x1.0p31,0x1.fffffffcp30)); }
-static simd_int3  SIMD_CFUNC simd_int_sat(simd_double3  __x) { return simd_int(simd_clamp(__x,-0x1.0p31,0x1.fffffffcp30)); }
-static simd_int4  SIMD_CFUNC simd_int_sat(simd_double4  __x) { return simd_int(simd_clamp(__x,-0x1.0p31,0x1.fffffffcp30)); }
-static simd_int8  SIMD_CFUNC simd_int_sat(simd_double8  __x) { return simd_int(simd_clamp(__x,-0x1.0p31,0x1.fffffffcp30)); }
-static simd_int2  SIMD_CFUNC simd_int_sat(simd_uchar2   __x) { return simd_int(__x); }
-static simd_int3  SIMD_CFUNC simd_int_sat(simd_uchar3   __x) { return simd_int(__x); }
-static simd_int4  SIMD_CFUNC simd_int_sat(simd_uchar4   __x) { return simd_int(__x); }
-static simd_int8  SIMD_CFUNC simd_int_sat(simd_uchar8   __x) { return simd_int(__x); }
-static simd_int16 SIMD_CFUNC simd_int_sat(simd_uchar16  __x) { return simd_int(__x); }
-static simd_int2  SIMD_CFUNC simd_int_sat(simd_ushort2  __x) { return simd_int(__x); }
-static simd_int3  SIMD_CFUNC simd_int_sat(simd_ushort3  __x) { return simd_int(__x); }
-static simd_int4  SIMD_CFUNC simd_int_sat(simd_ushort4  __x) { return simd_int(__x); }
-static simd_int8  SIMD_CFUNC simd_int_sat(simd_ushort8  __x) { return simd_int(__x); }
-static simd_int16 SIMD_CFUNC simd_int_sat(simd_ushort16 __x) { return simd_int(__x); }
-static simd_int2  SIMD_CFUNC simd_int_sat(simd_uint2    __x) { return simd_int(simd_min(__x,0x7fffffff)); }
-static simd_int3  SIMD_CFUNC simd_int_sat(simd_uint3    __x) { return simd_int(simd_min(__x,0x7fffffff)); }
-static simd_int4  SIMD_CFUNC simd_int_sat(simd_uint4    __x) { return simd_int(simd_min(__x,0x7fffffff)); }
-static simd_int8  SIMD_CFUNC simd_int_sat(simd_uint8    __x) { return simd_int(simd_min(__x,0x7fffffff)); }
-static simd_int16 SIMD_CFUNC simd_int_sat(simd_uint16   __x) { return simd_int(simd_min(__x,0x7fffffff)); }
-static simd_int2  SIMD_CFUNC simd_int_sat(simd_ulong2   __x) { return simd_int(simd_min(__x,0x7fffffff)); }
-static simd_int3  SIMD_CFUNC simd_int_sat(simd_ulong3   __x) { return simd_int(simd_min(__x,0x7fffffff)); }
-static simd_int4  SIMD_CFUNC simd_int_sat(simd_ulong4   __x) { return simd_int(simd_min(__x,0x7fffffff)); }
-static simd_int8  SIMD_CFUNC simd_int_sat(simd_ulong8   __x) { return simd_int(simd_min(__x,0x7fffffff)); }
-
-static simd_uint2  SIMD_CFUNC simd_uint(simd_char2    __x) { return simd_uint(simd_int(__x)); }
-static simd_uint3  SIMD_CFUNC simd_uint(simd_char3    __x) { return simd_uint(simd_int(__x)); }
-static simd_uint4  SIMD_CFUNC simd_uint(simd_char4    __x) { return simd_uint(simd_int(__x)); }
-static simd_uint8  SIMD_CFUNC simd_uint(simd_char8    __x) { return simd_uint(simd_int(__x)); }
-static simd_uint16 SIMD_CFUNC simd_uint(simd_char16   __x) { return simd_uint(simd_int(__x)); }
-static simd_uint2  SIMD_CFUNC simd_uint(simd_uchar2   __x) { return simd_uint(simd_int(__x)); }
-static simd_uint3  SIMD_CFUNC simd_uint(simd_uchar3   __x) { return simd_uint(simd_int(__x)); }
-static simd_uint4  SIMD_CFUNC simd_uint(simd_uchar4   __x) { return simd_uint(simd_int(__x)); }
-static simd_uint8  SIMD_CFUNC simd_uint(simd_uchar8   __x) { return simd_uint(simd_int(__x)); }
-static simd_uint16 SIMD_CFUNC simd_uint(simd_uchar16  __x) { return simd_uint(simd_int(__x)); }
-static simd_uint2  SIMD_CFUNC simd_uint(simd_short2   __x) { return simd_uint(simd_int(__x)); }
-static simd_uint3  SIMD_CFUNC simd_uint(simd_short3   __x) { return simd_uint(simd_int(__x)); }
-static simd_uint4  SIMD_CFUNC simd_uint(simd_short4   __x) { return simd_uint(simd_int(__x)); }
-static simd_uint8  SIMD_CFUNC simd_uint(simd_short8   __x) { return simd_uint(simd_int(__x)); }
-static simd_uint16 SIMD_CFUNC simd_uint(simd_short16  __x) { return simd_uint(simd_int(__x)); }
-static simd_uint2  SIMD_CFUNC simd_uint(simd_ushort2  __x) { return simd_uint(simd_int(__x)); }
-static simd_uint3  SIMD_CFUNC simd_uint(simd_ushort3  __x) { return simd_uint(simd_int(__x)); }
-static simd_uint4  SIMD_CFUNC simd_uint(simd_ushort4  __x) { return simd_uint(simd_int(__x)); }
-static simd_uint8  SIMD_CFUNC simd_uint(simd_ushort8  __x) { return simd_uint(simd_int(__x)); }
-static simd_uint16 SIMD_CFUNC simd_uint(simd_ushort16 __x) { return simd_uint(simd_int(__x)); }
-static simd_uint2  SIMD_CFUNC simd_uint(simd_int2     __x) { return (simd_uint2)__x; }
-static simd_uint3  SIMD_CFUNC simd_uint(simd_int3     __x) { return (simd_uint3)__x; }
-static simd_uint4  SIMD_CFUNC simd_uint(simd_int4     __x) { return (simd_uint4)__x; }
-static simd_uint8  SIMD_CFUNC simd_uint(simd_int8     __x) { return (simd_uint8)__x; }
-static simd_uint16 SIMD_CFUNC simd_uint(simd_int16    __x) { return (simd_uint16)__x; }
-static simd_uint2  SIMD_CFUNC simd_uint(simd_uint2    __x) { return __x; }
-static simd_uint3  SIMD_CFUNC simd_uint(simd_uint3    __x) { return __x; }
-static simd_uint4  SIMD_CFUNC simd_uint(simd_uint4    __x) { return __x; }
-static simd_uint8  SIMD_CFUNC simd_uint(simd_uint8    __x) { return __x; }
-static simd_uint16 SIMD_CFUNC simd_uint(simd_uint16   __x) { return __x; }
-static simd_uint2  SIMD_CFUNC simd_uint(simd_float2   __x) { simd_int2  __big = __x > 0x1.0p31f; return simd_uint(simd_int(__x - simd_bitselect((simd_float2)0,0x1.0p31f,__big))) + simd_bitselect((simd_uint2)0,0x80000000,__big); }
-static simd_uint3  SIMD_CFUNC simd_uint(simd_float3   __x) { simd_int3  __big = __x > 0x1.0p31f; return simd_uint(simd_int(__x - simd_bitselect((simd_float3)0,0x1.0p31f,__big))) + simd_bitselect((simd_uint3)0,0x80000000,__big); }
-static simd_uint4  SIMD_CFUNC simd_uint(simd_float4   __x) { simd_int4  __big = __x > 0x1.0p31f; return simd_uint(simd_int(__x - simd_bitselect((simd_float4)0,0x1.0p31f,__big))) + simd_bitselect((simd_uint4)0,0x80000000,__big); }
-static simd_uint8  SIMD_CFUNC simd_uint(simd_float8   __x) { simd_int8  __big = __x > 0x1.0p31f; return simd_uint(simd_int(__x - simd_bitselect((simd_float8)0,0x1.0p31f,__big))) + simd_bitselect((simd_uint8)0,0x80000000,__big); }
-static simd_uint16 SIMD_CFUNC simd_uint(simd_float16  __x) { simd_int16 __big = __x > 0x1.0p31f; return simd_uint(simd_int(__x - simd_bitselect((simd_float16)0,0x1.0p31f,__big))) + simd_bitselect((simd_uint16)0,0x80000000,__big); }
-static simd_uint2  SIMD_CFUNC simd_uint(simd_long2    __x) { return simd_uint(simd_int(__x)); }
-static simd_uint3  SIMD_CFUNC simd_uint(simd_long3    __x) { return simd_uint(simd_int(__x)); }
-static simd_uint4  SIMD_CFUNC simd_uint(simd_long4    __x) { return simd_uint(simd_int(__x)); }
-static simd_uint8  SIMD_CFUNC simd_uint(simd_long8    __x) { return simd_uint(simd_int(__x)); }
-static simd_uint2  SIMD_CFUNC simd_uint(simd_ulong2   __x) { return simd_uint(simd_int(__x)); }
-static simd_uint3  SIMD_CFUNC simd_uint(simd_ulong3   __x) { return simd_uint(simd_int(__x)); }
-static simd_uint4  SIMD_CFUNC simd_uint(simd_ulong4   __x) { return simd_uint(simd_int(__x)); }
-static simd_uint8  SIMD_CFUNC simd_uint(simd_ulong8   __x) { return simd_uint(simd_int(__x)); }
-static simd_uint2  SIMD_CFUNC simd_uint(simd_double2  __x) { simd_long2 __big = __x > 0x1.fffffffcp30; return simd_uint(simd_int(__x - simd_bitselect((simd_double2)0,0x1.0p31,__big))) + simd_bitselect((simd_uint2)0,0x80000000,simd_int(__big)); }
-static simd_uint3  SIMD_CFUNC simd_uint(simd_double3  __x) { simd_long3 __big = __x > 0x1.fffffffcp30; return simd_uint(simd_int(__x - simd_bitselect((simd_double3)0,0x1.0p31,__big))) + simd_bitselect((simd_uint3)0,0x80000000,simd_int(__big)); }
-static simd_uint4  SIMD_CFUNC simd_uint(simd_double4  __x) { simd_long4 __big = __x > 0x1.fffffffcp30; return simd_uint(simd_int(__x - simd_bitselect((simd_double4)0,0x1.0p31,__big))) + simd_bitselect((simd_uint4)0,0x80000000,simd_int(__big)); }
-static simd_uint8  SIMD_CFUNC simd_uint(simd_double8  __x) { simd_long8 __big = __x > 0x1.fffffffcp30; return simd_uint(simd_int(__x - simd_bitselect((simd_double8)0,0x1.0p31,__big))) + simd_bitselect((simd_uint8)0,0x80000000,simd_int(__big)); }
-    
-static simd_uint2  SIMD_CFUNC simd_uint_sat(simd_char2    __x) { return simd_uint(simd_max(__x,0)); }
-static simd_uint3  SIMD_CFUNC simd_uint_sat(simd_char3    __x) { return simd_uint(simd_max(__x,0)); }
-static simd_uint4  SIMD_CFUNC simd_uint_sat(simd_char4    __x) { return simd_uint(simd_max(__x,0)); }
-static simd_uint8  SIMD_CFUNC simd_uint_sat(simd_char8    __x) { return simd_uint(simd_max(__x,0)); }
-static simd_uint16 SIMD_CFUNC simd_uint_sat(simd_char16   __x) { return simd_uint(simd_max(__x,0)); }
-static simd_uint2  SIMD_CFUNC simd_uint_sat(simd_short2   __x) { return simd_uint(simd_max(__x,0)); }
-static simd_uint3  SIMD_CFUNC simd_uint_sat(simd_short3   __x) { return simd_uint(simd_max(__x,0)); }
-static simd_uint4  SIMD_CFUNC simd_uint_sat(simd_short4   __x) { return simd_uint(simd_max(__x,0)); }
-static simd_uint8  SIMD_CFUNC simd_uint_sat(simd_short8   __x) { return simd_uint(simd_max(__x,0)); }
-static simd_uint16 SIMD_CFUNC simd_uint_sat(simd_short16  __x) { return simd_uint(simd_max(__x,0)); }
-static simd_uint2  SIMD_CFUNC simd_uint_sat(simd_int2     __x) { return simd_uint(simd_max(__x,0)); }
-static simd_uint3  SIMD_CFUNC simd_uint_sat(simd_int3     __x) { return simd_uint(simd_max(__x,0)); }
-static simd_uint4  SIMD_CFUNC simd_uint_sat(simd_int4     __x) { return simd_uint(simd_max(__x,0)); }
-static simd_uint8  SIMD_CFUNC simd_uint_sat(simd_int8     __x) { return simd_uint(simd_max(__x,0)); }
-static simd_uint16 SIMD_CFUNC simd_uint_sat(simd_int16    __x) { return simd_uint(simd_max(__x,0)); }
-static simd_uint2  SIMD_CFUNC simd_uint_sat(simd_float2   __x) { return simd_bitselect(simd_uint(simd_max(__x,0)), 0xffffffff, __x >= 0x1.0p32f); }
-static simd_uint3  SIMD_CFUNC simd_uint_sat(simd_float3   __x) { return simd_bitselect(simd_uint(simd_max(__x,0)), 0xffffffff, __x >= 0x1.0p32f); }
-static simd_uint4  SIMD_CFUNC simd_uint_sat(simd_float4   __x) { return simd_bitselect(simd_uint(simd_max(__x,0)), 0xffffffff, __x >= 0x1.0p32f); }
-static simd_uint8  SIMD_CFUNC simd_uint_sat(simd_float8   __x) { return simd_bitselect(simd_uint(simd_max(__x,0)), 0xffffffff, __x >= 0x1.0p32f); }
-static simd_uint16 SIMD_CFUNC simd_uint_sat(simd_float16  __x) { return simd_bitselect(simd_uint(simd_max(__x,0)), 0xffffffff, __x >= 0x1.0p32f); }
-static simd_uint2  SIMD_CFUNC simd_uint_sat(simd_long2    __x) { return simd_uint(simd_clamp(__x,0,0xffffffff)); }
-static simd_uint3  SIMD_CFUNC simd_uint_sat(simd_long3    __x) { return simd_uint(simd_clamp(__x,0,0xffffffff)); }
-static simd_uint4  SIMD_CFUNC simd_uint_sat(simd_long4    __x) { return simd_uint(simd_clamp(__x,0,0xffffffff)); }
-static simd_uint8  SIMD_CFUNC simd_uint_sat(simd_long8    __x) { return simd_uint(simd_clamp(__x,0,0xffffffff)); }
-static simd_uint2  SIMD_CFUNC simd_uint_sat(simd_double2  __x) { return simd_uint(simd_clamp(__x,0,0xffffffff)); }
-static simd_uint3  SIMD_CFUNC simd_uint_sat(simd_double3  __x) { return simd_uint(simd_clamp(__x,0,0xffffffff)); }
-static simd_uint4  SIMD_CFUNC simd_uint_sat(simd_double4  __x) { return simd_uint(simd_clamp(__x,0,0xffffffff)); }
-static simd_uint8  SIMD_CFUNC simd_uint_sat(simd_double8  __x) { return simd_uint(simd_clamp(__x,0,0xffffffff)); }
-static simd_uint2  SIMD_CFUNC simd_uint_sat(simd_uchar2   __x) { return simd_uint(__x); }
-static simd_uint3  SIMD_CFUNC simd_uint_sat(simd_uchar3   __x) { return simd_uint(__x); }
-static simd_uint4  SIMD_CFUNC simd_uint_sat(simd_uchar4   __x) { return simd_uint(__x); }
-static simd_uint8  SIMD_CFUNC simd_uint_sat(simd_uchar8   __x) { return simd_uint(__x); }
-static simd_uint16 SIMD_CFUNC simd_uint_sat(simd_uchar16  __x) { return simd_uint(__x); }
-static simd_uint2  SIMD_CFUNC simd_uint_sat(simd_ushort2  __x) { return simd_uint(__x); }
-static simd_uint3  SIMD_CFUNC simd_uint_sat(simd_ushort3  __x) { return simd_uint(__x); }
-static simd_uint4  SIMD_CFUNC simd_uint_sat(simd_ushort4  __x) { return simd_uint(__x); }
-static simd_uint8  SIMD_CFUNC simd_uint_sat(simd_ushort8  __x) { return simd_uint(__x); }
-static simd_uint16 SIMD_CFUNC simd_uint_sat(simd_ushort16 __x) { return simd_uint(__x); }
-static simd_uint2  SIMD_CFUNC simd_uint_sat(simd_uint2    __x) { return __x; }
-static simd_uint3  SIMD_CFUNC simd_uint_sat(simd_uint3    __x) { return __x; }
-static simd_uint4  SIMD_CFUNC simd_uint_sat(simd_uint4    __x) { return __x; }
-static simd_uint8  SIMD_CFUNC simd_uint_sat(simd_uint8    __x) { return __x; }
-static simd_uint16 SIMD_CFUNC simd_uint_sat(simd_uint16   __x) { return __x; }
-static simd_uint2  SIMD_CFUNC simd_uint_sat(simd_ulong2   __x) { return simd_uint(simd_clamp(__x,0,0xffffffff)); }
-static simd_uint3  SIMD_CFUNC simd_uint_sat(simd_ulong3   __x) { return simd_uint(simd_clamp(__x,0,0xffffffff)); }
-static simd_uint4  SIMD_CFUNC simd_uint_sat(simd_ulong4   __x) { return simd_uint(simd_clamp(__x,0,0xffffffff)); }
-static simd_uint8  SIMD_CFUNC simd_uint_sat(simd_ulong8   __x) { return simd_uint(simd_clamp(__x,0,0xffffffff)); }
-
-static simd_float2  SIMD_CFUNC simd_float(simd_char2    __x) { return (simd_float2)(simd_int(__x) + 0x4b400000) - 0x1.8p23f; }
-static simd_float3  SIMD_CFUNC simd_float(simd_char3    __x) { return (simd_float3)(simd_int(__x) + 0x4b400000) - 0x1.8p23f; }
-static simd_float4  SIMD_CFUNC simd_float(simd_char4    __x) { return (simd_float4)(simd_int(__x) + 0x4b400000) - 0x1.8p23f; }
-static simd_float8  SIMD_CFUNC simd_float(simd_char8    __x) { return (simd_float8)(simd_int(__x) + 0x4b400000) - 0x1.8p23f; }
-static simd_float16 SIMD_CFUNC simd_float(simd_char16   __x) { return (simd_float16)(simd_int(__x) + 0x4b400000) - 0x1.8p23f; }
-static simd_float2  SIMD_CFUNC simd_float(simd_uchar2   __x) { return (simd_float2)(simd_int(__x) + 0x4b400000) - 0x1.8p23f; }
-static simd_float3  SIMD_CFUNC simd_float(simd_uchar3   __x) { return (simd_float3)(simd_int(__x) + 0x4b400000) - 0x1.8p23f; }
-static simd_float4  SIMD_CFUNC simd_float(simd_uchar4   __x) { return (simd_float4)(simd_int(__x) + 0x4b400000) - 0x1.8p23f; }
-static simd_float8  SIMD_CFUNC simd_float(simd_uchar8   __x) { return (simd_float8)(simd_int(__x) + 0x4b400000) - 0x1.8p23f; }
-static simd_float16 SIMD_CFUNC simd_float(simd_uchar16  __x) { return (simd_float16)(simd_int(__x) + 0x4b400000) - 0x1.8p23f; }
-static simd_float2  SIMD_CFUNC simd_float(simd_short2   __x) { return (simd_float2)(simd_int(__x) + 0x4b400000) - 0x1.8p23f; }
-static simd_float3  SIMD_CFUNC simd_float(simd_short3   __x) { return (simd_float3)(simd_int(__x) + 0x4b400000) - 0x1.8p23f; }
-static simd_float4  SIMD_CFUNC simd_float(simd_short4   __x) { return (simd_float4)(simd_int(__x) + 0x4b400000) - 0x1.8p23f; }
-static simd_float8  SIMD_CFUNC simd_float(simd_short8   __x) { return (simd_float8)(simd_int(__x) + 0x4b400000) - 0x1.8p23f; }
-static simd_float16 SIMD_CFUNC simd_float(simd_short16  __x) { return (simd_float16)(simd_int(__x) + 0x4b400000) - 0x1.8p23f; }
-static simd_float2  SIMD_CFUNC simd_float(simd_ushort2  __x) { return (simd_float2)(simd_int(__x) + 0x4b400000) - 0x1.8p23f; }
-static simd_float3  SIMD_CFUNC simd_float(simd_ushort3  __x) { return (simd_float3)(simd_int(__x) + 0x4b400000) - 0x1.8p23f; }
-static simd_float4  SIMD_CFUNC simd_float(simd_ushort4  __x) { return (simd_float4)(simd_int(__x) + 0x4b400000) - 0x1.8p23f; }
-static simd_float8  SIMD_CFUNC simd_float(simd_ushort8  __x) { return (simd_float8)(simd_int(__x) + 0x4b400000) - 0x1.8p23f; }
-static simd_float16 SIMD_CFUNC simd_float(simd_ushort16 __x) { return (simd_float16)(simd_int(__x) + 0x4b400000) - 0x1.8p23f; }
-static simd_float2  SIMD_CFUNC simd_float(simd_int2     __x) { return __builtin_convertvector(__x,simd_float2); }
-static simd_float3  SIMD_CFUNC simd_float(simd_int3     __x) { return __builtin_convertvector(__x,simd_float3); }
-static simd_float4  SIMD_CFUNC simd_float(simd_int4     __x) { return __builtin_convertvector(__x,simd_float4); }
-static simd_float8  SIMD_CFUNC simd_float(simd_int8     __x) { return __builtin_convertvector(__x,simd_float8); }
-static simd_float16 SIMD_CFUNC simd_float(simd_int16    __x) { return __builtin_convertvector(__x,simd_float16); }
-static simd_float2  SIMD_CFUNC simd_float(simd_uint2    __x) { return __builtin_convertvector(__x,simd_float2); }
-static simd_float3  SIMD_CFUNC simd_float(simd_uint3    __x) { return __builtin_convertvector(__x,simd_float3); }
-static simd_float4  SIMD_CFUNC simd_float(simd_uint4    __x) { return __builtin_convertvector(__x,simd_float4); }
-static simd_float8  SIMD_CFUNC simd_float(simd_uint8    __x) { return __builtin_convertvector(__x,simd_float8); }
-static simd_float16 SIMD_CFUNC simd_float(simd_uint16   __x) { return __builtin_convertvector(__x,simd_float16); }
-static simd_float2  SIMD_CFUNC simd_float(simd_float2   __x) { return __x; }
-static simd_float3  SIMD_CFUNC simd_float(simd_float3   __x) { return __x; }
-static simd_float4  SIMD_CFUNC simd_float(simd_float4   __x) { return __x; }
-static simd_float8  SIMD_CFUNC simd_float(simd_float8   __x) { return __x; }
-static simd_float16 SIMD_CFUNC simd_float(simd_float16  __x) { return __x; }
-static simd_float2  SIMD_CFUNC simd_float(simd_long2    __x) { return __builtin_convertvector(__x,simd_float2); }
-static simd_float3  SIMD_CFUNC simd_float(simd_long3    __x) { return __builtin_convertvector(__x,simd_float3); }
-static simd_float4  SIMD_CFUNC simd_float(simd_long4    __x) { return __builtin_convertvector(__x,simd_float4); }
-static simd_float8  SIMD_CFUNC simd_float(simd_long8    __x) { return __builtin_convertvector(__x,simd_float8); }
-static simd_float2  SIMD_CFUNC simd_float(simd_ulong2   __x) { return __builtin_convertvector(__x,simd_float2); }
-static simd_float3  SIMD_CFUNC simd_float(simd_ulong3   __x) { return __builtin_convertvector(__x,simd_float3); }
-static simd_float4  SIMD_CFUNC simd_float(simd_ulong4   __x) { return __builtin_convertvector(__x,simd_float4); }
-static simd_float8  SIMD_CFUNC simd_float(simd_ulong8   __x) { return __builtin_convertvector(__x,simd_float8); }
-static simd_float2  SIMD_CFUNC simd_float(simd_double2  __x) { return __builtin_convertvector(__x,simd_float2); }
-static simd_float3  SIMD_CFUNC simd_float(simd_double3  __x) { return __builtin_convertvector(__x,simd_float3); }
-static simd_float4  SIMD_CFUNC simd_float(simd_double4  __x) { return __builtin_convertvector(__x,simd_float4); }
-static simd_float8  SIMD_CFUNC simd_float(simd_double8  __x) { return __builtin_convertvector(__x,simd_float8); }
-
-static simd_long2  SIMD_CFUNC simd_long(simd_char2    __x) { return __builtin_convertvector(__x,simd_long2); }
-static simd_long3  SIMD_CFUNC simd_long(simd_char3    __x) { return __builtin_convertvector(__x,simd_long3); }
-static simd_long4  SIMD_CFUNC simd_long(simd_char4    __x) { return __builtin_convertvector(__x,simd_long4); }
-static simd_long8  SIMD_CFUNC simd_long(simd_char8    __x) { return __builtin_convertvector(__x,simd_long8); }
-static simd_long2  SIMD_CFUNC simd_long(simd_uchar2   __x) { return __builtin_convertvector(__x,simd_long2); }
-static simd_long3  SIMD_CFUNC simd_long(simd_uchar3   __x) { return __builtin_convertvector(__x,simd_long3); }
-static simd_long4  SIMD_CFUNC simd_long(simd_uchar4   __x) { return __builtin_convertvector(__x,simd_long4); }
-static simd_long8  SIMD_CFUNC simd_long(simd_uchar8   __x) { return __builtin_convertvector(__x,simd_long8); }
-static simd_long2  SIMD_CFUNC simd_long(simd_short2   __x) { return __builtin_convertvector(__x,simd_long2); }
-static simd_long3  SIMD_CFUNC simd_long(simd_short3   __x) { return __builtin_convertvector(__x,simd_long3); }
-static simd_long4  SIMD_CFUNC simd_long(simd_short4   __x) { return __builtin_convertvector(__x,simd_long4); }
-static simd_long8  SIMD_CFUNC simd_long(simd_short8   __x) { return __builtin_convertvector(__x,simd_long8); }
-static simd_long2  SIMD_CFUNC simd_long(simd_ushort2  __x) { return __builtin_convertvector(__x,simd_long2); }
-static simd_long3  SIMD_CFUNC simd_long(simd_ushort3  __x) { return __builtin_convertvector(__x,simd_long3); }
-static simd_long4  SIMD_CFUNC simd_long(simd_ushort4  __x) { return __builtin_convertvector(__x,simd_long4); }
-static simd_long8  SIMD_CFUNC simd_long(simd_ushort8  __x) { return __builtin_convertvector(__x,simd_long8); }
-static simd_long2  SIMD_CFUNC simd_long(simd_int2     __x) { return __builtin_convertvector(__x,simd_long2); }
-static simd_long3  SIMD_CFUNC simd_long(simd_int3     __x) { return __builtin_convertvector(__x,simd_long3); }
-static simd_long4  SIMD_CFUNC simd_long(simd_int4     __x) { return __builtin_convertvector(__x,simd_long4); }
-static simd_long8  SIMD_CFUNC simd_long(simd_int8     __x) { return __builtin_convertvector(__x,simd_long8); }
-static simd_long2  SIMD_CFUNC simd_long(simd_uint2    __x) { return __builtin_convertvector(__x,simd_long2); }
-static simd_long3  SIMD_CFUNC simd_long(simd_uint3    __x) { return __builtin_convertvector(__x,simd_long3); }
-static simd_long4  SIMD_CFUNC simd_long(simd_uint4    __x) { return __builtin_convertvector(__x,simd_long4); }
-static simd_long8  SIMD_CFUNC simd_long(simd_uint8    __x) { return __builtin_convertvector(__x,simd_long8); }
-static simd_long2  SIMD_CFUNC simd_long(simd_float2   __x) { return __builtin_convertvector(__x,simd_long2); }
-static simd_long3  SIMD_CFUNC simd_long(simd_float3   __x) { return __builtin_convertvector(__x,simd_long3); }
-static simd_long4  SIMD_CFUNC simd_long(simd_float4   __x) { return __builtin_convertvector(__x,simd_long4); }
-static simd_long8  SIMD_CFUNC simd_long(simd_float8   __x) { return __builtin_convertvector(__x,simd_long8); }
-static simd_long2  SIMD_CFUNC simd_long(simd_long2    __x) { return __x; }
-static simd_long3  SIMD_CFUNC simd_long(simd_long3    __x) { return __x; }
-static simd_long4  SIMD_CFUNC simd_long(simd_long4    __x) { return __x; }
-static simd_long8  SIMD_CFUNC simd_long(simd_long8    __x) { return __x; }
-static simd_long2  SIMD_CFUNC simd_long(simd_ulong2   __x) { return (simd_long2)__x; }
-static simd_long3  SIMD_CFUNC simd_long(simd_ulong3   __x) { return (simd_long3)__x; }
-static simd_long4  SIMD_CFUNC simd_long(simd_ulong4   __x) { return (simd_long4)__x; }
-static simd_long8  SIMD_CFUNC simd_long(simd_ulong8   __x) { return (simd_long8)__x; }
-static simd_long2  SIMD_CFUNC simd_long(simd_double2  __x) { return __builtin_convertvector(__x,simd_long2); }
-static simd_long3  SIMD_CFUNC simd_long(simd_double3  __x) { return __builtin_convertvector(__x,simd_long3); }
-static simd_long4  SIMD_CFUNC simd_long(simd_double4  __x) { return __builtin_convertvector(__x,simd_long4); }
-static simd_long8  SIMD_CFUNC simd_long(simd_double8  __x) { return __builtin_convertvector(__x,simd_long8); }
-    
-static simd_long2  SIMD_CFUNC simd_long_sat(simd_char2    __x) { return simd_long(__x); }
-static simd_long3  SIMD_CFUNC simd_long_sat(simd_char3    __x) { return simd_long(__x); }
-static simd_long4  SIMD_CFUNC simd_long_sat(simd_char4    __x) { return simd_long(__x); }
-static simd_long8  SIMD_CFUNC simd_long_sat(simd_char8    __x) { return simd_long(__x); }
-static simd_long2  SIMD_CFUNC simd_long_sat(simd_short2   __x) { return simd_long(__x); }
-static simd_long3  SIMD_CFUNC simd_long_sat(simd_short3   __x) { return simd_long(__x); }
-static simd_long4  SIMD_CFUNC simd_long_sat(simd_short4   __x) { return simd_long(__x); }
-static simd_long8  SIMD_CFUNC simd_long_sat(simd_short8   __x) { return simd_long(__x); }
-static simd_long2  SIMD_CFUNC simd_long_sat(simd_int2     __x) { return simd_long(__x); }
-static simd_long3  SIMD_CFUNC simd_long_sat(simd_int3     __x) { return simd_long(__x); }
-static simd_long4  SIMD_CFUNC simd_long_sat(simd_int4     __x) { return simd_long(__x); }
-static simd_long8  SIMD_CFUNC simd_long_sat(simd_int8     __x) { return simd_long(__x); }
-static simd_long2  SIMD_CFUNC simd_long_sat(simd_float2   __x) { return simd_bitselect(simd_long(simd_max(__x,-0x1.0p63f)), 0x7fffffffffffffff, simd_long(__x >= 0x1.0p63f)); }
-static simd_long3  SIMD_CFUNC simd_long_sat(simd_float3   __x) { return simd_bitselect(simd_long(simd_max(__x,-0x1.0p63f)), 0x7fffffffffffffff, simd_long(__x >= 0x1.0p63f)); }
-static simd_long4  SIMD_CFUNC simd_long_sat(simd_float4   __x) { return simd_bitselect(simd_long(simd_max(__x,-0x1.0p63f)), 0x7fffffffffffffff, simd_long(__x >= 0x1.0p63f)); }
-static simd_long8  SIMD_CFUNC simd_long_sat(simd_float8   __x) { return simd_bitselect(simd_long(simd_max(__x,-0x1.0p63f)), 0x7fffffffffffffff, simd_long(__x >= 0x1.0p63f)); }
-static simd_long2  SIMD_CFUNC simd_long_sat(simd_long2    __x) { return __x; }
-static simd_long3  SIMD_CFUNC simd_long_sat(simd_long3    __x) { return __x; }
-static simd_long4  SIMD_CFUNC simd_long_sat(simd_long4    __x) { return __x; }
-static simd_long8  SIMD_CFUNC simd_long_sat(simd_long8    __x) { return __x; }
-static simd_long2  SIMD_CFUNC simd_long_sat(simd_double2  __x) { return simd_bitselect(simd_long(simd_max(__x,-0x1.0p63)), 0x7fffffffffffffff, __x >= 0x1.0p63); }
-static simd_long3  SIMD_CFUNC simd_long_sat(simd_double3  __x) { return simd_bitselect(simd_long(simd_max(__x,-0x1.0p63)), 0x7fffffffffffffff, __x >= 0x1.0p63); }
-static simd_long4  SIMD_CFUNC simd_long_sat(simd_double4  __x) { return simd_bitselect(simd_long(simd_max(__x,-0x1.0p63)), 0x7fffffffffffffff, __x >= 0x1.0p63); }
-static simd_long8  SIMD_CFUNC simd_long_sat(simd_double8  __x) { return simd_bitselect(simd_long(simd_max(__x,-0x1.0p63)), 0x7fffffffffffffff, __x >= 0x1.0p63); }
-static simd_long2  SIMD_CFUNC simd_long_sat(simd_uchar2   __x) { return simd_long(__x); }
-static simd_long3  SIMD_CFUNC simd_long_sat(simd_uchar3   __x) { return simd_long(__x); }
-static simd_long4  SIMD_CFUNC simd_long_sat(simd_uchar4   __x) { return simd_long(__x); }
-static simd_long8  SIMD_CFUNC simd_long_sat(simd_uchar8   __x) { return simd_long(__x); }
-static simd_long2  SIMD_CFUNC simd_long_sat(simd_ushort2  __x) { return simd_long(__x); }
-static simd_long3  SIMD_CFUNC simd_long_sat(simd_ushort3  __x) { return simd_long(__x); }
-static simd_long4  SIMD_CFUNC simd_long_sat(simd_ushort4  __x) { return simd_long(__x); }
-static simd_long8  SIMD_CFUNC simd_long_sat(simd_ushort8  __x) { return simd_long(__x); }
-static simd_long2  SIMD_CFUNC simd_long_sat(simd_uint2    __x) { return simd_long(__x); }
-static simd_long3  SIMD_CFUNC simd_long_sat(simd_uint3    __x) { return simd_long(__x); }
-static simd_long4  SIMD_CFUNC simd_long_sat(simd_uint4    __x) { return simd_long(__x); }
-static simd_long8  SIMD_CFUNC simd_long_sat(simd_uint8    __x) { return simd_long(__x); }
-static simd_long2  SIMD_CFUNC simd_long_sat(simd_ulong2   __x) { return simd_long(simd_min(__x,0x7fffffffffffffff)); }
-static simd_long3  SIMD_CFUNC simd_long_sat(simd_ulong3   __x) { return simd_long(simd_min(__x,0x7fffffffffffffff)); }
-static simd_long4  SIMD_CFUNC simd_long_sat(simd_ulong4   __x) { return simd_long(simd_min(__x,0x7fffffffffffffff)); }
-static simd_long8  SIMD_CFUNC simd_long_sat(simd_ulong8   __x) { return simd_long(simd_min(__x,0x7fffffffffffffff)); }
-
-static simd_ulong2  SIMD_CFUNC simd_ulong(simd_char2    __x) { return simd_ulong(simd_long(__x)); }
-static simd_ulong3  SIMD_CFUNC simd_ulong(simd_char3    __x) { return simd_ulong(simd_long(__x)); }
-static simd_ulong4  SIMD_CFUNC simd_ulong(simd_char4    __x) { return simd_ulong(simd_long(__x)); }
-static simd_ulong8  SIMD_CFUNC simd_ulong(simd_char8    __x) { return simd_ulong(simd_long(__x)); }
-static simd_ulong2  SIMD_CFUNC simd_ulong(simd_uchar2   __x) { return simd_ulong(simd_long(__x)); }
-static simd_ulong3  SIMD_CFUNC simd_ulong(simd_uchar3   __x) { return simd_ulong(simd_long(__x)); }
-static simd_ulong4  SIMD_CFUNC simd_ulong(simd_uchar4   __x) { return simd_ulong(simd_long(__x)); }
-static simd_ulong8  SIMD_CFUNC simd_ulong(simd_uchar8   __x) { return simd_ulong(simd_long(__x)); }
-static simd_ulong2  SIMD_CFUNC simd_ulong(simd_short2   __x) { return simd_ulong(simd_long(__x)); }
-static simd_ulong3  SIMD_CFUNC simd_ulong(simd_short3   __x) { return simd_ulong(simd_long(__x)); }
-static simd_ulong4  SIMD_CFUNC simd_ulong(simd_short4   __x) { return simd_ulong(simd_long(__x)); }
-static simd_ulong8  SIMD_CFUNC simd_ulong(simd_short8   __x) { return simd_ulong(simd_long(__x)); }
-static simd_ulong2  SIMD_CFUNC simd_ulong(simd_ushort2  __x) { return simd_ulong(simd_long(__x)); }
-static simd_ulong3  SIMD_CFUNC simd_ulong(simd_ushort3  __x) { return simd_ulong(simd_long(__x)); }
-static simd_ulong4  SIMD_CFUNC simd_ulong(simd_ushort4  __x) { return simd_ulong(simd_long(__x)); }
-static simd_ulong8  SIMD_CFUNC simd_ulong(simd_ushort8  __x) { return simd_ulong(simd_long(__x)); }
-static simd_ulong2  SIMD_CFUNC simd_ulong(simd_int2     __x) { return simd_ulong(simd_long(__x)); }
-static simd_ulong3  SIMD_CFUNC simd_ulong(simd_int3     __x) { return simd_ulong(simd_long(__x)); }
-static simd_ulong4  SIMD_CFUNC simd_ulong(simd_int4     __x) { return simd_ulong(simd_long(__x)); }
-static simd_ulong8  SIMD_CFUNC simd_ulong(simd_int8     __x) { return simd_ulong(simd_long(__x)); }
-static simd_ulong2  SIMD_CFUNC simd_ulong(simd_uint2    __x) { return simd_ulong(simd_long(__x)); }
-static simd_ulong3  SIMD_CFUNC simd_ulong(simd_uint3    __x) { return simd_ulong(simd_long(__x)); }
-static simd_ulong4  SIMD_CFUNC simd_ulong(simd_uint4    __x) { return simd_ulong(simd_long(__x)); }
-static simd_ulong8  SIMD_CFUNC simd_ulong(simd_uint8    __x) { return simd_ulong(simd_long(__x)); }
-static simd_ulong2  SIMD_CFUNC simd_ulong(simd_float2   __x) { simd_int2 __big = __x >= 0x1.0p63f; return simd_ulong(simd_long(__x - simd_bitselect((simd_float2)0,0x1.0p63f,__big))) + simd_bitselect((simd_ulong2)0,0x8000000000000000,simd_long(__big)); }
-static simd_ulong3  SIMD_CFUNC simd_ulong(simd_float3   __x) { simd_int3 __big = __x >= 0x1.0p63f; return simd_ulong(simd_long(__x - simd_bitselect((simd_float3)0,0x1.0p63f,__big))) + simd_bitselect((simd_ulong3)0,0x8000000000000000,simd_long(__big)); }
-static simd_ulong4  SIMD_CFUNC simd_ulong(simd_float4   __x) { simd_int4 __big = __x >= 0x1.0p63f; return simd_ulong(simd_long(__x - simd_bitselect((simd_float4)0,0x1.0p63f,__big))) + simd_bitselect((simd_ulong4)0,0x8000000000000000,simd_long(__big)); }
-static simd_ulong8  SIMD_CFUNC simd_ulong(simd_float8   __x) { simd_int8 __big = __x >= 0x1.0p63f; return simd_ulong(simd_long(__x - simd_bitselect((simd_float8)0,0x1.0p63f,__big))) + simd_bitselect((simd_ulong8)0,0x8000000000000000,simd_long(__big)); }
-static simd_ulong2  SIMD_CFUNC simd_ulong(simd_long2    __x) { return (simd_ulong2)__x; }
-static simd_ulong3  SIMD_CFUNC simd_ulong(simd_long3    __x) { return (simd_ulong3)__x; }
-static simd_ulong4  SIMD_CFUNC simd_ulong(simd_long4    __x) { return (simd_ulong4)__x; }
-static simd_ulong8  SIMD_CFUNC simd_ulong(simd_long8    __x) { return (simd_ulong8)__x; }
-static simd_ulong2  SIMD_CFUNC simd_ulong(simd_ulong2   __x) { return __x; }
-static simd_ulong3  SIMD_CFUNC simd_ulong(simd_ulong3   __x) { return __x; }
-static simd_ulong4  SIMD_CFUNC simd_ulong(simd_ulong4   __x) { return __x; }
-static simd_ulong8  SIMD_CFUNC simd_ulong(simd_ulong8   __x) { return __x; }
-static simd_ulong2  SIMD_CFUNC simd_ulong(simd_double2  __x) { simd_long2 __big = __x >= 0x1.0p63; return simd_ulong(simd_long(__x - simd_bitselect((simd_double2)0,0x1.0p63,__big))) + simd_bitselect((simd_ulong2)0,0x8000000000000000,__big); }
-static simd_ulong3  SIMD_CFUNC simd_ulong(simd_double3  __x) { simd_long3 __big = __x >= 0x1.0p63; return simd_ulong(simd_long(__x - simd_bitselect((simd_double3)0,0x1.0p63,__big))) + simd_bitselect((simd_ulong3)0,0x8000000000000000,__big); }
-static simd_ulong4  SIMD_CFUNC simd_ulong(simd_double4  __x) { simd_long4 __big = __x >= 0x1.0p63; return simd_ulong(simd_long(__x - simd_bitselect((simd_double4)0,0x1.0p63,__big))) + simd_bitselect((simd_ulong4)0,0x8000000000000000,__big); }
-static simd_ulong8  SIMD_CFUNC simd_ulong(simd_double8  __x) { simd_long8 __big = __x >= 0x1.0p63; return simd_ulong(simd_long(__x - simd_bitselect((simd_double8)0,0x1.0p63,__big))) + simd_bitselect((simd_ulong8)0,0x8000000000000000,__big); }
-    
-static simd_ulong2  SIMD_CFUNC simd_ulong_sat(simd_char2    __x) { return simd_ulong(simd_max(__x,0)); }
-static simd_ulong3  SIMD_CFUNC simd_ulong_sat(simd_char3    __x) { return simd_ulong(simd_max(__x,0)); }
-static simd_ulong4  SIMD_CFUNC simd_ulong_sat(simd_char4    __x) { return simd_ulong(simd_max(__x,0)); }
-static simd_ulong8  SIMD_CFUNC simd_ulong_sat(simd_char8    __x) { return simd_ulong(simd_max(__x,0)); }
-static simd_ulong2  SIMD_CFUNC simd_ulong_sat(simd_short2   __x) { return simd_ulong(simd_max(__x,0)); }
-static simd_ulong3  SIMD_CFUNC simd_ulong_sat(simd_short3   __x) { return simd_ulong(simd_max(__x,0)); }
-static simd_ulong4  SIMD_CFUNC simd_ulong_sat(simd_short4   __x) { return simd_ulong(simd_max(__x,0)); }
-static simd_ulong8  SIMD_CFUNC simd_ulong_sat(simd_short8   __x) { return simd_ulong(simd_max(__x,0)); }
-static simd_ulong2  SIMD_CFUNC simd_ulong_sat(simd_int2     __x) { return simd_ulong(simd_max(__x,0)); }
-static simd_ulong3  SIMD_CFUNC simd_ulong_sat(simd_int3     __x) { return simd_ulong(simd_max(__x,0)); }
-static simd_ulong4  SIMD_CFUNC simd_ulong_sat(simd_int4     __x) { return simd_ulong(simd_max(__x,0)); }
-static simd_ulong8  SIMD_CFUNC simd_ulong_sat(simd_int8     __x) { return simd_ulong(simd_max(__x,0)); }
-static simd_ulong2  SIMD_CFUNC simd_ulong_sat(simd_float2   __x) { return simd_bitselect(simd_ulong(simd_max(__x,0.f)), 0xffffffffffffffff, simd_long(__x >= 0x1.0p64f)); }
-static simd_ulong3  SIMD_CFUNC simd_ulong_sat(simd_float3   __x) { return simd_bitselect(simd_ulong(simd_max(__x,0.f)), 0xffffffffffffffff, simd_long(__x >= 0x1.0p64f)); }
-static simd_ulong4  SIMD_CFUNC simd_ulong_sat(simd_float4   __x) { return simd_bitselect(simd_ulong(simd_max(__x,0.f)), 0xffffffffffffffff, simd_long(__x >= 0x1.0p64f)); }
-static simd_ulong8  SIMD_CFUNC simd_ulong_sat(simd_float8   __x) { return simd_bitselect(simd_ulong(simd_max(__x,0.f)), 0xffffffffffffffff, simd_long(__x >= 0x1.0p64f)); }
-static simd_ulong2  SIMD_CFUNC simd_ulong_sat(simd_long2    __x) { return simd_ulong(simd_max(__x,0)); }
-static simd_ulong3  SIMD_CFUNC simd_ulong_sat(simd_long3    __x) { return simd_ulong(simd_max(__x,0)); }
-static simd_ulong4  SIMD_CFUNC simd_ulong_sat(simd_long4    __x) { return simd_ulong(simd_max(__x,0)); }
-static simd_ulong8  SIMD_CFUNC simd_ulong_sat(simd_long8    __x) { return simd_ulong(simd_max(__x,0)); }
-static simd_ulong2  SIMD_CFUNC simd_ulong_sat(simd_double2  __x) { return simd_bitselect(simd_ulong(simd_max(__x,0.0)), 0xffffffffffffffff, __x >= 0x1.0p64); }
-static simd_ulong3  SIMD_CFUNC simd_ulong_sat(simd_double3  __x) { return simd_bitselect(simd_ulong(simd_max(__x,0.0)), 0xffffffffffffffff, __x >= 0x1.0p64); }
-static simd_ulong4  SIMD_CFUNC simd_ulong_sat(simd_double4  __x) { return simd_bitselect(simd_ulong(simd_max(__x,0.0)), 0xffffffffffffffff, __x >= 0x1.0p64); }
-static simd_ulong8  SIMD_CFUNC simd_ulong_sat(simd_double8  __x) { return simd_bitselect(simd_ulong(simd_max(__x,0.0)), 0xffffffffffffffff, __x >= 0x1.0p64); }
-static simd_ulong2  SIMD_CFUNC simd_ulong_sat(simd_uchar2   __x) { return simd_ulong(__x); }
-static simd_ulong3  SIMD_CFUNC simd_ulong_sat(simd_uchar3   __x) { return simd_ulong(__x); }
-static simd_ulong4  SIMD_CFUNC simd_ulong_sat(simd_uchar4   __x) { return simd_ulong(__x); }
-static simd_ulong8  SIMD_CFUNC simd_ulong_sat(simd_uchar8   __x) { return simd_ulong(__x); }
-static simd_ulong2  SIMD_CFUNC simd_ulong_sat(simd_ushort2  __x) { return simd_ulong(__x); }
-static simd_ulong3  SIMD_CFUNC simd_ulong_sat(simd_ushort3  __x) { return simd_ulong(__x); }
-static simd_ulong4  SIMD_CFUNC simd_ulong_sat(simd_ushort4  __x) { return simd_ulong(__x); }
-static simd_ulong8  SIMD_CFUNC simd_ulong_sat(simd_ushort8  __x) { return simd_ulong(__x); }
-static simd_ulong2  SIMD_CFUNC simd_ulong_sat(simd_uint2    __x) { return simd_ulong(__x); }
-static simd_ulong3  SIMD_CFUNC simd_ulong_sat(simd_uint3    __x) { return simd_ulong(__x); }
-static simd_ulong4  SIMD_CFUNC simd_ulong_sat(simd_uint4    __x) { return simd_ulong(__x); }
-static simd_ulong8  SIMD_CFUNC simd_ulong_sat(simd_uint8    __x) { return simd_ulong(__x); }
-static simd_ulong2  SIMD_CFUNC simd_ulong_sat(simd_ulong2   __x) { return __x; }
-static simd_ulong3  SIMD_CFUNC simd_ulong_sat(simd_ulong3   __x) { return __x; }
-static simd_ulong4  SIMD_CFUNC simd_ulong_sat(simd_ulong4   __x) { return __x; }
-static simd_ulong8  SIMD_CFUNC simd_ulong_sat(simd_ulong8   __x) { return __x; }
-
-static simd_double2  SIMD_CFUNC simd_double(simd_char2    __x) { return simd_double(simd_int(__x)); }
-static simd_double3  SIMD_CFUNC simd_double(simd_char3    __x) { return simd_double(simd_int(__x)); }
-static simd_double4  SIMD_CFUNC simd_double(simd_char4    __x) { return simd_double(simd_int(__x)); }
-static simd_double8  SIMD_CFUNC simd_double(simd_char8    __x) { return simd_double(simd_int(__x)); }
-static simd_double2  SIMD_CFUNC simd_double(simd_uchar2   __x) { return simd_double(simd_int(__x)); }
-static simd_double3  SIMD_CFUNC simd_double(simd_uchar3   __x) { return simd_double(simd_int(__x)); }
-static simd_double4  SIMD_CFUNC simd_double(simd_uchar4   __x) { return simd_double(simd_int(__x)); }
-static simd_double8  SIMD_CFUNC simd_double(simd_uchar8   __x) { return simd_double(simd_int(__x)); }
-static simd_double2  SIMD_CFUNC simd_double(simd_short2   __x) { return simd_double(simd_int(__x)); }
-static simd_double3  SIMD_CFUNC simd_double(simd_short3   __x) { return simd_double(simd_int(__x)); }
-static simd_double4  SIMD_CFUNC simd_double(simd_short4   __x) { return simd_double(simd_int(__x)); }
-static simd_double8  SIMD_CFUNC simd_double(simd_short8   __x) { return simd_double(simd_int(__x)); }
-static simd_double2  SIMD_CFUNC simd_double(simd_ushort2  __x) { return simd_double(simd_int(__x)); }
-static simd_double3  SIMD_CFUNC simd_double(simd_ushort3  __x) { return simd_double(simd_int(__x)); }
-static simd_double4  SIMD_CFUNC simd_double(simd_ushort4  __x) { return simd_double(simd_int(__x)); }
-static simd_double8  SIMD_CFUNC simd_double(simd_ushort8  __x) { return simd_double(simd_int(__x)); }
-static simd_double2  SIMD_CFUNC simd_double(simd_int2     __x) { return __builtin_convertvector(__x, simd_double2); }
-static simd_double3  SIMD_CFUNC simd_double(simd_int3     __x) { return __builtin_convertvector(__x, simd_double3); }
-static simd_double4  SIMD_CFUNC simd_double(simd_int4     __x) { return __builtin_convertvector(__x, simd_double4); }
-static simd_double8  SIMD_CFUNC simd_double(simd_int8     __x) { return __builtin_convertvector(__x, simd_double8); }
-static simd_double2  SIMD_CFUNC simd_double(simd_uint2    __x) { return __builtin_convertvector(__x, simd_double2); }
-static simd_double3  SIMD_CFUNC simd_double(simd_uint3    __x) { return __builtin_convertvector(__x, simd_double3); }
-static simd_double4  SIMD_CFUNC simd_double(simd_uint4    __x) { return __builtin_convertvector(__x, simd_double4); }
-static simd_double8  SIMD_CFUNC simd_double(simd_uint8    __x) { return __builtin_convertvector(__x, simd_double8); }
-static simd_double2  SIMD_CFUNC simd_double(simd_float2   __x) { return __builtin_convertvector(__x, simd_double2); }
-static simd_double3  SIMD_CFUNC simd_double(simd_float3   __x) { return __builtin_convertvector(__x, simd_double3); }
-static simd_double4  SIMD_CFUNC simd_double(simd_float4   __x) { return __builtin_convertvector(__x, simd_double4); }
-static simd_double8  SIMD_CFUNC simd_double(simd_float8   __x) { return __builtin_convertvector(__x, simd_double8); }
-static simd_double2  SIMD_CFUNC simd_double(simd_long2    __x) { return __builtin_convertvector(__x, simd_double2); }
-static simd_double3  SIMD_CFUNC simd_double(simd_long3    __x) { return __builtin_convertvector(__x, simd_double3); }
-static simd_double4  SIMD_CFUNC simd_double(simd_long4    __x) { return __builtin_convertvector(__x, simd_double4); }
-static simd_double8  SIMD_CFUNC simd_double(simd_long8    __x) { return __builtin_convertvector(__x, simd_double8); }
-static simd_double2  SIMD_CFUNC simd_double(simd_ulong2   __x) { return __builtin_convertvector(__x, simd_double2); }
-static simd_double3  SIMD_CFUNC simd_double(simd_ulong3   __x) { return __builtin_convertvector(__x, simd_double3); }
-static simd_double4  SIMD_CFUNC simd_double(simd_ulong4   __x) { return __builtin_convertvector(__x, simd_double4); }
-static simd_double8  SIMD_CFUNC simd_double(simd_ulong8   __x) { return __builtin_convertvector(__x, simd_double8); }
-static simd_double2  SIMD_CFUNC simd_double(simd_double2  __x) { return __builtin_convertvector(__x, simd_double2); }
-static simd_double3  SIMD_CFUNC simd_double(simd_double3  __x) { return __builtin_convertvector(__x, simd_double3); }
-static simd_double4  SIMD_CFUNC simd_double(simd_double4  __x) { return __builtin_convertvector(__x, simd_double4); }
-static simd_double8  SIMD_CFUNC simd_double(simd_double8  __x) { return __builtin_convertvector(__x, simd_double8); }
-
-#ifdef __cplusplus
-}
-#endif
-#endif // SIMD_COMPILER_HAS_REQUIRED_FEATURES
-#endif // __SIMD_CONVERSION_HEADER__
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/simd/logic.h b/lib/libc/include/x86_64-macos-gnu/simd/logic.h
deleted file mode 100644
index 38bd9bf58c..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/simd/logic.h
+++ /dev/null
@@ -1,1315 +0,0 @@
-/*! @header
- *  The interfaces declared in this header provide logical and bitwise
- *  operations on vectors.  Some of these function operate elementwise,
- *  and some produce a scalar result that depends on all lanes of the input.
- *
- *  For functions returning a boolean value, the return type in C and
- *  Objective-C is _Bool; for C++ it is bool.
- *
- *      Function                    Result
- *      ------------------------------------------------------------------
- *      simd_all(comparison)        True if and only if the comparison is true
- *                                  in every vector lane.  e.g.:
- *
- *                                      if (simd_all(x == 0.0f)) {
- *                                          // executed if every lane of x
- *                                          // contains zero.
- *                                      }
- *
- *                                  The precise function of simd_all is to
- *                                  return the high-order bit of the result
- *                                  of a horizontal bitwise AND of all vector
- *                                  lanes.
- *
- *      simd_any(comparison)        True if and only if the comparison is true
- *                                  in at least one vector lane.  e.g.:
- *
- *                                      if (simd_any(x < 0.0f)) {
- *                                          // executed if any lane of x
- *                                          // contains a negative value.
- *                                      }
- *
- *                                  The precise function of simd_all is to
- *                                  return the high-order bit of the result
- *                                  of a horizontal bitwise OR of all vector
- *                                  lanes.
- *
- *      simd_select(x,y,mask)       For each lane in the result, selects the
- *                                  corresponding element of x if the high-
- *                                  order bit of the corresponding element of
- *                                  mask is 0, and the corresponding element
- *                                  of y otherwise.
- *
- *      simd_bitselect(x,y,mask)    For each bit in the result, selects the
- *                                  corresponding bit of x if the corresponding
- *                                  bit of mask is clear, and the corresponding
- *                                  of y otherwise.
- *
- *  In C++, these functions are available under the simd:: namespace:
- *
- *      C++ Function                    Equivalent C Function
- *      --------------------------------------------------------------------
- *      simd::all(comparison)           simd_all(comparison)
- *      simd::any(comparison)           simd_any(comparison)
- *      simd::select(x,y,mask)          simd_select(x,y,mask)
- *      simd::bitselect(x,y,mask)       simd_bitselect(x,y,mask)
- *
- *  @copyright 2014-2017 Apple, Inc. All rights reserved.
- *  @unsorted                                                                 */
-
-#ifndef SIMD_LOGIC_HEADER
-#define SIMD_LOGIC_HEADER
-
-#include <simd/base.h>
-#if SIMD_COMPILER_HAS_REQUIRED_FEATURES
-#include <simd/vector_make.h>
-#include <stdint.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/*! @abstract True if and only if the high-order bit of any lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_any(simd_char2 x);
-/*! @abstract True if and only if the high-order bit of any lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_any(simd_char3 x);
-/*! @abstract True if and only if the high-order bit of any lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_any(simd_char4 x);
-/*! @abstract True if and only if the high-order bit of any lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_any(simd_char8 x);
-/*! @abstract True if and only if the high-order bit of any lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_any(simd_char16 x);
-/*! @abstract True if and only if the high-order bit of any lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_any(simd_char32 x);
-/*! @abstract True if and only if the high-order bit of any lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_any(simd_char64 x);
-/*! @abstract True if and only if the high-order bit of any lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_any(simd_uchar2 x);
-/*! @abstract True if and only if the high-order bit of any lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_any(simd_uchar3 x);
-/*! @abstract True if and only if the high-order bit of any lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_any(simd_uchar4 x);
-/*! @abstract True if and only if the high-order bit of any lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_any(simd_uchar8 x);
-/*! @abstract True if and only if the high-order bit of any lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_any(simd_uchar16 x);
-/*! @abstract True if and only if the high-order bit of any lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_any(simd_uchar32 x);
-/*! @abstract True if and only if the high-order bit of any lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_any(simd_uchar64 x);
-/*! @abstract True if and only if the high-order bit of any lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_any(simd_short2 x);
-/*! @abstract True if and only if the high-order bit of any lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_any(simd_short3 x);
-/*! @abstract True if and only if the high-order bit of any lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_any(simd_short4 x);
-/*! @abstract True if and only if the high-order bit of any lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_any(simd_short8 x);
-/*! @abstract True if and only if the high-order bit of any lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_any(simd_short16 x);
-/*! @abstract True if and only if the high-order bit of any lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_any(simd_short32 x);
-/*! @abstract True if and only if the high-order bit of any lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_any(simd_ushort2 x);
-/*! @abstract True if and only if the high-order bit of any lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_any(simd_ushort3 x);
-/*! @abstract True if and only if the high-order bit of any lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_any(simd_ushort4 x);
-/*! @abstract True if and only if the high-order bit of any lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_any(simd_ushort8 x);
-/*! @abstract True if and only if the high-order bit of any lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_any(simd_ushort16 x);
-/*! @abstract True if and only if the high-order bit of any lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_any(simd_ushort32 x);
-/*! @abstract True if and only if the high-order bit of any lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_any(simd_int2 x);
-/*! @abstract True if and only if the high-order bit of any lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_any(simd_int3 x);
-/*! @abstract True if and only if the high-order bit of any lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_any(simd_int4 x);
-/*! @abstract True if and only if the high-order bit of any lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_any(simd_int8 x);
-/*! @abstract True if and only if the high-order bit of any lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_any(simd_int16 x);
-/*! @abstract True if and only if the high-order bit of any lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_any(simd_uint2 x);
-/*! @abstract True if and only if the high-order bit of any lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_any(simd_uint3 x);
-/*! @abstract True if and only if the high-order bit of any lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_any(simd_uint4 x);
-/*! @abstract True if and only if the high-order bit of any lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_any(simd_uint8 x);
-/*! @abstract True if and only if the high-order bit of any lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_any(simd_uint16 x);
-/*! @abstract True if and only if the high-order bit of any lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_any(simd_long2 x);
-/*! @abstract True if and only if the high-order bit of any lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_any(simd_long3 x);
-/*! @abstract True if and only if the high-order bit of any lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_any(simd_long4 x);
-/*! @abstract True if and only if the high-order bit of any lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_any(simd_long8 x);
-/*! @abstract True if and only if the high-order bit of any lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_any(simd_ulong2 x);
-/*! @abstract True if and only if the high-order bit of any lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_any(simd_ulong3 x);
-/*! @abstract True if and only if the high-order bit of any lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_any(simd_ulong4 x);
-/*! @abstract True if and only if the high-order bit of any lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_any(simd_ulong8 x);
-/*! @abstract True if and only if the high-order bit of any lane of the
- *  vector is set.
- *  @discussion Deprecated. Use simd_any instead.                             */
-#define vector_any simd_any
-
-/*! @abstract True if and only if the high-order bit of every lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_all(simd_char2 x);
-/*! @abstract True if and only if the high-order bit of every lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_all(simd_char3 x);
-/*! @abstract True if and only if the high-order bit of every lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_all(simd_char4 x);
-/*! @abstract True if and only if the high-order bit of every lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_all(simd_char8 x);
-/*! @abstract True if and only if the high-order bit of every lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_all(simd_char16 x);
-/*! @abstract True if and only if the high-order bit of every lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_all(simd_char32 x);
-/*! @abstract True if and only if the high-order bit of every lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_all(simd_char64 x);
-/*! @abstract True if and only if the high-order bit of every lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_all(simd_uchar2 x);
-/*! @abstract True if and only if the high-order bit of every lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_all(simd_uchar3 x);
-/*! @abstract True if and only if the high-order bit of every lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_all(simd_uchar4 x);
-/*! @abstract True if and only if the high-order bit of every lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_all(simd_uchar8 x);
-/*! @abstract True if and only if the high-order bit of every lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_all(simd_uchar16 x);
-/*! @abstract True if and only if the high-order bit of every lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_all(simd_uchar32 x);
-/*! @abstract True if and only if the high-order bit of every lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_all(simd_uchar64 x);
-/*! @abstract True if and only if the high-order bit of every lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_all(simd_short2 x);
-/*! @abstract True if and only if the high-order bit of every lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_all(simd_short3 x);
-/*! @abstract True if and only if the high-order bit of every lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_all(simd_short4 x);
-/*! @abstract True if and only if the high-order bit of every lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_all(simd_short8 x);
-/*! @abstract True if and only if the high-order bit of every lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_all(simd_short16 x);
-/*! @abstract True if and only if the high-order bit of every lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_all(simd_short32 x);
-/*! @abstract True if and only if the high-order bit of every lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_all(simd_ushort2 x);
-/*! @abstract True if and only if the high-order bit of every lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_all(simd_ushort3 x);
-/*! @abstract True if and only if the high-order bit of every lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_all(simd_ushort4 x);
-/*! @abstract True if and only if the high-order bit of every lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_all(simd_ushort8 x);
-/*! @abstract True if and only if the high-order bit of every lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_all(simd_ushort16 x);
-/*! @abstract True if and only if the high-order bit of every lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_all(simd_ushort32 x);
-/*! @abstract True if and only if the high-order bit of every lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_all(simd_int2 x);
-/*! @abstract True if and only if the high-order bit of every lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_all(simd_int3 x);
-/*! @abstract True if and only if the high-order bit of every lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_all(simd_int4 x);
-/*! @abstract True if and only if the high-order bit of every lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_all(simd_int8 x);
-/*! @abstract True if and only if the high-order bit of every lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_all(simd_int16 x);
-/*! @abstract True if and only if the high-order bit of every lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_all(simd_uint2 x);
-/*! @abstract True if and only if the high-order bit of every lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_all(simd_uint3 x);
-/*! @abstract True if and only if the high-order bit of every lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_all(simd_uint4 x);
-/*! @abstract True if and only if the high-order bit of every lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_all(simd_uint8 x);
-/*! @abstract True if and only if the high-order bit of every lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_all(simd_uint16 x);
-/*! @abstract True if and only if the high-order bit of every lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_all(simd_long2 x);
-/*! @abstract True if and only if the high-order bit of every lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_all(simd_long3 x);
-/*! @abstract True if and only if the high-order bit of every lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_all(simd_long4 x);
-/*! @abstract True if and only if the high-order bit of every lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_all(simd_long8 x);
-/*! @abstract True if and only if the high-order bit of every lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_all(simd_ulong2 x);
-/*! @abstract True if and only if the high-order bit of every lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_all(simd_ulong3 x);
-/*! @abstract True if and only if the high-order bit of every lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_all(simd_ulong4 x);
-/*! @abstract True if and only if the high-order bit of every lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_all(simd_ulong8 x);
-/*! @abstract True if and only if the high-order bit of every lane of the
- *  vector is set.
- *  @discussion Deprecated. Use simd_all instead.                             */
-#define vector_all simd_all
-
-/*! @abstract For each lane in the result, selects the corresponding element
- *  of x or y according to whether the high-order bit of the corresponding
- *  lane of mask is 0 or 1, respectively.                                     */
-static inline SIMD_CFUNC simd_float2 simd_select(simd_float2 x, simd_float2 y, simd_int2 mask);
-/*! @abstract For each lane in the result, selects the corresponding element
- *  of x or y according to whether the high-order bit of the corresponding
- *  lane of mask is 0 or 1, respectively.                                     */
-static inline SIMD_CFUNC simd_float3 simd_select(simd_float3 x, simd_float3 y, simd_int3 mask);
-/*! @abstract For each lane in the result, selects the corresponding element
- *  of x or y according to whether the high-order bit of the corresponding
- *  lane of mask is 0 or 1, respectively.                                     */
-static inline SIMD_CFUNC simd_float4 simd_select(simd_float4 x, simd_float4 y, simd_int4 mask);
-/*! @abstract For each lane in the result, selects the corresponding element
- *  of x or y according to whether the high-order bit of the corresponding
- *  lane of mask is 0 or 1, respectively.                                     */
-static inline SIMD_CFUNC simd_float8 simd_select(simd_float8 x, simd_float8 y, simd_int8 mask);
-/*! @abstract For each lane in the result, selects the corresponding element
- *  of x or y according to whether the high-order bit of the corresponding
- *  lane of mask is 0 or 1, respectively.                                     */
-static inline SIMD_CFUNC simd_float16 simd_select(simd_float16 x, simd_float16 y, simd_int16 mask);
-/*! @abstract For each lane in the result, selects the corresponding element
- *  of x or y according to whether the high-order bit of the corresponding
- *  lane of mask is 0 or 1, respectively.                                     */
-static inline SIMD_CFUNC simd_double2 simd_select(simd_double2 x, simd_double2 y, simd_long2 mask);
-/*! @abstract For each lane in the result, selects the corresponding element
- *  of x or y according to whether the high-order bit of the corresponding
- *  lane of mask is 0 or 1, respectively.                                     */
-static inline SIMD_CFUNC simd_double3 simd_select(simd_double3 x, simd_double3 y, simd_long3 mask);
-/*! @abstract For each lane in the result, selects the corresponding element
- *  of x or y according to whether the high-order bit of the corresponding
- *  lane of mask is 0 or 1, respectively.                                     */
-static inline SIMD_CFUNC simd_double4 simd_select(simd_double4 x, simd_double4 y, simd_long4 mask);
-/*! @abstract For each lane in the result, selects the corresponding element
- *  of x or y according to whether the high-order bit of the corresponding
- *  lane of mask is 0 or 1, respectively.                                     */
-static inline SIMD_CFUNC simd_double8 simd_select(simd_double8 x, simd_double8 y, simd_long8 mask);
-/*! @abstract For each lane in the result, selects the corresponding element
- *  of x or y according to whether the high-order bit of the corresponding
- *  lane of mask is 0 or 1, respectively.
- *  @discussion Deprecated. Use simd_select instead.                          */
-#define vector_select simd_select
-  
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_char2 simd_bitselect(simd_char2 x, simd_char2 y, simd_char2 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_char3 simd_bitselect(simd_char3 x, simd_char3 y, simd_char3 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_char4 simd_bitselect(simd_char4 x, simd_char4 y, simd_char4 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_char8 simd_bitselect(simd_char8 x, simd_char8 y, simd_char8 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_char16 simd_bitselect(simd_char16 x, simd_char16 y, simd_char16 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_char32 simd_bitselect(simd_char32 x, simd_char32 y, simd_char32 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_char64 simd_bitselect(simd_char64 x, simd_char64 y, simd_char64 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_uchar2 simd_bitselect(simd_uchar2 x, simd_uchar2 y, simd_char2 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_uchar3 simd_bitselect(simd_uchar3 x, simd_uchar3 y, simd_char3 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_uchar4 simd_bitselect(simd_uchar4 x, simd_uchar4 y, simd_char4 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_uchar8 simd_bitselect(simd_uchar8 x, simd_uchar8 y, simd_char8 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_uchar16 simd_bitselect(simd_uchar16 x, simd_uchar16 y, simd_char16 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_uchar32 simd_bitselect(simd_uchar32 x, simd_uchar32 y, simd_char32 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_uchar64 simd_bitselect(simd_uchar64 x, simd_uchar64 y, simd_char64 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_short2 simd_bitselect(simd_short2 x, simd_short2 y, simd_short2 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_short3 simd_bitselect(simd_short3 x, simd_short3 y, simd_short3 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_short4 simd_bitselect(simd_short4 x, simd_short4 y, simd_short4 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_short8 simd_bitselect(simd_short8 x, simd_short8 y, simd_short8 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_short16 simd_bitselect(simd_short16 x, simd_short16 y, simd_short16 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_short32 simd_bitselect(simd_short32 x, simd_short32 y, simd_short32 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_ushort2 simd_bitselect(simd_ushort2 x, simd_ushort2 y, simd_short2 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_ushort3 simd_bitselect(simd_ushort3 x, simd_ushort3 y, simd_short3 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_ushort4 simd_bitselect(simd_ushort4 x, simd_ushort4 y, simd_short4 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_ushort8 simd_bitselect(simd_ushort8 x, simd_ushort8 y, simd_short8 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_ushort16 simd_bitselect(simd_ushort16 x, simd_ushort16 y, simd_short16 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_ushort32 simd_bitselect(simd_ushort32 x, simd_ushort32 y, simd_short32 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_int2 simd_bitselect(simd_int2 x, simd_int2 y, simd_int2 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_int3 simd_bitselect(simd_int3 x, simd_int3 y, simd_int3 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_int4 simd_bitselect(simd_int4 x, simd_int4 y, simd_int4 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_int8 simd_bitselect(simd_int8 x, simd_int8 y, simd_int8 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_int16 simd_bitselect(simd_int16 x, simd_int16 y, simd_int16 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_uint2 simd_bitselect(simd_uint2 x, simd_uint2 y, simd_int2 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_uint3 simd_bitselect(simd_uint3 x, simd_uint3 y, simd_int3 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_uint4 simd_bitselect(simd_uint4 x, simd_uint4 y, simd_int4 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_uint8 simd_bitselect(simd_uint8 x, simd_uint8 y, simd_int8 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_uint16 simd_bitselect(simd_uint16 x, simd_uint16 y, simd_int16 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_float2 simd_bitselect(simd_float2 x, simd_float2 y, simd_int2 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_float3 simd_bitselect(simd_float3 x, simd_float3 y, simd_int3 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_float4 simd_bitselect(simd_float4 x, simd_float4 y, simd_int4 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_float8 simd_bitselect(simd_float8 x, simd_float8 y, simd_int8 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_float16 simd_bitselect(simd_float16 x, simd_float16 y, simd_int16 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_long2 simd_bitselect(simd_long2 x, simd_long2 y, simd_long2 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_long3 simd_bitselect(simd_long3 x, simd_long3 y, simd_long3 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_long4 simd_bitselect(simd_long4 x, simd_long4 y, simd_long4 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_long8 simd_bitselect(simd_long8 x, simd_long8 y, simd_long8 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_ulong2 simd_bitselect(simd_ulong2 x, simd_ulong2 y, simd_long2 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_ulong3 simd_bitselect(simd_ulong3 x, simd_ulong3 y, simd_long3 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_ulong4 simd_bitselect(simd_ulong4 x, simd_ulong4 y, simd_long4 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_ulong8 simd_bitselect(simd_ulong8 x, simd_ulong8 y, simd_long8 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_double2 simd_bitselect(simd_double2 x, simd_double2 y, simd_long2 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_double3 simd_bitselect(simd_double3 x, simd_double3 y, simd_long3 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_double4 simd_bitselect(simd_double4 x, simd_double4 y, simd_long4 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_double8 simd_bitselect(simd_double8 x, simd_double8 y, simd_long8 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.
- *  @discussion Deprecated. Use simd_bitselect instead.                       */
-#define vector_bitselect simd_bitselect
-
-#ifdef __cplusplus
-} /* extern "C" */
-
-namespace simd {
-  /*! @abstract True if and only if the high-order bit of every lane is set.  */
-  template <typename inttypeN> static SIMD_CPPFUNC simd_bool all(const inttypeN predicate) { return ::simd_all(predicate); }
-  /*! @abstract True if and only if the high-order bit of any lane is set.    */
-  template <typename inttypeN> static SIMD_CPPFUNC simd_bool any(const inttypeN predicate) { return ::simd_any(predicate); }
-  /*! @abstract Each lane of the result is selected from the corresponding lane
-   *  of x or y according to whether the high-order bit of the corresponding
-   *  lane of mask is 0 or 1, respectively.                                   */
-  template <typename inttypeN, typename fptypeN> static SIMD_CPPFUNC fptypeN select(const fptypeN x, const fptypeN y, const inttypeN predicate) { return ::simd_select(x,y,predicate); }
-  /*! @abstract For each bit in the result, selects the corresponding bit of x
-   *  or y according to whether the corresponding bit of mask is 0 or 1,
-   *  respectively.                                                           */
-  template <typename inttypeN, typename typeN> static SIMD_CPPFUNC typeN bitselect(const typeN x, const typeN y, const inttypeN mask) { return ::simd_bitselect(x,y,mask); }
-}
-
-extern "C" {
-#endif /* __cplusplus */
-
-#pragma mark - Implementations
-
-static inline SIMD_CFUNC simd_bool simd_any(simd_char2 x) {
-#if defined __SSE2__
-  return (_mm_movemask_epi8(simd_make_char16_undef(x)) & 0x3);
-#elif defined __arm64__
-  return simd_any(x.xyxy);
-#else
-  union { uint16_t i; simd_char2 v; } u = { .v = x };
-  return (u.i & 0x8080);
-#endif
-}
-static inline SIMD_CFUNC simd_bool simd_any(simd_char3 x) {
-#if defined __SSE2__
-  return (_mm_movemask_epi8(simd_make_char16_undef(x)) & 0x7);
-#elif defined __arm64__
-  return simd_any(x.xyzz);
-#else
-  union { uint32_t i; simd_char3 v; } u = { .v = x };
-  return (u.i & 0x808080);
-#endif
-}
-static inline SIMD_CFUNC simd_bool simd_any(simd_char4 x) {
-#if defined __SSE2__
-  return (_mm_movemask_epi8(simd_make_char16_undef(x)) & 0xf);
-#elif defined __arm64__
-  return simd_any(x.xyzwxyzw);
-#else
-  union { uint32_t i; simd_char4 v; } u = { .v = x };
-  return (u.i & 0x80808080);
-#endif
-}
-static inline SIMD_CFUNC simd_bool simd_any(simd_char8 x) {
-#if defined __SSE2__
-  return (_mm_movemask_epi8(simd_make_char16_undef(x)) & 0xff);
-#elif defined __arm64__
-  return vmaxv_u8(x) & 0x80;
-#else
-  union { uint64_t i; simd_char8 v; } u = { .v = x };
-  return (u.i & 0x8080808080808080);
-#endif
-}
-static inline SIMD_CFUNC simd_bool simd_any(simd_char16 x) {
-#if defined __SSE2__
-  return _mm_movemask_epi8(x);
-#elif defined __arm64__
-  return vmaxvq_u8(x) & 0x80;
-#else
-  return simd_any(x.lo | x.hi);
-#endif
-}
-static inline SIMD_CFUNC simd_bool simd_any(simd_char32 x) {
-#if defined __AVX2__
-  return _mm256_movemask_epi8(x);
-#else
-  return simd_any(x.lo | x.hi);
-#endif
-}
-static inline SIMD_CFUNC simd_bool simd_any(simd_char64 x) {
-  return simd_any(x.lo | x.hi);
-}
-static inline SIMD_CFUNC simd_bool simd_any(simd_uchar2 x) {
-  return simd_any((simd_char2)x);
-}
-static inline SIMD_CFUNC simd_bool simd_any(simd_uchar3 x) {
-  return simd_any((simd_char3)x);
-}
-static inline SIMD_CFUNC simd_bool simd_any(simd_uchar4 x) {
-  return simd_any((simd_char4)x);
-}
-static inline SIMD_CFUNC simd_bool simd_any(simd_uchar8 x) {
-  return simd_any((simd_char8)x);
-}
-static inline SIMD_CFUNC simd_bool simd_any(simd_uchar16 x) {
-  return simd_any((simd_char16)x);
-}
-static inline SIMD_CFUNC simd_bool simd_any(simd_uchar32 x) {
-  return simd_any((simd_char32)x);
-}
-static inline SIMD_CFUNC simd_bool simd_any(simd_uchar64 x) {
-  return simd_any((simd_char64)x);
-}
-static inline SIMD_CFUNC simd_bool simd_any(simd_short2 x) {
-#if defined __SSE2__
-  return (_mm_movemask_epi8(simd_make_short8_undef(x)) & 0xa);
-#elif defined __arm64__
-  return simd_any(x.xyxy);
-#else
-  union { uint32_t i; simd_short2 v; } u = { .v = x };
-  return (u.i & 0x80008000);
-#endif
-}
-static inline SIMD_CFUNC simd_bool simd_any(simd_short3 x) {
-#if defined __SSE2__
-  return (_mm_movemask_epi8(simd_make_short8_undef(x)) & 0x2a);
-#elif defined __arm64__
-  return simd_any(x.xyzz);
-#else
-  union { uint64_t i; simd_short3 v; } u = { .v = x };
-  return (u.i & 0x800080008000);
-#endif
-}
-static inline SIMD_CFUNC simd_bool simd_any(simd_short4 x) {
-#if defined __SSE2__
-  return (_mm_movemask_epi8(simd_make_short8_undef(x)) & 0xaa);
-#elif defined __arm64__
-  return vmaxv_u16(x) & 0x8000;
-#else
-  union { uint64_t i; simd_short4 v; } u = { .v = x };
-  return (u.i & 0x8000800080008000);
-#endif
-}
-static inline SIMD_CFUNC simd_bool simd_any(simd_short8 x) {
-#if defined __SSE2__
-  return (_mm_movemask_epi8(x) & 0xaaaa);
-#elif defined __arm64__
-  return vmaxvq_u16(x) & 0x8000;
-#else
-  return simd_any(x.lo | x.hi);
-#endif
-}
-static inline SIMD_CFUNC simd_bool simd_any(simd_short16 x) {
-#if defined __AVX2__
-  return (_mm256_movemask_epi8(x) & 0xaaaaaaaa);
-#else
-  return simd_any(x.lo | x.hi);
-#endif
-}
-static inline SIMD_CFUNC simd_bool simd_any(simd_short32 x) {
-  return simd_any(x.lo | x.hi);
-}
-static inline SIMD_CFUNC simd_bool simd_any(simd_ushort2 x) {
-  return simd_any((simd_short2)x);
-}
-static inline SIMD_CFUNC simd_bool simd_any(simd_ushort3 x) {
-  return simd_any((simd_short3)x);
-}
-static inline SIMD_CFUNC simd_bool simd_any(simd_ushort4 x) {
-  return simd_any((simd_short4)x);
-}
-static inline SIMD_CFUNC simd_bool simd_any(simd_ushort8 x) {
-  return simd_any((simd_short8)x);
-}
-static inline SIMD_CFUNC simd_bool simd_any(simd_ushort16 x) {
-  return simd_any((simd_short16)x);
-}
-static inline SIMD_CFUNC simd_bool simd_any(simd_ushort32 x) {
-  return simd_any((simd_short32)x);
-}
-static inline SIMD_CFUNC simd_bool simd_any(simd_int2 x) {
-#if defined __SSE2__
-  return (_mm_movemask_ps(simd_make_int4_undef(x)) & 0x3);
-#elif defined __arm64__
-  return vmaxv_u32(x) & 0x80000000;
-#else
-  union { uint64_t i; simd_int2 v; } u = { .v = x };
-  return (u.i & 0x8000000080000000);
-#endif
-}
-static inline SIMD_CFUNC simd_bool simd_any(simd_int3 x) {
-#if defined __SSE2__
-  return (_mm_movemask_ps(simd_make_int4_undef(x)) & 0x7);
-#elif defined __arm64__
-  return simd_any(x.xyzz);
-#else
-  return (x.x | x.y | x.z) & 0x80000000;
-#endif
-}
-static inline SIMD_CFUNC simd_bool simd_any(simd_int4 x) {
-#if defined __SSE2__
-  return _mm_movemask_ps(x);
-#elif defined __arm64__
-  return vmaxvq_u32(x) & 0x80000000;
-#else
-  return simd_any(x.lo | x.hi);
-#endif
-}
-static inline SIMD_CFUNC simd_bool simd_any(simd_int8 x) {
-#if defined __AVX__
-  return _mm256_movemask_ps(x);
-#else
-  return simd_any(x.lo | x.hi);
-#endif
-}
-static inline SIMD_CFUNC simd_bool simd_any(simd_int16 x) {
-  return simd_any(x.lo | x.hi);
-}
-static inline SIMD_CFUNC simd_bool simd_any(simd_uint2 x) {
-  return simd_any((simd_int2)x);
-}
-static inline SIMD_CFUNC simd_bool simd_any(simd_uint3 x) {
-  return simd_any((simd_int3)x);
-}
-static inline SIMD_CFUNC simd_bool simd_any(simd_uint4 x) {
-  return simd_any((simd_int4)x);
-}
-static inline SIMD_CFUNC simd_bool simd_any(simd_uint8 x) {
-  return simd_any((simd_int8)x);
-}
-static inline SIMD_CFUNC simd_bool simd_any(simd_uint16 x) {
-  return simd_any((simd_int16)x);
-}
-static inline SIMD_CFUNC simd_bool simd_any(simd_long2 x) {
-#if defined __SSE2__
-  return _mm_movemask_pd(x);
-#elif defined __arm64__
-  return (x.x | x.y) & 0x8000000000000000U;
-#else
-  return (x.x | x.y) & 0x8000000000000000U;
-#endif
-}
-static inline SIMD_CFUNC simd_bool simd_any(simd_long3 x) {
-#if defined __AVX__
-  return (_mm256_movemask_pd(simd_make_long4_undef(x)) & 0x7);
-#else
-  return (x.x | x.y | x.z) & 0x8000000000000000U;
-#endif
-}
-static inline SIMD_CFUNC simd_bool simd_any(simd_long4 x) {
-#if defined __AVX__
-  return _mm256_movemask_pd(x);
-#else
-  return simd_any(x.lo | x.hi);
-#endif
-}
-static inline SIMD_CFUNC simd_bool simd_any(simd_long8 x) {
-  return simd_any(x.lo | x.hi);
-}
-static inline SIMD_CFUNC simd_bool simd_any(simd_ulong2 x) {
-  return simd_any((simd_long2)x);
-}
-static inline SIMD_CFUNC simd_bool simd_any(simd_ulong3 x) {
-  return simd_any((simd_long3)x);
-}
-static inline SIMD_CFUNC simd_bool simd_any(simd_ulong4 x) {
-  return simd_any((simd_long4)x);
-}
-static inline SIMD_CFUNC simd_bool simd_any(simd_ulong8 x) {
-  return simd_any((simd_long8)x);
-}
-  
-static inline SIMD_CFUNC simd_bool simd_all(simd_char2 x) {
-#if defined __SSE2__
-  return (_mm_movemask_epi8(simd_make_char16_undef(x)) & 0x3) == 0x3;
-#elif defined __arm64__
-  return simd_all(x.xyxy);
-#else
-  union { uint16_t i; simd_char2 v; } u = { .v = x };
-  return (u.i & 0x8080) == 0x8080;
-#endif
-}
-static inline SIMD_CFUNC simd_bool simd_all(simd_char3 x) {
-#if defined __SSE2__
-  return (_mm_movemask_epi8(simd_make_char16_undef(x)) & 0x7) == 0x7;
-#elif defined __arm64__
-  return simd_all(x.xyzz);
-#else
-  union { uint32_t i; simd_char3 v; } u = { .v = x };
-  return (u.i & 0x808080) == 0x808080;
-#endif
-}
-static inline SIMD_CFUNC simd_bool simd_all(simd_char4 x) {
-#if defined __SSE2__
-  return (_mm_movemask_epi8(simd_make_char16_undef(x)) & 0xf) == 0xf;
-#elif defined __arm64__
-  return simd_all(x.xyzwxyzw);
-#else
-  union { uint32_t i; simd_char4 v; } u = { .v = x };
-  return (u.i & 0x80808080) == 0x80808080;
-#endif
-}
-static inline SIMD_CFUNC simd_bool simd_all(simd_char8 x) {
-#if defined __SSE2__
-  return (_mm_movemask_epi8(simd_make_char16_undef(x)) & 0xff) == 0xff;
-#elif defined __arm64__
-  return vminv_u8(x) & 0x80;
-#else
-  union { uint64_t i; simd_char8 v; } u = { .v = x };
-  return (u.i & 0x8080808080808080) == 0x8080808080808080;
-#endif
-}
-static inline SIMD_CFUNC simd_bool simd_all(simd_char16 x) {
-#if defined __SSE2__
-  return _mm_movemask_epi8(x) == 0xffff;
-#elif defined __arm64__
-  return vminvq_u8(x) & 0x80;
-#else
-  return simd_all(x.lo & x.hi);
-#endif
-}
-static inline SIMD_CFUNC simd_bool simd_all(simd_char32 x) {
-#if defined __AVX2__
-  return _mm256_movemask_epi8(x) == 0xffffffff;
-#else
-  return simd_all(x.lo & x.hi);
-#endif
-}
-static inline SIMD_CFUNC simd_bool simd_all(simd_char64 x) {
-  return simd_all(x.lo & x.hi);
-}
-static inline SIMD_CFUNC simd_bool simd_all(simd_uchar2 x) {
-  return simd_all((simd_char2)x);
-}
-static inline SIMD_CFUNC simd_bool simd_all(simd_uchar3 x) {
-  return simd_all((simd_char3)x);
-}
-static inline SIMD_CFUNC simd_bool simd_all(simd_uchar4 x) {
-  return simd_all((simd_char4)x);
-}
-static inline SIMD_CFUNC simd_bool simd_all(simd_uchar8 x) {
-  return simd_all((simd_char8)x);
-}
-static inline SIMD_CFUNC simd_bool simd_all(simd_uchar16 x) {
-  return simd_all((simd_char16)x);
-}
-static inline SIMD_CFUNC simd_bool simd_all(simd_uchar32 x) {
-  return simd_all((simd_char32)x);
-}
-static inline SIMD_CFUNC simd_bool simd_all(simd_uchar64 x) {
-  return simd_all((simd_char64)x);
-}
-static inline SIMD_CFUNC simd_bool simd_all(simd_short2 x) {
-#if defined __SSE2__
-  return (_mm_movemask_epi8(simd_make_short8_undef(x)) & 0xa) == 0xa;
-#elif defined __arm64__
-  return simd_all(x.xyxy);
-#else
-  union { uint32_t i; simd_short2 v; } u = { .v = x };
-  return (u.i & 0x80008000) == 0x80008000;
-#endif
-}
-static inline SIMD_CFUNC simd_bool simd_all(simd_short3 x) {
-#if defined __SSE2__
-  return (_mm_movemask_epi8(simd_make_short8_undef(x)) & 0x2a) == 0x2a;
-#elif defined __arm64__
-  return simd_all(x.xyzz);
-#else
-  union { uint64_t i; simd_short3 v; } u = { .v = x };
-  return (u.i & 0x800080008000) == 0x800080008000;
-#endif
-}
-static inline SIMD_CFUNC simd_bool simd_all(simd_short4 x) {
-#if defined __SSE2__
-  return (_mm_movemask_epi8(simd_make_short8_undef(x)) & 0xaa) == 0xaa;
-#elif defined __arm64__
-  return vminv_u16(x) & 0x8000;
-#else
-  union { uint64_t i; simd_short4 v; } u = { .v = x };
-  return (u.i & 0x8000800080008000) == 0x8000800080008000;
-#endif
-}
-static inline SIMD_CFUNC simd_bool simd_all(simd_short8 x) {
-#if defined __SSE2__
-  return (_mm_movemask_epi8(x) & 0xaaaa) == 0xaaaa;
-#elif defined __arm64__
-  return vminvq_u16(x) & 0x8000;
-#else
-  return simd_all(x.lo & x.hi);
-#endif
-}
-static inline SIMD_CFUNC simd_bool simd_all(simd_short16 x) {
-#if defined __AVX2__
-  return (_mm256_movemask_epi8(x) & 0xaaaaaaaa) == 0xaaaaaaaa;
-#else
-  return simd_all(x.lo & x.hi);
-#endif
-}
-static inline SIMD_CFUNC simd_bool simd_all(simd_short32 x) {
-  return simd_all(x.lo & x.hi);
-}
-static inline SIMD_CFUNC simd_bool simd_all(simd_ushort2 x) {
-  return simd_all((simd_short2)x);
-}
-static inline SIMD_CFUNC simd_bool simd_all(simd_ushort3 x) {
-  return simd_all((simd_short3)x);
-}
-static inline SIMD_CFUNC simd_bool simd_all(simd_ushort4 x) {
-  return simd_all((simd_short4)x);
-}
-static inline SIMD_CFUNC simd_bool simd_all(simd_ushort8 x) {
-  return simd_all((simd_short8)x);
-}
-static inline SIMD_CFUNC simd_bool simd_all(simd_ushort16 x) {
-  return simd_all((simd_short16)x);
-}
-static inline SIMD_CFUNC simd_bool simd_all(simd_ushort32 x) {
-  return simd_all((simd_short32)x);
-}
-static inline SIMD_CFUNC simd_bool simd_all(simd_int2 x) {
-#if defined __SSE2__
-  return (_mm_movemask_ps(simd_make_int4_undef(x)) & 0x3) == 0x3;
-#elif defined __arm64__
-  return vminv_u32(x) & 0x80000000;
-#else
-  union { uint64_t i; simd_int2 v; } u = { .v = x };
-  return (u.i & 0x8000000080000000) == 0x8000000080000000;
-#endif
-}
-static inline SIMD_CFUNC simd_bool simd_all(simd_int3 x) {
-#if defined __SSE2__
-  return (_mm_movemask_ps(simd_make_int4_undef(x)) & 0x7) == 0x7;
-#elif defined __arm64__
-  return simd_all(x.xyzz);
-#else
-  return (x.x & x.y & x.z) & 0x80000000;
-#endif
-}
-static inline SIMD_CFUNC simd_bool simd_all(simd_int4 x) {
-#if defined __SSE2__
-  return _mm_movemask_ps(x) == 0xf;
-#elif defined __arm64__
-  return vminvq_u32(x) & 0x80000000;
-#else
-  return simd_all(x.lo & x.hi);
-#endif
-}
-static inline SIMD_CFUNC simd_bool simd_all(simd_int8 x) {
-#if defined __AVX__
-  return _mm256_movemask_ps(x) == 0xff;
-#else
-  return simd_all(x.lo & x.hi);
-#endif
-}
-static inline SIMD_CFUNC simd_bool simd_all(simd_int16 x) {
-  return simd_all(x.lo & x.hi);
-}
-static inline SIMD_CFUNC simd_bool simd_all(simd_uint2 x) {
-  return simd_all((simd_int2)x);
-}
-static inline SIMD_CFUNC simd_bool simd_all(simd_uint3 x) {
-  return simd_all((simd_int3)x);
-}
-static inline SIMD_CFUNC simd_bool simd_all(simd_uint4 x) {
-  return simd_all((simd_int4)x);
-}
-static inline SIMD_CFUNC simd_bool simd_all(simd_uint8 x) {
-  return simd_all((simd_int8)x);
-}
-static inline SIMD_CFUNC simd_bool simd_all(simd_uint16 x) {
-  return simd_all((simd_int16)x);
-}
-static inline SIMD_CFUNC simd_bool simd_all(simd_long2 x) {
-#if defined __SSE2__
-  return _mm_movemask_pd(x) == 0x3;
-#elif defined __arm64__
-  return (x.x & x.y) & 0x8000000000000000U;
-#else
-  return (x.x & x.y) & 0x8000000000000000U;
-#endif
-}
-static inline SIMD_CFUNC simd_bool simd_all(simd_long3 x) {
-#if defined __AVX__
-  return (_mm256_movemask_pd(simd_make_long4_undef(x)) & 0x7) == 0x7;
-#else
-  return (x.x & x.y & x.z) & 0x8000000000000000U;
-#endif
-}
-static inline SIMD_CFUNC simd_bool simd_all(simd_long4 x) {
-#if defined __AVX__
-  return _mm256_movemask_pd(x) == 0xf;
-#else
-  return simd_all(x.lo & x.hi);
-#endif
-}
-static inline SIMD_CFUNC simd_bool simd_all(simd_long8 x) {
-  return simd_all(x.lo & x.hi);
-}
-static inline SIMD_CFUNC simd_bool simd_all(simd_ulong2 x) {
-  return simd_all((simd_long2)x);
-}
-static inline SIMD_CFUNC simd_bool simd_all(simd_ulong3 x) {
-  return simd_all((simd_long3)x);
-}
-static inline SIMD_CFUNC simd_bool simd_all(simd_ulong4 x) {
-  return simd_all((simd_long4)x);
-}
-static inline SIMD_CFUNC simd_bool simd_all(simd_ulong8 x) {
-  return simd_all((simd_long8)x);
-}
-  
-static inline SIMD_CFUNC simd_float2 simd_select(simd_float2 x, simd_float2 y, simd_int2 mask) {
-  return simd_make_float2(simd_select(simd_make_float4_undef(x), simd_make_float4_undef(y), simd_make_int4_undef(mask)));
-}
-static inline SIMD_CFUNC simd_float3 simd_select(simd_float3 x, simd_float3 y, simd_int3 mask) {
-  return simd_make_float3(simd_select(simd_make_float4_undef(x), simd_make_float4_undef(y), simd_make_int4_undef(mask)));
-}
-static inline SIMD_CFUNC simd_float4 simd_select(simd_float4 x, simd_float4 y, simd_int4 mask) {
-#if defined __SSE4_1__
-  return _mm_blendv_ps(x, y, mask);
-#else
-  return simd_bitselect(x, y, mask >> 31);
-#endif
-}
-static inline SIMD_CFUNC simd_float8 simd_select(simd_float8 x, simd_float8 y, simd_int8 mask) {
-#if defined __AVX__
-  return _mm256_blendv_ps(x, y, mask);
-#else
-  return simd_bitselect(x, y, mask >> 31);
-#endif
-}
-static inline SIMD_CFUNC simd_float16 simd_select(simd_float16 x, simd_float16 y, simd_int16 mask) {
-  return simd_bitselect(x, y, mask >> 31);
-}
-static inline SIMD_CFUNC simd_double2 simd_select(simd_double2 x, simd_double2 y, simd_long2 mask) {
-#if defined __SSE4_1__
-  return _mm_blendv_pd(x, y, mask);
-#else
-  return simd_bitselect(x, y, mask >> 63);
-#endif
-}
-static inline SIMD_CFUNC simd_double3 simd_select(simd_double3 x, simd_double3 y, simd_long3 mask) {
-  return simd_make_double3(simd_select(simd_make_double4_undef(x), simd_make_double4_undef(y), simd_make_long4_undef(mask)));
-}
-static inline SIMD_CFUNC simd_double4 simd_select(simd_double4 x, simd_double4 y, simd_long4 mask) {
-#if defined __AVX__
-  return _mm256_blendv_pd(x, y, mask);
-#else
-  return simd_bitselect(x, y, mask >> 63);
-#endif
-}
-static inline SIMD_CFUNC simd_double8 simd_select(simd_double8 x, simd_double8 y, simd_long8 mask) {
-  return simd_bitselect(x, y, mask >> 63);
-}
-  
-static inline SIMD_CFUNC simd_char2 simd_bitselect(simd_char2 x, simd_char2 y, simd_char2 mask) {
-  return (x & ~mask) | (y & mask);
-}
-static inline SIMD_CFUNC simd_char3 simd_bitselect(simd_char3 x, simd_char3 y, simd_char3 mask) {
-  return (x & ~mask) | (y & mask);
-}
-static inline SIMD_CFUNC simd_char4 simd_bitselect(simd_char4 x, simd_char4 y, simd_char4 mask) {
-  return (x & ~mask) | (y & mask);
-}
-static inline SIMD_CFUNC simd_char8 simd_bitselect(simd_char8 x, simd_char8 y, simd_char8 mask) {
-  return (x & ~mask) | (y & mask);
-}
-static inline SIMD_CFUNC simd_char16 simd_bitselect(simd_char16 x, simd_char16 y, simd_char16 mask) {
-  return (x & ~mask) | (y & mask);
-}
-static inline SIMD_CFUNC simd_char32 simd_bitselect(simd_char32 x, simd_char32 y, simd_char32 mask) {
-  return (x & ~mask) | (y & mask);
-}
-static inline SIMD_CFUNC simd_char64 simd_bitselect(simd_char64 x, simd_char64 y, simd_char64 mask) {
-  return (x & ~mask) | (y & mask);
-}
-static inline SIMD_CFUNC simd_uchar2 simd_bitselect(simd_uchar2 x, simd_uchar2 y, simd_char2 mask) {
-  return (simd_uchar2)simd_bitselect((simd_char2)x, (simd_char2)y, mask);
-}
-static inline SIMD_CFUNC simd_uchar3 simd_bitselect(simd_uchar3 x, simd_uchar3 y, simd_char3 mask) {
-  return (simd_uchar3)simd_bitselect((simd_char3)x, (simd_char3)y, mask);
-}
-static inline SIMD_CFUNC simd_uchar4 simd_bitselect(simd_uchar4 x, simd_uchar4 y, simd_char4 mask) {
-  return (simd_uchar4)simd_bitselect((simd_char4)x, (simd_char4)y, mask);
-}
-static inline SIMD_CFUNC simd_uchar8 simd_bitselect(simd_uchar8 x, simd_uchar8 y, simd_char8 mask) {
-  return (simd_uchar8)simd_bitselect((simd_char8)x, (simd_char8)y, mask);
-}
-static inline SIMD_CFUNC simd_uchar16 simd_bitselect(simd_uchar16 x, simd_uchar16 y, simd_char16 mask) {
-  return (simd_uchar16)simd_bitselect((simd_char16)x, (simd_char16)y, mask);
-}
-static inline SIMD_CFUNC simd_uchar32 simd_bitselect(simd_uchar32 x, simd_uchar32 y, simd_char32 mask) {
-  return (simd_uchar32)simd_bitselect((simd_char32)x, (simd_char32)y, mask);
-}
-static inline SIMD_CFUNC simd_uchar64 simd_bitselect(simd_uchar64 x, simd_uchar64 y, simd_char64 mask) {
-  return (simd_uchar64)simd_bitselect((simd_char64)x, (simd_char64)y, mask);
-}
-static inline SIMD_CFUNC simd_short2 simd_bitselect(simd_short2 x, simd_short2 y, simd_short2 mask) {
-  return (x & ~mask) | (y & mask);
-}
-static inline SIMD_CFUNC simd_short3 simd_bitselect(simd_short3 x, simd_short3 y, simd_short3 mask) {
-  return (x & ~mask) | (y & mask);
-}
-static inline SIMD_CFUNC simd_short4 simd_bitselect(simd_short4 x, simd_short4 y, simd_short4 mask) {
-  return (x & ~mask) | (y & mask);
-}
-static inline SIMD_CFUNC simd_short8 simd_bitselect(simd_short8 x, simd_short8 y, simd_short8 mask) {
-  return (x & ~mask) | (y & mask);
-}
-static inline SIMD_CFUNC simd_short16 simd_bitselect(simd_short16 x, simd_short16 y, simd_short16 mask) {
-  return (x & ~mask) | (y & mask);
-}
-static inline SIMD_CFUNC simd_short32 simd_bitselect(simd_short32 x, simd_short32 y, simd_short32 mask) {
-  return (x & ~mask) | (y & mask);
-}
-static inline SIMD_CFUNC simd_ushort2 simd_bitselect(simd_ushort2 x, simd_ushort2 y, simd_short2 mask) {
-  return (simd_ushort2)simd_bitselect((simd_short2)x, (simd_short2)y, mask);
-}
-static inline SIMD_CFUNC simd_ushort3 simd_bitselect(simd_ushort3 x, simd_ushort3 y, simd_short3 mask) {
-  return (simd_ushort3)simd_bitselect((simd_short3)x, (simd_short3)y, mask);
-}
-static inline SIMD_CFUNC simd_ushort4 simd_bitselect(simd_ushort4 x, simd_ushort4 y, simd_short4 mask) {
-  return (simd_ushort4)simd_bitselect((simd_short4)x, (simd_short4)y, mask);
-}
-static inline SIMD_CFUNC simd_ushort8 simd_bitselect(simd_ushort8 x, simd_ushort8 y, simd_short8 mask) {
-  return (simd_ushort8)simd_bitselect((simd_short8)x, (simd_short8)y, mask);
-}
-static inline SIMD_CFUNC simd_ushort16 simd_bitselect(simd_ushort16 x, simd_ushort16 y, simd_short16 mask) {
-  return (simd_ushort16)simd_bitselect((simd_short16)x, (simd_short16)y, mask);
-}
-static inline SIMD_CFUNC simd_ushort32 simd_bitselect(simd_ushort32 x, simd_ushort32 y, simd_short32 mask) {
-  return (simd_ushort32)simd_bitselect((simd_short32)x, (simd_short32)y, mask);
-}
-static inline SIMD_CFUNC simd_int2 simd_bitselect(simd_int2 x, simd_int2 y, simd_int2 mask) {
-  return (x & ~mask) | (y & mask);
-}
-static inline SIMD_CFUNC simd_int3 simd_bitselect(simd_int3 x, simd_int3 y, simd_int3 mask) {
-  return (x & ~mask) | (y & mask);
-}
-static inline SIMD_CFUNC simd_int4 simd_bitselect(simd_int4 x, simd_int4 y, simd_int4 mask) {
-  return (x & ~mask) | (y & mask);
-}
-static inline SIMD_CFUNC simd_int8 simd_bitselect(simd_int8 x, simd_int8 y, simd_int8 mask) {
-  return (x & ~mask) | (y & mask);
-}
-static inline SIMD_CFUNC simd_int16 simd_bitselect(simd_int16 x, simd_int16 y, simd_int16 mask) {
-  return (x & ~mask) | (y & mask);
-}
-static inline SIMD_CFUNC simd_uint2 simd_bitselect(simd_uint2 x, simd_uint2 y, simd_int2 mask) {
-  return (simd_uint2)simd_bitselect((simd_int2)x, (simd_int2)y, mask);
-}
-static inline SIMD_CFUNC simd_uint3 simd_bitselect(simd_uint3 x, simd_uint3 y, simd_int3 mask) {
-  return (simd_uint3)simd_bitselect((simd_int3)x, (simd_int3)y, mask);
-}
-static inline SIMD_CFUNC simd_uint4 simd_bitselect(simd_uint4 x, simd_uint4 y, simd_int4 mask) {
-  return (simd_uint4)simd_bitselect((simd_int4)x, (simd_int4)y, mask);
-}
-static inline SIMD_CFUNC simd_uint8 simd_bitselect(simd_uint8 x, simd_uint8 y, simd_int8 mask) {
-  return (simd_uint8)simd_bitselect((simd_int8)x, (simd_int8)y, mask);
-}
-static inline SIMD_CFUNC simd_uint16 simd_bitselect(simd_uint16 x, simd_uint16 y, simd_int16 mask) {
-  return (simd_uint16)simd_bitselect((simd_int16)x, (simd_int16)y, mask);
-}
-static inline SIMD_CFUNC simd_float2 simd_bitselect(simd_float2 x, simd_float2 y, simd_int2 mask) {
-  return (simd_float2)simd_bitselect((simd_int2)x, (simd_int2)y, mask);
-}
-static inline SIMD_CFUNC simd_float3 simd_bitselect(simd_float3 x, simd_float3 y, simd_int3 mask) {
-  return (simd_float3)simd_bitselect((simd_int3)x, (simd_int3)y, mask);
-}
-static inline SIMD_CFUNC simd_float4 simd_bitselect(simd_float4 x, simd_float4 y, simd_int4 mask) {
-  return (simd_float4)simd_bitselect((simd_int4)x, (simd_int4)y, mask);
-}
-static inline SIMD_CFUNC simd_float8 simd_bitselect(simd_float8 x, simd_float8 y, simd_int8 mask) {
-  return (simd_float8)simd_bitselect((simd_int8)x, (simd_int8)y, mask);
-}
-static inline SIMD_CFUNC simd_float16 simd_bitselect(simd_float16 x, simd_float16 y, simd_int16 mask) {
-  return (simd_float16)simd_bitselect((simd_int16)x, (simd_int16)y, mask);
-}
-static inline SIMD_CFUNC simd_long2 simd_bitselect(simd_long2 x, simd_long2 y, simd_long2 mask) {
-  return (x & ~mask) | (y & mask);
-}
-static inline SIMD_CFUNC simd_long3 simd_bitselect(simd_long3 x, simd_long3 y, simd_long3 mask) {
-  return (x & ~mask) | (y & mask);
-}
-static inline SIMD_CFUNC simd_long4 simd_bitselect(simd_long4 x, simd_long4 y, simd_long4 mask) {
-  return (x & ~mask) | (y & mask);
-}
-static inline SIMD_CFUNC simd_long8 simd_bitselect(simd_long8 x, simd_long8 y, simd_long8 mask) {
-  return (x & ~mask) | (y & mask);
-}
-static inline SIMD_CFUNC simd_ulong2 simd_bitselect(simd_ulong2 x, simd_ulong2 y, simd_long2 mask) {
-  return (simd_ulong2)simd_bitselect((simd_long2)x, (simd_long2)y, mask);
-}
-static inline SIMD_CFUNC simd_ulong3 simd_bitselect(simd_ulong3 x, simd_ulong3 y, simd_long3 mask) {
-  return (simd_ulong3)simd_bitselect((simd_long3)x, (simd_long3)y, mask);
-}
-static inline SIMD_CFUNC simd_ulong4 simd_bitselect(simd_ulong4 x, simd_ulong4 y, simd_long4 mask) {
-  return (simd_ulong4)simd_bitselect((simd_long4)x, (simd_long4)y, mask);
-}
-static inline SIMD_CFUNC simd_ulong8 simd_bitselect(simd_ulong8 x, simd_ulong8 y, simd_long8 mask) {
-  return (simd_ulong8)simd_bitselect((simd_long8)x, (simd_long8)y, mask);
-}
-static inline SIMD_CFUNC simd_double2 simd_bitselect(simd_double2 x, simd_double2 y, simd_long2 mask) {
-  return (simd_double2)simd_bitselect((simd_long2)x, (simd_long2)y, mask);
-}
-static inline SIMD_CFUNC simd_double3 simd_bitselect(simd_double3 x, simd_double3 y, simd_long3 mask) {
-  return (simd_double3)simd_bitselect((simd_long3)x, (simd_long3)y, mask);
-}
-static inline SIMD_CFUNC simd_double4 simd_bitselect(simd_double4 x, simd_double4 y, simd_long4 mask) {
-  return (simd_double4)simd_bitselect((simd_long4)x, (simd_long4)y, mask);
-}
-static inline SIMD_CFUNC simd_double8 simd_bitselect(simd_double8 x, simd_double8 y, simd_long8 mask) {
-  return (simd_double8)simd_bitselect((simd_long8)x, (simd_long8)y, mask);
-}
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* SIMD_COMPILER_HAS_REQUIRED_FEATURES */
-#endif /* __SIMD_LOGIC_HEADER__ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/simd/math.h b/lib/libc/include/x86_64-macos-gnu/simd/math.h
deleted file mode 100644
index 5e2b31cae2..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/simd/math.h
+++ /dev/null
@@ -1,5379 +0,0 @@
-/*! @header
- *  The interfaces declared in this header provide elementwise math operations
- *  on vectors; each lane of the result vector depends only on the data in the
- *  corresponding lane of the argument(s) to the function.
- *
- *  You should not use the C functions declared in this header directly (these
- *  are functions with names like `__tg_cos(x)`). These are merely
- *  implementation details of <tgmath.h> overloading; instead of calling
- *  `__tg_cos(x)`, call `cos(x)`. If you are writing C++, use `simd::cos(x)`.
- *
- *  Note that while these vector functions are relatively recent additions,
- *  scalar fallback is provided for all of them, so they are available even
- *  when targeting older OS versions.
- *
- *  The following functions are available:
- *
- *    C name        C++ name          Notes
- *    ----------------------------------------------------------------------
- *    acos(x)       simd::acos(x)     
- *    asin(x)       simd::asin(x)
- *    atan(x)       simd::atan(x)
- *    atan2(y,x)    simd::atan2(y,x)  The argument order matches the scalar
- *                                    atan2 function, which gives the angle
- *                                    of a line with slope y/x.
- *    cos(x)        simd::cos(x)
- *    sin(x)        simd::sin(x)
- *    tan(x)        simd::tan(x)
- *    
- *    cospi(x)      simd::cospi(x)    Returns cos(pi*x), sin(pi*x), tan(pi*x)
- *    sinpi(x)      simd::sinpi(x)    more efficiently and accurately than
- *    tanpi(x)      simd::tanpi(x)    would otherwise be possible
- *
- *    acosh(x)      simd::acosh(x)
- *    asinh(x)      simd::asinh(x)
- *    atanh(x)      simd::atanh(x)
- *
- *    cosh(x)       simd::cosh(x)
- *    sinh(x)       simd::sinh(x)
- *    tanh(x)       simd::tanh(x)
- *
- *    exp(x)        simd::exp(x)
- *    exp2(x)       simd::exp2(x)
- *    exp10(x)      simd::exp10(x)    More efficient that pow(10,x).
- *    expm1(x)      simd::expm1(x)    exp(x)-1, accurate even for tiny x.
- *
- *    log(x)        simd::log(x)
- *    log2(x)       simd::log2(x)
- *    log10(x)      simd::log10(x)
- *    log1p(x)      simd::log1p(x)    log(1+x), accurate even for tiny x.
- *
- *    fabs(x)       simd::fabs(x)
- *    cbrt(x)       simd::cbrt(x)
- *    sqrt(x)       simd::sqrt(x)
- *    pow(x,y)      simd::pow(x,y)
- *    copysign(x,y) simd::copysign(x,y)
- *    hypot(x,y)    simd::hypot(x,y)  sqrt(x*x + y*y), computed without
- *                                    overflow.1
- *    erf(x)        simd::erf(x)
- *    erfc(x)       simd::erfc(x)
- *    tgamma(x)     simd::tgamma(x)
- *
- *    fmod(x,y)      simd::fmod(x,y)
- *    remainder(x,y) simd::remainder(x,y)
- *
- *    ceil(x)       simd::ceil(x)
- *    floor(x)      simd::floor(x)
- *    rint(x)       simd::rint(x)
- *    round(x)      simd::round(x)
- *    trunc(x)      simd::trunc(x)
- *
- *    fdim(x,y)     simd::fdim(x,y)
- *    fmax(x,y)     simd::fmax(x,y)   When one argument to fmin or fmax is
- *    fmin(x,y)     simd::fmin(x,y)   constant, use it as the *second* (y)
- *                                    argument to get better codegen on some
- *                                    architectures. E.g., write fmin(x,2)
- *                                    instead of fmin(2,x).
- *    fma(x,y,z)    simd::fma(x,y,z)  Fast on arm64 and when targeting AVX2
- *                                    and later; may be quite expensive on
- *                                    older hardware.
- *    simd_muladd(x,y,z) simd::muladd(x,y,z)
- *
- *  @copyright 2014-2017 Apple, Inc. All rights reserved.
- *  @unsorted                                                                 */
-
-#ifndef SIMD_MATH_HEADER
-#define SIMD_MATH_HEADER
-
-#include <simd/base.h>
-#if SIMD_COMPILER_HAS_REQUIRED_FEATURES
-#include <simd/vector_make.h>
-#include <simd/logic.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-/*! @abstract Do not call this function; instead use `acos` in C and
- *  Objective-C, and `simd::acos` in C++.                                     */
-static inline SIMD_CFUNC simd_float2 __tg_acos(simd_float2 x);
-/*! @abstract Do not call this function; instead use `acos` in C and
- *  Objective-C, and `simd::acos` in C++.                                     */
-static inline SIMD_CFUNC simd_float3 __tg_acos(simd_float3 x);
-/*! @abstract Do not call this function; instead use `acos` in C and
- *  Objective-C, and `simd::acos` in C++.                                     */
-static inline SIMD_CFUNC simd_float4 __tg_acos(simd_float4 x);
-/*! @abstract Do not call this function; instead use `acos` in C and
- *  Objective-C, and `simd::acos` in C++.                                     */
-static inline SIMD_CFUNC simd_float8 __tg_acos(simd_float8 x);
-/*! @abstract Do not call this function; instead use `acos` in C and
- *  Objective-C, and `simd::acos` in C++.                                     */
-static inline SIMD_CFUNC simd_float16 __tg_acos(simd_float16 x);
-/*! @abstract Do not call this function; instead use `acos` in C and
- *  Objective-C, and `simd::acos` in C++.                                     */
-static inline SIMD_CFUNC simd_double2 __tg_acos(simd_double2 x);
-/*! @abstract Do not call this function; instead use `acos` in C and
- *  Objective-C, and `simd::acos` in C++.                                     */
-static inline SIMD_CFUNC simd_double3 __tg_acos(simd_double3 x);
-/*! @abstract Do not call this function; instead use `acos` in C and
- *  Objective-C, and `simd::acos` in C++.                                     */
-static inline SIMD_CFUNC simd_double4 __tg_acos(simd_double4 x);
-/*! @abstract Do not call this function; instead use `acos` in C and
- *  Objective-C, and `simd::acos` in C++.                                     */
-static inline SIMD_CFUNC simd_double8 __tg_acos(simd_double8 x);
-
-/*! @abstract Do not call this function; instead use `asin` in C and
- *  Objective-C, and `simd::asin` in C++.                                     */
-static inline SIMD_CFUNC simd_float2 __tg_asin(simd_float2 x);
-/*! @abstract Do not call this function; instead use `asin` in C and
- *  Objective-C, and `simd::asin` in C++.                                     */
-static inline SIMD_CFUNC simd_float3 __tg_asin(simd_float3 x);
-/*! @abstract Do not call this function; instead use `asin` in C and
- *  Objective-C, and `simd::asin` in C++.                                     */
-static inline SIMD_CFUNC simd_float4 __tg_asin(simd_float4 x);
-/*! @abstract Do not call this function; instead use `asin` in C and
- *  Objective-C, and `simd::asin` in C++.                                     */
-static inline SIMD_CFUNC simd_float8 __tg_asin(simd_float8 x);
-/*! @abstract Do not call this function; instead use `asin` in C and
- *  Objective-C, and `simd::asin` in C++.                                     */
-static inline SIMD_CFUNC simd_float16 __tg_asin(simd_float16 x);
-/*! @abstract Do not call this function; instead use `asin` in C and
- *  Objective-C, and `simd::asin` in C++.                                     */
-static inline SIMD_CFUNC simd_double2 __tg_asin(simd_double2 x);
-/*! @abstract Do not call this function; instead use `asin` in C and
- *  Objective-C, and `simd::asin` in C++.                                     */
-static inline SIMD_CFUNC simd_double3 __tg_asin(simd_double3 x);
-/*! @abstract Do not call this function; instead use `asin` in C and
- *  Objective-C, and `simd::asin` in C++.                                     */
-static inline SIMD_CFUNC simd_double4 __tg_asin(simd_double4 x);
-/*! @abstract Do not call this function; instead use `asin` in C and
- *  Objective-C, and `simd::asin` in C++.                                     */
-static inline SIMD_CFUNC simd_double8 __tg_asin(simd_double8 x);
-
-/*! @abstract Do not call this function; instead use `atan` in C and
- *  Objective-C, and `simd::atan` in C++.                                     */
-static inline SIMD_CFUNC simd_float2 __tg_atan(simd_float2 x);
-/*! @abstract Do not call this function; instead use `atan` in C and
- *  Objective-C, and `simd::atan` in C++.                                     */
-static inline SIMD_CFUNC simd_float3 __tg_atan(simd_float3 x);
-/*! @abstract Do not call this function; instead use `atan` in C and
- *  Objective-C, and `simd::atan` in C++.                                     */
-static inline SIMD_CFUNC simd_float4 __tg_atan(simd_float4 x);
-/*! @abstract Do not call this function; instead use `atan` in C and
- *  Objective-C, and `simd::atan` in C++.                                     */
-static inline SIMD_CFUNC simd_float8 __tg_atan(simd_float8 x);
-/*! @abstract Do not call this function; instead use `atan` in C and
- *  Objective-C, and `simd::atan` in C++.                                     */
-static inline SIMD_CFUNC simd_float16 __tg_atan(simd_float16 x);
-/*! @abstract Do not call this function; instead use `atan` in C and
- *  Objective-C, and `simd::atan` in C++.                                     */
-static inline SIMD_CFUNC simd_double2 __tg_atan(simd_double2 x);
-/*! @abstract Do not call this function; instead use `atan` in C and
- *  Objective-C, and `simd::atan` in C++.                                     */
-static inline SIMD_CFUNC simd_double3 __tg_atan(simd_double3 x);
-/*! @abstract Do not call this function; instead use `atan` in C and
- *  Objective-C, and `simd::atan` in C++.                                     */
-static inline SIMD_CFUNC simd_double4 __tg_atan(simd_double4 x);
-/*! @abstract Do not call this function; instead use `atan` in C and
- *  Objective-C, and `simd::atan` in C++.                                     */
-static inline SIMD_CFUNC simd_double8 __tg_atan(simd_double8 x);
-
-/*! @abstract Do not call this function; instead use `cos` in C and
- *  Objective-C, and `simd::cos` in C++.                                      */
-static inline SIMD_CFUNC simd_float2 __tg_cos(simd_float2 x);
-/*! @abstract Do not call this function; instead use `cos` in C and
- *  Objective-C, and `simd::cos` in C++.                                      */
-static inline SIMD_CFUNC simd_float3 __tg_cos(simd_float3 x);
-/*! @abstract Do not call this function; instead use `cos` in C and
- *  Objective-C, and `simd::cos` in C++.                                      */
-static inline SIMD_CFUNC simd_float4 __tg_cos(simd_float4 x);
-/*! @abstract Do not call this function; instead use `cos` in C and
- *  Objective-C, and `simd::cos` in C++.                                      */
-static inline SIMD_CFUNC simd_float8 __tg_cos(simd_float8 x);
-/*! @abstract Do not call this function; instead use `cos` in C and
- *  Objective-C, and `simd::cos` in C++.                                      */
-static inline SIMD_CFUNC simd_float16 __tg_cos(simd_float16 x);
-/*! @abstract Do not call this function; instead use `cos` in C and
- *  Objective-C, and `simd::cos` in C++.                                      */
-static inline SIMD_CFUNC simd_double2 __tg_cos(simd_double2 x);
-/*! @abstract Do not call this function; instead use `cos` in C and
- *  Objective-C, and `simd::cos` in C++.                                      */
-static inline SIMD_CFUNC simd_double3 __tg_cos(simd_double3 x);
-/*! @abstract Do not call this function; instead use `cos` in C and
- *  Objective-C, and `simd::cos` in C++.                                      */
-static inline SIMD_CFUNC simd_double4 __tg_cos(simd_double4 x);
-/*! @abstract Do not call this function; instead use `cos` in C and
- *  Objective-C, and `simd::cos` in C++.                                      */
-static inline SIMD_CFUNC simd_double8 __tg_cos(simd_double8 x);
-
-/*! @abstract Do not call this function; instead use `sin` in C and
- *  Objective-C, and `simd::sin` in C++.                                      */
-static inline SIMD_CFUNC simd_float2 __tg_sin(simd_float2 x);
-/*! @abstract Do not call this function; instead use `sin` in C and
- *  Objective-C, and `simd::sin` in C++.                                      */
-static inline SIMD_CFUNC simd_float3 __tg_sin(simd_float3 x);
-/*! @abstract Do not call this function; instead use `sin` in C and
- *  Objective-C, and `simd::sin` in C++.                                      */
-static inline SIMD_CFUNC simd_float4 __tg_sin(simd_float4 x);
-/*! @abstract Do not call this function; instead use `sin` in C and
- *  Objective-C, and `simd::sin` in C++.                                      */
-static inline SIMD_CFUNC simd_float8 __tg_sin(simd_float8 x);
-/*! @abstract Do not call this function; instead use `sin` in C and
- *  Objective-C, and `simd::sin` in C++.                                      */
-static inline SIMD_CFUNC simd_float16 __tg_sin(simd_float16 x);
-/*! @abstract Do not call this function; instead use `sin` in C and
- *  Objective-C, and `simd::sin` in C++.                                      */
-static inline SIMD_CFUNC simd_double2 __tg_sin(simd_double2 x);
-/*! @abstract Do not call this function; instead use `sin` in C and
- *  Objective-C, and `simd::sin` in C++.                                      */
-static inline SIMD_CFUNC simd_double3 __tg_sin(simd_double3 x);
-/*! @abstract Do not call this function; instead use `sin` in C and
- *  Objective-C, and `simd::sin` in C++.                                      */
-static inline SIMD_CFUNC simd_double4 __tg_sin(simd_double4 x);
-/*! @abstract Do not call this function; instead use `sin` in C and
- *  Objective-C, and `simd::sin` in C++.                                      */
-static inline SIMD_CFUNC simd_double8 __tg_sin(simd_double8 x);
-
-/*! @abstract Do not call this function; instead use `tan` in C and
- *  Objective-C, and `simd::tan` in C++.                                      */
-static inline SIMD_CFUNC simd_float2 __tg_tan(simd_float2 x);
-/*! @abstract Do not call this function; instead use `tan` in C and
- *  Objective-C, and `simd::tan` in C++.                                      */
-static inline SIMD_CFUNC simd_float3 __tg_tan(simd_float3 x);
-/*! @abstract Do not call this function; instead use `tan` in C and
- *  Objective-C, and `simd::tan` in C++.                                      */
-static inline SIMD_CFUNC simd_float4 __tg_tan(simd_float4 x);
-/*! @abstract Do not call this function; instead use `tan` in C and
- *  Objective-C, and `simd::tan` in C++.                                      */
-static inline SIMD_CFUNC simd_float8 __tg_tan(simd_float8 x);
-/*! @abstract Do not call this function; instead use `tan` in C and
- *  Objective-C, and `simd::tan` in C++.                                      */
-static inline SIMD_CFUNC simd_float16 __tg_tan(simd_float16 x);
-/*! @abstract Do not call this function; instead use `tan` in C and
- *  Objective-C, and `simd::tan` in C++.                                      */
-static inline SIMD_CFUNC simd_double2 __tg_tan(simd_double2 x);
-/*! @abstract Do not call this function; instead use `tan` in C and
- *  Objective-C, and `simd::tan` in C++.                                      */
-static inline SIMD_CFUNC simd_double3 __tg_tan(simd_double3 x);
-/*! @abstract Do not call this function; instead use `tan` in C and
- *  Objective-C, and `simd::tan` in C++.                                      */
-static inline SIMD_CFUNC simd_double4 __tg_tan(simd_double4 x);
-/*! @abstract Do not call this function; instead use `tan` in C and
- *  Objective-C, and `simd::tan` in C++.                                      */
-static inline SIMD_CFUNC simd_double8 __tg_tan(simd_double8 x);
-
-#if SIMD_LIBRARY_VERSION >= 1
-/*! @abstract Do not call this function; instead use `cospi` in C and
- *  Objective-C, and `simd::cospi` in C++.                                    */
-static inline SIMD_CFUNC simd_float2 __tg_cospi(simd_float2 x);
-/*! @abstract Do not call this function; instead use `cospi` in C and
- *  Objective-C, and `simd::cospi` in C++.                                    */
-static inline SIMD_CFUNC simd_float3 __tg_cospi(simd_float3 x);
-/*! @abstract Do not call this function; instead use `cospi` in C and
- *  Objective-C, and `simd::cospi` in C++.                                    */
-static inline SIMD_CFUNC simd_float4 __tg_cospi(simd_float4 x);
-/*! @abstract Do not call this function; instead use `cospi` in C and
- *  Objective-C, and `simd::cospi` in C++.                                    */
-static inline SIMD_CFUNC simd_float8 __tg_cospi(simd_float8 x);
-/*! @abstract Do not call this function; instead use `cospi` in C and
- *  Objective-C, and `simd::cospi` in C++.                                    */
-static inline SIMD_CFUNC simd_float16 __tg_cospi(simd_float16 x);
-/*! @abstract Do not call this function; instead use `cospi` in C and
- *  Objective-C, and `simd::cospi` in C++.                                    */
-static inline SIMD_CFUNC simd_double2 __tg_cospi(simd_double2 x);
-/*! @abstract Do not call this function; instead use `cospi` in C and
- *  Objective-C, and `simd::cospi` in C++.                                    */
-static inline SIMD_CFUNC simd_double3 __tg_cospi(simd_double3 x);
-/*! @abstract Do not call this function; instead use `cospi` in C and
- *  Objective-C, and `simd::cospi` in C++.                                    */
-static inline SIMD_CFUNC simd_double4 __tg_cospi(simd_double4 x);
-/*! @abstract Do not call this function; instead use `cospi` in C and
- *  Objective-C, and `simd::cospi` in C++.                                    */
-static inline SIMD_CFUNC simd_double8 __tg_cospi(simd_double8 x);
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 1
-/*! @abstract Do not call this function; instead use `sinpi` in C and
- *  Objective-C, and `simd::sinpi` in C++.                                    */
-static inline SIMD_CFUNC simd_float2 __tg_sinpi(simd_float2 x);
-/*! @abstract Do not call this function; instead use `sinpi` in C and
- *  Objective-C, and `simd::sinpi` in C++.                                    */
-static inline SIMD_CFUNC simd_float3 __tg_sinpi(simd_float3 x);
-/*! @abstract Do not call this function; instead use `sinpi` in C and
- *  Objective-C, and `simd::sinpi` in C++.                                    */
-static inline SIMD_CFUNC simd_float4 __tg_sinpi(simd_float4 x);
-/*! @abstract Do not call this function; instead use `sinpi` in C and
- *  Objective-C, and `simd::sinpi` in C++.                                    */
-static inline SIMD_CFUNC simd_float8 __tg_sinpi(simd_float8 x);
-/*! @abstract Do not call this function; instead use `sinpi` in C and
- *  Objective-C, and `simd::sinpi` in C++.                                    */
-static inline SIMD_CFUNC simd_float16 __tg_sinpi(simd_float16 x);
-/*! @abstract Do not call this function; instead use `sinpi` in C and
- *  Objective-C, and `simd::sinpi` in C++.                                    */
-static inline SIMD_CFUNC simd_double2 __tg_sinpi(simd_double2 x);
-/*! @abstract Do not call this function; instead use `sinpi` in C and
- *  Objective-C, and `simd::sinpi` in C++.                                    */
-static inline SIMD_CFUNC simd_double3 __tg_sinpi(simd_double3 x);
-/*! @abstract Do not call this function; instead use `sinpi` in C and
- *  Objective-C, and `simd::sinpi` in C++.                                    */
-static inline SIMD_CFUNC simd_double4 __tg_sinpi(simd_double4 x);
-/*! @abstract Do not call this function; instead use `sinpi` in C and
- *  Objective-C, and `simd::sinpi` in C++.                                    */
-static inline SIMD_CFUNC simd_double8 __tg_sinpi(simd_double8 x);
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 1
-/*! @abstract Do not call this function; instead use `tanpi` in C and
- *  Objective-C, and `simd::tanpi` in C++.                                    */
-static inline SIMD_CFUNC simd_float2 __tg_tanpi(simd_float2 x);
-/*! @abstract Do not call this function; instead use `tanpi` in C and
- *  Objective-C, and `simd::tanpi` in C++.                                    */
-static inline SIMD_CFUNC simd_float3 __tg_tanpi(simd_float3 x);
-/*! @abstract Do not call this function; instead use `tanpi` in C and
- *  Objective-C, and `simd::tanpi` in C++.                                    */
-static inline SIMD_CFUNC simd_float4 __tg_tanpi(simd_float4 x);
-/*! @abstract Do not call this function; instead use `tanpi` in C and
- *  Objective-C, and `simd::tanpi` in C++.                                    */
-static inline SIMD_CFUNC simd_float8 __tg_tanpi(simd_float8 x);
-/*! @abstract Do not call this function; instead use `tanpi` in C and
- *  Objective-C, and `simd::tanpi` in C++.                                    */
-static inline SIMD_CFUNC simd_float16 __tg_tanpi(simd_float16 x);
-/*! @abstract Do not call this function; instead use `tanpi` in C and
- *  Objective-C, and `simd::tanpi` in C++.                                    */
-static inline SIMD_CFUNC simd_double2 __tg_tanpi(simd_double2 x);
-/*! @abstract Do not call this function; instead use `tanpi` in C and
- *  Objective-C, and `simd::tanpi` in C++.                                    */
-static inline SIMD_CFUNC simd_double3 __tg_tanpi(simd_double3 x);
-/*! @abstract Do not call this function; instead use `tanpi` in C and
- *  Objective-C, and `simd::tanpi` in C++.                                    */
-static inline SIMD_CFUNC simd_double4 __tg_tanpi(simd_double4 x);
-/*! @abstract Do not call this function; instead use `tanpi` in C and
- *  Objective-C, and `simd::tanpi` in C++.                                    */
-static inline SIMD_CFUNC simd_double8 __tg_tanpi(simd_double8 x);
-#endif
-
-/*! @abstract Do not call this function; instead use `acosh` in C and
- *  Objective-C, and `simd::acosh` in C++.                                    */
-static inline SIMD_CFUNC simd_float2 __tg_acosh(simd_float2 x);
-/*! @abstract Do not call this function; instead use `acosh` in C and
- *  Objective-C, and `simd::acosh` in C++.                                    */
-static inline SIMD_CFUNC simd_float3 __tg_acosh(simd_float3 x);
-/*! @abstract Do not call this function; instead use `acosh` in C and
- *  Objective-C, and `simd::acosh` in C++.                                    */
-static inline SIMD_CFUNC simd_float4 __tg_acosh(simd_float4 x);
-/*! @abstract Do not call this function; instead use `acosh` in C and
- *  Objective-C, and `simd::acosh` in C++.                                    */
-static inline SIMD_CFUNC simd_float8 __tg_acosh(simd_float8 x);
-/*! @abstract Do not call this function; instead use `acosh` in C and
- *  Objective-C, and `simd::acosh` in C++.                                    */
-static inline SIMD_CFUNC simd_float16 __tg_acosh(simd_float16 x);
-/*! @abstract Do not call this function; instead use `acosh` in C and
- *  Objective-C, and `simd::acosh` in C++.                                    */
-static inline SIMD_CFUNC simd_double2 __tg_acosh(simd_double2 x);
-/*! @abstract Do not call this function; instead use `acosh` in C and
- *  Objective-C, and `simd::acosh` in C++.                                    */
-static inline SIMD_CFUNC simd_double3 __tg_acosh(simd_double3 x);
-/*! @abstract Do not call this function; instead use `acosh` in C and
- *  Objective-C, and `simd::acosh` in C++.                                    */
-static inline SIMD_CFUNC simd_double4 __tg_acosh(simd_double4 x);
-/*! @abstract Do not call this function; instead use `acosh` in C and
- *  Objective-C, and `simd::acosh` in C++.                                    */
-static inline SIMD_CFUNC simd_double8 __tg_acosh(simd_double8 x);
-
-/*! @abstract Do not call this function; instead use `asinh` in C and
- *  Objective-C, and `simd::asinh` in C++.                                    */
-static inline SIMD_CFUNC simd_float2 __tg_asinh(simd_float2 x);
-/*! @abstract Do not call this function; instead use `asinh` in C and
- *  Objective-C, and `simd::asinh` in C++.                                    */
-static inline SIMD_CFUNC simd_float3 __tg_asinh(simd_float3 x);
-/*! @abstract Do not call this function; instead use `asinh` in C and
- *  Objective-C, and `simd::asinh` in C++.                                    */
-static inline SIMD_CFUNC simd_float4 __tg_asinh(simd_float4 x);
-/*! @abstract Do not call this function; instead use `asinh` in C and
- *  Objective-C, and `simd::asinh` in C++.                                    */
-static inline SIMD_CFUNC simd_float8 __tg_asinh(simd_float8 x);
-/*! @abstract Do not call this function; instead use `asinh` in C and
- *  Objective-C, and `simd::asinh` in C++.                                    */
-static inline SIMD_CFUNC simd_float16 __tg_asinh(simd_float16 x);
-/*! @abstract Do not call this function; instead use `asinh` in C and
- *  Objective-C, and `simd::asinh` in C++.                                    */
-static inline SIMD_CFUNC simd_double2 __tg_asinh(simd_double2 x);
-/*! @abstract Do not call this function; instead use `asinh` in C and
- *  Objective-C, and `simd::asinh` in C++.                                    */
-static inline SIMD_CFUNC simd_double3 __tg_asinh(simd_double3 x);
-/*! @abstract Do not call this function; instead use `asinh` in C and
- *  Objective-C, and `simd::asinh` in C++.                                    */
-static inline SIMD_CFUNC simd_double4 __tg_asinh(simd_double4 x);
-/*! @abstract Do not call this function; instead use `asinh` in C and
- *  Objective-C, and `simd::asinh` in C++.                                    */
-static inline SIMD_CFUNC simd_double8 __tg_asinh(simd_double8 x);
-
-/*! @abstract Do not call this function; instead use `atanh` in C and
- *  Objective-C, and `simd::atanh` in C++.                                    */
-static inline SIMD_CFUNC simd_float2 __tg_atanh(simd_float2 x);
-/*! @abstract Do not call this function; instead use `atanh` in C and
- *  Objective-C, and `simd::atanh` in C++.                                    */
-static inline SIMD_CFUNC simd_float3 __tg_atanh(simd_float3 x);
-/*! @abstract Do not call this function; instead use `atanh` in C and
- *  Objective-C, and `simd::atanh` in C++.                                    */
-static inline SIMD_CFUNC simd_float4 __tg_atanh(simd_float4 x);
-/*! @abstract Do not call this function; instead use `atanh` in C and
- *  Objective-C, and `simd::atanh` in C++.                                    */
-static inline SIMD_CFUNC simd_float8 __tg_atanh(simd_float8 x);
-/*! @abstract Do not call this function; instead use `atanh` in C and
- *  Objective-C, and `simd::atanh` in C++.                                    */
-static inline SIMD_CFUNC simd_float16 __tg_atanh(simd_float16 x);
-/*! @abstract Do not call this function; instead use `atanh` in C and
- *  Objective-C, and `simd::atanh` in C++.                                    */
-static inline SIMD_CFUNC simd_double2 __tg_atanh(simd_double2 x);
-/*! @abstract Do not call this function; instead use `atanh` in C and
- *  Objective-C, and `simd::atanh` in C++.                                    */
-static inline SIMD_CFUNC simd_double3 __tg_atanh(simd_double3 x);
-/*! @abstract Do not call this function; instead use `atanh` in C and
- *  Objective-C, and `simd::atanh` in C++.                                    */
-static inline SIMD_CFUNC simd_double4 __tg_atanh(simd_double4 x);
-/*! @abstract Do not call this function; instead use `atanh` in C and
- *  Objective-C, and `simd::atanh` in C++.                                    */
-static inline SIMD_CFUNC simd_double8 __tg_atanh(simd_double8 x);
-
-/*! @abstract Do not call this function; instead use `cosh` in C and
- *  Objective-C, and `simd::cosh` in C++.                                     */
-static inline SIMD_CFUNC simd_float2 __tg_cosh(simd_float2 x);
-/*! @abstract Do not call this function; instead use `cosh` in C and
- *  Objective-C, and `simd::cosh` in C++.                                     */
-static inline SIMD_CFUNC simd_float3 __tg_cosh(simd_float3 x);
-/*! @abstract Do not call this function; instead use `cosh` in C and
- *  Objective-C, and `simd::cosh` in C++.                                     */
-static inline SIMD_CFUNC simd_float4 __tg_cosh(simd_float4 x);
-/*! @abstract Do not call this function; instead use `cosh` in C and
- *  Objective-C, and `simd::cosh` in C++.                                     */
-static inline SIMD_CFUNC simd_float8 __tg_cosh(simd_float8 x);
-/*! @abstract Do not call this function; instead use `cosh` in C and
- *  Objective-C, and `simd::cosh` in C++.                                     */
-static inline SIMD_CFUNC simd_float16 __tg_cosh(simd_float16 x);
-/*! @abstract Do not call this function; instead use `cosh` in C and
- *  Objective-C, and `simd::cosh` in C++.                                     */
-static inline SIMD_CFUNC simd_double2 __tg_cosh(simd_double2 x);
-/*! @abstract Do not call this function; instead use `cosh` in C and
- *  Objective-C, and `simd::cosh` in C++.                                     */
-static inline SIMD_CFUNC simd_double3 __tg_cosh(simd_double3 x);
-/*! @abstract Do not call this function; instead use `cosh` in C and
- *  Objective-C, and `simd::cosh` in C++.                                     */
-static inline SIMD_CFUNC simd_double4 __tg_cosh(simd_double4 x);
-/*! @abstract Do not call this function; instead use `cosh` in C and
- *  Objective-C, and `simd::cosh` in C++.                                     */
-static inline SIMD_CFUNC simd_double8 __tg_cosh(simd_double8 x);
-
-/*! @abstract Do not call this function; instead use `sinh` in C and
- *  Objective-C, and `simd::sinh` in C++.                                     */
-static inline SIMD_CFUNC simd_float2 __tg_sinh(simd_float2 x);
-/*! @abstract Do not call this function; instead use `sinh` in C and
- *  Objective-C, and `simd::sinh` in C++.                                     */
-static inline SIMD_CFUNC simd_float3 __tg_sinh(simd_float3 x);
-/*! @abstract Do not call this function; instead use `sinh` in C and
- *  Objective-C, and `simd::sinh` in C++.                                     */
-static inline SIMD_CFUNC simd_float4 __tg_sinh(simd_float4 x);
-/*! @abstract Do not call this function; instead use `sinh` in C and
- *  Objective-C, and `simd::sinh` in C++.                                     */
-static inline SIMD_CFUNC simd_float8 __tg_sinh(simd_float8 x);
-/*! @abstract Do not call this function; instead use `sinh` in C and
- *  Objective-C, and `simd::sinh` in C++.                                     */
-static inline SIMD_CFUNC simd_float16 __tg_sinh(simd_float16 x);
-/*! @abstract Do not call this function; instead use `sinh` in C and
- *  Objective-C, and `simd::sinh` in C++.                                     */
-static inline SIMD_CFUNC simd_double2 __tg_sinh(simd_double2 x);
-/*! @abstract Do not call this function; instead use `sinh` in C and
- *  Objective-C, and `simd::sinh` in C++.                                     */
-static inline SIMD_CFUNC simd_double3 __tg_sinh(simd_double3 x);
-/*! @abstract Do not call this function; instead use `sinh` in C and
- *  Objective-C, and `simd::sinh` in C++.                                     */
-static inline SIMD_CFUNC simd_double4 __tg_sinh(simd_double4 x);
-/*! @abstract Do not call this function; instead use `sinh` in C and
- *  Objective-C, and `simd::sinh` in C++.                                     */
-static inline SIMD_CFUNC simd_double8 __tg_sinh(simd_double8 x);
-
-/*! @abstract Do not call this function; instead use `tanh` in C and
- *  Objective-C, and `simd::tanh` in C++.                                     */
-static inline SIMD_CFUNC simd_float2 __tg_tanh(simd_float2 x);
-/*! @abstract Do not call this function; instead use `tanh` in C and
- *  Objective-C, and `simd::tanh` in C++.                                     */
-static inline SIMD_CFUNC simd_float3 __tg_tanh(simd_float3 x);
-/*! @abstract Do not call this function; instead use `tanh` in C and
- *  Objective-C, and `simd::tanh` in C++.                                     */
-static inline SIMD_CFUNC simd_float4 __tg_tanh(simd_float4 x);
-/*! @abstract Do not call this function; instead use `tanh` in C and
- *  Objective-C, and `simd::tanh` in C++.                                     */
-static inline SIMD_CFUNC simd_float8 __tg_tanh(simd_float8 x);
-/*! @abstract Do not call this function; instead use `tanh` in C and
- *  Objective-C, and `simd::tanh` in C++.                                     */
-static inline SIMD_CFUNC simd_float16 __tg_tanh(simd_float16 x);
-/*! @abstract Do not call this function; instead use `tanh` in C and
- *  Objective-C, and `simd::tanh` in C++.                                     */
-static inline SIMD_CFUNC simd_double2 __tg_tanh(simd_double2 x);
-/*! @abstract Do not call this function; instead use `tanh` in C and
- *  Objective-C, and `simd::tanh` in C++.                                     */
-static inline SIMD_CFUNC simd_double3 __tg_tanh(simd_double3 x);
-/*! @abstract Do not call this function; instead use `tanh` in C and
- *  Objective-C, and `simd::tanh` in C++.                                     */
-static inline SIMD_CFUNC simd_double4 __tg_tanh(simd_double4 x);
-/*! @abstract Do not call this function; instead use `tanh` in C and
- *  Objective-C, and `simd::tanh` in C++.                                     */
-static inline SIMD_CFUNC simd_double8 __tg_tanh(simd_double8 x);
-
-/*! @abstract Do not call this function; instead use `exp` in C and
- *  Objective-C, and `simd::exp` in C++.                                      */
-static inline SIMD_CFUNC simd_float2 __tg_exp(simd_float2 x);
-/*! @abstract Do not call this function; instead use `exp` in C and
- *  Objective-C, and `simd::exp` in C++.                                      */
-static inline SIMD_CFUNC simd_float3 __tg_exp(simd_float3 x);
-/*! @abstract Do not call this function; instead use `exp` in C and
- *  Objective-C, and `simd::exp` in C++.                                      */
-static inline SIMD_CFUNC simd_float4 __tg_exp(simd_float4 x);
-/*! @abstract Do not call this function; instead use `exp` in C and
- *  Objective-C, and `simd::exp` in C++.                                      */
-static inline SIMD_CFUNC simd_float8 __tg_exp(simd_float8 x);
-/*! @abstract Do not call this function; instead use `exp` in C and
- *  Objective-C, and `simd::exp` in C++.                                      */
-static inline SIMD_CFUNC simd_float16 __tg_exp(simd_float16 x);
-/*! @abstract Do not call this function; instead use `exp` in C and
- *  Objective-C, and `simd::exp` in C++.                                      */
-static inline SIMD_CFUNC simd_double2 __tg_exp(simd_double2 x);
-/*! @abstract Do not call this function; instead use `exp` in C and
- *  Objective-C, and `simd::exp` in C++.                                      */
-static inline SIMD_CFUNC simd_double3 __tg_exp(simd_double3 x);
-/*! @abstract Do not call this function; instead use `exp` in C and
- *  Objective-C, and `simd::exp` in C++.                                      */
-static inline SIMD_CFUNC simd_double4 __tg_exp(simd_double4 x);
-/*! @abstract Do not call this function; instead use `exp` in C and
- *  Objective-C, and `simd::exp` in C++.                                      */
-static inline SIMD_CFUNC simd_double8 __tg_exp(simd_double8 x);
-
-/*! @abstract Do not call this function; instead use `exp2` in C and
- *  Objective-C, and `simd::exp2` in C++.                                     */
-static inline SIMD_CFUNC simd_float2 __tg_exp2(simd_float2 x);
-/*! @abstract Do not call this function; instead use `exp2` in C and
- *  Objective-C, and `simd::exp2` in C++.                                     */
-static inline SIMD_CFUNC simd_float3 __tg_exp2(simd_float3 x);
-/*! @abstract Do not call this function; instead use `exp2` in C and
- *  Objective-C, and `simd::exp2` in C++.                                     */
-static inline SIMD_CFUNC simd_float4 __tg_exp2(simd_float4 x);
-/*! @abstract Do not call this function; instead use `exp2` in C and
- *  Objective-C, and `simd::exp2` in C++.                                     */
-static inline SIMD_CFUNC simd_float8 __tg_exp2(simd_float8 x);
-/*! @abstract Do not call this function; instead use `exp2` in C and
- *  Objective-C, and `simd::exp2` in C++.                                     */
-static inline SIMD_CFUNC simd_float16 __tg_exp2(simd_float16 x);
-/*! @abstract Do not call this function; instead use `exp2` in C and
- *  Objective-C, and `simd::exp2` in C++.                                     */
-static inline SIMD_CFUNC simd_double2 __tg_exp2(simd_double2 x);
-/*! @abstract Do not call this function; instead use `exp2` in C and
- *  Objective-C, and `simd::exp2` in C++.                                     */
-static inline SIMD_CFUNC simd_double3 __tg_exp2(simd_double3 x);
-/*! @abstract Do not call this function; instead use `exp2` in C and
- *  Objective-C, and `simd::exp2` in C++.                                     */
-static inline SIMD_CFUNC simd_double4 __tg_exp2(simd_double4 x);
-/*! @abstract Do not call this function; instead use `exp2` in C and
- *  Objective-C, and `simd::exp2` in C++.                                     */
-static inline SIMD_CFUNC simd_double8 __tg_exp2(simd_double8 x);
-
-#if SIMD_LIBRARY_VERSION >= 1
-/*! @abstract Do not call this function; instead use `exp10` in C and
- *  Objective-C, and `simd::exp10` in C++.                                    */
-static inline SIMD_CFUNC simd_float2 __tg_exp10(simd_float2 x);
-/*! @abstract Do not call this function; instead use `exp10` in C and
- *  Objective-C, and `simd::exp10` in C++.                                    */
-static inline SIMD_CFUNC simd_float3 __tg_exp10(simd_float3 x);
-/*! @abstract Do not call this function; instead use `exp10` in C and
- *  Objective-C, and `simd::exp10` in C++.                                    */
-static inline SIMD_CFUNC simd_float4 __tg_exp10(simd_float4 x);
-/*! @abstract Do not call this function; instead use `exp10` in C and
- *  Objective-C, and `simd::exp10` in C++.                                    */
-static inline SIMD_CFUNC simd_float8 __tg_exp10(simd_float8 x);
-/*! @abstract Do not call this function; instead use `exp10` in C and
- *  Objective-C, and `simd::exp10` in C++.                                    */
-static inline SIMD_CFUNC simd_float16 __tg_exp10(simd_float16 x);
-/*! @abstract Do not call this function; instead use `exp10` in C and
- *  Objective-C, and `simd::exp10` in C++.                                    */
-static inline SIMD_CFUNC simd_double2 __tg_exp10(simd_double2 x);
-/*! @abstract Do not call this function; instead use `exp10` in C and
- *  Objective-C, and `simd::exp10` in C++.                                    */
-static inline SIMD_CFUNC simd_double3 __tg_exp10(simd_double3 x);
-/*! @abstract Do not call this function; instead use `exp10` in C and
- *  Objective-C, and `simd::exp10` in C++.                                    */
-static inline SIMD_CFUNC simd_double4 __tg_exp10(simd_double4 x);
-/*! @abstract Do not call this function; instead use `exp10` in C and
- *  Objective-C, and `simd::exp10` in C++.                                    */
-static inline SIMD_CFUNC simd_double8 __tg_exp10(simd_double8 x);
-#endif
-
-/*! @abstract Do not call this function; instead use `expm1` in C and
- *  Objective-C, and `simd::expm1` in C++.                                    */
-static inline SIMD_CFUNC simd_float2 __tg_expm1(simd_float2 x);
-/*! @abstract Do not call this function; instead use `expm1` in C and
- *  Objective-C, and `simd::expm1` in C++.                                    */
-static inline SIMD_CFUNC simd_float3 __tg_expm1(simd_float3 x);
-/*! @abstract Do not call this function; instead use `expm1` in C and
- *  Objective-C, and `simd::expm1` in C++.                                    */
-static inline SIMD_CFUNC simd_float4 __tg_expm1(simd_float4 x);
-/*! @abstract Do not call this function; instead use `expm1` in C and
- *  Objective-C, and `simd::expm1` in C++.                                    */
-static inline SIMD_CFUNC simd_float8 __tg_expm1(simd_float8 x);
-/*! @abstract Do not call this function; instead use `expm1` in C and
- *  Objective-C, and `simd::expm1` in C++.                                    */
-static inline SIMD_CFUNC simd_float16 __tg_expm1(simd_float16 x);
-/*! @abstract Do not call this function; instead use `expm1` in C and
- *  Objective-C, and `simd::expm1` in C++.                                    */
-static inline SIMD_CFUNC simd_double2 __tg_expm1(simd_double2 x);
-/*! @abstract Do not call this function; instead use `expm1` in C and
- *  Objective-C, and `simd::expm1` in C++.                                    */
-static inline SIMD_CFUNC simd_double3 __tg_expm1(simd_double3 x);
-/*! @abstract Do not call this function; instead use `expm1` in C and
- *  Objective-C, and `simd::expm1` in C++.                                    */
-static inline SIMD_CFUNC simd_double4 __tg_expm1(simd_double4 x);
-/*! @abstract Do not call this function; instead use `expm1` in C and
- *  Objective-C, and `simd::expm1` in C++.                                    */
-static inline SIMD_CFUNC simd_double8 __tg_expm1(simd_double8 x);
-
-/*! @abstract Do not call this function; instead use `log` in C and
- *  Objective-C, and `simd::log` in C++.                                      */
-static inline SIMD_CFUNC simd_float2 __tg_log(simd_float2 x);
-/*! @abstract Do not call this function; instead use `log` in C and
- *  Objective-C, and `simd::log` in C++.                                      */
-static inline SIMD_CFUNC simd_float3 __tg_log(simd_float3 x);
-/*! @abstract Do not call this function; instead use `log` in C and
- *  Objective-C, and `simd::log` in C++.                                      */
-static inline SIMD_CFUNC simd_float4 __tg_log(simd_float4 x);
-/*! @abstract Do not call this function; instead use `log` in C and
- *  Objective-C, and `simd::log` in C++.                                      */
-static inline SIMD_CFUNC simd_float8 __tg_log(simd_float8 x);
-/*! @abstract Do not call this function; instead use `log` in C and
- *  Objective-C, and `simd::log` in C++.                                      */
-static inline SIMD_CFUNC simd_float16 __tg_log(simd_float16 x);
-/*! @abstract Do not call this function; instead use `log` in C and
- *  Objective-C, and `simd::log` in C++.                                      */
-static inline SIMD_CFUNC simd_double2 __tg_log(simd_double2 x);
-/*! @abstract Do not call this function; instead use `log` in C and
- *  Objective-C, and `simd::log` in C++.                                      */
-static inline SIMD_CFUNC simd_double3 __tg_log(simd_double3 x);
-/*! @abstract Do not call this function; instead use `log` in C and
- *  Objective-C, and `simd::log` in C++.                                      */
-static inline SIMD_CFUNC simd_double4 __tg_log(simd_double4 x);
-/*! @abstract Do not call this function; instead use `log` in C and
- *  Objective-C, and `simd::log` in C++.                                      */
-static inline SIMD_CFUNC simd_double8 __tg_log(simd_double8 x);
-
-/*! @abstract Do not call this function; instead use `log2` in C and
- *  Objective-C, and `simd::log2` in C++.                                     */
-static inline SIMD_CFUNC simd_float2 __tg_log2(simd_float2 x);
-/*! @abstract Do not call this function; instead use `log2` in C and
- *  Objective-C, and `simd::log2` in C++.                                     */
-static inline SIMD_CFUNC simd_float3 __tg_log2(simd_float3 x);
-/*! @abstract Do not call this function; instead use `log2` in C and
- *  Objective-C, and `simd::log2` in C++.                                     */
-static inline SIMD_CFUNC simd_float4 __tg_log2(simd_float4 x);
-/*! @abstract Do not call this function; instead use `log2` in C and
- *  Objective-C, and `simd::log2` in C++.                                     */
-static inline SIMD_CFUNC simd_float8 __tg_log2(simd_float8 x);
-/*! @abstract Do not call this function; instead use `log2` in C and
- *  Objective-C, and `simd::log2` in C++.                                     */
-static inline SIMD_CFUNC simd_float16 __tg_log2(simd_float16 x);
-/*! @abstract Do not call this function; instead use `log2` in C and
- *  Objective-C, and `simd::log2` in C++.                                     */
-static inline SIMD_CFUNC simd_double2 __tg_log2(simd_double2 x);
-/*! @abstract Do not call this function; instead use `log2` in C and
- *  Objective-C, and `simd::log2` in C++.                                     */
-static inline SIMD_CFUNC simd_double3 __tg_log2(simd_double3 x);
-/*! @abstract Do not call this function; instead use `log2` in C and
- *  Objective-C, and `simd::log2` in C++.                                     */
-static inline SIMD_CFUNC simd_double4 __tg_log2(simd_double4 x);
-/*! @abstract Do not call this function; instead use `log2` in C and
- *  Objective-C, and `simd::log2` in C++.                                     */
-static inline SIMD_CFUNC simd_double8 __tg_log2(simd_double8 x);
-
-/*! @abstract Do not call this function; instead use `log10` in C and
- *  Objective-C, and `simd::log10` in C++.                                    */
-static inline SIMD_CFUNC simd_float2 __tg_log10(simd_float2 x);
-/*! @abstract Do not call this function; instead use `log10` in C and
- *  Objective-C, and `simd::log10` in C++.                                    */
-static inline SIMD_CFUNC simd_float3 __tg_log10(simd_float3 x);
-/*! @abstract Do not call this function; instead use `log10` in C and
- *  Objective-C, and `simd::log10` in C++.                                    */
-static inline SIMD_CFUNC simd_float4 __tg_log10(simd_float4 x);
-/*! @abstract Do not call this function; instead use `log10` in C and
- *  Objective-C, and `simd::log10` in C++.                                    */
-static inline SIMD_CFUNC simd_float8 __tg_log10(simd_float8 x);
-/*! @abstract Do not call this function; instead use `log10` in C and
- *  Objective-C, and `simd::log10` in C++.                                    */
-static inline SIMD_CFUNC simd_float16 __tg_log10(simd_float16 x);
-/*! @abstract Do not call this function; instead use `log10` in C and
- *  Objective-C, and `simd::log10` in C++.                                    */
-static inline SIMD_CFUNC simd_double2 __tg_log10(simd_double2 x);
-/*! @abstract Do not call this function; instead use `log10` in C and
- *  Objective-C, and `simd::log10` in C++.                                    */
-static inline SIMD_CFUNC simd_double3 __tg_log10(simd_double3 x);
-/*! @abstract Do not call this function; instead use `log10` in C and
- *  Objective-C, and `simd::log10` in C++.                                    */
-static inline SIMD_CFUNC simd_double4 __tg_log10(simd_double4 x);
-/*! @abstract Do not call this function; instead use `log10` in C and
- *  Objective-C, and `simd::log10` in C++.                                    */
-static inline SIMD_CFUNC simd_double8 __tg_log10(simd_double8 x);
-
-/*! @abstract Do not call this function; instead use `log1p` in C and
- *  Objective-C, and `simd::log1p` in C++.                                    */
-static inline SIMD_CFUNC simd_float2 __tg_log1p(simd_float2 x);
-/*! @abstract Do not call this function; instead use `log1p` in C and
- *  Objective-C, and `simd::log1p` in C++.                                    */
-static inline SIMD_CFUNC simd_float3 __tg_log1p(simd_float3 x);
-/*! @abstract Do not call this function; instead use `log1p` in C and
- *  Objective-C, and `simd::log1p` in C++.                                    */
-static inline SIMD_CFUNC simd_float4 __tg_log1p(simd_float4 x);
-/*! @abstract Do not call this function; instead use `log1p` in C and
- *  Objective-C, and `simd::log1p` in C++.                                    */
-static inline SIMD_CFUNC simd_float8 __tg_log1p(simd_float8 x);
-/*! @abstract Do not call this function; instead use `log1p` in C and
- *  Objective-C, and `simd::log1p` in C++.                                    */
-static inline SIMD_CFUNC simd_float16 __tg_log1p(simd_float16 x);
-/*! @abstract Do not call this function; instead use `log1p` in C and
- *  Objective-C, and `simd::log1p` in C++.                                    */
-static inline SIMD_CFUNC simd_double2 __tg_log1p(simd_double2 x);
-/*! @abstract Do not call this function; instead use `log1p` in C and
- *  Objective-C, and `simd::log1p` in C++.                                    */
-static inline SIMD_CFUNC simd_double3 __tg_log1p(simd_double3 x);
-/*! @abstract Do not call this function; instead use `log1p` in C and
- *  Objective-C, and `simd::log1p` in C++.                                    */
-static inline SIMD_CFUNC simd_double4 __tg_log1p(simd_double4 x);
-/*! @abstract Do not call this function; instead use `log1p` in C and
- *  Objective-C, and `simd::log1p` in C++.                                    */
-static inline SIMD_CFUNC simd_double8 __tg_log1p(simd_double8 x);
-
-/*! @abstract Do not call this function; instead use `fabs` in C and
- *  Objective-C, and `simd::fabs` in C++.                                     */
-static inline SIMD_CFUNC simd_float2 __tg_fabs(simd_float2 x);
-/*! @abstract Do not call this function; instead use `fabs` in C and
- *  Objective-C, and `simd::fabs` in C++.                                     */
-static inline SIMD_CFUNC simd_float3 __tg_fabs(simd_float3 x);
-/*! @abstract Do not call this function; instead use `fabs` in C and
- *  Objective-C, and `simd::fabs` in C++.                                     */
-static inline SIMD_CFUNC simd_float4 __tg_fabs(simd_float4 x);
-/*! @abstract Do not call this function; instead use `fabs` in C and
- *  Objective-C, and `simd::fabs` in C++.                                     */
-static inline SIMD_CFUNC simd_float8 __tg_fabs(simd_float8 x);
-/*! @abstract Do not call this function; instead use `fabs` in C and
- *  Objective-C, and `simd::fabs` in C++.                                     */
-static inline SIMD_CFUNC simd_float16 __tg_fabs(simd_float16 x);
-/*! @abstract Do not call this function; instead use `fabs` in C and
- *  Objective-C, and `simd::fabs` in C++.                                     */
-static inline SIMD_CFUNC simd_double2 __tg_fabs(simd_double2 x);
-/*! @abstract Do not call this function; instead use `fabs` in C and
- *  Objective-C, and `simd::fabs` in C++.                                     */
-static inline SIMD_CFUNC simd_double3 __tg_fabs(simd_double3 x);
-/*! @abstract Do not call this function; instead use `fabs` in C and
- *  Objective-C, and `simd::fabs` in C++.                                     */
-static inline SIMD_CFUNC simd_double4 __tg_fabs(simd_double4 x);
-/*! @abstract Do not call this function; instead use `fabs` in C and
- *  Objective-C, and `simd::fabs` in C++.                                     */
-static inline SIMD_CFUNC simd_double8 __tg_fabs(simd_double8 x);
-
-/*! @abstract Do not call this function; instead use `cbrt` in C and
- *  Objective-C, and `simd::cbrt` in C++.                                     */
-static inline SIMD_CFUNC simd_float2 __tg_cbrt(simd_float2 x);
-/*! @abstract Do not call this function; instead use `cbrt` in C and
- *  Objective-C, and `simd::cbrt` in C++.                                     */
-static inline SIMD_CFUNC simd_float3 __tg_cbrt(simd_float3 x);
-/*! @abstract Do not call this function; instead use `cbrt` in C and
- *  Objective-C, and `simd::cbrt` in C++.                                     */
-static inline SIMD_CFUNC simd_float4 __tg_cbrt(simd_float4 x);
-/*! @abstract Do not call this function; instead use `cbrt` in C and
- *  Objective-C, and `simd::cbrt` in C++.                                     */
-static inline SIMD_CFUNC simd_float8 __tg_cbrt(simd_float8 x);
-/*! @abstract Do not call this function; instead use `cbrt` in C and
- *  Objective-C, and `simd::cbrt` in C++.                                     */
-static inline SIMD_CFUNC simd_float16 __tg_cbrt(simd_float16 x);
-/*! @abstract Do not call this function; instead use `cbrt` in C and
- *  Objective-C, and `simd::cbrt` in C++.                                     */
-static inline SIMD_CFUNC simd_double2 __tg_cbrt(simd_double2 x);
-/*! @abstract Do not call this function; instead use `cbrt` in C and
- *  Objective-C, and `simd::cbrt` in C++.                                     */
-static inline SIMD_CFUNC simd_double3 __tg_cbrt(simd_double3 x);
-/*! @abstract Do not call this function; instead use `cbrt` in C and
- *  Objective-C, and `simd::cbrt` in C++.                                     */
-static inline SIMD_CFUNC simd_double4 __tg_cbrt(simd_double4 x);
-/*! @abstract Do not call this function; instead use `cbrt` in C and
- *  Objective-C, and `simd::cbrt` in C++.                                     */
-static inline SIMD_CFUNC simd_double8 __tg_cbrt(simd_double8 x);
-
-/*! @abstract Do not call this function; instead use `sqrt` in C and
- *  Objective-C, and `simd::sqrt` in C++.                                     */
-static inline SIMD_CFUNC simd_float2 __tg_sqrt(simd_float2 x);
-/*! @abstract Do not call this function; instead use `sqrt` in C and
- *  Objective-C, and `simd::sqrt` in C++.                                     */
-static inline SIMD_CFUNC simd_float3 __tg_sqrt(simd_float3 x);
-/*! @abstract Do not call this function; instead use `sqrt` in C and
- *  Objective-C, and `simd::sqrt` in C++.                                     */
-static inline SIMD_CFUNC simd_float4 __tg_sqrt(simd_float4 x);
-/*! @abstract Do not call this function; instead use `sqrt` in C and
- *  Objective-C, and `simd::sqrt` in C++.                                     */
-static inline SIMD_CFUNC simd_float8 __tg_sqrt(simd_float8 x);
-/*! @abstract Do not call this function; instead use `sqrt` in C and
- *  Objective-C, and `simd::sqrt` in C++.                                     */
-static inline SIMD_CFUNC simd_float16 __tg_sqrt(simd_float16 x);
-/*! @abstract Do not call this function; instead use `sqrt` in C and
- *  Objective-C, and `simd::sqrt` in C++.                                     */
-static inline SIMD_CFUNC simd_double2 __tg_sqrt(simd_double2 x);
-/*! @abstract Do not call this function; instead use `sqrt` in C and
- *  Objective-C, and `simd::sqrt` in C++.                                     */
-static inline SIMD_CFUNC simd_double3 __tg_sqrt(simd_double3 x);
-/*! @abstract Do not call this function; instead use `sqrt` in C and
- *  Objective-C, and `simd::sqrt` in C++.                                     */
-static inline SIMD_CFUNC simd_double4 __tg_sqrt(simd_double4 x);
-/*! @abstract Do not call this function; instead use `sqrt` in C and
- *  Objective-C, and `simd::sqrt` in C++.                                     */
-static inline SIMD_CFUNC simd_double8 __tg_sqrt(simd_double8 x);
-
-/*! @abstract Do not call this function; instead use `erf` in C and
- *  Objective-C, and `simd::erf` in C++.                                      */
-static inline SIMD_CFUNC simd_float2 __tg_erf(simd_float2 x);
-/*! @abstract Do not call this function; instead use `erf` in C and
- *  Objective-C, and `simd::erf` in C++.                                      */
-static inline SIMD_CFUNC simd_float3 __tg_erf(simd_float3 x);
-/*! @abstract Do not call this function; instead use `erf` in C and
- *  Objective-C, and `simd::erf` in C++.                                      */
-static inline SIMD_CFUNC simd_float4 __tg_erf(simd_float4 x);
-/*! @abstract Do not call this function; instead use `erf` in C and
- *  Objective-C, and `simd::erf` in C++.                                      */
-static inline SIMD_CFUNC simd_float8 __tg_erf(simd_float8 x);
-/*! @abstract Do not call this function; instead use `erf` in C and
- *  Objective-C, and `simd::erf` in C++.                                      */
-static inline SIMD_CFUNC simd_float16 __tg_erf(simd_float16 x);
-/*! @abstract Do not call this function; instead use `erf` in C and
- *  Objective-C, and `simd::erf` in C++.                                      */
-static inline SIMD_CFUNC simd_double2 __tg_erf(simd_double2 x);
-/*! @abstract Do not call this function; instead use `erf` in C and
- *  Objective-C, and `simd::erf` in C++.                                      */
-static inline SIMD_CFUNC simd_double3 __tg_erf(simd_double3 x);
-/*! @abstract Do not call this function; instead use `erf` in C and
- *  Objective-C, and `simd::erf` in C++.                                      */
-static inline SIMD_CFUNC simd_double4 __tg_erf(simd_double4 x);
-/*! @abstract Do not call this function; instead use `erf` in C and
- *  Objective-C, and `simd::erf` in C++.                                      */
-static inline SIMD_CFUNC simd_double8 __tg_erf(simd_double8 x);
-
-/*! @abstract Do not call this function; instead use `erfc` in C and
- *  Objective-C, and `simd::erfc` in C++.                                     */
-static inline SIMD_CFUNC simd_float2 __tg_erfc(simd_float2 x);
-/*! @abstract Do not call this function; instead use `erfc` in C and
- *  Objective-C, and `simd::erfc` in C++.                                     */
-static inline SIMD_CFUNC simd_float3 __tg_erfc(simd_float3 x);
-/*! @abstract Do not call this function; instead use `erfc` in C and
- *  Objective-C, and `simd::erfc` in C++.                                     */
-static inline SIMD_CFUNC simd_float4 __tg_erfc(simd_float4 x);
-/*! @abstract Do not call this function; instead use `erfc` in C and
- *  Objective-C, and `simd::erfc` in C++.                                     */
-static inline SIMD_CFUNC simd_float8 __tg_erfc(simd_float8 x);
-/*! @abstract Do not call this function; instead use `erfc` in C and
- *  Objective-C, and `simd::erfc` in C++.                                     */
-static inline SIMD_CFUNC simd_float16 __tg_erfc(simd_float16 x);
-/*! @abstract Do not call this function; instead use `erfc` in C and
- *  Objective-C, and `simd::erfc` in C++.                                     */
-static inline SIMD_CFUNC simd_double2 __tg_erfc(simd_double2 x);
-/*! @abstract Do not call this function; instead use `erfc` in C and
- *  Objective-C, and `simd::erfc` in C++.                                     */
-static inline SIMD_CFUNC simd_double3 __tg_erfc(simd_double3 x);
-/*! @abstract Do not call this function; instead use `erfc` in C and
- *  Objective-C, and `simd::erfc` in C++.                                     */
-static inline SIMD_CFUNC simd_double4 __tg_erfc(simd_double4 x);
-/*! @abstract Do not call this function; instead use `erfc` in C and
- *  Objective-C, and `simd::erfc` in C++.                                     */
-static inline SIMD_CFUNC simd_double8 __tg_erfc(simd_double8 x);
-
-/*! @abstract Do not call this function; instead use `tgamma` in C and
- *  Objective-C, and `simd::tgamma` in C++.                                   */
-static inline SIMD_CFUNC simd_float2 __tg_tgamma(simd_float2 x);
-/*! @abstract Do not call this function; instead use `tgamma` in C and
- *  Objective-C, and `simd::tgamma` in C++.                                   */
-static inline SIMD_CFUNC simd_float3 __tg_tgamma(simd_float3 x);
-/*! @abstract Do not call this function; instead use `tgamma` in C and
- *  Objective-C, and `simd::tgamma` in C++.                                   */
-static inline SIMD_CFUNC simd_float4 __tg_tgamma(simd_float4 x);
-/*! @abstract Do not call this function; instead use `tgamma` in C and
- *  Objective-C, and `simd::tgamma` in C++.                                   */
-static inline SIMD_CFUNC simd_float8 __tg_tgamma(simd_float8 x);
-/*! @abstract Do not call this function; instead use `tgamma` in C and
- *  Objective-C, and `simd::tgamma` in C++.                                   */
-static inline SIMD_CFUNC simd_float16 __tg_tgamma(simd_float16 x);
-/*! @abstract Do not call this function; instead use `tgamma` in C and
- *  Objective-C, and `simd::tgamma` in C++.                                   */
-static inline SIMD_CFUNC simd_double2 __tg_tgamma(simd_double2 x);
-/*! @abstract Do not call this function; instead use `tgamma` in C and
- *  Objective-C, and `simd::tgamma` in C++.                                   */
-static inline SIMD_CFUNC simd_double3 __tg_tgamma(simd_double3 x);
-/*! @abstract Do not call this function; instead use `tgamma` in C and
- *  Objective-C, and `simd::tgamma` in C++.                                   */
-static inline SIMD_CFUNC simd_double4 __tg_tgamma(simd_double4 x);
-/*! @abstract Do not call this function; instead use `tgamma` in C and
- *  Objective-C, and `simd::tgamma` in C++.                                   */
-static inline SIMD_CFUNC simd_double8 __tg_tgamma(simd_double8 x);
-
-/*! @abstract Do not call this function; instead use `ceil` in C and
- *  Objective-C, and `simd::ceil` in C++.                                     */
-static inline SIMD_CFUNC simd_float2 __tg_ceil(simd_float2 x);
-/*! @abstract Do not call this function; instead use `ceil` in C and
- *  Objective-C, and `simd::ceil` in C++.                                     */
-static inline SIMD_CFUNC simd_float3 __tg_ceil(simd_float3 x);
-/*! @abstract Do not call this function; instead use `ceil` in C and
- *  Objective-C, and `simd::ceil` in C++.                                     */
-static inline SIMD_CFUNC simd_float4 __tg_ceil(simd_float4 x);
-/*! @abstract Do not call this function; instead use `ceil` in C and
- *  Objective-C, and `simd::ceil` in C++.                                     */
-static inline SIMD_CFUNC simd_float8 __tg_ceil(simd_float8 x);
-/*! @abstract Do not call this function; instead use `ceil` in C and
- *  Objective-C, and `simd::ceil` in C++.                                     */
-static inline SIMD_CFUNC simd_float16 __tg_ceil(simd_float16 x);
-/*! @abstract Do not call this function; instead use `ceil` in C and
- *  Objective-C, and `simd::ceil` in C++.                                     */
-static inline SIMD_CFUNC simd_double2 __tg_ceil(simd_double2 x);
-/*! @abstract Do not call this function; instead use `ceil` in C and
- *  Objective-C, and `simd::ceil` in C++.                                     */
-static inline SIMD_CFUNC simd_double3 __tg_ceil(simd_double3 x);
-/*! @abstract Do not call this function; instead use `ceil` in C and
- *  Objective-C, and `simd::ceil` in C++.                                     */
-static inline SIMD_CFUNC simd_double4 __tg_ceil(simd_double4 x);
-/*! @abstract Do not call this function; instead use `ceil` in C and
- *  Objective-C, and `simd::ceil` in C++.                                     */
-static inline SIMD_CFUNC simd_double8 __tg_ceil(simd_double8 x);
-
-/*! @abstract Do not call this function; instead use `floor` in C and
- *  Objective-C, and `simd::floor` in C++.                                    */
-static inline SIMD_CFUNC simd_float2 __tg_floor(simd_float2 x);
-/*! @abstract Do not call this function; instead use `floor` in C and
- *  Objective-C, and `simd::floor` in C++.                                    */
-static inline SIMD_CFUNC simd_float3 __tg_floor(simd_float3 x);
-/*! @abstract Do not call this function; instead use `floor` in C and
- *  Objective-C, and `simd::floor` in C++.                                    */
-static inline SIMD_CFUNC simd_float4 __tg_floor(simd_float4 x);
-/*! @abstract Do not call this function; instead use `floor` in C and
- *  Objective-C, and `simd::floor` in C++.                                    */
-static inline SIMD_CFUNC simd_float8 __tg_floor(simd_float8 x);
-/*! @abstract Do not call this function; instead use `floor` in C and
- *  Objective-C, and `simd::floor` in C++.                                    */
-static inline SIMD_CFUNC simd_float16 __tg_floor(simd_float16 x);
-/*! @abstract Do not call this function; instead use `floor` in C and
- *  Objective-C, and `simd::floor` in C++.                                    */
-static inline SIMD_CFUNC simd_double2 __tg_floor(simd_double2 x);
-/*! @abstract Do not call this function; instead use `floor` in C and
- *  Objective-C, and `simd::floor` in C++.                                    */
-static inline SIMD_CFUNC simd_double3 __tg_floor(simd_double3 x);
-/*! @abstract Do not call this function; instead use `floor` in C and
- *  Objective-C, and `simd::floor` in C++.                                    */
-static inline SIMD_CFUNC simd_double4 __tg_floor(simd_double4 x);
-/*! @abstract Do not call this function; instead use `floor` in C and
- *  Objective-C, and `simd::floor` in C++.                                    */
-static inline SIMD_CFUNC simd_double8 __tg_floor(simd_double8 x);
-
-/*! @abstract Do not call this function; instead use `rint` in C and
- *  Objective-C, and `simd::rint` in C++.                                     */
-static inline SIMD_CFUNC simd_float2 __tg_rint(simd_float2 x);
-/*! @abstract Do not call this function; instead use `rint` in C and
- *  Objective-C, and `simd::rint` in C++.                                     */
-static inline SIMD_CFUNC simd_float3 __tg_rint(simd_float3 x);
-/*! @abstract Do not call this function; instead use `rint` in C and
- *  Objective-C, and `simd::rint` in C++.                                     */
-static inline SIMD_CFUNC simd_float4 __tg_rint(simd_float4 x);
-/*! @abstract Do not call this function; instead use `rint` in C and
- *  Objective-C, and `simd::rint` in C++.                                     */
-static inline SIMD_CFUNC simd_float8 __tg_rint(simd_float8 x);
-/*! @abstract Do not call this function; instead use `rint` in C and
- *  Objective-C, and `simd::rint` in C++.                                     */
-static inline SIMD_CFUNC simd_float16 __tg_rint(simd_float16 x);
-/*! @abstract Do not call this function; instead use `rint` in C and
- *  Objective-C, and `simd::rint` in C++.                                     */
-static inline SIMD_CFUNC simd_double2 __tg_rint(simd_double2 x);
-/*! @abstract Do not call this function; instead use `rint` in C and
- *  Objective-C, and `simd::rint` in C++.                                     */
-static inline SIMD_CFUNC simd_double3 __tg_rint(simd_double3 x);
-/*! @abstract Do not call this function; instead use `rint` in C and
- *  Objective-C, and `simd::rint` in C++.                                     */
-static inline SIMD_CFUNC simd_double4 __tg_rint(simd_double4 x);
-/*! @abstract Do not call this function; instead use `rint` in C and
- *  Objective-C, and `simd::rint` in C++.                                     */
-static inline SIMD_CFUNC simd_double8 __tg_rint(simd_double8 x);
-
-/*! @abstract Do not call this function; instead use `round` in C and
- *  Objective-C, and `simd::round` in C++.                                    */
-static inline SIMD_CFUNC simd_float2 __tg_round(simd_float2 x);
-/*! @abstract Do not call this function; instead use `round` in C and
- *  Objective-C, and `simd::round` in C++.                                    */
-static inline SIMD_CFUNC simd_float3 __tg_round(simd_float3 x);
-/*! @abstract Do not call this function; instead use `round` in C and
- *  Objective-C, and `simd::round` in C++.                                    */
-static inline SIMD_CFUNC simd_float4 __tg_round(simd_float4 x);
-/*! @abstract Do not call this function; instead use `round` in C and
- *  Objective-C, and `simd::round` in C++.                                    */
-static inline SIMD_CFUNC simd_float8 __tg_round(simd_float8 x);
-/*! @abstract Do not call this function; instead use `round` in C and
- *  Objective-C, and `simd::round` in C++.                                    */
-static inline SIMD_CFUNC simd_float16 __tg_round(simd_float16 x);
-/*! @abstract Do not call this function; instead use `round` in C and
- *  Objective-C, and `simd::round` in C++.                                    */
-static inline SIMD_CFUNC simd_double2 __tg_round(simd_double2 x);
-/*! @abstract Do not call this function; instead use `round` in C and
- *  Objective-C, and `simd::round` in C++.                                    */
-static inline SIMD_CFUNC simd_double3 __tg_round(simd_double3 x);
-/*! @abstract Do not call this function; instead use `round` in C and
- *  Objective-C, and `simd::round` in C++.                                    */
-static inline SIMD_CFUNC simd_double4 __tg_round(simd_double4 x);
-/*! @abstract Do not call this function; instead use `round` in C and
- *  Objective-C, and `simd::round` in C++.                                    */
-static inline SIMD_CFUNC simd_double8 __tg_round(simd_double8 x);
-
-/*! @abstract Do not call this function; instead use `trunc` in C and
- *  Objective-C, and `simd::trunc` in C++.                                    */
-static inline SIMD_CFUNC simd_float2 __tg_trunc(simd_float2 x);
-/*! @abstract Do not call this function; instead use `trunc` in C and
- *  Objective-C, and `simd::trunc` in C++.                                    */
-static inline SIMD_CFUNC simd_float3 __tg_trunc(simd_float3 x);
-/*! @abstract Do not call this function; instead use `trunc` in C and
- *  Objective-C, and `simd::trunc` in C++.                                    */
-static inline SIMD_CFUNC simd_float4 __tg_trunc(simd_float4 x);
-/*! @abstract Do not call this function; instead use `trunc` in C and
- *  Objective-C, and `simd::trunc` in C++.                                    */
-static inline SIMD_CFUNC simd_float8 __tg_trunc(simd_float8 x);
-/*! @abstract Do not call this function; instead use `trunc` in C and
- *  Objective-C, and `simd::trunc` in C++.                                    */
-static inline SIMD_CFUNC simd_float16 __tg_trunc(simd_float16 x);
-/*! @abstract Do not call this function; instead use `trunc` in C and
- *  Objective-C, and `simd::trunc` in C++.                                    */
-static inline SIMD_CFUNC simd_double2 __tg_trunc(simd_double2 x);
-/*! @abstract Do not call this function; instead use `trunc` in C and
- *  Objective-C, and `simd::trunc` in C++.                                    */
-static inline SIMD_CFUNC simd_double3 __tg_trunc(simd_double3 x);
-/*! @abstract Do not call this function; instead use `trunc` in C and
- *  Objective-C, and `simd::trunc` in C++.                                    */
-static inline SIMD_CFUNC simd_double4 __tg_trunc(simd_double4 x);
-/*! @abstract Do not call this function; instead use `trunc` in C and
- *  Objective-C, and `simd::trunc` in C++.                                    */
-static inline SIMD_CFUNC simd_double8 __tg_trunc(simd_double8 x);
-
-    
-/*! @abstract Do not call this function; instead use `atan2` in C and
- *  Objective-C, and `simd::atan2` in C++.                                    */
-static inline SIMD_CFUNC simd_float2 __tg_atan2(simd_float2 y, simd_float2 x);
-/*! @abstract Do not call this function; instead use `atan2` in C and
- *  Objective-C, and `simd::atan2` in C++.                                    */
-static inline SIMD_CFUNC simd_float3 __tg_atan2(simd_float3 y, simd_float3 x);
-/*! @abstract Do not call this function; instead use `atan2` in C and
- *  Objective-C, and `simd::atan2` in C++.                                    */
-static inline SIMD_CFUNC simd_float4 __tg_atan2(simd_float4 y, simd_float4 x);
-/*! @abstract Do not call this function; instead use `atan2` in C and
- *  Objective-C, and `simd::atan2` in C++.                                    */
-static inline SIMD_CFUNC simd_float8 __tg_atan2(simd_float8 y, simd_float8 x);
-/*! @abstract Do not call this function; instead use `atan2` in C and
- *  Objective-C, and `simd::atan2` in C++.                                    */
-static inline SIMD_CFUNC simd_float16 __tg_atan2(simd_float16 y, simd_float16 x);
-/*! @abstract Do not call this function; instead use `atan2` in C and
- *  Objective-C, and `simd::atan2` in C++.                                    */
-static inline SIMD_CFUNC simd_double2 __tg_atan2(simd_double2 y, simd_double2 x);
-/*! @abstract Do not call this function; instead use `atan2` in C and
- *  Objective-C, and `simd::atan2` in C++.                                    */
-static inline SIMD_CFUNC simd_double3 __tg_atan2(simd_double3 y, simd_double3 x);
-/*! @abstract Do not call this function; instead use `atan2` in C and
- *  Objective-C, and `simd::atan2` in C++.                                    */
-static inline SIMD_CFUNC simd_double4 __tg_atan2(simd_double4 y, simd_double4 x);
-/*! @abstract Do not call this function; instead use `atan2` in C and
- *  Objective-C, and `simd::atan2` in C++.                                    */
-static inline SIMD_CFUNC simd_double8 __tg_atan2(simd_double8 y, simd_double8 x);
-
-/*! @abstract Do not call this function; instead use `hypot` in C and
- *  Objective-C, and `simd::hypot` in C++.                                    */
-static inline SIMD_CFUNC simd_float2 __tg_hypot(simd_float2 x, simd_float2 y);
-/*! @abstract Do not call this function; instead use `hypot` in C and
- *  Objective-C, and `simd::hypot` in C++.                                    */
-static inline SIMD_CFUNC simd_float3 __tg_hypot(simd_float3 x, simd_float3 y);
-/*! @abstract Do not call this function; instead use `hypot` in C and
- *  Objective-C, and `simd::hypot` in C++.                                    */
-static inline SIMD_CFUNC simd_float4 __tg_hypot(simd_float4 x, simd_float4 y);
-/*! @abstract Do not call this function; instead use `hypot` in C and
- *  Objective-C, and `simd::hypot` in C++.                                    */
-static inline SIMD_CFUNC simd_float8 __tg_hypot(simd_float8 x, simd_float8 y);
-/*! @abstract Do not call this function; instead use `hypot` in C and
- *  Objective-C, and `simd::hypot` in C++.                                    */
-static inline SIMD_CFUNC simd_float16 __tg_hypot(simd_float16 x, simd_float16 y);
-/*! @abstract Do not call this function; instead use `hypot` in C and
- *  Objective-C, and `simd::hypot` in C++.                                    */
-static inline SIMD_CFUNC simd_double2 __tg_hypot(simd_double2 x, simd_double2 y);
-/*! @abstract Do not call this function; instead use `hypot` in C and
- *  Objective-C, and `simd::hypot` in C++.                                    */
-static inline SIMD_CFUNC simd_double3 __tg_hypot(simd_double3 x, simd_double3 y);
-/*! @abstract Do not call this function; instead use `hypot` in C and
- *  Objective-C, and `simd::hypot` in C++.                                    */
-static inline SIMD_CFUNC simd_double4 __tg_hypot(simd_double4 x, simd_double4 y);
-/*! @abstract Do not call this function; instead use `hypot` in C and
- *  Objective-C, and `simd::hypot` in C++.                                    */
-static inline SIMD_CFUNC simd_double8 __tg_hypot(simd_double8 x, simd_double8 y);
-
-/*! @abstract Do not call this function; instead use `pow` in C and
- *  Objective-C, and `simd::pow` in C++.                                      */
-static inline SIMD_CFUNC simd_float2 __tg_pow(simd_float2 x, simd_float2 y);
-/*! @abstract Do not call this function; instead use `pow` in C and
- *  Objective-C, and `simd::pow` in C++.                                      */
-static inline SIMD_CFUNC simd_float3 __tg_pow(simd_float3 x, simd_float3 y);
-/*! @abstract Do not call this function; instead use `pow` in C and
- *  Objective-C, and `simd::pow` in C++.                                      */
-static inline SIMD_CFUNC simd_float4 __tg_pow(simd_float4 x, simd_float4 y);
-/*! @abstract Do not call this function; instead use `pow` in C and
- *  Objective-C, and `simd::pow` in C++.                                      */
-static inline SIMD_CFUNC simd_float8 __tg_pow(simd_float8 x, simd_float8 y);
-/*! @abstract Do not call this function; instead use `pow` in C and
- *  Objective-C, and `simd::pow` in C++.                                      */
-static inline SIMD_CFUNC simd_float16 __tg_pow(simd_float16 x, simd_float16 y);
-/*! @abstract Do not call this function; instead use `pow` in C and
- *  Objective-C, and `simd::pow` in C++.                                      */
-static inline SIMD_CFUNC simd_double2 __tg_pow(simd_double2 x, simd_double2 y);
-/*! @abstract Do not call this function; instead use `pow` in C and
- *  Objective-C, and `simd::pow` in C++.                                      */
-static inline SIMD_CFUNC simd_double3 __tg_pow(simd_double3 x, simd_double3 y);
-/*! @abstract Do not call this function; instead use `pow` in C and
- *  Objective-C, and `simd::pow` in C++.                                      */
-static inline SIMD_CFUNC simd_double4 __tg_pow(simd_double4 x, simd_double4 y);
-/*! @abstract Do not call this function; instead use `pow` in C and
- *  Objective-C, and `simd::pow` in C++.                                      */
-static inline SIMD_CFUNC simd_double8 __tg_pow(simd_double8 x, simd_double8 y);
-
-/*! @abstract Do not call this function; instead use `fmod` in C and
- *  Objective-C, and `simd::fmod` in C++.                                     */
-static inline SIMD_CFUNC simd_float2 __tg_fmod(simd_float2 x, simd_float2 y);
-/*! @abstract Do not call this function; instead use `fmod` in C and
- *  Objective-C, and `simd::fmod` in C++.                                     */
-static inline SIMD_CFUNC simd_float3 __tg_fmod(simd_float3 x, simd_float3 y);
-/*! @abstract Do not call this function; instead use `fmod` in C and
- *  Objective-C, and `simd::fmod` in C++.                                     */
-static inline SIMD_CFUNC simd_float4 __tg_fmod(simd_float4 x, simd_float4 y);
-/*! @abstract Do not call this function; instead use `fmod` in C and
- *  Objective-C, and `simd::fmod` in C++.                                     */
-static inline SIMD_CFUNC simd_float8 __tg_fmod(simd_float8 x, simd_float8 y);
-/*! @abstract Do not call this function; instead use `fmod` in C and
- *  Objective-C, and `simd::fmod` in C++.                                     */
-static inline SIMD_CFUNC simd_float16 __tg_fmod(simd_float16 x, simd_float16 y);
-/*! @abstract Do not call this function; instead use `fmod` in C and
- *  Objective-C, and `simd::fmod` in C++.                                     */
-static inline SIMD_CFUNC simd_double2 __tg_fmod(simd_double2 x, simd_double2 y);
-/*! @abstract Do not call this function; instead use `fmod` in C and
- *  Objective-C, and `simd::fmod` in C++.                                     */
-static inline SIMD_CFUNC simd_double3 __tg_fmod(simd_double3 x, simd_double3 y);
-/*! @abstract Do not call this function; instead use `fmod` in C and
- *  Objective-C, and `simd::fmod` in C++.                                     */
-static inline SIMD_CFUNC simd_double4 __tg_fmod(simd_double4 x, simd_double4 y);
-/*! @abstract Do not call this function; instead use `fmod` in C and
- *  Objective-C, and `simd::fmod` in C++.                                     */
-static inline SIMD_CFUNC simd_double8 __tg_fmod(simd_double8 x, simd_double8 y);
-
-/*! @abstract Do not call this function; instead use `remainder` in C and
- *  Objective-C, and `simd::remainder` in C++.                                */
-static inline SIMD_CFUNC simd_float2 __tg_remainder(simd_float2 x, simd_float2 y);
-/*! @abstract Do not call this function; instead use `remainder` in C and
- *  Objective-C, and `simd::remainder` in C++.                                */
-static inline SIMD_CFUNC simd_float3 __tg_remainder(simd_float3 x, simd_float3 y);
-/*! @abstract Do not call this function; instead use `remainder` in C and
- *  Objective-C, and `simd::remainder` in C++.                                */
-static inline SIMD_CFUNC simd_float4 __tg_remainder(simd_float4 x, simd_float4 y);
-/*! @abstract Do not call this function; instead use `remainder` in C and
- *  Objective-C, and `simd::remainder` in C++.                                */
-static inline SIMD_CFUNC simd_float8 __tg_remainder(simd_float8 x, simd_float8 y);
-/*! @abstract Do not call this function; instead use `remainder` in C and
- *  Objective-C, and `simd::remainder` in C++.                                */
-static inline SIMD_CFUNC simd_float16 __tg_remainder(simd_float16 x, simd_float16 y);
-/*! @abstract Do not call this function; instead use `remainder` in C and
- *  Objective-C, and `simd::remainder` in C++.                                */
-static inline SIMD_CFUNC simd_double2 __tg_remainder(simd_double2 x, simd_double2 y);
-/*! @abstract Do not call this function; instead use `remainder` in C and
- *  Objective-C, and `simd::remainder` in C++.                                */
-static inline SIMD_CFUNC simd_double3 __tg_remainder(simd_double3 x, simd_double3 y);
-/*! @abstract Do not call this function; instead use `remainder` in C and
- *  Objective-C, and `simd::remainder` in C++.                                */
-static inline SIMD_CFUNC simd_double4 __tg_remainder(simd_double4 x, simd_double4 y);
-/*! @abstract Do not call this function; instead use `remainder` in C and
- *  Objective-C, and `simd::remainder` in C++.                                */
-static inline SIMD_CFUNC simd_double8 __tg_remainder(simd_double8 x, simd_double8 y);
-
-/*! @abstract Do not call this function; instead use `copysign` in C and
- *  Objective-C, and `simd::copysign` in C++.                                 */
-static inline SIMD_CFUNC simd_float2 __tg_copysign(simd_float2 x, simd_float2 y);
-/*! @abstract Do not call this function; instead use `copysign` in C and
- *  Objective-C, and `simd::copysign` in C++.                                 */
-static inline SIMD_CFUNC simd_float3 __tg_copysign(simd_float3 x, simd_float3 y);
-/*! @abstract Do not call this function; instead use `copysign` in C and
- *  Objective-C, and `simd::copysign` in C++.                                 */
-static inline SIMD_CFUNC simd_float4 __tg_copysign(simd_float4 x, simd_float4 y);
-/*! @abstract Do not call this function; instead use `copysign` in C and
- *  Objective-C, and `simd::copysign` in C++.                                 */
-static inline SIMD_CFUNC simd_float8 __tg_copysign(simd_float8 x, simd_float8 y);
-/*! @abstract Do not call this function; instead use `copysign` in C and
- *  Objective-C, and `simd::copysign` in C++.                                 */
-static inline SIMD_CFUNC simd_float16 __tg_copysign(simd_float16 x, simd_float16 y);
-/*! @abstract Do not call this function; instead use `copysign` in C and
- *  Objective-C, and `simd::copysign` in C++.                                 */
-static inline SIMD_CFUNC simd_double2 __tg_copysign(simd_double2 x, simd_double2 y);
-/*! @abstract Do not call this function; instead use `copysign` in C and
- *  Objective-C, and `simd::copysign` in C++.                                 */
-static inline SIMD_CFUNC simd_double3 __tg_copysign(simd_double3 x, simd_double3 y);
-/*! @abstract Do not call this function; instead use `copysign` in C and
- *  Objective-C, and `simd::copysign` in C++.                                 */
-static inline SIMD_CFUNC simd_double4 __tg_copysign(simd_double4 x, simd_double4 y);
-/*! @abstract Do not call this function; instead use `copysign` in C and
- *  Objective-C, and `simd::copysign` in C++.                                 */
-static inline SIMD_CFUNC simd_double8 __tg_copysign(simd_double8 x, simd_double8 y);
-
-/*! @abstract Do not call this function; instead use `nextafter` in C and
- *  Objective-C, and `simd::nextafter` in C++.                                */
-static inline SIMD_CFUNC simd_float2 __tg_nextafter(simd_float2 x, simd_float2 y);
-/*! @abstract Do not call this function; instead use `nextafter` in C and
- *  Objective-C, and `simd::nextafter` in C++.                                */
-static inline SIMD_CFUNC simd_float3 __tg_nextafter(simd_float3 x, simd_float3 y);
-/*! @abstract Do not call this function; instead use `nextafter` in C and
- *  Objective-C, and `simd::nextafter` in C++.                                */
-static inline SIMD_CFUNC simd_float4 __tg_nextafter(simd_float4 x, simd_float4 y);
-/*! @abstract Do not call this function; instead use `nextafter` in C and
- *  Objective-C, and `simd::nextafter` in C++.                                */
-static inline SIMD_CFUNC simd_float8 __tg_nextafter(simd_float8 x, simd_float8 y);
-/*! @abstract Do not call this function; instead use `nextafter` in C and
- *  Objective-C, and `simd::nextafter` in C++.                                */
-static inline SIMD_CFUNC simd_float16 __tg_nextafter(simd_float16 x, simd_float16 y);
-/*! @abstract Do not call this function; instead use `nextafter` in C and
- *  Objective-C, and `simd::nextafter` in C++.                                */
-static inline SIMD_CFUNC simd_double2 __tg_nextafter(simd_double2 x, simd_double2 y);
-/*! @abstract Do not call this function; instead use `nextafter` in C and
- *  Objective-C, and `simd::nextafter` in C++.                                */
-static inline SIMD_CFUNC simd_double3 __tg_nextafter(simd_double3 x, simd_double3 y);
-/*! @abstract Do not call this function; instead use `nextafter` in C and
- *  Objective-C, and `simd::nextafter` in C++.                                */
-static inline SIMD_CFUNC simd_double4 __tg_nextafter(simd_double4 x, simd_double4 y);
-/*! @abstract Do not call this function; instead use `nextafter` in C and
- *  Objective-C, and `simd::nextafter` in C++.                                */
-static inline SIMD_CFUNC simd_double8 __tg_nextafter(simd_double8 x, simd_double8 y);
-
-/*! @abstract Do not call this function; instead use `fdim` in C and
- *  Objective-C, and `simd::fdim` in C++.                                     */
-static inline SIMD_CFUNC simd_float2 __tg_fdim(simd_float2 x, simd_float2 y);
-/*! @abstract Do not call this function; instead use `fdim` in C and
- *  Objective-C, and `simd::fdim` in C++.                                     */
-static inline SIMD_CFUNC simd_float3 __tg_fdim(simd_float3 x, simd_float3 y);
-/*! @abstract Do not call this function; instead use `fdim` in C and
- *  Objective-C, and `simd::fdim` in C++.                                     */
-static inline SIMD_CFUNC simd_float4 __tg_fdim(simd_float4 x, simd_float4 y);
-/*! @abstract Do not call this function; instead use `fdim` in C and
- *  Objective-C, and `simd::fdim` in C++.                                     */
-static inline SIMD_CFUNC simd_float8 __tg_fdim(simd_float8 x, simd_float8 y);
-/*! @abstract Do not call this function; instead use `fdim` in C and
- *  Objective-C, and `simd::fdim` in C++.                                     */
-static inline SIMD_CFUNC simd_float16 __tg_fdim(simd_float16 x, simd_float16 y);
-/*! @abstract Do not call this function; instead use `fdim` in C and
- *  Objective-C, and `simd::fdim` in C++.                                     */
-static inline SIMD_CFUNC simd_double2 __tg_fdim(simd_double2 x, simd_double2 y);
-/*! @abstract Do not call this function; instead use `fdim` in C and
- *  Objective-C, and `simd::fdim` in C++.                                     */
-static inline SIMD_CFUNC simd_double3 __tg_fdim(simd_double3 x, simd_double3 y);
-/*! @abstract Do not call this function; instead use `fdim` in C and
- *  Objective-C, and `simd::fdim` in C++.                                     */
-static inline SIMD_CFUNC simd_double4 __tg_fdim(simd_double4 x, simd_double4 y);
-/*! @abstract Do not call this function; instead use `fdim` in C and
- *  Objective-C, and `simd::fdim` in C++.                                     */
-static inline SIMD_CFUNC simd_double8 __tg_fdim(simd_double8 x, simd_double8 y);
-
-/*! @abstract Do not call this function; instead use `fmax` in C and
- *  Objective-C, and `simd::fmax` in C++.                                     */
-static inline SIMD_CFUNC simd_float2 __tg_fmax(simd_float2 x, simd_float2 y);
-/*! @abstract Do not call this function; instead use `fmax` in C and
- *  Objective-C, and `simd::fmax` in C++.                                     */
-static inline SIMD_CFUNC simd_float3 __tg_fmax(simd_float3 x, simd_float3 y);
-/*! @abstract Do not call this function; instead use `fmax` in C and
- *  Objective-C, and `simd::fmax` in C++.                                     */
-static inline SIMD_CFUNC simd_float4 __tg_fmax(simd_float4 x, simd_float4 y);
-/*! @abstract Do not call this function; instead use `fmax` in C and
- *  Objective-C, and `simd::fmax` in C++.                                     */
-static inline SIMD_CFUNC simd_float8 __tg_fmax(simd_float8 x, simd_float8 y);
-/*! @abstract Do not call this function; instead use `fmax` in C and
- *  Objective-C, and `simd::fmax` in C++.                                     */
-static inline SIMD_CFUNC simd_float16 __tg_fmax(simd_float16 x, simd_float16 y);
-/*! @abstract Do not call this function; instead use `fmax` in C and
- *  Objective-C, and `simd::fmax` in C++.                                     */
-static inline SIMD_CFUNC simd_double2 __tg_fmax(simd_double2 x, simd_double2 y);
-/*! @abstract Do not call this function; instead use `fmax` in C and
- *  Objective-C, and `simd::fmax` in C++.                                     */
-static inline SIMD_CFUNC simd_double3 __tg_fmax(simd_double3 x, simd_double3 y);
-/*! @abstract Do not call this function; instead use `fmax` in C and
- *  Objective-C, and `simd::fmax` in C++.                                     */
-static inline SIMD_CFUNC simd_double4 __tg_fmax(simd_double4 x, simd_double4 y);
-/*! @abstract Do not call this function; instead use `fmax` in C and
- *  Objective-C, and `simd::fmax` in C++.                                     */
-static inline SIMD_CFUNC simd_double8 __tg_fmax(simd_double8 x, simd_double8 y);
-
-/*! @abstract Do not call this function; instead use `fmin` in C and
- *  Objective-C, and `simd::fmin` in C++.                                     */
-static inline SIMD_CFUNC simd_float2 __tg_fmin(simd_float2 x, simd_float2 y);
-/*! @abstract Do not call this function; instead use `fmin` in C and
- *  Objective-C, and `simd::fmin` in C++.                                     */
-static inline SIMD_CFUNC simd_float3 __tg_fmin(simd_float3 x, simd_float3 y);
-/*! @abstract Do not call this function; instead use `fmin` in C and
- *  Objective-C, and `simd::fmin` in C++.                                     */
-static inline SIMD_CFUNC simd_float4 __tg_fmin(simd_float4 x, simd_float4 y);
-/*! @abstract Do not call this function; instead use `fmin` in C and
- *  Objective-C, and `simd::fmin` in C++.                                     */
-static inline SIMD_CFUNC simd_float8 __tg_fmin(simd_float8 x, simd_float8 y);
-/*! @abstract Do not call this function; instead use `fmin` in C and
- *  Objective-C, and `simd::fmin` in C++.                                     */
-static inline SIMD_CFUNC simd_float16 __tg_fmin(simd_float16 x, simd_float16 y);
-/*! @abstract Do not call this function; instead use `fmin` in C and
- *  Objective-C, and `simd::fmin` in C++.                                     */
-static inline SIMD_CFUNC simd_double2 __tg_fmin(simd_double2 x, simd_double2 y);
-/*! @abstract Do not call this function; instead use `fmin` in C and
- *  Objective-C, and `simd::fmin` in C++.                                     */
-static inline SIMD_CFUNC simd_double3 __tg_fmin(simd_double3 x, simd_double3 y);
-/*! @abstract Do not call this function; instead use `fmin` in C and
- *  Objective-C, and `simd::fmin` in C++.                                     */
-static inline SIMD_CFUNC simd_double4 __tg_fmin(simd_double4 x, simd_double4 y);
-/*! @abstract Do not call this function; instead use `fmin` in C and
- *  Objective-C, and `simd::fmin` in C++.                                     */
-static inline SIMD_CFUNC simd_double8 __tg_fmin(simd_double8 x, simd_double8 y);
-
-
-/*! @abstract Do not call this function; instead use `fma` in C and Objective-C,
- *  and `simd::fma` in C++.                                                   */
-static inline SIMD_CFUNC simd_float2 __tg_fma(simd_float2 x, simd_float2 y, simd_float2 z);
-/*! @abstract Do not call this function; instead use `fma` in C and Objective-C,
- *  and `simd::fma` in C++.                                                   */
-static inline SIMD_CFUNC simd_float3 __tg_fma(simd_float3 x, simd_float3 y, simd_float3 z);
-/*! @abstract Do not call this function; instead use `fma` in C and Objective-C,
- *  and `simd::fma` in C++.                                                   */
-static inline SIMD_CFUNC simd_float4 __tg_fma(simd_float4 x, simd_float4 y, simd_float4 z);
-/*! @abstract Do not call this function; instead use `fma` in C and Objective-C,
- *  and `simd::fma` in C++.                                                   */
-static inline SIMD_CFUNC simd_float8 __tg_fma(simd_float8 x, simd_float8 y, simd_float8 z);
-/*! @abstract Do not call this function; instead use `fma` in C and Objective-C,
- *  and `simd::fma` in C++.                                                   */
-static inline SIMD_CFUNC simd_float16 __tg_fma(simd_float16 x, simd_float16 y, simd_float16 z);
-/*! @abstract Do not call this function; instead use `fma` in C and Objective-C,
- *  and `simd::fma` in C++.                                                   */
-static inline SIMD_CFUNC simd_double2 __tg_fma(simd_double2 x, simd_double2 y, simd_double2 z);
-/*! @abstract Do not call this function; instead use `fma` in C and Objective-C,
- *  and `simd::fma` in C++.                                                   */
-static inline SIMD_CFUNC simd_double3 __tg_fma(simd_double3 x, simd_double3 y, simd_double3 z);
-/*! @abstract Do not call this function; instead use `fma` in C and Objective-C,
- *  and `simd::fma` in C++.                                                   */
-static inline SIMD_CFUNC simd_double4 __tg_fma(simd_double4 x, simd_double4 y, simd_double4 z);
-/*! @abstract Do not call this function; instead use `fma` in C and Objective-C,
- *  and `simd::fma` in C++.                                                   */
-static inline SIMD_CFUNC simd_double8 __tg_fma(simd_double8 x, simd_double8 y, simd_double8 z);
-    
-/*! @abstract Computes accum + x*y by the most efficient means available;
- *  either a fused multiply add or separate multiply and add instructions.    */
-static inline SIMD_CFUNC float simd_muladd(float x, float y, float z);
-/*! @abstract Computes accum + x*y by the most efficient means available;
- *  either a fused multiply add or separate multiply and add instructions.    */
-static inline SIMD_CFUNC simd_float2 simd_muladd(simd_float2 x, simd_float2 y, simd_float2 z);
-/*! @abstract Computes accum + x*y by the most efficient means available;
- *  either a fused multiply add or separate multiply and add instructions.    */
-static inline SIMD_CFUNC simd_float3 simd_muladd(simd_float3 x, simd_float3 y, simd_float3 z);
-/*! @abstract Computes accum + x*y by the most efficient means available;
- *  either a fused multiply add or separate multiply and add instructions.    */
-static inline SIMD_CFUNC simd_float4 simd_muladd(simd_float4 x, simd_float4 y, simd_float4 z);
-/*! @abstract Computes accum + x*y by the most efficient means available;
- *  either a fused multiply add or separate multiply and add instructions.    */
-static inline SIMD_CFUNC simd_float8 simd_muladd(simd_float8 x, simd_float8 y, simd_float8 z);
-/*! @abstract Computes accum + x*y by the most efficient means available;
- *  either a fused multiply add or separate multiply and add instructions.    */
-static inline SIMD_CFUNC simd_float16 simd_muladd(simd_float16 x, simd_float16 y, simd_float16 z);
-/*! @abstract Computes accum + x*y by the most efficient means available;
- *  either a fused multiply add or separate multiply and add instructions.    */
-static inline SIMD_CFUNC double simd_muladd(double x, double y, double z);
-/*! @abstract Computes accum + x*y by the most efficient means available;
- *  either a fused multiply add or separate multiply and add instructions.    */
-static inline SIMD_CFUNC simd_double2 simd_muladd(simd_double2 x, simd_double2 y, simd_double2 z);
-/*! @abstract Computes accum + x*y by the most efficient means available;
- *  either a fused multiply add or separate multiply and add instructions.    */
-static inline SIMD_CFUNC simd_double3 simd_muladd(simd_double3 x, simd_double3 y, simd_double3 z);
-/*! @abstract Computes accum + x*y by the most efficient means available;
- *  either a fused multiply add or separate multiply and add instructions.    */
-static inline SIMD_CFUNC simd_double4 simd_muladd(simd_double4 x, simd_double4 y, simd_double4 z);
-/*! @abstract Computes accum + x*y by the most efficient means available;
- *  either a fused multiply add or separate multiply and add instructions.    */
-static inline SIMD_CFUNC simd_double8 simd_muladd(simd_double8 x, simd_double8 y, simd_double8 z);
-    
-#ifdef __cplusplus
-} /* extern "C" */
-
-#include <cmath>
-/*! @abstract Do not call this function directly; use simd::acos instead.     */
-static SIMD_CPPFUNC float __tg_acos(float x) { return ::acos(x); }
-/*! @abstract Do not call this function directly; use simd::acos instead.     */
-static SIMD_CPPFUNC double __tg_acos(double x) { return ::acos(x); }
-/*! @abstract Do not call this function directly; use simd::asin instead.     */
-static SIMD_CPPFUNC float __tg_asin(float x) { return ::asin(x); }
-/*! @abstract Do not call this function directly; use simd::asin instead.     */
-static SIMD_CPPFUNC double __tg_asin(double x) { return ::asin(x); }
-/*! @abstract Do not call this function directly; use simd::atan instead.     */
-static SIMD_CPPFUNC float __tg_atan(float x) { return ::atan(x); }
-/*! @abstract Do not call this function directly; use simd::atan instead.     */
-static SIMD_CPPFUNC double __tg_atan(double x) { return ::atan(x); }
-/*! @abstract Do not call this function directly; use simd::cos instead.      */
-static SIMD_CPPFUNC float __tg_cos(float x) { return ::cos(x); }
-/*! @abstract Do not call this function directly; use simd::cos instead.      */
-static SIMD_CPPFUNC double __tg_cos(double x) { return ::cos(x); }
-/*! @abstract Do not call this function directly; use simd::sin instead.      */
-static SIMD_CPPFUNC float __tg_sin(float x) { return ::sin(x); }
-/*! @abstract Do not call this function directly; use simd::sin instead.      */
-static SIMD_CPPFUNC double __tg_sin(double x) { return ::sin(x); }
-/*! @abstract Do not call this function directly; use simd::tan instead.      */
-static SIMD_CPPFUNC float __tg_tan(float x) { return ::tan(x); }
-/*! @abstract Do not call this function directly; use simd::tan instead.      */
-static SIMD_CPPFUNC double __tg_tan(double x) { return ::tan(x); }
-/*! @abstract Do not call this function directly; use simd::cospi instead.    */
-static SIMD_CPPFUNC float __tg_cospi(float x) { return ::__cospi(x); }
-/*! @abstract Do not call this function directly; use simd::cospi instead.    */
-static SIMD_CPPFUNC double __tg_cospi(double x) { return ::__cospi(x); }
-/*! @abstract Do not call this function directly; use simd::sinpi instead.    */
-static SIMD_CPPFUNC float __tg_sinpi(float x) { return ::__sinpi(x); }
-/*! @abstract Do not call this function directly; use simd::sinpi instead.    */
-static SIMD_CPPFUNC double __tg_sinpi(double x) { return ::__sinpi(x); }
-/*! @abstract Do not call this function directly; use simd::tanpi instead.    */
-static SIMD_CPPFUNC float __tg_tanpi(float x) { return ::__tanpi(x); }
-/*! @abstract Do not call this function directly; use simd::tanpi instead.    */
-static SIMD_CPPFUNC double __tg_tanpi(double x) { return ::__tanpi(x); }
-/*! @abstract Do not call this function directly; use simd::acosh instead.    */
-static SIMD_CPPFUNC float __tg_acosh(float x) { return ::acosh(x); }
-/*! @abstract Do not call this function directly; use simd::acosh instead.    */
-static SIMD_CPPFUNC double __tg_acosh(double x) { return ::acosh(x); }
-/*! @abstract Do not call this function directly; use simd::asinh instead.    */
-static SIMD_CPPFUNC float __tg_asinh(float x) { return ::asinh(x); }
-/*! @abstract Do not call this function directly; use simd::asinh instead.    */
-static SIMD_CPPFUNC double __tg_asinh(double x) { return ::asinh(x); }
-/*! @abstract Do not call this function directly; use simd::atanh instead.    */
-static SIMD_CPPFUNC float __tg_atanh(float x) { return ::atanh(x); }
-/*! @abstract Do not call this function directly; use simd::atanh instead.    */
-static SIMD_CPPFUNC double __tg_atanh(double x) { return ::atanh(x); }
-/*! @abstract Do not call this function directly; use simd::cosh instead.     */
-static SIMD_CPPFUNC float __tg_cosh(float x) { return ::cosh(x); }
-/*! @abstract Do not call this function directly; use simd::cosh instead.     */
-static SIMD_CPPFUNC double __tg_cosh(double x) { return ::cosh(x); }
-/*! @abstract Do not call this function directly; use simd::sinh instead.     */
-static SIMD_CPPFUNC float __tg_sinh(float x) { return ::sinh(x); }
-/*! @abstract Do not call this function directly; use simd::sinh instead.     */
-static SIMD_CPPFUNC double __tg_sinh(double x) { return ::sinh(x); }
-/*! @abstract Do not call this function directly; use simd::tanh instead.     */
-static SIMD_CPPFUNC float __tg_tanh(float x) { return ::tanh(x); }
-/*! @abstract Do not call this function directly; use simd::tanh instead.     */
-static SIMD_CPPFUNC double __tg_tanh(double x) { return ::tanh(x); }
-/*! @abstract Do not call this function directly; use simd::exp instead.      */
-static SIMD_CPPFUNC float __tg_exp(float x) { return ::exp(x); }
-/*! @abstract Do not call this function directly; use simd::exp instead.      */
-static SIMD_CPPFUNC double __tg_exp(double x) { return ::exp(x); }
-/*! @abstract Do not call this function directly; use simd::exp2 instead.     */
-static SIMD_CPPFUNC float __tg_exp2(float x) { return ::exp2(x); }
-/*! @abstract Do not call this function directly; use simd::exp2 instead.     */
-static SIMD_CPPFUNC double __tg_exp2(double x) { return ::exp2(x); }
-/*! @abstract Do not call this function directly; use simd::exp10 instead.    */
-static SIMD_CPPFUNC float __tg_exp10(float x) { return ::__exp10(x); }
-/*! @abstract Do not call this function directly; use simd::exp10 instead.    */
-static SIMD_CPPFUNC double __tg_exp10(double x) { return ::__exp10(x); }
-/*! @abstract Do not call this function directly; use simd::expm1 instead.    */
-static SIMD_CPPFUNC float __tg_expm1(float x) { return ::expm1(x); }
-/*! @abstract Do not call this function directly; use simd::expm1 instead.    */
-static SIMD_CPPFUNC double __tg_expm1(double x) { return ::expm1(x); }
-/*! @abstract Do not call this function directly; use simd::log instead.      */
-static SIMD_CPPFUNC float __tg_log(float x) { return ::log(x); }
-/*! @abstract Do not call this function directly; use simd::log instead.      */
-static SIMD_CPPFUNC double __tg_log(double x) { return ::log(x); }
-/*! @abstract Do not call this function directly; use simd::log2 instead.     */
-static SIMD_CPPFUNC float __tg_log2(float x) { return ::log2(x); }
-/*! @abstract Do not call this function directly; use simd::log2 instead.     */
-static SIMD_CPPFUNC double __tg_log2(double x) { return ::log2(x); }
-/*! @abstract Do not call this function directly; use simd::log10 instead.    */
-static SIMD_CPPFUNC float __tg_log10(float x) { return ::log10(x); }
-/*! @abstract Do not call this function directly; use simd::log10 instead.    */
-static SIMD_CPPFUNC double __tg_log10(double x) { return ::log10(x); }
-/*! @abstract Do not call this function directly; use simd::log1p instead.    */
-static SIMD_CPPFUNC float __tg_log1p(float x) { return ::log1p(x); }
-/*! @abstract Do not call this function directly; use simd::log1p instead.    */
-static SIMD_CPPFUNC double __tg_log1p(double x) { return ::log1p(x); }
-/*! @abstract Do not call this function directly; use simd::fabs instead.     */
-static SIMD_CPPFUNC float __tg_fabs(float x) { return ::fabs(x); }
-/*! @abstract Do not call this function directly; use simd::fabs instead.     */
-static SIMD_CPPFUNC double __tg_fabs(double x) { return ::fabs(x); }
-/*! @abstract Do not call this function directly; use simd::cbrt instead.     */
-static SIMD_CPPFUNC float __tg_cbrt(float x) { return ::cbrt(x); }
-/*! @abstract Do not call this function directly; use simd::cbrt instead.     */
-static SIMD_CPPFUNC double __tg_cbrt(double x) { return ::cbrt(x); }
-/*! @abstract Do not call this function directly; use simd::sqrt instead.     */
-static SIMD_CPPFUNC float __tg_sqrt(float x) { return ::sqrt(x); }
-/*! @abstract Do not call this function directly; use simd::sqrt instead.     */
-static SIMD_CPPFUNC double __tg_sqrt(double x) { return ::sqrt(x); }
-/*! @abstract Do not call this function directly; use simd::erf instead.      */
-static SIMD_CPPFUNC float __tg_erf(float x) { return ::erf(x); }
-/*! @abstract Do not call this function directly; use simd::erf instead.      */
-static SIMD_CPPFUNC double __tg_erf(double x) { return ::erf(x); }
-/*! @abstract Do not call this function directly; use simd::erfc instead.     */
-static SIMD_CPPFUNC float __tg_erfc(float x) { return ::erfc(x); }
-/*! @abstract Do not call this function directly; use simd::erfc instead.     */
-static SIMD_CPPFUNC double __tg_erfc(double x) { return ::erfc(x); }
-/*! @abstract Do not call this function directly; use simd::tgamma instead.   */
-static SIMD_CPPFUNC float __tg_tgamma(float x) { return ::tgamma(x); }
-/*! @abstract Do not call this function directly; use simd::tgamma instead.   */
-static SIMD_CPPFUNC double __tg_tgamma(double x) { return ::tgamma(x); }
-/*! @abstract Do not call this function directly; use simd::ceil instead.     */
-static SIMD_CPPFUNC float __tg_ceil(float x) { return ::ceil(x); }
-/*! @abstract Do not call this function directly; use simd::ceil instead.     */
-static SIMD_CPPFUNC double __tg_ceil(double x) { return ::ceil(x); }
-/*! @abstract Do not call this function directly; use simd::floor instead.    */
-static SIMD_CPPFUNC float __tg_floor(float x) { return ::floor(x); }
-/*! @abstract Do not call this function directly; use simd::floor instead.    */
-static SIMD_CPPFUNC double __tg_floor(double x) { return ::floor(x); }
-/*! @abstract Do not call this function directly; use simd::rint instead.     */
-static SIMD_CPPFUNC float __tg_rint(float x) { return ::rint(x); }
-/*! @abstract Do not call this function directly; use simd::rint instead.     */
-static SIMD_CPPFUNC double __tg_rint(double x) { return ::rint(x); }
-/*! @abstract Do not call this function directly; use simd::round instead.    */
-static SIMD_CPPFUNC float __tg_round(float x) { return ::round(x); }
-/*! @abstract Do not call this function directly; use simd::round instead.    */
-static SIMD_CPPFUNC double __tg_round(double x) { return ::round(x); }
-/*! @abstract Do not call this function directly; use simd::trunc instead.    */
-static SIMD_CPPFUNC float __tg_trunc(float x) { return ::trunc(x); }
-/*! @abstract Do not call this function directly; use simd::trunc instead.    */
-static SIMD_CPPFUNC double __tg_trunc(double x) { return ::trunc(x); }
-/*! @abstract Do not call this function directly; use simd::atan2 instead.    */
-static SIMD_CPPFUNC float __tg_atan2(float x, float y) { return ::atan2(x, y); }
-/*! @abstract Do not call this function directly; use simd::atan2 instead.    */
-static SIMD_CPPFUNC double __tg_atan2(double x, float y) { return ::atan2(x, y); }
-/*! @abstract Do not call this function directly; use simd::hypot instead.    */
-static SIMD_CPPFUNC float __tg_hypot(float x, float y) { return ::hypot(x, y); }
-/*! @abstract Do not call this function directly; use simd::hypot instead.    */
-static SIMD_CPPFUNC double __tg_hypot(double x, float y) { return ::hypot(x, y); }
-/*! @abstract Do not call this function directly; use simd::pow instead.      */
-static SIMD_CPPFUNC float __tg_pow(float x, float y) { return ::pow(x, y); }
-/*! @abstract Do not call this function directly; use simd::pow instead.      */
-static SIMD_CPPFUNC double __tg_pow(double x, float y) { return ::pow(x, y); }
-/*! @abstract Do not call this function directly; use simd::fmod instead.     */
-static SIMD_CPPFUNC float __tg_fmod(float x, float y) { return ::fmod(x, y); }
-/*! @abstract Do not call this function directly; use simd::fmod instead.     */
-static SIMD_CPPFUNC double __tg_fmod(double x, float y) { return ::fmod(x, y); }
-/*! @abstract Do not call this function directly; use simd::remainder
- *  instead.                                                                  */
-static SIMD_CPPFUNC float __tg_remainder(float x, float y) { return ::remainder(x, y); }
-/*! @abstract Do not call this function directly; use simd::remainder
- *  instead.                                                                  */
-static SIMD_CPPFUNC double __tg_remainder(double x, float y) { return ::remainder(x, y); }
-/*! @abstract Do not call this function directly; use simd::copysign
- *  instead.                                                                  */
-static SIMD_CPPFUNC float __tg_copysign(float x, float y) { return ::copysign(x, y); }
-/*! @abstract Do not call this function directly; use simd::copysign
- *  instead.                                                                  */
-static SIMD_CPPFUNC double __tg_copysign(double x, float y) { return ::copysign(x, y); }
-/*! @abstract Do not call this function directly; use simd::nextafter
- *  instead.                                                                  */
-static SIMD_CPPFUNC float __tg_nextafter(float x, float y) { return ::nextafter(x, y); }
-/*! @abstract Do not call this function directly; use simd::nextafter
- *  instead.                                                                  */
-static SIMD_CPPFUNC double __tg_nextafter(double x, float y) { return ::nextafter(x, y); }
-/*! @abstract Do not call this function directly; use simd::fdim instead.     */
-static SIMD_CPPFUNC float __tg_fdim(float x, float y) { return ::fdim(x, y); }
-/*! @abstract Do not call this function directly; use simd::fdim instead.     */
-static SIMD_CPPFUNC double __tg_fdim(double x, float y) { return ::fdim(x, y); }
-/*! @abstract Do not call this function directly; use simd::fmax instead.     */
-static SIMD_CPPFUNC float __tg_fmax(float x, float y) { return ::fmax(x, y); }
-/*! @abstract Do not call this function directly; use simd::fmax instead.     */
-static SIMD_CPPFUNC double __tg_fmax(double x, float y) { return ::fmax(x, y); }
-/*! @abstract Do not call this function directly; use simd::fmin instead.     */
-static SIMD_CPPFUNC float __tg_fmin(float x, float y) { return ::fmin(x, y); }
-/*! @abstract Do not call this function directly; use simd::fmin instead.     */
-static SIMD_CPPFUNC double __tg_fmin(double x, float y) { return ::fmin(x, y); }
-/*! @abstract Do not call this function directly; use simd::fma instead.      */
-static SIMD_CPPFUNC float __tg_fma(float x, float y, float z) { return ::fma(x, y, z); }
-/*! @abstract Do not call this function directly; use simd::fma instead.      */
-static SIMD_CPPFUNC double __tg_fma(double x, double y, double z) { return ::fma(x, y, z); }
-  
-namespace simd {
-/*! @abstract Generalizes the <cmath> function acos to operate on vectors of
- *  floats and doubles.                                                       */
-  template <typename fptypeN>
-  static SIMD_CPPFUNC fptypeN acos(fptypeN x) { return ::__tg_acos(x); }
-  
-/*! @abstract Generalizes the <cmath> function asin to operate on vectors of
- *  floats and doubles.                                                       */
-  template <typename fptypeN>
-  static SIMD_CPPFUNC fptypeN asin(fptypeN x) { return ::__tg_asin(x); }
-  
-/*! @abstract Generalizes the <cmath> function atan to operate on vectors of
- *  floats and doubles.                                                       */
-  template <typename fptypeN>
-  static SIMD_CPPFUNC fptypeN atan(fptypeN x) { return ::__tg_atan(x); }
-  
-/*! @abstract Generalizes the <cmath> function cos to operate on vectors of
- *  floats and doubles.                                                       */
-  template <typename fptypeN>
-  static SIMD_CPPFUNC fptypeN cos(fptypeN x) { return ::__tg_cos(x); }
-  
-/*! @abstract Generalizes the <cmath> function sin to operate on vectors of
- *  floats and doubles.                                                       */
-  template <typename fptypeN>
-  static SIMD_CPPFUNC fptypeN sin(fptypeN x) { return ::__tg_sin(x); }
-  
-/*! @abstract Generalizes the <cmath> function tan to operate on vectors of
- *  floats and doubles.                                                       */
-  template <typename fptypeN>
-  static SIMD_CPPFUNC fptypeN tan(fptypeN x) { return ::__tg_tan(x); }
-  
-#if SIMD_LIBRARY_VERSION >= 1
-/*! @abstract Generalizes the <cmath> function cospi to operate on vectors
- *  of floats and doubles.                                                    */
-  template <typename fptypeN>
-  static SIMD_CPPFUNC fptypeN cospi(fptypeN x) { return ::__tg_cospi(x); }
-#endif
-  
-#if SIMD_LIBRARY_VERSION >= 1
-/*! @abstract Generalizes the <cmath> function sinpi to operate on vectors
- *  of floats and doubles.                                                    */
-  template <typename fptypeN>
-  static SIMD_CPPFUNC fptypeN sinpi(fptypeN x) { return ::__tg_sinpi(x); }
-#endif
-  
-#if SIMD_LIBRARY_VERSION >= 1
-/*! @abstract Generalizes the <cmath> function tanpi to operate on vectors
- *  of floats and doubles.                                                    */
-  template <typename fptypeN>
-  static SIMD_CPPFUNC fptypeN tanpi(fptypeN x) { return ::__tg_tanpi(x); }
-#endif
-  
-/*! @abstract Generalizes the <cmath> function acosh to operate on vectors
- *  of floats and doubles.                                                    */
-  template <typename fptypeN>
-  static SIMD_CPPFUNC fptypeN acosh(fptypeN x) { return ::__tg_acosh(x); }
-  
-/*! @abstract Generalizes the <cmath> function asinh to operate on vectors
- *  of floats and doubles.                                                    */
-  template <typename fptypeN>
-  static SIMD_CPPFUNC fptypeN asinh(fptypeN x) { return ::__tg_asinh(x); }
-  
-/*! @abstract Generalizes the <cmath> function atanh to operate on vectors
- *  of floats and doubles.                                                    */
-  template <typename fptypeN>
-  static SIMD_CPPFUNC fptypeN atanh(fptypeN x) { return ::__tg_atanh(x); }
-  
-/*! @abstract Generalizes the <cmath> function cosh to operate on vectors of
- *  floats and doubles.                                                       */
-  template <typename fptypeN>
-  static SIMD_CPPFUNC fptypeN cosh(fptypeN x) { return ::__tg_cosh(x); }
-  
-/*! @abstract Generalizes the <cmath> function sinh to operate on vectors of
- *  floats and doubles.                                                       */
-  template <typename fptypeN>
-  static SIMD_CPPFUNC fptypeN sinh(fptypeN x) { return ::__tg_sinh(x); }
-  
-/*! @abstract Generalizes the <cmath> function tanh to operate on vectors of
- *  floats and doubles.                                                       */
-  template <typename fptypeN>
-  static SIMD_CPPFUNC fptypeN tanh(fptypeN x) { return ::__tg_tanh(x); }
-  
-/*! @abstract Generalizes the <cmath> function exp to operate on vectors of
- *  floats and doubles.                                                       */
-  template <typename fptypeN>
-  static SIMD_CPPFUNC fptypeN exp(fptypeN x) { return ::__tg_exp(x); }
-  
-/*! @abstract Generalizes the <cmath> function exp2 to operate on vectors of
- *  floats and doubles.                                                       */
-  template <typename fptypeN>
-  static SIMD_CPPFUNC fptypeN exp2(fptypeN x) { return ::__tg_exp2(x); }
-  
-#if SIMD_LIBRARY_VERSION >= 1
-/*! @abstract Generalizes the <cmath> function exp10 to operate on vectors
- *  of floats and doubles.                                                    */
-  template <typename fptypeN>
-  static SIMD_CPPFUNC fptypeN exp10(fptypeN x) { return ::__tg_exp10(x); }
-#endif
-  
-/*! @abstract Generalizes the <cmath> function expm1 to operate on vectors
- *  of floats and doubles.                                                    */
-  template <typename fptypeN>
-  static SIMD_CPPFUNC fptypeN expm1(fptypeN x) { return ::__tg_expm1(x); }
-  
-/*! @abstract Generalizes the <cmath> function log to operate on vectors of
- *  floats and doubles.                                                       */
-  template <typename fptypeN>
-  static SIMD_CPPFUNC fptypeN log(fptypeN x) { return ::__tg_log(x); }
-  
-/*! @abstract Generalizes the <cmath> function log2 to operate on vectors of
- *  floats and doubles.                                                       */
-  template <typename fptypeN>
-  static SIMD_CPPFUNC fptypeN log2(fptypeN x) { return ::__tg_log2(x); }
-  
-/*! @abstract Generalizes the <cmath> function log10 to operate on vectors
- *  of floats and doubles.                                                    */
-  template <typename fptypeN>
-  static SIMD_CPPFUNC fptypeN log10(fptypeN x) { return ::__tg_log10(x); }
-  
-/*! @abstract Generalizes the <cmath> function log1p to operate on vectors
- *  of floats and doubles.                                                    */
-  template <typename fptypeN>
-  static SIMD_CPPFUNC fptypeN log1p(fptypeN x) { return ::__tg_log1p(x); }
-  
-/*! @abstract Generalizes the <cmath> function fabs to operate on vectors of
- *  floats and doubles.                                                       */
-  template <typename fptypeN>
-  static SIMD_CPPFUNC fptypeN fabs(fptypeN x) { return ::__tg_fabs(x); }
-  
-/*! @abstract Generalizes the <cmath> function cbrt to operate on vectors of
- *  floats and doubles.                                                       */
-  template <typename fptypeN>
-  static SIMD_CPPFUNC fptypeN cbrt(fptypeN x) { return ::__tg_cbrt(x); }
-  
-/*! @abstract Generalizes the <cmath> function sqrt to operate on vectors of
- *  floats and doubles.                                                       */
-  template <typename fptypeN>
-  static SIMD_CPPFUNC fptypeN sqrt(fptypeN x) { return ::__tg_sqrt(x); }
-  
-/*! @abstract Generalizes the <cmath> function erf to operate on vectors of
- *  floats and doubles.                                                       */
-  template <typename fptypeN>
-  static SIMD_CPPFUNC fptypeN erf(fptypeN x) { return ::__tg_erf(x); }
-  
-/*! @abstract Generalizes the <cmath> function erfc to operate on vectors of
- *  floats and doubles.                                                       */
-  template <typename fptypeN>
-  static SIMD_CPPFUNC fptypeN erfc(fptypeN x) { return ::__tg_erfc(x); }
-  
-/*! @abstract Generalizes the <cmath> function tgamma to operate on vectors
- *  of floats and doubles.                                                    */
-  template <typename fptypeN>
-  static SIMD_CPPFUNC fptypeN tgamma(fptypeN x) { return ::__tg_tgamma(x); }
-  
-/*! @abstract Generalizes the <cmath> function ceil to operate on vectors of
- *  floats and doubles.                                                       */
-  template <typename fptypeN>
-  static SIMD_CPPFUNC fptypeN ceil(fptypeN x) { return ::__tg_ceil(x); }
-  
-/*! @abstract Generalizes the <cmath> function floor to operate on vectors
- *  of floats and doubles.                                                    */
-  template <typename fptypeN>
-  static SIMD_CPPFUNC fptypeN floor(fptypeN x) { return ::__tg_floor(x); }
-  
-/*! @abstract Generalizes the <cmath> function rint to operate on vectors of
- *  floats and doubles.                                                       */
-  template <typename fptypeN>
-  static SIMD_CPPFUNC fptypeN rint(fptypeN x) { return ::__tg_rint(x); }
-  
-/*! @abstract Generalizes the <cmath> function round to operate on vectors
- *  of floats and doubles.                                                    */
-  template <typename fptypeN>
-  static SIMD_CPPFUNC fptypeN round(fptypeN x) { return ::__tg_round(x); }
-  
-/*! @abstract Generalizes the <cmath> function trunc to operate on vectors
- *  of floats and doubles.                                                    */
-  template <typename fptypeN>
-  static SIMD_CPPFUNC fptypeN trunc(fptypeN x) { return ::__tg_trunc(x); }
-  
-/*! @abstract Generalizes the <cmath> function atan2 to operate on vectors
- *  of floats and doubles.                                                    */
-  template <typename fptypeN>
-  static SIMD_CPPFUNC fptypeN atan2(fptypeN y, fptypeN x) { return ::__tg_atan2(y, x); }
-    
-/*! @abstract Generalizes the <cmath> function hypot to operate on vectors
- *  of floats and doubles.                                                    */
-  template <typename fptypeN>
-  static SIMD_CPPFUNC fptypeN hypot(fptypeN x, fptypeN y) { return ::__tg_hypot(x, y); }
-    
-/*! @abstract Generalizes the <cmath> function pow to operate on vectors of
- *  floats and doubles.                                                       */
-  template <typename fptypeN>
-  static SIMD_CPPFUNC fptypeN pow(fptypeN x, fptypeN y) { return ::__tg_pow(x, y); }
-    
-/*! @abstract Generalizes the <cmath> function fmod to operate on vectors of
- *  floats and doubles.                                                       */
-  template <typename fptypeN>
-  static SIMD_CPPFUNC fptypeN fmod(fptypeN x, fptypeN y) { return ::__tg_fmod(x, y); }
-    
-/*! @abstract Generalizes the <cmath> function remainder to operate on
- *  vectors of floats and doubles.                                            */
-  template <typename fptypeN>
-  static SIMD_CPPFUNC fptypeN remainder(fptypeN x, fptypeN y) { return ::__tg_remainder(x, y); }
-    
-/*! @abstract Generalizes the <cmath> function copysign to operate on
- *  vectors of floats and doubles.                                            */
-  template <typename fptypeN>
-  static SIMD_CPPFUNC fptypeN copysign(fptypeN x, fptypeN y) { return ::__tg_copysign(x, y); }
-    
-/*! @abstract Generalizes the <cmath> function nextafter to operate on
- *  vectors of floats and doubles.                                            */
-  template <typename fptypeN>
-  static SIMD_CPPFUNC fptypeN nextafter(fptypeN x, fptypeN y) { return ::__tg_nextafter(x, y); }
-    
-/*! @abstract Generalizes the <cmath> function fdim to operate on vectors of
- *  floats and doubles.                                                       */
-  template <typename fptypeN>
-  static SIMD_CPPFUNC fptypeN fdim(fptypeN x, fptypeN y) { return ::__tg_fdim(x, y); }
-    
-/*! @abstract Generalizes the <cmath> function fmax to operate on vectors of
- *  floats and doubles.                                                       */
-  template <typename fptypeN>
-  static SIMD_CPPFUNC fptypeN fmax(fptypeN x, fptypeN y) { return ::__tg_fmax(x, y); }
-    
-/*! @abstract Generalizes the <cmath> function fmin to operate on vectors of
- *  floats and doubles.                                                       */
-  template <typename fptypeN>
-  static SIMD_CPPFUNC fptypeN fmin(fptypeN x, fptypeN y) { return ::__tg_fmin(x, y); }
-    
-/*! @abstract Generalizes the <cmath> function fma to operate on vectors of
- *  floats and doubles.                                                       */
-  template <typename fptypeN>
-  static SIMD_CPPFUNC fptypeN fma(fptypeN x, fptypeN y, fptypeN z) { return ::__tg_fma(x, y, z); }
-        
-/*! @abstract Computes x*y + z by the most efficient means available; either
- *  a fused multiply add or separate multiply and add.                        */
-  template <typename fptypeN>
-  static SIMD_CPPFUNC fptypeN muladd(fptypeN x, fptypeN y, fptypeN z) { return ::simd_muladd(x, y, z); }
-};
-
-extern "C" {
-#else
-#include <tgmath.h>
-/* C and Objective-C, we need some infrastructure to piggyback on tgmath.h    */
-static SIMD_OVERLOAD simd_float2 __tg_promote(simd_float2);
-static SIMD_OVERLOAD simd_float3 __tg_promote(simd_float3);
-static SIMD_OVERLOAD simd_float4 __tg_promote(simd_float4);
-static SIMD_OVERLOAD simd_float8 __tg_promote(simd_float8);
-static SIMD_OVERLOAD simd_float16 __tg_promote(simd_float16);
-static SIMD_OVERLOAD simd_double2 __tg_promote(simd_double2);
-static SIMD_OVERLOAD simd_double3 __tg_promote(simd_double3);
-static SIMD_OVERLOAD simd_double4 __tg_promote(simd_double4);
-static SIMD_OVERLOAD simd_double8 __tg_promote(simd_double8);
-
-/*  Apple extensions to <math.h>, added in macOS 10.9 and iOS 7.0             */
-#if __MAC_OS_X_VERSION_MIN_REQUIRED >= __MAC_10_9   || \
-    __IPHONE_OS_VERSION_MIN_REQUIRED >= __IPHONE_7_0 || \
-    __DRIVERKIT_VERSION_MIN_REQUIRED >= __DRIVERKIT_19_0
-static inline SIMD_CFUNC float __tg_cospi(float x) { return __cospif(x); }
-static inline SIMD_CFUNC double __tg_cospi(double x) { return __cospi(x); }
-#undef cospi
-/*! @abstract `cospi(x)` computes `cos(pi * x)` without intermediate rounding.
- *
- *  @discussion Both faster and more accurate than multiplying by `pi` and then
- *  calling `cos`. Defined for `float` and `double` as well as vectors of
- *  floats and doubles as provided by `<simd/simd.h>`.                        */
-#define cospi(__x) __tg_cospi(__tg_promote1((__x))(__x))
-
-static inline SIMD_CFUNC float __tg_sinpi(float x) { return __sinpif(x); }
-static inline SIMD_CFUNC double __tg_sinpi(double x) { return __sinpi(x); }
-#undef sinpi
-/*! @abstract `sinpi(x)` computes `sin(pi * x)` without intermediate rounding.
- *
- *  @discussion Both faster and more accurate than multiplying by `pi` and then
- *  calling `sin`. Defined for `float` and `double` as well as vectors
- *  of floats and doubles as provided by `<simd/simd.h>`.                     */
-#define sinpi(__x) __tg_sinpi(__tg_promote1((__x))(__x))
-
-static inline SIMD_CFUNC float __tg_tanpi(float x) { return __tanpif(x); }
-static inline SIMD_CFUNC double __tg_tanpi(double x) { return __tanpi(x); }
-#undef tanpi
-/*! @abstract `tanpi(x)` computes `tan(pi * x)` without intermediate rounding.
- *
- *  @discussion Both faster and more accurate than multiplying by `pi` and then
- *  calling `tan`. Defined for `float` and `double` as well as vectors of
- *  floats and doubles as provided by `<simd/simd.h>`.                        */
-#define tanpi(__x) __tg_tanpi(__tg_promote1((__x))(__x))
-
-static inline SIMD_CFUNC float __tg_exp10(float x) { return __exp10f(x); }
-static inline SIMD_CFUNC double __tg_exp10(double x) { return __exp10(x); }
-#undef exp10
-/*! @abstract `exp10(x)` computes `10**x` more efficiently and accurately
- *  than `pow(10, x)`.
- *
- *  @discussion Defined for `float` and `double` as well as vectors of floats
- *  and doubles as provided by `<simd/simd.h>`.                               */
-#define exp10(__x) __tg_exp10(__tg_promote1((__x))(__x))
-#endif
-  
-#endif /* !__cplusplus */
-  
-#pragma mark - fabs implementation
-static inline SIMD_CFUNC simd_float2 __tg_fabs(simd_float2 x) { return simd_bitselect(0.0, x, 0x7fffffff); }
-static inline SIMD_CFUNC simd_float3 __tg_fabs(simd_float3 x) { return simd_bitselect(0.0, x, 0x7fffffff); }
-static inline SIMD_CFUNC simd_float4 __tg_fabs(simd_float4 x) { return simd_bitselect(0.0, x, 0x7fffffff); }
-static inline SIMD_CFUNC simd_float8 __tg_fabs(simd_float8 x) { return simd_bitselect(0.0, x, 0x7fffffff); }
-static inline SIMD_CFUNC simd_float16 __tg_fabs(simd_float16 x) { return simd_bitselect(0.0, x, 0x7fffffff); }
-static inline SIMD_CFUNC simd_double2 __tg_fabs(simd_double2 x) { return simd_bitselect(0.0, x, 0x7fffffffffffffffL); }
-static inline SIMD_CFUNC simd_double3 __tg_fabs(simd_double3 x) { return simd_bitselect(0.0, x, 0x7fffffffffffffffL); }
-static inline SIMD_CFUNC simd_double4 __tg_fabs(simd_double4 x) { return simd_bitselect(0.0, x, 0x7fffffffffffffffL); }
-static inline SIMD_CFUNC simd_double8 __tg_fabs(simd_double8 x) { return simd_bitselect(0.0, x, 0x7fffffffffffffffL); }
-  
-#pragma mark - fmin, fmax implementation
-static SIMD_CFUNC simd_float2 __tg_fmin(simd_float2 x, simd_float2 y) {
-#if defined __SSE2__
-  return simd_make_float2(__tg_fmin(simd_make_float4_undef(x), simd_make_float4_undef(y)));
-#elif defined __arm64__
-  return vminnm_f32(x, y);
-#elif defined __arm__ && __FINITE_MATH_ONLY__
-  return vmin_f32(x, y);
-#else
-  return simd_bitselect(y, x, (x <= y) | (y != y));
-#endif
-}
-  
-static SIMD_CFUNC simd_float3 __tg_fmin(simd_float3 x, simd_float3 y) {
-  return simd_make_float3(__tg_fmin(simd_make_float4_undef(x), simd_make_float4_undef(y)));
-}
-  
-static SIMD_CFUNC simd_float4 __tg_fmin(simd_float4 x, simd_float4 y) {
-#if defined __AVX512DQ__ && defined __AVX512VL__ && !__FINITE_MATH_ONLY__
-  return _mm_range_ps(x, y, 4);
-#elif defined __SSE2__ && __FINITE_MATH_ONLY__
-  return _mm_min_ps(x, y);
-#elif defined __SSE2__
-  return simd_bitselect(_mm_min_ps(x, y), x, y != y);
-#elif defined __arm64__
-  return vminnmq_f32(x, y);
-#elif defined __arm__ && __FINITE_MATH_ONLY__
-  return vminq_f32(x, y);
-#else
-  return simd_bitselect(y, x, (x <= y) | (y != y));
-#endif
-}
-  
-static SIMD_CFUNC simd_float8 __tg_fmin(simd_float8 x, simd_float8 y) {
-#if defined __AVX512DQ__ && defined __AVX512VL__ && !__FINITE_MATH_ONLY__
-  return _mm256_range_ps(x, y, 4);
-#elif defined __AVX__ && __FINITE_MATH_ONLY__
-  return _mm256_min_ps(x, y);
-#elif defined __AVX__
-  return simd_bitselect(_mm256_min_ps(x, y), x, y != y);
-#else
-  return simd_make_float8(__tg_fmin(x.lo, y.lo), __tg_fmin(x.hi, y.hi));
-#endif
-}
-  
-static SIMD_CFUNC simd_float16 __tg_fmin(simd_float16 x, simd_float16 y) {
-#if defined __AVX512DQ__ && !__FINITE_MATH_ONLY__
-  return _mm512_range_ps(x, y, 4);
-#elif defined __AVX512F__ && __FINITE_MATH_ONLY__
-  return _mm512_min_ps(x, y);
-#elif defined __AVX512F__
-  return simd_bitselect(_mm512_min_ps(x, y), x, y != y);
-#else
-  return simd_make_float16(__tg_fmin(x.lo, y.lo), __tg_fmin(x.hi, y.hi));
-#endif
-}
-  
-static SIMD_CFUNC simd_double2 __tg_fmin(simd_double2 x, simd_double2 y) {
-#if defined __AVX512DQ__ && defined __AVX512VL__
-  return _mm_range_pd(x, y, 4);
-#elif defined __SSE2__ && __FINITE_MATH_ONLY__
-  return _mm_min_pd(x, y);
-#elif defined __SSE2__
-  return simd_bitselect(_mm_min_pd(x, y), x, y != y);
-#elif defined __arm64__
-  return vminnmq_f64(x, y);
-#else
-  return simd_bitselect(y, x, (x <= y) | (y != y));
-#endif
-}
-  
-static SIMD_CFUNC simd_double3 __tg_fmin(simd_double3 x, simd_double3 y) {
-  return simd_make_double3(__tg_fmin(simd_make_double4_undef(x), simd_make_double4_undef(y)));
-}
-  
-static SIMD_CFUNC simd_double4 __tg_fmin(simd_double4 x, simd_double4 y) {
-#if defined __AVX512DQ__ && defined __AVX512VL__
-  return _mm256_range_pd(x, y, 4);
-#elif defined __AVX__ && __FINITE_MATH_ONLY__
-  return _mm256_min_pd(x, y);
-#elif defined __AVX__
-  return simd_bitselect(_mm256_min_pd(x, y), x, y != y);
-#else
-  return simd_make_double4(__tg_fmin(x.lo, y.lo), __tg_fmin(x.hi, y.hi));
-#endif
-}
-
-static SIMD_CFUNC simd_double8 __tg_fmin(simd_double8 x, simd_double8 y) {
-#if defined __AVX512DQ__
-  return _mm512_range_pd(x, y, 4);
-#elif defined __AVX512F__ && __FINITE_MATH_ONLY__
-  return _mm512_min_pd(x, y);
-#elif defined __AVX512F__
-  return simd_bitselect(_mm512_min_pd(x, y), x, y != y);
-#else
-  return simd_make_double8(__tg_fmin(x.lo, y.lo), __tg_fmin(x.hi, y.hi));
-#endif
-}
-
-static SIMD_CFUNC simd_float2 __tg_fmax(simd_float2 x, simd_float2 y) {
-#if defined __SSE2__
-  return simd_make_float2(__tg_fmax(simd_make_float4_undef(x), simd_make_float4_undef(y)));
-#elif defined __arm64__
-  return vmaxnm_f32(x, y);
-#elif defined __arm__ && __FINITE_MATH_ONLY__
-  return vmax_f32(x, y);
-#else
-  return simd_bitselect(y, x, (x >= y) | (y != y));
-#endif
-}
-  
-static SIMD_CFUNC simd_float3 __tg_fmax(simd_float3 x, simd_float3 y) {
-  return simd_make_float3(__tg_fmax(simd_make_float4_undef(x), simd_make_float4_undef(y)));
-}
-  
-static SIMD_CFUNC simd_float4 __tg_fmax(simd_float4 x, simd_float4 y) {
-#if defined __AVX512DQ__ && defined __AVX512VL__ && !__FINITE_MATH_ONLY__
-  return _mm_range_ps(x, y, 5);
-#elif defined __SSE2__ && __FINITE_MATH_ONLY__
-  return _mm_max_ps(x, y);
-#elif defined __SSE2__
-  return simd_bitselect(_mm_max_ps(x, y), x, y != y);
-#elif defined __arm64__
-  return vmaxnmq_f32(x, y);
-#elif defined __arm__ && __FINITE_MATH_ONLY__
-  return vmaxq_f32(x, y);
-#else
-  return simd_bitselect(y, x, (x >= y) | (y != y));
-#endif
-}
-  
-static SIMD_CFUNC simd_float8 __tg_fmax(simd_float8 x, simd_float8 y) {
-#if defined __AVX512DQ__ && defined __AVX512VL__ && !__FINITE_MATH_ONLY__
-  return _mm256_range_ps(x, y, 5);
-#elif defined __AVX__ && __FINITE_MATH_ONLY__
-  return _mm256_max_ps(x, y);
-#elif defined __AVX__
-  return simd_bitselect(_mm256_max_ps(x, y), x, y != y);
-#else
-  return simd_make_float8(__tg_fmax(x.lo, y.lo), __tg_fmax(x.hi, y.hi));
-#endif
-}
-  
-static SIMD_CFUNC simd_float16 __tg_fmax(simd_float16 x, simd_float16 y) {
-#if defined __AVX512DQ__ && !__FINITE_MATH_ONLY__
-  return _mm512_range_ps(x, y, 5);
-#elif defined __AVX512F__ && __FINITE_MATH_ONLY__
-  return _mm512_max_ps(x, y);
-#elif defined __AVX512F__
-  return simd_bitselect(_mm512_max_ps(x, y), x, y != y);
-#else
-  return simd_make_float16(__tg_fmax(x.lo, y.lo), __tg_fmax(x.hi, y.hi));
-#endif
-}
-  
-static SIMD_CFUNC simd_double2 __tg_fmax(simd_double2 x, simd_double2 y) {
-#if defined __AVX512DQ__ && defined __AVX512VL__
-  return _mm_range_pd(x, y, 5);
-#elif defined __SSE2__ && __FINITE_MATH_ONLY__
-  return _mm_max_pd(x, y);
-#elif defined __SSE2__
-  return simd_bitselect(_mm_max_pd(x, y), x, y != y);
-#elif defined __arm64__
-  return vmaxnmq_f64(x, y);
-#else
-  return simd_bitselect(y, x, (x >= y) | (y != y));
-#endif
-}
-  
-static SIMD_CFUNC simd_double3 __tg_fmax(simd_double3 x, simd_double3 y) {
-  return simd_make_double3(__tg_fmax(simd_make_double4_undef(x), simd_make_double4_undef(y)));
-}
-  
-static SIMD_CFUNC simd_double4 __tg_fmax(simd_double4 x, simd_double4 y) {
-#if defined __AVX512DQ__ && defined __AVX512VL__
-  return _mm256_range_pd(x, y, 5);
-#elif defined __AVX__ && __FINITE_MATH_ONLY__
-  return _mm256_max_pd(x, y);
-#elif defined __AVX__
-  return simd_bitselect(_mm256_max_pd(x, y), x, y != y);
-#else
-  return simd_make_double4(__tg_fmax(x.lo, y.lo), __tg_fmax(x.hi, y.hi));
-#endif
-}
-
-static SIMD_CFUNC simd_double8 __tg_fmax(simd_double8 x, simd_double8 y) {
-#if defined __AVX512DQ__
-  return _mm512_range_pd(x, y, 5);
-#elif defined __AVX512F__ && __FINITE_MATH_ONLY__
-  return _mm512_max_pd(x, y);
-#elif defined __AVX512F__
-  return simd_bitselect(_mm512_max_pd(x, y), x, y != y);
-#else
-  return simd_make_double8(__tg_fmax(x.lo, y.lo), __tg_fmax(x.hi, y.hi));
-#endif
-}
-
-#pragma mark - copysign implementation
-static inline SIMD_CFUNC simd_float2 __tg_copysign(simd_float2 x, simd_float2 y) { return simd_bitselect(y, x, 0x7fffffff); }
-static inline SIMD_CFUNC simd_float3 __tg_copysign(simd_float3 x, simd_float3 y) { return simd_bitselect(y, x, 0x7fffffff); }
-static inline SIMD_CFUNC simd_float4 __tg_copysign(simd_float4 x, simd_float4 y) { return simd_bitselect(y, x, 0x7fffffff); }
-static inline SIMD_CFUNC simd_float8 __tg_copysign(simd_float8 x, simd_float8 y) { return simd_bitselect(y, x, 0x7fffffff); }
-static inline SIMD_CFUNC simd_float16 __tg_copysign(simd_float16 x, simd_float16 y) { return simd_bitselect(y, x, 0x7fffffff); }
-static inline SIMD_CFUNC simd_double2 __tg_copysign(simd_double2 x, simd_double2 y) { return simd_bitselect(y, x, 0x7fffffffffffffffL); }
-static inline SIMD_CFUNC simd_double3 __tg_copysign(simd_double3 x, simd_double3 y) { return simd_bitselect(y, x, 0x7fffffffffffffffL); }
-static inline SIMD_CFUNC simd_double4 __tg_copysign(simd_double4 x, simd_double4 y) { return simd_bitselect(y, x, 0x7fffffffffffffffL); }
-static inline SIMD_CFUNC simd_double8 __tg_copysign(simd_double8 x, simd_double8 y) { return simd_bitselect(y, x, 0x7fffffffffffffffL); }
-  
-#pragma mark - sqrt implementation
-static SIMD_CFUNC simd_float2 __tg_sqrt(simd_float2 x) {
-#if defined __SSE2__
-  return simd_make_float2(__tg_sqrt(simd_make_float4_undef(x)));
-#elif defined __arm64__
-  return vsqrt_f32(x);
-#else
-  return simd_make_float2(sqrt(x.x), sqrt(x.y));
-#endif
-}
-
-static SIMD_CFUNC simd_float3 __tg_sqrt(simd_float3 x) {
-  return simd_make_float3(__tg_sqrt(simd_make_float4_undef(x)));
-}
-
-static SIMD_CFUNC simd_float4 __tg_sqrt(simd_float4 x) {
-#if defined __SSE2__
-  return _mm_sqrt_ps(x);
-#elif defined __arm64__
-  return vsqrtq_f32(x);
-#else
-  return simd_make_float4(__tg_sqrt(x.lo), __tg_sqrt(x.hi));
-#endif
-}
-
-static SIMD_CFUNC simd_float8 __tg_sqrt(simd_float8 x) {
-#if defined __AVX__
-  return _mm256_sqrt_ps(x);
-#else
-  return simd_make_float8(__tg_sqrt(x.lo), __tg_sqrt(x.hi));
-#endif
-}
-  
-static SIMD_CFUNC simd_float16 __tg_sqrt(simd_float16 x) {
-#if defined __AVX512F__
-  return _mm512_sqrt_ps(x);
-#else
-  return simd_make_float16(__tg_sqrt(x.lo), __tg_sqrt(x.hi));
-#endif
-}
-
-static SIMD_CFUNC simd_double2 __tg_sqrt(simd_double2 x) {
-#if defined __SSE2__
-  return _mm_sqrt_pd(x);
-#elif defined __arm64__
-  return vsqrtq_f64(x);
-#else
-  return simd_make_double2(sqrt(x.x), sqrt(x.y));
-#endif
-}
-  
-static SIMD_CFUNC simd_double3 __tg_sqrt(simd_double3 x) {
-  return simd_make_double3(__tg_sqrt(simd_make_double4_undef(x)));
-}
-
-static SIMD_CFUNC simd_double4 __tg_sqrt(simd_double4 x) {
-#if defined __AVX__
-  return _mm256_sqrt_pd(x);
-#else
-  return simd_make_double4(__tg_sqrt(x.lo), __tg_sqrt(x.hi));
-#endif
-}
-  
-static SIMD_CFUNC simd_double8 __tg_sqrt(simd_double8 x) {
-#if defined __AVX512F__
-  return _mm512_sqrt_pd(x);
-#else
-  return simd_make_double8(__tg_sqrt(x.lo), __tg_sqrt(x.hi));
-#endif
-}
-  
-#pragma mark - ceil, floor, rint, trunc implementation
-static SIMD_CFUNC simd_float2 __tg_ceil(simd_float2 x) {
-#if defined __arm64__
-  return vrndp_f32(x);
-#else
-  return simd_make_float2(__tg_ceil(simd_make_float4_undef(x)));
-#endif
-}
-  
-static SIMD_CFUNC simd_float3 __tg_ceil(simd_float3 x) {
-  return simd_make_float3(__tg_ceil(simd_make_float4_undef(x)));
-}
-  
-#if defined __arm__ && SIMD_LIBRARY_VERSION >= 3
-extern simd_float4 _simd_ceil_f4(simd_float4 x);
-#endif
-
-static SIMD_CFUNC simd_float4 __tg_ceil(simd_float4 x) {
-#if defined __SSE4_1__
-  return _mm_round_ps(x, _MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC);
-#elif defined __arm64__
-  return vrndpq_f32(x);
-#elif defined __arm__ && SIMD_LIBRARY_VERSION >= 3
-  return _simd_ceil_f4(x);
-#else
-  simd_float4 truncated = __tg_trunc(x);
-  simd_float4 adjust = simd_bitselect((simd_float4)0, 1, truncated < x);
-  return __tg_copysign(truncated + adjust, x);
-#endif
-}
- 
-static SIMD_CFUNC simd_float8 __tg_ceil(simd_float8 x) {
-#if defined __AVX__
-  return _mm256_round_ps(x, _MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC);
-#else
-  return simd_make_float8(__tg_ceil(x.lo), __tg_ceil(x.hi));
-#endif
-}
- 
-static SIMD_CFUNC simd_float16 __tg_ceil(simd_float16 x) {
-#if defined __AVX512F__
-  return _mm512_roundscale_ps(x, _MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC);
-#else
-  return simd_make_float16(__tg_ceil(x.lo), __tg_ceil(x.hi));
-#endif
-}
-  
-#if defined __arm__ && SIMD_LIBRARY_VERSION >= 3
-extern simd_double2 _simd_ceil_d2(simd_double2 x);
-#endif
-  
-static SIMD_CFUNC simd_double2 __tg_ceil(simd_double2 x) {
-#if defined __SSE4_1__
-  return _mm_round_pd(x, _MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC);
-#elif defined __arm64__
-  return vrndpq_f64(x);
-#elif defined __arm__ && SIMD_LIBRARY_VERSION >= 3
-  return _simd_ceil_d2(x);
-#else
-  simd_double2 truncated = __tg_trunc(x);
-  simd_double2 adjust = simd_bitselect((simd_double2)0, 1, truncated < x);
-  return __tg_copysign(truncated + adjust, x);
-#endif
-}
-  
-static SIMD_CFUNC simd_double3 __tg_ceil(simd_double3 x) {
-  return simd_make_double3(__tg_ceil(simd_make_double4_undef(x)));
-}
- 
-static SIMD_CFUNC simd_double4 __tg_ceil(simd_double4 x) {
-#if defined __AVX__
-  return _mm256_round_pd(x, _MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC);
-#else
-  return simd_make_double4(__tg_ceil(x.lo), __tg_ceil(x.hi));
-#endif
-}
- 
-static SIMD_CFUNC simd_double8 __tg_ceil(simd_double8 x) {
-#if defined __AVX512F__
-  return _mm512_roundscale_pd(x, _MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC);
-#else
-  return simd_make_double8(__tg_ceil(x.lo), __tg_ceil(x.hi));
-#endif
-}
-
-static SIMD_CFUNC simd_float2 __tg_floor(simd_float2 x) {
-#if defined __arm64__
-  return vrndm_f32(x);
-#else
-  return simd_make_float2(__tg_floor(simd_make_float4_undef(x)));
-#endif
-}
-  
-static SIMD_CFUNC simd_float3 __tg_floor(simd_float3 x) {
-  return simd_make_float3(__tg_floor(simd_make_float4_undef(x)));
-}
-  
-#if defined __arm__ && SIMD_LIBRARY_VERSION >= 3
-extern simd_float4 _simd_floor_f4(simd_float4 x);
-#endif
-
-static SIMD_CFUNC simd_float4 __tg_floor(simd_float4 x) {
-#if defined __SSE4_1__
-  return _mm_round_ps(x, _MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC);
-#elif defined __arm64__
-  return vrndmq_f32(x);
-#elif defined __arm__ && SIMD_LIBRARY_VERSION >= 3
-  return _simd_floor_f4(x);
-#else
-  simd_float4 truncated = __tg_trunc(x);
-  simd_float4 adjust = simd_bitselect((simd_float4)0, 1, truncated > x);
-  return truncated - adjust;
-#endif
-}
- 
-static SIMD_CFUNC simd_float8 __tg_floor(simd_float8 x) {
-#if defined __AVX__
-  return _mm256_round_ps(x, _MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC);
-#else
-  return simd_make_float8(__tg_floor(x.lo), __tg_floor(x.hi));
-#endif
-}
- 
-static SIMD_CFUNC simd_float16 __tg_floor(simd_float16 x) {
-#if defined __AVX512F__
-  return _mm512_roundscale_ps(x, _MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC);
-#else
-  return simd_make_float16(__tg_floor(x.lo), __tg_floor(x.hi));
-#endif
-}
-  
-#if defined __arm__ && SIMD_LIBRARY_VERSION >= 3
-extern simd_double2 _simd_floor_d2(simd_double2 x);
-#endif
-  
-static SIMD_CFUNC simd_double2 __tg_floor(simd_double2 x) {
-#if defined __SSE4_1__
-  return _mm_round_pd(x, _MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC);
-#elif defined __arm64__
-  return vrndmq_f64(x);
-#elif defined __arm__ && SIMD_LIBRARY_VERSION >= 3
-  return _simd_floor_d2(x);
-#else
-  simd_double2 truncated = __tg_trunc(x);
-  simd_double2 adjust = simd_bitselect((simd_double2)0, 1, truncated > x);
-  return truncated - adjust;
-#endif
-}
-  
-static SIMD_CFUNC simd_double3 __tg_floor(simd_double3 x) {
-  return simd_make_double3(__tg_floor(simd_make_double4_undef(x)));
-}
- 
-static SIMD_CFUNC simd_double4 __tg_floor(simd_double4 x) {
-#if defined __AVX__
-  return _mm256_round_pd(x, _MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC);
-#else
-  return simd_make_double4(__tg_floor(x.lo), __tg_floor(x.hi));
-#endif
-}
- 
-static SIMD_CFUNC simd_double8 __tg_floor(simd_double8 x) {
-#if defined __AVX512F__
-  return _mm512_roundscale_pd(x, _MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC);
-#else
-  return simd_make_double8(__tg_floor(x.lo), __tg_floor(x.hi));
-#endif
-}
-
-static SIMD_CFUNC simd_float2 __tg_rint(simd_float2 x) {
-#if defined __arm64__
-  return vrndx_f32(x);
-#else
-  return simd_make_float2(__tg_rint(simd_make_float4_undef(x)));
-#endif
-}
-  
-static SIMD_CFUNC simd_float3 __tg_rint(simd_float3 x) {
-  return simd_make_float3(__tg_rint(simd_make_float4_undef(x)));
-}
-  
-#if defined __arm__ && SIMD_LIBRARY_VERSION >= 3
-extern simd_float4 _simd_rint_f4(simd_float4 x);
-#endif
-
-static SIMD_CFUNC simd_float4 __tg_rint(simd_float4 x) {
-#if defined __SSE4_1__
-  return _mm_round_ps(x, _MM_FROUND_RINT);
-#elif defined __arm64__
-  return vrndxq_f32(x);
-#elif defined __arm__ && SIMD_LIBRARY_VERSION >= 3
-  return _simd_rint_f4(x);
-#else
-  simd_float4 magic = __tg_copysign(0x1.0p23, x);
-  simd_int4 x_is_small = __tg_fabs(x) < 0x1.0p23;
-  return simd_bitselect(x, (x + magic) - magic, x_is_small & 0x7fffffff);
-#endif
-}
- 
-static SIMD_CFUNC simd_float8 __tg_rint(simd_float8 x) {
-#if defined __AVX__
-  return _mm256_round_ps(x, _MM_FROUND_RINT);
-#else
-  return simd_make_float8(__tg_rint(x.lo), __tg_rint(x.hi));
-#endif
-}
- 
-static SIMD_CFUNC simd_float16 __tg_rint(simd_float16 x) {
-#if defined __AVX512F__
-  return _mm512_roundscale_ps(x, _MM_FROUND_RINT);
-#else
-  return simd_make_float16(__tg_rint(x.lo), __tg_rint(x.hi));
-#endif
-}
-  
-#if defined __arm__ && SIMD_LIBRARY_VERSION >= 3
-extern simd_double2 _simd_rint_d2(simd_double2 x);
-#endif
-  
-static SIMD_CFUNC simd_double2 __tg_rint(simd_double2 x) {
-#if defined __SSE4_1__
-  return _mm_round_pd(x, _MM_FROUND_RINT);
-#elif defined __arm64__
-  return vrndxq_f64(x);
-#elif defined __arm__ && SIMD_LIBRARY_VERSION >= 3
-  return _simd_rint_d2(x);
-#else
-  simd_double2 magic = __tg_copysign(0x1.0p52, x);
-  simd_long2 x_is_small = __tg_fabs(x) < 0x1.0p52;
-  return simd_bitselect(x, (x + magic) - magic, x_is_small & 0x7fffffffffffffff);
-#endif
-}
-  
-static SIMD_CFUNC simd_double3 __tg_rint(simd_double3 x) {
-  return simd_make_double3(__tg_rint(simd_make_double4_undef(x)));
-}
- 
-static SIMD_CFUNC simd_double4 __tg_rint(simd_double4 x) {
-#if defined __AVX__
-  return _mm256_round_pd(x, _MM_FROUND_RINT);
-#else
-  return simd_make_double4(__tg_rint(x.lo), __tg_rint(x.hi));
-#endif
-}
- 
-static SIMD_CFUNC simd_double8 __tg_rint(simd_double8 x) {
-#if defined __AVX512F__
-  return _mm512_roundscale_pd(x, _MM_FROUND_RINT);
-#else
-  return simd_make_double8(__tg_rint(x.lo), __tg_rint(x.hi));
-#endif
-}
-
-static SIMD_CFUNC simd_float2 __tg_trunc(simd_float2 x) {
-#if defined __arm64__
-  return vrnd_f32(x);
-#else
-  return simd_make_float2(__tg_trunc(simd_make_float4_undef(x)));
-#endif
-}
-  
-static SIMD_CFUNC simd_float3 __tg_trunc(simd_float3 x) {
-  return simd_make_float3(__tg_trunc(simd_make_float4_undef(x)));
-}
-  
-#if defined __arm__ && SIMD_LIBRARY_VERSION >= 3
-extern simd_float4 _simd_trunc_f4(simd_float4 x);
-#endif
-
-static SIMD_CFUNC simd_float4 __tg_trunc(simd_float4 x) {
-#if defined __SSE4_1__
-  return _mm_round_ps(x, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
-#elif defined __arm64__
-  return vrndq_f32(x);
-#elif defined __arm__ && SIMD_LIBRARY_VERSION >= 3
-  return _simd_trunc_f4(x);
-#else
-  simd_float4 binade = simd_bitselect(0, x, 0x7f800000);
-  simd_int4 mask = (simd_int4)__tg_fmin(-2*binade + 1, -0);
-  simd_float4 result = simd_bitselect(0, x, mask);
-  return simd_bitselect(x, result, binade < 0x1.0p23);
-#endif
-}
- 
-static SIMD_CFUNC simd_float8 __tg_trunc(simd_float8 x) {
-#if defined __AVX__
-  return _mm256_round_ps(x, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
-#else
-  return simd_make_float8(__tg_trunc(x.lo), __tg_trunc(x.hi));
-#endif
-}
- 
-static SIMD_CFUNC simd_float16 __tg_trunc(simd_float16 x) {
-#if defined __AVX512F__
-  return _mm512_roundscale_ps(x, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
-#else
-  return simd_make_float16(__tg_trunc(x.lo), __tg_trunc(x.hi));
-#endif
-}
-  
-#if defined __arm__ && SIMD_LIBRARY_VERSION >= 3
-extern simd_double2 _simd_trunc_d2(simd_double2 x);
-#endif
-  
-static SIMD_CFUNC simd_double2 __tg_trunc(simd_double2 x) {
-#if defined __SSE4_1__
-  return _mm_round_pd(x, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
-#elif defined __arm64__
-  return vrndq_f64(x);
-#elif defined __arm__ && SIMD_LIBRARY_VERSION >= 3
-  return _simd_trunc_d2(x);
-#else
-  simd_double2 binade = simd_bitselect(0, x, 0x7ff0000000000000);
-  simd_long2 mask = (simd_long2)__tg_fmin(-2*binade + 1, -0);
-  simd_double2 result = simd_bitselect(0, x, mask);
-  return simd_bitselect(x, result, binade < 0x1.0p52);
-#endif
-}
-  
-static SIMD_CFUNC simd_double3 __tg_trunc(simd_double3 x) {
-  return simd_make_double3(__tg_trunc(simd_make_double4_undef(x)));
-}
- 
-static SIMD_CFUNC simd_double4 __tg_trunc(simd_double4 x) {
-#if defined __AVX__
-  return _mm256_round_pd(x, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
-#else
-  return simd_make_double4(__tg_trunc(x.lo), __tg_trunc(x.hi));
-#endif
-}
- 
-static SIMD_CFUNC simd_double8 __tg_trunc(simd_double8 x) {
-#if defined __AVX512F__
-  return _mm512_roundscale_pd(x, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
-#else
-  return simd_make_double8(__tg_trunc(x.lo), __tg_trunc(x.hi));
-#endif
-}
-
-#pragma mark - sine, cosine implementation
-static inline SIMD_CFUNC simd_float2 __tg_sin(simd_float2 x) {
-  return simd_make_float2(__tg_sin(simd_make_float4(x)));
-}
-  
-static inline SIMD_CFUNC simd_float3 __tg_sin(simd_float3 x) {
-  return simd_make_float3(__tg_sin(simd_make_float4(x)));
-}
-  
-#if SIMD_LIBRARY_VERSION >= 3
-extern simd_float4 _simd_sin_f4(simd_float4 x);
-static inline SIMD_CFUNC simd_float4 __tg_sin(simd_float4 x) {
-  return _simd_sin_f4(x);
-}
-#elif SIMD_LIBRARY_VERSION == 1
-extern simd_float4 __sin_f4(simd_float4 x);
-static inline SIMD_CFUNC simd_float4 __tg_sin(simd_float4 x) {
-  return __sin_f4(x);
-}
-#else
-static inline SIMD_CFUNC simd_float4 __tg_sin(simd_float4 x) {
-  return simd_make_float4(sin(x.x), sin(x.y), sin(x.z), sin(x.w));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
-extern simd_float8 _simd_sin_f8(simd_float8 x);
-static inline SIMD_CFUNC simd_float8 __tg_sin(simd_float8 x) {
-  return _simd_sin_f8(x);
-}
-#else
-static inline SIMD_CFUNC simd_float8 __tg_sin(simd_float8 x) {
-  return simd_make_float8(__tg_sin(x.lo), __tg_sin(x.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
-extern simd_float16 _simd_sin_f16(simd_float16 x);
-static inline SIMD_CFUNC simd_float16 __tg_sin(simd_float16 x) {
-  return _simd_sin_f16(x);
-}
-#else
-static inline SIMD_CFUNC simd_float16 __tg_sin(simd_float16 x) {
-  return simd_make_float16(__tg_sin(x.lo), __tg_sin(x.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3
-extern simd_double2 _simd_sin_d2(simd_double2 x);
-static inline SIMD_CFUNC simd_double2 __tg_sin(simd_double2 x) {
-  return _simd_sin_d2(x);
-}
-#elif SIMD_LIBRARY_VERSION == 1
-extern simd_double2 __sin_d2(simd_double2 x);
-static inline SIMD_CFUNC simd_double2 __tg_sin(simd_double2 x) {
-  return __sin_d2(x);
-}
-#else
-static inline SIMD_CFUNC simd_double2 __tg_sin(simd_double2 x) {
-  return simd_make_double2(sin(x.x), sin(x.y));
-}
-#endif
-
-static inline SIMD_CFUNC simd_double3 __tg_sin(simd_double3 x) {
-  return simd_make_double3(__tg_sin(simd_make_double4(x)));
-}
-  
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
-extern simd_double4 _simd_sin_d4(simd_double4 x);
-static inline SIMD_CFUNC simd_double4 __tg_sin(simd_double4 x) {
-  return _simd_sin_d4(x);
-}
-#else
-static inline SIMD_CFUNC simd_double4 __tg_sin(simd_double4 x) {
-  return simd_make_double4(__tg_sin(x.lo), __tg_sin(x.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
-extern simd_double8 _simd_sin_d8(simd_double8 x);
-static inline SIMD_CFUNC simd_double8 __tg_sin(simd_double8 x) {
-  return _simd_sin_d8(x);
-}
-#else
-static inline SIMD_CFUNC simd_double8 __tg_sin(simd_double8 x) {
-  return simd_make_double8(__tg_sin(x.lo), __tg_sin(x.hi));
-}
-#endif
-
-static inline SIMD_CFUNC simd_float2 __tg_cos(simd_float2 x) {
-  return simd_make_float2(__tg_cos(simd_make_float4(x)));
-}
-  
-static inline SIMD_CFUNC simd_float3 __tg_cos(simd_float3 x) {
-  return simd_make_float3(__tg_cos(simd_make_float4(x)));
-}
-  
-#if SIMD_LIBRARY_VERSION >= 3
-extern simd_float4 _simd_cos_f4(simd_float4 x);
-static inline SIMD_CFUNC simd_float4 __tg_cos(simd_float4 x) {
-  return _simd_cos_f4(x);
-}
-#elif SIMD_LIBRARY_VERSION == 1
-extern simd_float4 __cos_f4(simd_float4 x);
-static inline SIMD_CFUNC simd_float4 __tg_cos(simd_float4 x) {
-  return __cos_f4(x);
-}
-#else
-static inline SIMD_CFUNC simd_float4 __tg_cos(simd_float4 x) {
-  return simd_make_float4(cos(x.x), cos(x.y), cos(x.z), cos(x.w));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
-extern simd_float8 _simd_cos_f8(simd_float8 x);
-static inline SIMD_CFUNC simd_float8 __tg_cos(simd_float8 x) {
-  return _simd_cos_f8(x);
-}
-#else
-static inline SIMD_CFUNC simd_float8 __tg_cos(simd_float8 x) {
-  return simd_make_float8(__tg_cos(x.lo), __tg_cos(x.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
-extern simd_float16 _simd_cos_f16(simd_float16 x);
-static inline SIMD_CFUNC simd_float16 __tg_cos(simd_float16 x) {
-  return _simd_cos_f16(x);
-}
-#else
-static inline SIMD_CFUNC simd_float16 __tg_cos(simd_float16 x) {
-  return simd_make_float16(__tg_cos(x.lo), __tg_cos(x.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3
-extern simd_double2 _simd_cos_d2(simd_double2 x);
-static inline SIMD_CFUNC simd_double2 __tg_cos(simd_double2 x) {
-  return _simd_cos_d2(x);
-}
-#elif SIMD_LIBRARY_VERSION == 1
-extern simd_double2 __cos_d2(simd_double2 x);
-static inline SIMD_CFUNC simd_double2 __tg_cos(simd_double2 x) {
-  return __cos_d2(x);
-}
-#else
-static inline SIMD_CFUNC simd_double2 __tg_cos(simd_double2 x) {
-  return simd_make_double2(cos(x.x), cos(x.y));
-}
-#endif
-
-static inline SIMD_CFUNC simd_double3 __tg_cos(simd_double3 x) {
-  return simd_make_double3(__tg_cos(simd_make_double4(x)));
-}
-  
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
-extern simd_double4 _simd_cos_d4(simd_double4 x);
-static inline SIMD_CFUNC simd_double4 __tg_cos(simd_double4 x) {
-  return _simd_cos_d4(x);
-}
-#else
-static inline SIMD_CFUNC simd_double4 __tg_cos(simd_double4 x) {
-  return simd_make_double4(__tg_cos(x.lo), __tg_cos(x.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
-extern simd_double8 _simd_cos_d8(simd_double8 x);
-static inline SIMD_CFUNC simd_double8 __tg_cos(simd_double8 x) {
-  return _simd_cos_d8(x);
-}
-#else
-static inline SIMD_CFUNC simd_double8 __tg_cos(simd_double8 x) {
-  return simd_make_double8(__tg_cos(x.lo), __tg_cos(x.hi));
-}
-#endif
-
-  
-#pragma mark - acos implementation
-static inline SIMD_CFUNC simd_float2 __tg_acos(simd_float2 x) {
-  return simd_make_float2(__tg_acos(simd_make_float4(x)));
-}
-
-static inline SIMD_CFUNC simd_float3 __tg_acos(simd_float3 x) {
-  return simd_make_float3(__tg_acos(simd_make_float4(x)));
-}
-
-#if SIMD_LIBRARY_VERSION >= 3
-extern simd_float4 _simd_acos_f4(simd_float4 x);
-static inline SIMD_CFUNC simd_float4 __tg_acos(simd_float4 x) {
-  return _simd_acos_f4(x);
-}
-#else
-static inline SIMD_CFUNC simd_float4 __tg_acos(simd_float4 x) {
-  return simd_make_float4(acos(x.x), acos(x.y), acos(x.z), acos(x.w));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
-extern simd_float8 _simd_acos_f8(simd_float8 x);
-static inline SIMD_CFUNC simd_float8 __tg_acos(simd_float8 x) {
-  return _simd_acos_f8(x);
-}
-#else
-static inline SIMD_CFUNC simd_float8 __tg_acos(simd_float8 x) {
-  return simd_make_float8(__tg_acos(x.lo), __tg_acos(x.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
-extern simd_float16 _simd_acos_f16(simd_float16 x);
-static inline SIMD_CFUNC simd_float16 __tg_acos(simd_float16 x) {
-  return _simd_acos_f16(x);
-}
-#else
-static inline SIMD_CFUNC simd_float16 __tg_acos(simd_float16 x) {
-  return simd_make_float16(__tg_acos(x.lo), __tg_acos(x.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3
-extern simd_double2 _simd_acos_d2(simd_double2 x);
-static inline SIMD_CFUNC simd_double2 __tg_acos(simd_double2 x) {
-  return _simd_acos_d2(x);
-}
-#else
-static inline SIMD_CFUNC simd_double2 __tg_acos(simd_double2 x) {
-  return simd_make_double2(acos(x.x), acos(x.y));
-}
-#endif
-
-static inline SIMD_CFUNC simd_double3 __tg_acos(simd_double3 x) {
-  return simd_make_double3(__tg_acos(simd_make_double4(x)));
-}
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
-extern simd_double4 _simd_acos_d4(simd_double4 x);
-static inline SIMD_CFUNC simd_double4 __tg_acos(simd_double4 x) {
-  return _simd_acos_d4(x);
-}
-#else
-static inline SIMD_CFUNC simd_double4 __tg_acos(simd_double4 x) {
-  return simd_make_double4(__tg_acos(x.lo), __tg_acos(x.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
-extern simd_double8 _simd_acos_d8(simd_double8 x);
-static inline SIMD_CFUNC simd_double8 __tg_acos(simd_double8 x) {
-  return _simd_acos_d8(x);
-}
-#else
-static inline SIMD_CFUNC simd_double8 __tg_acos(simd_double8 x) {
-  return simd_make_double8(__tg_acos(x.lo), __tg_acos(x.hi));
-}
-#endif
-
-#pragma mark - asin implementation
-static inline SIMD_CFUNC simd_float2 __tg_asin(simd_float2 x) {
-  return simd_make_float2(__tg_asin(simd_make_float4(x)));
-}
-
-static inline SIMD_CFUNC simd_float3 __tg_asin(simd_float3 x) {
-  return simd_make_float3(__tg_asin(simd_make_float4(x)));
-}
-
-#if SIMD_LIBRARY_VERSION >= 3
-extern simd_float4 _simd_asin_f4(simd_float4 x);
-static inline SIMD_CFUNC simd_float4 __tg_asin(simd_float4 x) {
-  return _simd_asin_f4(x);
-}
-#else
-static inline SIMD_CFUNC simd_float4 __tg_asin(simd_float4 x) {
-  return simd_make_float4(asin(x.x), asin(x.y), asin(x.z), asin(x.w));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
-extern simd_float8 _simd_asin_f8(simd_float8 x);
-static inline SIMD_CFUNC simd_float8 __tg_asin(simd_float8 x) {
-  return _simd_asin_f8(x);
-}
-#else
-static inline SIMD_CFUNC simd_float8 __tg_asin(simd_float8 x) {
-  return simd_make_float8(__tg_asin(x.lo), __tg_asin(x.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
-extern simd_float16 _simd_asin_f16(simd_float16 x);
-static inline SIMD_CFUNC simd_float16 __tg_asin(simd_float16 x) {
-  return _simd_asin_f16(x);
-}
-#else
-static inline SIMD_CFUNC simd_float16 __tg_asin(simd_float16 x) {
-  return simd_make_float16(__tg_asin(x.lo), __tg_asin(x.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3
-extern simd_double2 _simd_asin_d2(simd_double2 x);
-static inline SIMD_CFUNC simd_double2 __tg_asin(simd_double2 x) {
-  return _simd_asin_d2(x);
-}
-#else
-static inline SIMD_CFUNC simd_double2 __tg_asin(simd_double2 x) {
-  return simd_make_double2(asin(x.x), asin(x.y));
-}
-#endif
-
-static inline SIMD_CFUNC simd_double3 __tg_asin(simd_double3 x) {
-  return simd_make_double3(__tg_asin(simd_make_double4(x)));
-}
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
-extern simd_double4 _simd_asin_d4(simd_double4 x);
-static inline SIMD_CFUNC simd_double4 __tg_asin(simd_double4 x) {
-  return _simd_asin_d4(x);
-}
-#else
-static inline SIMD_CFUNC simd_double4 __tg_asin(simd_double4 x) {
-  return simd_make_double4(__tg_asin(x.lo), __tg_asin(x.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
-extern simd_double8 _simd_asin_d8(simd_double8 x);
-static inline SIMD_CFUNC simd_double8 __tg_asin(simd_double8 x) {
-  return _simd_asin_d8(x);
-}
-#else
-static inline SIMD_CFUNC simd_double8 __tg_asin(simd_double8 x) {
-  return simd_make_double8(__tg_asin(x.lo), __tg_asin(x.hi));
-}
-#endif
-
-#pragma mark - atan implementation
-static inline SIMD_CFUNC simd_float2 __tg_atan(simd_float2 x) {
-  return simd_make_float2(__tg_atan(simd_make_float4(x)));
-}
-
-static inline SIMD_CFUNC simd_float3 __tg_atan(simd_float3 x) {
-  return simd_make_float3(__tg_atan(simd_make_float4(x)));
-}
-
-#if SIMD_LIBRARY_VERSION >= 3
-extern simd_float4 _simd_atan_f4(simd_float4 x);
-static inline SIMD_CFUNC simd_float4 __tg_atan(simd_float4 x) {
-  return _simd_atan_f4(x);
-}
-#else
-static inline SIMD_CFUNC simd_float4 __tg_atan(simd_float4 x) {
-  return simd_make_float4(atan(x.x), atan(x.y), atan(x.z), atan(x.w));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
-extern simd_float8 _simd_atan_f8(simd_float8 x);
-static inline SIMD_CFUNC simd_float8 __tg_atan(simd_float8 x) {
-  return _simd_atan_f8(x);
-}
-#else
-static inline SIMD_CFUNC simd_float8 __tg_atan(simd_float8 x) {
-  return simd_make_float8(__tg_atan(x.lo), __tg_atan(x.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
-extern simd_float16 _simd_atan_f16(simd_float16 x);
-static inline SIMD_CFUNC simd_float16 __tg_atan(simd_float16 x) {
-  return _simd_atan_f16(x);
-}
-#else
-static inline SIMD_CFUNC simd_float16 __tg_atan(simd_float16 x) {
-  return simd_make_float16(__tg_atan(x.lo), __tg_atan(x.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3
-extern simd_double2 _simd_atan_d2(simd_double2 x);
-static inline SIMD_CFUNC simd_double2 __tg_atan(simd_double2 x) {
-  return _simd_atan_d2(x);
-}
-#else
-static inline SIMD_CFUNC simd_double2 __tg_atan(simd_double2 x) {
-  return simd_make_double2(atan(x.x), atan(x.y));
-}
-#endif
-
-static inline SIMD_CFUNC simd_double3 __tg_atan(simd_double3 x) {
-  return simd_make_double3(__tg_atan(simd_make_double4(x)));
-}
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
-extern simd_double4 _simd_atan_d4(simd_double4 x);
-static inline SIMD_CFUNC simd_double4 __tg_atan(simd_double4 x) {
-  return _simd_atan_d4(x);
-}
-#else
-static inline SIMD_CFUNC simd_double4 __tg_atan(simd_double4 x) {
-  return simd_make_double4(__tg_atan(x.lo), __tg_atan(x.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
-extern simd_double8 _simd_atan_d8(simd_double8 x);
-static inline SIMD_CFUNC simd_double8 __tg_atan(simd_double8 x) {
-  return _simd_atan_d8(x);
-}
-#else
-static inline SIMD_CFUNC simd_double8 __tg_atan(simd_double8 x) {
-  return simd_make_double8(__tg_atan(x.lo), __tg_atan(x.hi));
-}
-#endif
-
-#pragma mark - tan implementation
-static inline SIMD_CFUNC simd_float2 __tg_tan(simd_float2 x) {
-  return simd_make_float2(__tg_tan(simd_make_float4(x)));
-}
-
-static inline SIMD_CFUNC simd_float3 __tg_tan(simd_float3 x) {
-  return simd_make_float3(__tg_tan(simd_make_float4(x)));
-}
-
-#if SIMD_LIBRARY_VERSION >= 3
-extern simd_float4 _simd_tan_f4(simd_float4 x);
-static inline SIMD_CFUNC simd_float4 __tg_tan(simd_float4 x) {
-  return _simd_tan_f4(x);
-}
-#else
-static inline SIMD_CFUNC simd_float4 __tg_tan(simd_float4 x) {
-  return simd_make_float4(tan(x.x), tan(x.y), tan(x.z), tan(x.w));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
-extern simd_float8 _simd_tan_f8(simd_float8 x);
-static inline SIMD_CFUNC simd_float8 __tg_tan(simd_float8 x) {
-  return _simd_tan_f8(x);
-}
-#else
-static inline SIMD_CFUNC simd_float8 __tg_tan(simd_float8 x) {
-  return simd_make_float8(__tg_tan(x.lo), __tg_tan(x.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
-extern simd_float16 _simd_tan_f16(simd_float16 x);
-static inline SIMD_CFUNC simd_float16 __tg_tan(simd_float16 x) {
-  return _simd_tan_f16(x);
-}
-#else
-static inline SIMD_CFUNC simd_float16 __tg_tan(simd_float16 x) {
-  return simd_make_float16(__tg_tan(x.lo), __tg_tan(x.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3
-extern simd_double2 _simd_tan_d2(simd_double2 x);
-static inline SIMD_CFUNC simd_double2 __tg_tan(simd_double2 x) {
-  return _simd_tan_d2(x);
-}
-#else
-static inline SIMD_CFUNC simd_double2 __tg_tan(simd_double2 x) {
-  return simd_make_double2(tan(x.x), tan(x.y));
-}
-#endif
-
-static inline SIMD_CFUNC simd_double3 __tg_tan(simd_double3 x) {
-  return simd_make_double3(__tg_tan(simd_make_double4(x)));
-}
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
-extern simd_double4 _simd_tan_d4(simd_double4 x);
-static inline SIMD_CFUNC simd_double4 __tg_tan(simd_double4 x) {
-  return _simd_tan_d4(x);
-}
-#else
-static inline SIMD_CFUNC simd_double4 __tg_tan(simd_double4 x) {
-  return simd_make_double4(__tg_tan(x.lo), __tg_tan(x.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
-extern simd_double8 _simd_tan_d8(simd_double8 x);
-static inline SIMD_CFUNC simd_double8 __tg_tan(simd_double8 x) {
-  return _simd_tan_d8(x);
-}
-#else
-static inline SIMD_CFUNC simd_double8 __tg_tan(simd_double8 x) {
-  return simd_make_double8(__tg_tan(x.lo), __tg_tan(x.hi));
-}
-#endif
-
-#pragma mark - cospi implementation
-#if SIMD_LIBRARY_VERSION >= 1
-static inline SIMD_CFUNC simd_float2 __tg_cospi(simd_float2 x) {
-  return simd_make_float2(__tg_cospi(simd_make_float4(x)));
-}
-
-static inline SIMD_CFUNC simd_float3 __tg_cospi(simd_float3 x) {
-  return simd_make_float3(__tg_cospi(simd_make_float4(x)));
-}
-
-#if SIMD_LIBRARY_VERSION >= 3
-extern simd_float4 _simd_cospi_f4(simd_float4 x);
-static inline SIMD_CFUNC simd_float4 __tg_cospi(simd_float4 x) {
-  return _simd_cospi_f4(x);
-}
-#else
-static inline SIMD_CFUNC simd_float4 __tg_cospi(simd_float4 x) {
-  return simd_make_float4(__cospi(x.x), __cospi(x.y), __cospi(x.z), __cospi(x.w));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
-extern simd_float8 _simd_cospi_f8(simd_float8 x);
-static inline SIMD_CFUNC simd_float8 __tg_cospi(simd_float8 x) {
-  return _simd_cospi_f8(x);
-}
-#else
-static inline SIMD_CFUNC simd_float8 __tg_cospi(simd_float8 x) {
-  return simd_make_float8(__tg_cospi(x.lo), __tg_cospi(x.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
-extern simd_float16 _simd_cospi_f16(simd_float16 x);
-static inline SIMD_CFUNC simd_float16 __tg_cospi(simd_float16 x) {
-  return _simd_cospi_f16(x);
-}
-#else
-static inline SIMD_CFUNC simd_float16 __tg_cospi(simd_float16 x) {
-  return simd_make_float16(__tg_cospi(x.lo), __tg_cospi(x.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3
-extern simd_double2 _simd_cospi_d2(simd_double2 x);
-static inline SIMD_CFUNC simd_double2 __tg_cospi(simd_double2 x) {
-  return _simd_cospi_d2(x);
-}
-#else
-static inline SIMD_CFUNC simd_double2 __tg_cospi(simd_double2 x) {
-  return simd_make_double2(__cospi(x.x), __cospi(x.y));
-}
-#endif
-
-static inline SIMD_CFUNC simd_double3 __tg_cospi(simd_double3 x) {
-  return simd_make_double3(__tg_cospi(simd_make_double4(x)));
-}
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
-extern simd_double4 _simd_cospi_d4(simd_double4 x);
-static inline SIMD_CFUNC simd_double4 __tg_cospi(simd_double4 x) {
-  return _simd_cospi_d4(x);
-}
-#else
-static inline SIMD_CFUNC simd_double4 __tg_cospi(simd_double4 x) {
-  return simd_make_double4(__tg_cospi(x.lo), __tg_cospi(x.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
-extern simd_double8 _simd_cospi_d8(simd_double8 x);
-static inline SIMD_CFUNC simd_double8 __tg_cospi(simd_double8 x) {
-  return _simd_cospi_d8(x);
-}
-#else
-static inline SIMD_CFUNC simd_double8 __tg_cospi(simd_double8 x) {
-  return simd_make_double8(__tg_cospi(x.lo), __tg_cospi(x.hi));
-}
-#endif
-
-#endif /* SIMD_LIBRARY_VERSION */
-#pragma mark - sinpi implementation
-#if SIMD_LIBRARY_VERSION >= 1
-static inline SIMD_CFUNC simd_float2 __tg_sinpi(simd_float2 x) {
-  return simd_make_float2(__tg_sinpi(simd_make_float4(x)));
-}
-
-static inline SIMD_CFUNC simd_float3 __tg_sinpi(simd_float3 x) {
-  return simd_make_float3(__tg_sinpi(simd_make_float4(x)));
-}
-
-#if SIMD_LIBRARY_VERSION >= 3
-extern simd_float4 _simd_sinpi_f4(simd_float4 x);
-static inline SIMD_CFUNC simd_float4 __tg_sinpi(simd_float4 x) {
-  return _simd_sinpi_f4(x);
-}
-#else
-static inline SIMD_CFUNC simd_float4 __tg_sinpi(simd_float4 x) {
-  return simd_make_float4(__sinpi(x.x), __sinpi(x.y), __sinpi(x.z), __sinpi(x.w));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
-extern simd_float8 _simd_sinpi_f8(simd_float8 x);
-static inline SIMD_CFUNC simd_float8 __tg_sinpi(simd_float8 x) {
-  return _simd_sinpi_f8(x);
-}
-#else
-static inline SIMD_CFUNC simd_float8 __tg_sinpi(simd_float8 x) {
-  return simd_make_float8(__tg_sinpi(x.lo), __tg_sinpi(x.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
-extern simd_float16 _simd_sinpi_f16(simd_float16 x);
-static inline SIMD_CFUNC simd_float16 __tg_sinpi(simd_float16 x) {
-  return _simd_sinpi_f16(x);
-}
-#else
-static inline SIMD_CFUNC simd_float16 __tg_sinpi(simd_float16 x) {
-  return simd_make_float16(__tg_sinpi(x.lo), __tg_sinpi(x.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3
-extern simd_double2 _simd_sinpi_d2(simd_double2 x);
-static inline SIMD_CFUNC simd_double2 __tg_sinpi(simd_double2 x) {
-  return _simd_sinpi_d2(x);
-}
-#else
-static inline SIMD_CFUNC simd_double2 __tg_sinpi(simd_double2 x) {
-  return simd_make_double2(__sinpi(x.x), __sinpi(x.y));
-}
-#endif
-
-static inline SIMD_CFUNC simd_double3 __tg_sinpi(simd_double3 x) {
-  return simd_make_double3(__tg_sinpi(simd_make_double4(x)));
-}
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
-extern simd_double4 _simd_sinpi_d4(simd_double4 x);
-static inline SIMD_CFUNC simd_double4 __tg_sinpi(simd_double4 x) {
-  return _simd_sinpi_d4(x);
-}
-#else
-static inline SIMD_CFUNC simd_double4 __tg_sinpi(simd_double4 x) {
-  return simd_make_double4(__tg_sinpi(x.lo), __tg_sinpi(x.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
-extern simd_double8 _simd_sinpi_d8(simd_double8 x);
-static inline SIMD_CFUNC simd_double8 __tg_sinpi(simd_double8 x) {
-  return _simd_sinpi_d8(x);
-}
-#else
-static inline SIMD_CFUNC simd_double8 __tg_sinpi(simd_double8 x) {
-  return simd_make_double8(__tg_sinpi(x.lo), __tg_sinpi(x.hi));
-}
-#endif
-
-#endif /* SIMD_LIBRARY_VERSION */
-#pragma mark - tanpi implementation
-#if SIMD_LIBRARY_VERSION >= 1
-static inline SIMD_CFUNC simd_float2 __tg_tanpi(simd_float2 x) {
-  return simd_make_float2(__tg_tanpi(simd_make_float4(x)));
-}
-
-static inline SIMD_CFUNC simd_float3 __tg_tanpi(simd_float3 x) {
-  return simd_make_float3(__tg_tanpi(simd_make_float4(x)));
-}
-
-#if SIMD_LIBRARY_VERSION >= 3
-extern simd_float4 _simd_tanpi_f4(simd_float4 x);
-static inline SIMD_CFUNC simd_float4 __tg_tanpi(simd_float4 x) {
-  return _simd_tanpi_f4(x);
-}
-#else
-static inline SIMD_CFUNC simd_float4 __tg_tanpi(simd_float4 x) {
-  return simd_make_float4(__tanpi(x.x), __tanpi(x.y), __tanpi(x.z), __tanpi(x.w));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
-extern simd_float8 _simd_tanpi_f8(simd_float8 x);
-static inline SIMD_CFUNC simd_float8 __tg_tanpi(simd_float8 x) {
-  return _simd_tanpi_f8(x);
-}
-#else
-static inline SIMD_CFUNC simd_float8 __tg_tanpi(simd_float8 x) {
-  return simd_make_float8(__tg_tanpi(x.lo), __tg_tanpi(x.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
-extern simd_float16 _simd_tanpi_f16(simd_float16 x);
-static inline SIMD_CFUNC simd_float16 __tg_tanpi(simd_float16 x) {
-  return _simd_tanpi_f16(x);
-}
-#else
-static inline SIMD_CFUNC simd_float16 __tg_tanpi(simd_float16 x) {
-  return simd_make_float16(__tg_tanpi(x.lo), __tg_tanpi(x.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3
-extern simd_double2 _simd_tanpi_d2(simd_double2 x);
-static inline SIMD_CFUNC simd_double2 __tg_tanpi(simd_double2 x) {
-  return _simd_tanpi_d2(x);
-}
-#else
-static inline SIMD_CFUNC simd_double2 __tg_tanpi(simd_double2 x) {
-  return simd_make_double2(__tanpi(x.x), __tanpi(x.y));
-}
-#endif
-
-static inline SIMD_CFUNC simd_double3 __tg_tanpi(simd_double3 x) {
-  return simd_make_double3(__tg_tanpi(simd_make_double4(x)));
-}
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
-extern simd_double4 _simd_tanpi_d4(simd_double4 x);
-static inline SIMD_CFUNC simd_double4 __tg_tanpi(simd_double4 x) {
-  return _simd_tanpi_d4(x);
-}
-#else
-static inline SIMD_CFUNC simd_double4 __tg_tanpi(simd_double4 x) {
-  return simd_make_double4(__tg_tanpi(x.lo), __tg_tanpi(x.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
-extern simd_double8 _simd_tanpi_d8(simd_double8 x);
-static inline SIMD_CFUNC simd_double8 __tg_tanpi(simd_double8 x) {
-  return _simd_tanpi_d8(x);
-}
-#else
-static inline SIMD_CFUNC simd_double8 __tg_tanpi(simd_double8 x) {
-  return simd_make_double8(__tg_tanpi(x.lo), __tg_tanpi(x.hi));
-}
-#endif
-
-#endif /* SIMD_LIBRARY_VERSION */
-#pragma mark - acosh implementation
-static inline SIMD_CFUNC simd_float2 __tg_acosh(simd_float2 x) {
-  return simd_make_float2(__tg_acosh(simd_make_float4(x)));
-}
-
-static inline SIMD_CFUNC simd_float3 __tg_acosh(simd_float3 x) {
-  return simd_make_float3(__tg_acosh(simd_make_float4(x)));
-}
-
-#if SIMD_LIBRARY_VERSION >= 3
-extern simd_float4 _simd_acosh_f4(simd_float4 x);
-static inline SIMD_CFUNC simd_float4 __tg_acosh(simd_float4 x) {
-  return _simd_acosh_f4(x);
-}
-#else
-static inline SIMD_CFUNC simd_float4 __tg_acosh(simd_float4 x) {
-  return simd_make_float4(acosh(x.x), acosh(x.y), acosh(x.z), acosh(x.w));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
-extern simd_float8 _simd_acosh_f8(simd_float8 x);
-static inline SIMD_CFUNC simd_float8 __tg_acosh(simd_float8 x) {
-  return _simd_acosh_f8(x);
-}
-#else
-static inline SIMD_CFUNC simd_float8 __tg_acosh(simd_float8 x) {
-  return simd_make_float8(__tg_acosh(x.lo), __tg_acosh(x.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
-extern simd_float16 _simd_acosh_f16(simd_float16 x);
-static inline SIMD_CFUNC simd_float16 __tg_acosh(simd_float16 x) {
-  return _simd_acosh_f16(x);
-}
-#else
-static inline SIMD_CFUNC simd_float16 __tg_acosh(simd_float16 x) {
-  return simd_make_float16(__tg_acosh(x.lo), __tg_acosh(x.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3
-extern simd_double2 _simd_acosh_d2(simd_double2 x);
-static inline SIMD_CFUNC simd_double2 __tg_acosh(simd_double2 x) {
-  return _simd_acosh_d2(x);
-}
-#else
-static inline SIMD_CFUNC simd_double2 __tg_acosh(simd_double2 x) {
-  return simd_make_double2(acosh(x.x), acosh(x.y));
-}
-#endif
-
-static inline SIMD_CFUNC simd_double3 __tg_acosh(simd_double3 x) {
-  return simd_make_double3(__tg_acosh(simd_make_double4(x)));
-}
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
-extern simd_double4 _simd_acosh_d4(simd_double4 x);
-static inline SIMD_CFUNC simd_double4 __tg_acosh(simd_double4 x) {
-  return _simd_acosh_d4(x);
-}
-#else
-static inline SIMD_CFUNC simd_double4 __tg_acosh(simd_double4 x) {
-  return simd_make_double4(__tg_acosh(x.lo), __tg_acosh(x.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
-extern simd_double8 _simd_acosh_d8(simd_double8 x);
-static inline SIMD_CFUNC simd_double8 __tg_acosh(simd_double8 x) {
-  return _simd_acosh_d8(x);
-}
-#else
-static inline SIMD_CFUNC simd_double8 __tg_acosh(simd_double8 x) {
-  return simd_make_double8(__tg_acosh(x.lo), __tg_acosh(x.hi));
-}
-#endif
-
-#pragma mark - asinh implementation
-static inline SIMD_CFUNC simd_float2 __tg_asinh(simd_float2 x) {
-  return simd_make_float2(__tg_asinh(simd_make_float4(x)));
-}
-
-static inline SIMD_CFUNC simd_float3 __tg_asinh(simd_float3 x) {
-  return simd_make_float3(__tg_asinh(simd_make_float4(x)));
-}
-
-#if SIMD_LIBRARY_VERSION >= 3
-extern simd_float4 _simd_asinh_f4(simd_float4 x);
-static inline SIMD_CFUNC simd_float4 __tg_asinh(simd_float4 x) {
-  return _simd_asinh_f4(x);
-}
-#else
-static inline SIMD_CFUNC simd_float4 __tg_asinh(simd_float4 x) {
-  return simd_make_float4(asinh(x.x), asinh(x.y), asinh(x.z), asinh(x.w));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
-extern simd_float8 _simd_asinh_f8(simd_float8 x);
-static inline SIMD_CFUNC simd_float8 __tg_asinh(simd_float8 x) {
-  return _simd_asinh_f8(x);
-}
-#else
-static inline SIMD_CFUNC simd_float8 __tg_asinh(simd_float8 x) {
-  return simd_make_float8(__tg_asinh(x.lo), __tg_asinh(x.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
-extern simd_float16 _simd_asinh_f16(simd_float16 x);
-static inline SIMD_CFUNC simd_float16 __tg_asinh(simd_float16 x) {
-  return _simd_asinh_f16(x);
-}
-#else
-static inline SIMD_CFUNC simd_float16 __tg_asinh(simd_float16 x) {
-  return simd_make_float16(__tg_asinh(x.lo), __tg_asinh(x.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3
-extern simd_double2 _simd_asinh_d2(simd_double2 x);
-static inline SIMD_CFUNC simd_double2 __tg_asinh(simd_double2 x) {
-  return _simd_asinh_d2(x);
-}
-#else
-static inline SIMD_CFUNC simd_double2 __tg_asinh(simd_double2 x) {
-  return simd_make_double2(asinh(x.x), asinh(x.y));
-}
-#endif
-
-static inline SIMD_CFUNC simd_double3 __tg_asinh(simd_double3 x) {
-  return simd_make_double3(__tg_asinh(simd_make_double4(x)));
-}
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
-extern simd_double4 _simd_asinh_d4(simd_double4 x);
-static inline SIMD_CFUNC simd_double4 __tg_asinh(simd_double4 x) {
-  return _simd_asinh_d4(x);
-}
-#else
-static inline SIMD_CFUNC simd_double4 __tg_asinh(simd_double4 x) {
-  return simd_make_double4(__tg_asinh(x.lo), __tg_asinh(x.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
-extern simd_double8 _simd_asinh_d8(simd_double8 x);
-static inline SIMD_CFUNC simd_double8 __tg_asinh(simd_double8 x) {
-  return _simd_asinh_d8(x);
-}
-#else
-static inline SIMD_CFUNC simd_double8 __tg_asinh(simd_double8 x) {
-  return simd_make_double8(__tg_asinh(x.lo), __tg_asinh(x.hi));
-}
-#endif
-
-#pragma mark - atanh implementation
-static inline SIMD_CFUNC simd_float2 __tg_atanh(simd_float2 x) {
-  return simd_make_float2(__tg_atanh(simd_make_float4(x)));
-}
-
-static inline SIMD_CFUNC simd_float3 __tg_atanh(simd_float3 x) {
-  return simd_make_float3(__tg_atanh(simd_make_float4(x)));
-}
-
-#if SIMD_LIBRARY_VERSION >= 3
-extern simd_float4 _simd_atanh_f4(simd_float4 x);
-static inline SIMD_CFUNC simd_float4 __tg_atanh(simd_float4 x) {
-  return _simd_atanh_f4(x);
-}
-#else
-static inline SIMD_CFUNC simd_float4 __tg_atanh(simd_float4 x) {
-  return simd_make_float4(atanh(x.x), atanh(x.y), atanh(x.z), atanh(x.w));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
-extern simd_float8 _simd_atanh_f8(simd_float8 x);
-static inline SIMD_CFUNC simd_float8 __tg_atanh(simd_float8 x) {
-  return _simd_atanh_f8(x);
-}
-#else
-static inline SIMD_CFUNC simd_float8 __tg_atanh(simd_float8 x) {
-  return simd_make_float8(__tg_atanh(x.lo), __tg_atanh(x.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
-extern simd_float16 _simd_atanh_f16(simd_float16 x);
-static inline SIMD_CFUNC simd_float16 __tg_atanh(simd_float16 x) {
-  return _simd_atanh_f16(x);
-}
-#else
-static inline SIMD_CFUNC simd_float16 __tg_atanh(simd_float16 x) {
-  return simd_make_float16(__tg_atanh(x.lo), __tg_atanh(x.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3
-extern simd_double2 _simd_atanh_d2(simd_double2 x);
-static inline SIMD_CFUNC simd_double2 __tg_atanh(simd_double2 x) {
-  return _simd_atanh_d2(x);
-}
-#else
-static inline SIMD_CFUNC simd_double2 __tg_atanh(simd_double2 x) {
-  return simd_make_double2(atanh(x.x), atanh(x.y));
-}
-#endif
-
-static inline SIMD_CFUNC simd_double3 __tg_atanh(simd_double3 x) {
-  return simd_make_double3(__tg_atanh(simd_make_double4(x)));
-}
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
-extern simd_double4 _simd_atanh_d4(simd_double4 x);
-static inline SIMD_CFUNC simd_double4 __tg_atanh(simd_double4 x) {
-  return _simd_atanh_d4(x);
-}
-#else
-static inline SIMD_CFUNC simd_double4 __tg_atanh(simd_double4 x) {
-  return simd_make_double4(__tg_atanh(x.lo), __tg_atanh(x.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
-extern simd_double8 _simd_atanh_d8(simd_double8 x);
-static inline SIMD_CFUNC simd_double8 __tg_atanh(simd_double8 x) {
-  return _simd_atanh_d8(x);
-}
-#else
-static inline SIMD_CFUNC simd_double8 __tg_atanh(simd_double8 x) {
-  return simd_make_double8(__tg_atanh(x.lo), __tg_atanh(x.hi));
-}
-#endif
-
-#pragma mark - cosh implementation
-static inline SIMD_CFUNC simd_float2 __tg_cosh(simd_float2 x) {
-  return simd_make_float2(__tg_cosh(simd_make_float4(x)));
-}
-
-static inline SIMD_CFUNC simd_float3 __tg_cosh(simd_float3 x) {
-  return simd_make_float3(__tg_cosh(simd_make_float4(x)));
-}
-
-#if SIMD_LIBRARY_VERSION >= 3
-extern simd_float4 _simd_cosh_f4(simd_float4 x);
-static inline SIMD_CFUNC simd_float4 __tg_cosh(simd_float4 x) {
-  return _simd_cosh_f4(x);
-}
-#else
-static inline SIMD_CFUNC simd_float4 __tg_cosh(simd_float4 x) {
-  return simd_make_float4(cosh(x.x), cosh(x.y), cosh(x.z), cosh(x.w));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
-extern simd_float8 _simd_cosh_f8(simd_float8 x);
-static inline SIMD_CFUNC simd_float8 __tg_cosh(simd_float8 x) {
-  return _simd_cosh_f8(x);
-}
-#else
-static inline SIMD_CFUNC simd_float8 __tg_cosh(simd_float8 x) {
-  return simd_make_float8(__tg_cosh(x.lo), __tg_cosh(x.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
-extern simd_float16 _simd_cosh_f16(simd_float16 x);
-static inline SIMD_CFUNC simd_float16 __tg_cosh(simd_float16 x) {
-  return _simd_cosh_f16(x);
-}
-#else
-static inline SIMD_CFUNC simd_float16 __tg_cosh(simd_float16 x) {
-  return simd_make_float16(__tg_cosh(x.lo), __tg_cosh(x.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3
-extern simd_double2 _simd_cosh_d2(simd_double2 x);
-static inline SIMD_CFUNC simd_double2 __tg_cosh(simd_double2 x) {
-  return _simd_cosh_d2(x);
-}
-#else
-static inline SIMD_CFUNC simd_double2 __tg_cosh(simd_double2 x) {
-  return simd_make_double2(cosh(x.x), cosh(x.y));
-}
-#endif
-
-static inline SIMD_CFUNC simd_double3 __tg_cosh(simd_double3 x) {
-  return simd_make_double3(__tg_cosh(simd_make_double4(x)));
-}
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
-extern simd_double4 _simd_cosh_d4(simd_double4 x);
-static inline SIMD_CFUNC simd_double4 __tg_cosh(simd_double4 x) {
-  return _simd_cosh_d4(x);
-}
-#else
-static inline SIMD_CFUNC simd_double4 __tg_cosh(simd_double4 x) {
-  return simd_make_double4(__tg_cosh(x.lo), __tg_cosh(x.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
-extern simd_double8 _simd_cosh_d8(simd_double8 x);
-static inline SIMD_CFUNC simd_double8 __tg_cosh(simd_double8 x) {
-  return _simd_cosh_d8(x);
-}
-#else
-static inline SIMD_CFUNC simd_double8 __tg_cosh(simd_double8 x) {
-  return simd_make_double8(__tg_cosh(x.lo), __tg_cosh(x.hi));
-}
-#endif
-
-#pragma mark - sinh implementation
-static inline SIMD_CFUNC simd_float2 __tg_sinh(simd_float2 x) {
-  return simd_make_float2(__tg_sinh(simd_make_float4(x)));
-}
-
-static inline SIMD_CFUNC simd_float3 __tg_sinh(simd_float3 x) {
-  return simd_make_float3(__tg_sinh(simd_make_float4(x)));
-}
-
-#if SIMD_LIBRARY_VERSION >= 3
-extern simd_float4 _simd_sinh_f4(simd_float4 x);
-static inline SIMD_CFUNC simd_float4 __tg_sinh(simd_float4 x) {
-  return _simd_sinh_f4(x);
-}
-#else
-static inline SIMD_CFUNC simd_float4 __tg_sinh(simd_float4 x) {
-  return simd_make_float4(sinh(x.x), sinh(x.y), sinh(x.z), sinh(x.w));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
-extern simd_float8 _simd_sinh_f8(simd_float8 x);
-static inline SIMD_CFUNC simd_float8 __tg_sinh(simd_float8 x) {
-  return _simd_sinh_f8(x);
-}
-#else
-static inline SIMD_CFUNC simd_float8 __tg_sinh(simd_float8 x) {
-  return simd_make_float8(__tg_sinh(x.lo), __tg_sinh(x.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
-extern simd_float16 _simd_sinh_f16(simd_float16 x);
-static inline SIMD_CFUNC simd_float16 __tg_sinh(simd_float16 x) {
-  return _simd_sinh_f16(x);
-}
-#else
-static inline SIMD_CFUNC simd_float16 __tg_sinh(simd_float16 x) {
-  return simd_make_float16(__tg_sinh(x.lo), __tg_sinh(x.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3
-extern simd_double2 _simd_sinh_d2(simd_double2 x);
-static inline SIMD_CFUNC simd_double2 __tg_sinh(simd_double2 x) {
-  return _simd_sinh_d2(x);
-}
-#else
-static inline SIMD_CFUNC simd_double2 __tg_sinh(simd_double2 x) {
-  return simd_make_double2(sinh(x.x), sinh(x.y));
-}
-#endif
-
-static inline SIMD_CFUNC simd_double3 __tg_sinh(simd_double3 x) {
-  return simd_make_double3(__tg_sinh(simd_make_double4(x)));
-}
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
-extern simd_double4 _simd_sinh_d4(simd_double4 x);
-static inline SIMD_CFUNC simd_double4 __tg_sinh(simd_double4 x) {
-  return _simd_sinh_d4(x);
-}
-#else
-static inline SIMD_CFUNC simd_double4 __tg_sinh(simd_double4 x) {
-  return simd_make_double4(__tg_sinh(x.lo), __tg_sinh(x.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
-extern simd_double8 _simd_sinh_d8(simd_double8 x);
-static inline SIMD_CFUNC simd_double8 __tg_sinh(simd_double8 x) {
-  return _simd_sinh_d8(x);
-}
-#else
-static inline SIMD_CFUNC simd_double8 __tg_sinh(simd_double8 x) {
-  return simd_make_double8(__tg_sinh(x.lo), __tg_sinh(x.hi));
-}
-#endif
-
-#pragma mark - tanh implementation
-static inline SIMD_CFUNC simd_float2 __tg_tanh(simd_float2 x) {
-  return simd_make_float2(__tg_tanh(simd_make_float4(x)));
-}
-
-static inline SIMD_CFUNC simd_float3 __tg_tanh(simd_float3 x) {
-  return simd_make_float3(__tg_tanh(simd_make_float4(x)));
-}
-
-#if SIMD_LIBRARY_VERSION >= 3
-extern simd_float4 _simd_tanh_f4(simd_float4 x);
-static inline SIMD_CFUNC simd_float4 __tg_tanh(simd_float4 x) {
-  return _simd_tanh_f4(x);
-}
-#else
-static inline SIMD_CFUNC simd_float4 __tg_tanh(simd_float4 x) {
-  return simd_make_float4(tanh(x.x), tanh(x.y), tanh(x.z), tanh(x.w));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
-extern simd_float8 _simd_tanh_f8(simd_float8 x);
-static inline SIMD_CFUNC simd_float8 __tg_tanh(simd_float8 x) {
-  return _simd_tanh_f8(x);
-}
-#else
-static inline SIMD_CFUNC simd_float8 __tg_tanh(simd_float8 x) {
-  return simd_make_float8(__tg_tanh(x.lo), __tg_tanh(x.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
-extern simd_float16 _simd_tanh_f16(simd_float16 x);
-static inline SIMD_CFUNC simd_float16 __tg_tanh(simd_float16 x) {
-  return _simd_tanh_f16(x);
-}
-#else
-static inline SIMD_CFUNC simd_float16 __tg_tanh(simd_float16 x) {
-  return simd_make_float16(__tg_tanh(x.lo), __tg_tanh(x.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3
-extern simd_double2 _simd_tanh_d2(simd_double2 x);
-static inline SIMD_CFUNC simd_double2 __tg_tanh(simd_double2 x) {
-  return _simd_tanh_d2(x);
-}
-#else
-static inline SIMD_CFUNC simd_double2 __tg_tanh(simd_double2 x) {
-  return simd_make_double2(tanh(x.x), tanh(x.y));
-}
-#endif
-
-static inline SIMD_CFUNC simd_double3 __tg_tanh(simd_double3 x) {
-  return simd_make_double3(__tg_tanh(simd_make_double4(x)));
-}
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
-extern simd_double4 _simd_tanh_d4(simd_double4 x);
-static inline SIMD_CFUNC simd_double4 __tg_tanh(simd_double4 x) {
-  return _simd_tanh_d4(x);
-}
-#else
-static inline SIMD_CFUNC simd_double4 __tg_tanh(simd_double4 x) {
-  return simd_make_double4(__tg_tanh(x.lo), __tg_tanh(x.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
-extern simd_double8 _simd_tanh_d8(simd_double8 x);
-static inline SIMD_CFUNC simd_double8 __tg_tanh(simd_double8 x) {
-  return _simd_tanh_d8(x);
-}
-#else
-static inline SIMD_CFUNC simd_double8 __tg_tanh(simd_double8 x) {
-  return simd_make_double8(__tg_tanh(x.lo), __tg_tanh(x.hi));
-}
-#endif
-
-#pragma mark - exp implementation
-static inline SIMD_CFUNC simd_float2 __tg_exp(simd_float2 x) {
-  return simd_make_float2(__tg_exp(simd_make_float4(x)));
-}
-
-static inline SIMD_CFUNC simd_float3 __tg_exp(simd_float3 x) {
-  return simd_make_float3(__tg_exp(simd_make_float4(x)));
-}
-
-#if SIMD_LIBRARY_VERSION >= 3
-extern simd_float4 _simd_exp_f4(simd_float4 x);
-static inline SIMD_CFUNC simd_float4 __tg_exp(simd_float4 x) {
-  return _simd_exp_f4(x);
-}
-#else
-static inline SIMD_CFUNC simd_float4 __tg_exp(simd_float4 x) {
-  return simd_make_float4(exp(x.x), exp(x.y), exp(x.z), exp(x.w));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
-extern simd_float8 _simd_exp_f8(simd_float8 x);
-static inline SIMD_CFUNC simd_float8 __tg_exp(simd_float8 x) {
-  return _simd_exp_f8(x);
-}
-#else
-static inline SIMD_CFUNC simd_float8 __tg_exp(simd_float8 x) {
-  return simd_make_float8(__tg_exp(x.lo), __tg_exp(x.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
-extern simd_float16 _simd_exp_f16(simd_float16 x);
-static inline SIMD_CFUNC simd_float16 __tg_exp(simd_float16 x) {
-  return _simd_exp_f16(x);
-}
-#else
-static inline SIMD_CFUNC simd_float16 __tg_exp(simd_float16 x) {
-  return simd_make_float16(__tg_exp(x.lo), __tg_exp(x.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3
-extern simd_double2 _simd_exp_d2(simd_double2 x);
-static inline SIMD_CFUNC simd_double2 __tg_exp(simd_double2 x) {
-  return _simd_exp_d2(x);
-}
-#else
-static inline SIMD_CFUNC simd_double2 __tg_exp(simd_double2 x) {
-  return simd_make_double2(exp(x.x), exp(x.y));
-}
-#endif
-
-static inline SIMD_CFUNC simd_double3 __tg_exp(simd_double3 x) {
-  return simd_make_double3(__tg_exp(simd_make_double4(x)));
-}
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
-extern simd_double4 _simd_exp_d4(simd_double4 x);
-static inline SIMD_CFUNC simd_double4 __tg_exp(simd_double4 x) {
-  return _simd_exp_d4(x);
-}
-#else
-static inline SIMD_CFUNC simd_double4 __tg_exp(simd_double4 x) {
-  return simd_make_double4(__tg_exp(x.lo), __tg_exp(x.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
-extern simd_double8 _simd_exp_d8(simd_double8 x);
-static inline SIMD_CFUNC simd_double8 __tg_exp(simd_double8 x) {
-  return _simd_exp_d8(x);
-}
-#else
-static inline SIMD_CFUNC simd_double8 __tg_exp(simd_double8 x) {
-  return simd_make_double8(__tg_exp(x.lo), __tg_exp(x.hi));
-}
-#endif
-
-#pragma mark - exp2 implementation
-static inline SIMD_CFUNC simd_float2 __tg_exp2(simd_float2 x) {
-  return simd_make_float2(__tg_exp2(simd_make_float4(x)));
-}
-
-static inline SIMD_CFUNC simd_float3 __tg_exp2(simd_float3 x) {
-  return simd_make_float3(__tg_exp2(simd_make_float4(x)));
-}
-
-#if SIMD_LIBRARY_VERSION >= 3
-extern simd_float4 _simd_exp2_f4(simd_float4 x);
-static inline SIMD_CFUNC simd_float4 __tg_exp2(simd_float4 x) {
-  return _simd_exp2_f4(x);
-}
-#else
-static inline SIMD_CFUNC simd_float4 __tg_exp2(simd_float4 x) {
-  return simd_make_float4(exp2(x.x), exp2(x.y), exp2(x.z), exp2(x.w));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
-extern simd_float8 _simd_exp2_f8(simd_float8 x);
-static inline SIMD_CFUNC simd_float8 __tg_exp2(simd_float8 x) {
-  return _simd_exp2_f8(x);
-}
-#else
-static inline SIMD_CFUNC simd_float8 __tg_exp2(simd_float8 x) {
-  return simd_make_float8(__tg_exp2(x.lo), __tg_exp2(x.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
-extern simd_float16 _simd_exp2_f16(simd_float16 x);
-static inline SIMD_CFUNC simd_float16 __tg_exp2(simd_float16 x) {
-  return _simd_exp2_f16(x);
-}
-#else
-static inline SIMD_CFUNC simd_float16 __tg_exp2(simd_float16 x) {
-  return simd_make_float16(__tg_exp2(x.lo), __tg_exp2(x.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3
-extern simd_double2 _simd_exp2_d2(simd_double2 x);
-static inline SIMD_CFUNC simd_double2 __tg_exp2(simd_double2 x) {
-  return _simd_exp2_d2(x);
-}
-#else
-static inline SIMD_CFUNC simd_double2 __tg_exp2(simd_double2 x) {
-  return simd_make_double2(exp2(x.x), exp2(x.y));
-}
-#endif
-
-static inline SIMD_CFUNC simd_double3 __tg_exp2(simd_double3 x) {
-  return simd_make_double3(__tg_exp2(simd_make_double4(x)));
-}
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
-extern simd_double4 _simd_exp2_d4(simd_double4 x);
-static inline SIMD_CFUNC simd_double4 __tg_exp2(simd_double4 x) {
-  return _simd_exp2_d4(x);
-}
-#else
-static inline SIMD_CFUNC simd_double4 __tg_exp2(simd_double4 x) {
-  return simd_make_double4(__tg_exp2(x.lo), __tg_exp2(x.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
-extern simd_double8 _simd_exp2_d8(simd_double8 x);
-static inline SIMD_CFUNC simd_double8 __tg_exp2(simd_double8 x) {
-  return _simd_exp2_d8(x);
-}
-#else
-static inline SIMD_CFUNC simd_double8 __tg_exp2(simd_double8 x) {
-  return simd_make_double8(__tg_exp2(x.lo), __tg_exp2(x.hi));
-}
-#endif
-
-#pragma mark - exp10 implementation
-#if SIMD_LIBRARY_VERSION >= 1
-static inline SIMD_CFUNC simd_float2 __tg_exp10(simd_float2 x) {
-  return simd_make_float2(__tg_exp10(simd_make_float4(x)));
-}
-
-static inline SIMD_CFUNC simd_float3 __tg_exp10(simd_float3 x) {
-  return simd_make_float3(__tg_exp10(simd_make_float4(x)));
-}
-
-#if SIMD_LIBRARY_VERSION >= 3
-extern simd_float4 _simd_exp10_f4(simd_float4 x);
-static inline SIMD_CFUNC simd_float4 __tg_exp10(simd_float4 x) {
-  return _simd_exp10_f4(x);
-}
-#else
-static inline SIMD_CFUNC simd_float4 __tg_exp10(simd_float4 x) {
-  return simd_make_float4(__exp10(x.x), __exp10(x.y), __exp10(x.z), __exp10(x.w));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
-extern simd_float8 _simd_exp10_f8(simd_float8 x);
-static inline SIMD_CFUNC simd_float8 __tg_exp10(simd_float8 x) {
-  return _simd_exp10_f8(x);
-}
-#else
-static inline SIMD_CFUNC simd_float8 __tg_exp10(simd_float8 x) {
-  return simd_make_float8(__tg_exp10(x.lo), __tg_exp10(x.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
-extern simd_float16 _simd_exp10_f16(simd_float16 x);
-static inline SIMD_CFUNC simd_float16 __tg_exp10(simd_float16 x) {
-  return _simd_exp10_f16(x);
-}
-#else
-static inline SIMD_CFUNC simd_float16 __tg_exp10(simd_float16 x) {
-  return simd_make_float16(__tg_exp10(x.lo), __tg_exp10(x.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3
-extern simd_double2 _simd_exp10_d2(simd_double2 x);
-static inline SIMD_CFUNC simd_double2 __tg_exp10(simd_double2 x) {
-  return _simd_exp10_d2(x);
-}
-#else
-static inline SIMD_CFUNC simd_double2 __tg_exp10(simd_double2 x) {
-  return simd_make_double2(__exp10(x.x), __exp10(x.y));
-}
-#endif
-
-static inline SIMD_CFUNC simd_double3 __tg_exp10(simd_double3 x) {
-  return simd_make_double3(__tg_exp10(simd_make_double4(x)));
-}
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
-extern simd_double4 _simd_exp10_d4(simd_double4 x);
-static inline SIMD_CFUNC simd_double4 __tg_exp10(simd_double4 x) {
-  return _simd_exp10_d4(x);
-}
-#else
-static inline SIMD_CFUNC simd_double4 __tg_exp10(simd_double4 x) {
-  return simd_make_double4(__tg_exp10(x.lo), __tg_exp10(x.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
-extern simd_double8 _simd_exp10_d8(simd_double8 x);
-static inline SIMD_CFUNC simd_double8 __tg_exp10(simd_double8 x) {
-  return _simd_exp10_d8(x);
-}
-#else
-static inline SIMD_CFUNC simd_double8 __tg_exp10(simd_double8 x) {
-  return simd_make_double8(__tg_exp10(x.lo), __tg_exp10(x.hi));
-}
-#endif
-
-#endif /* SIMD_LIBRARY_VERSION */
-#pragma mark - expm1 implementation
-static inline SIMD_CFUNC simd_float2 __tg_expm1(simd_float2 x) {
-  return simd_make_float2(__tg_expm1(simd_make_float4(x)));
-}
-
-static inline SIMD_CFUNC simd_float3 __tg_expm1(simd_float3 x) {
-  return simd_make_float3(__tg_expm1(simd_make_float4(x)));
-}
-
-#if SIMD_LIBRARY_VERSION >= 3
-extern simd_float4 _simd_expm1_f4(simd_float4 x);
-static inline SIMD_CFUNC simd_float4 __tg_expm1(simd_float4 x) {
-  return _simd_expm1_f4(x);
-}
-#else
-static inline SIMD_CFUNC simd_float4 __tg_expm1(simd_float4 x) {
-  return simd_make_float4(expm1(x.x), expm1(x.y), expm1(x.z), expm1(x.w));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
-extern simd_float8 _simd_expm1_f8(simd_float8 x);
-static inline SIMD_CFUNC simd_float8 __tg_expm1(simd_float8 x) {
-  return _simd_expm1_f8(x);
-}
-#else
-static inline SIMD_CFUNC simd_float8 __tg_expm1(simd_float8 x) {
-  return simd_make_float8(__tg_expm1(x.lo), __tg_expm1(x.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
-extern simd_float16 _simd_expm1_f16(simd_float16 x);
-static inline SIMD_CFUNC simd_float16 __tg_expm1(simd_float16 x) {
-  return _simd_expm1_f16(x);
-}
-#else
-static inline SIMD_CFUNC simd_float16 __tg_expm1(simd_float16 x) {
-  return simd_make_float16(__tg_expm1(x.lo), __tg_expm1(x.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3
-extern simd_double2 _simd_expm1_d2(simd_double2 x);
-static inline SIMD_CFUNC simd_double2 __tg_expm1(simd_double2 x) {
-  return _simd_expm1_d2(x);
-}
-#else
-static inline SIMD_CFUNC simd_double2 __tg_expm1(simd_double2 x) {
-  return simd_make_double2(expm1(x.x), expm1(x.y));
-}
-#endif
-
-static inline SIMD_CFUNC simd_double3 __tg_expm1(simd_double3 x) {
-  return simd_make_double3(__tg_expm1(simd_make_double4(x)));
-}
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
-extern simd_double4 _simd_expm1_d4(simd_double4 x);
-static inline SIMD_CFUNC simd_double4 __tg_expm1(simd_double4 x) {
-  return _simd_expm1_d4(x);
-}
-#else
-static inline SIMD_CFUNC simd_double4 __tg_expm1(simd_double4 x) {
-  return simd_make_double4(__tg_expm1(x.lo), __tg_expm1(x.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
-extern simd_double8 _simd_expm1_d8(simd_double8 x);
-static inline SIMD_CFUNC simd_double8 __tg_expm1(simd_double8 x) {
-  return _simd_expm1_d8(x);
-}
-#else
-static inline SIMD_CFUNC simd_double8 __tg_expm1(simd_double8 x) {
-  return simd_make_double8(__tg_expm1(x.lo), __tg_expm1(x.hi));
-}
-#endif
-
-#pragma mark - log implementation
-static inline SIMD_CFUNC simd_float2 __tg_log(simd_float2 x) {
-  return simd_make_float2(__tg_log(simd_make_float4(x)));
-}
-
-static inline SIMD_CFUNC simd_float3 __tg_log(simd_float3 x) {
-  return simd_make_float3(__tg_log(simd_make_float4(x)));
-}
-
-#if SIMD_LIBRARY_VERSION >= 3
-extern simd_float4 _simd_log_f4(simd_float4 x);
-static inline SIMD_CFUNC simd_float4 __tg_log(simd_float4 x) {
-  return _simd_log_f4(x);
-}
-#else
-static inline SIMD_CFUNC simd_float4 __tg_log(simd_float4 x) {
-  return simd_make_float4(log(x.x), log(x.y), log(x.z), log(x.w));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
-extern simd_float8 _simd_log_f8(simd_float8 x);
-static inline SIMD_CFUNC simd_float8 __tg_log(simd_float8 x) {
-  return _simd_log_f8(x);
-}
-#else
-static inline SIMD_CFUNC simd_float8 __tg_log(simd_float8 x) {
-  return simd_make_float8(__tg_log(x.lo), __tg_log(x.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
-extern simd_float16 _simd_log_f16(simd_float16 x);
-static inline SIMD_CFUNC simd_float16 __tg_log(simd_float16 x) {
-  return _simd_log_f16(x);
-}
-#else
-static inline SIMD_CFUNC simd_float16 __tg_log(simd_float16 x) {
-  return simd_make_float16(__tg_log(x.lo), __tg_log(x.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3
-extern simd_double2 _simd_log_d2(simd_double2 x);
-static inline SIMD_CFUNC simd_double2 __tg_log(simd_double2 x) {
-  return _simd_log_d2(x);
-}
-#else
-static inline SIMD_CFUNC simd_double2 __tg_log(simd_double2 x) {
-  return simd_make_double2(log(x.x), log(x.y));
-}
-#endif
-
-static inline SIMD_CFUNC simd_double3 __tg_log(simd_double3 x) {
-  return simd_make_double3(__tg_log(simd_make_double4(x)));
-}
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
-extern simd_double4 _simd_log_d4(simd_double4 x);
-static inline SIMD_CFUNC simd_double4 __tg_log(simd_double4 x) {
-  return _simd_log_d4(x);
-}
-#else
-static inline SIMD_CFUNC simd_double4 __tg_log(simd_double4 x) {
-  return simd_make_double4(__tg_log(x.lo), __tg_log(x.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
-extern simd_double8 _simd_log_d8(simd_double8 x);
-static inline SIMD_CFUNC simd_double8 __tg_log(simd_double8 x) {
-  return _simd_log_d8(x);
-}
-#else
-static inline SIMD_CFUNC simd_double8 __tg_log(simd_double8 x) {
-  return simd_make_double8(__tg_log(x.lo), __tg_log(x.hi));
-}
-#endif
-
-#pragma mark - log2 implementation
-static inline SIMD_CFUNC simd_float2 __tg_log2(simd_float2 x) {
-  return simd_make_float2(__tg_log2(simd_make_float4(x)));
-}
-
-static inline SIMD_CFUNC simd_float3 __tg_log2(simd_float3 x) {
-  return simd_make_float3(__tg_log2(simd_make_float4(x)));
-}
-
-#if SIMD_LIBRARY_VERSION >= 3
-extern simd_float4 _simd_log2_f4(simd_float4 x);
-static inline SIMD_CFUNC simd_float4 __tg_log2(simd_float4 x) {
-  return _simd_log2_f4(x);
-}
-#else
-static inline SIMD_CFUNC simd_float4 __tg_log2(simd_float4 x) {
-  return simd_make_float4(log2(x.x), log2(x.y), log2(x.z), log2(x.w));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
-extern simd_float8 _simd_log2_f8(simd_float8 x);
-static inline SIMD_CFUNC simd_float8 __tg_log2(simd_float8 x) {
-  return _simd_log2_f8(x);
-}
-#else
-static inline SIMD_CFUNC simd_float8 __tg_log2(simd_float8 x) {
-  return simd_make_float8(__tg_log2(x.lo), __tg_log2(x.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
-extern simd_float16 _simd_log2_f16(simd_float16 x);
-static inline SIMD_CFUNC simd_float16 __tg_log2(simd_float16 x) {
-  return _simd_log2_f16(x);
-}
-#else
-static inline SIMD_CFUNC simd_float16 __tg_log2(simd_float16 x) {
-  return simd_make_float16(__tg_log2(x.lo), __tg_log2(x.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3
-extern simd_double2 _simd_log2_d2(simd_double2 x);
-static inline SIMD_CFUNC simd_double2 __tg_log2(simd_double2 x) {
-  return _simd_log2_d2(x);
-}
-#else
-static inline SIMD_CFUNC simd_double2 __tg_log2(simd_double2 x) {
-  return simd_make_double2(log2(x.x), log2(x.y));
-}
-#endif
-
-static inline SIMD_CFUNC simd_double3 __tg_log2(simd_double3 x) {
-  return simd_make_double3(__tg_log2(simd_make_double4(x)));
-}
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
-extern simd_double4 _simd_log2_d4(simd_double4 x);
-static inline SIMD_CFUNC simd_double4 __tg_log2(simd_double4 x) {
-  return _simd_log2_d4(x);
-}
-#else
-static inline SIMD_CFUNC simd_double4 __tg_log2(simd_double4 x) {
-  return simd_make_double4(__tg_log2(x.lo), __tg_log2(x.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
-extern simd_double8 _simd_log2_d8(simd_double8 x);
-static inline SIMD_CFUNC simd_double8 __tg_log2(simd_double8 x) {
-  return _simd_log2_d8(x);
-}
-#else
-static inline SIMD_CFUNC simd_double8 __tg_log2(simd_double8 x) {
-  return simd_make_double8(__tg_log2(x.lo), __tg_log2(x.hi));
-}
-#endif
-
-#pragma mark - log10 implementation
-static inline SIMD_CFUNC simd_float2 __tg_log10(simd_float2 x) {
-  return simd_make_float2(__tg_log10(simd_make_float4(x)));
-}
-
-static inline SIMD_CFUNC simd_float3 __tg_log10(simd_float3 x) {
-  return simd_make_float3(__tg_log10(simd_make_float4(x)));
-}
-
-#if SIMD_LIBRARY_VERSION >= 3
-extern simd_float4 _simd_log10_f4(simd_float4 x);
-static inline SIMD_CFUNC simd_float4 __tg_log10(simd_float4 x) {
-  return _simd_log10_f4(x);
-}
-#else
-static inline SIMD_CFUNC simd_float4 __tg_log10(simd_float4 x) {
-  return simd_make_float4(log10(x.x), log10(x.y), log10(x.z), log10(x.w));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
-extern simd_float8 _simd_log10_f8(simd_float8 x);
-static inline SIMD_CFUNC simd_float8 __tg_log10(simd_float8 x) {
-  return _simd_log10_f8(x);
-}
-#else
-static inline SIMD_CFUNC simd_float8 __tg_log10(simd_float8 x) {
-  return simd_make_float8(__tg_log10(x.lo), __tg_log10(x.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
-extern simd_float16 _simd_log10_f16(simd_float16 x);
-static inline SIMD_CFUNC simd_float16 __tg_log10(simd_float16 x) {
-  return _simd_log10_f16(x);
-}
-#else
-static inline SIMD_CFUNC simd_float16 __tg_log10(simd_float16 x) {
-  return simd_make_float16(__tg_log10(x.lo), __tg_log10(x.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3
-extern simd_double2 _simd_log10_d2(simd_double2 x);
-static inline SIMD_CFUNC simd_double2 __tg_log10(simd_double2 x) {
-  return _simd_log10_d2(x);
-}
-#else
-static inline SIMD_CFUNC simd_double2 __tg_log10(simd_double2 x) {
-  return simd_make_double2(log10(x.x), log10(x.y));
-}
-#endif
-
-static inline SIMD_CFUNC simd_double3 __tg_log10(simd_double3 x) {
-  return simd_make_double3(__tg_log10(simd_make_double4(x)));
-}
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
-extern simd_double4 _simd_log10_d4(simd_double4 x);
-static inline SIMD_CFUNC simd_double4 __tg_log10(simd_double4 x) {
-  return _simd_log10_d4(x);
-}
-#else
-static inline SIMD_CFUNC simd_double4 __tg_log10(simd_double4 x) {
-  return simd_make_double4(__tg_log10(x.lo), __tg_log10(x.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
-extern simd_double8 _simd_log10_d8(simd_double8 x);
-static inline SIMD_CFUNC simd_double8 __tg_log10(simd_double8 x) {
-  return _simd_log10_d8(x);
-}
-#else
-static inline SIMD_CFUNC simd_double8 __tg_log10(simd_double8 x) {
-  return simd_make_double8(__tg_log10(x.lo), __tg_log10(x.hi));
-}
-#endif
-
-#pragma mark - log1p implementation
-static inline SIMD_CFUNC simd_float2 __tg_log1p(simd_float2 x) {
-  return simd_make_float2(__tg_log1p(simd_make_float4(x)));
-}
-
-static inline SIMD_CFUNC simd_float3 __tg_log1p(simd_float3 x) {
-  return simd_make_float3(__tg_log1p(simd_make_float4(x)));
-}
-
-#if SIMD_LIBRARY_VERSION >= 3
-extern simd_float4 _simd_log1p_f4(simd_float4 x);
-static inline SIMD_CFUNC simd_float4 __tg_log1p(simd_float4 x) {
-  return _simd_log1p_f4(x);
-}
-#else
-static inline SIMD_CFUNC simd_float4 __tg_log1p(simd_float4 x) {
-  return simd_make_float4(log1p(x.x), log1p(x.y), log1p(x.z), log1p(x.w));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
-extern simd_float8 _simd_log1p_f8(simd_float8 x);
-static inline SIMD_CFUNC simd_float8 __tg_log1p(simd_float8 x) {
-  return _simd_log1p_f8(x);
-}
-#else
-static inline SIMD_CFUNC simd_float8 __tg_log1p(simd_float8 x) {
-  return simd_make_float8(__tg_log1p(x.lo), __tg_log1p(x.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
-extern simd_float16 _simd_log1p_f16(simd_float16 x);
-static inline SIMD_CFUNC simd_float16 __tg_log1p(simd_float16 x) {
-  return _simd_log1p_f16(x);
-}
-#else
-static inline SIMD_CFUNC simd_float16 __tg_log1p(simd_float16 x) {
-  return simd_make_float16(__tg_log1p(x.lo), __tg_log1p(x.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3
-extern simd_double2 _simd_log1p_d2(simd_double2 x);
-static inline SIMD_CFUNC simd_double2 __tg_log1p(simd_double2 x) {
-  return _simd_log1p_d2(x);
-}
-#else
-static inline SIMD_CFUNC simd_double2 __tg_log1p(simd_double2 x) {
-  return simd_make_double2(log1p(x.x), log1p(x.y));
-}
-#endif
-
-static inline SIMD_CFUNC simd_double3 __tg_log1p(simd_double3 x) {
-  return simd_make_double3(__tg_log1p(simd_make_double4(x)));
-}
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
-extern simd_double4 _simd_log1p_d4(simd_double4 x);
-static inline SIMD_CFUNC simd_double4 __tg_log1p(simd_double4 x) {
-  return _simd_log1p_d4(x);
-}
-#else
-static inline SIMD_CFUNC simd_double4 __tg_log1p(simd_double4 x) {
-  return simd_make_double4(__tg_log1p(x.lo), __tg_log1p(x.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
-extern simd_double8 _simd_log1p_d8(simd_double8 x);
-static inline SIMD_CFUNC simd_double8 __tg_log1p(simd_double8 x) {
-  return _simd_log1p_d8(x);
-}
-#else
-static inline SIMD_CFUNC simd_double8 __tg_log1p(simd_double8 x) {
-  return simd_make_double8(__tg_log1p(x.lo), __tg_log1p(x.hi));
-}
-#endif
-
-#pragma mark - cbrt implementation
-static inline SIMD_CFUNC simd_float2 __tg_cbrt(simd_float2 x) {
-  return simd_make_float2(__tg_cbrt(simd_make_float4(x)));
-}
-
-static inline SIMD_CFUNC simd_float3 __tg_cbrt(simd_float3 x) {
-  return simd_make_float3(__tg_cbrt(simd_make_float4(x)));
-}
-
-#if SIMD_LIBRARY_VERSION >= 3
-extern simd_float4 _simd_cbrt_f4(simd_float4 x);
-static inline SIMD_CFUNC simd_float4 __tg_cbrt(simd_float4 x) {
-  return _simd_cbrt_f4(x);
-}
-#else
-static inline SIMD_CFUNC simd_float4 __tg_cbrt(simd_float4 x) {
-  return simd_make_float4(cbrt(x.x), cbrt(x.y), cbrt(x.z), cbrt(x.w));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
-extern simd_float8 _simd_cbrt_f8(simd_float8 x);
-static inline SIMD_CFUNC simd_float8 __tg_cbrt(simd_float8 x) {
-  return _simd_cbrt_f8(x);
-}
-#else
-static inline SIMD_CFUNC simd_float8 __tg_cbrt(simd_float8 x) {
-  return simd_make_float8(__tg_cbrt(x.lo), __tg_cbrt(x.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
-extern simd_float16 _simd_cbrt_f16(simd_float16 x);
-static inline SIMD_CFUNC simd_float16 __tg_cbrt(simd_float16 x) {
-  return _simd_cbrt_f16(x);
-}
-#else
-static inline SIMD_CFUNC simd_float16 __tg_cbrt(simd_float16 x) {
-  return simd_make_float16(__tg_cbrt(x.lo), __tg_cbrt(x.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3
-extern simd_double2 _simd_cbrt_d2(simd_double2 x);
-static inline SIMD_CFUNC simd_double2 __tg_cbrt(simd_double2 x) {
-  return _simd_cbrt_d2(x);
-}
-#else
-static inline SIMD_CFUNC simd_double2 __tg_cbrt(simd_double2 x) {
-  return simd_make_double2(cbrt(x.x), cbrt(x.y));
-}
-#endif
-
-static inline SIMD_CFUNC simd_double3 __tg_cbrt(simd_double3 x) {
-  return simd_make_double3(__tg_cbrt(simd_make_double4(x)));
-}
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
-extern simd_double4 _simd_cbrt_d4(simd_double4 x);
-static inline SIMD_CFUNC simd_double4 __tg_cbrt(simd_double4 x) {
-  return _simd_cbrt_d4(x);
-}
-#else
-static inline SIMD_CFUNC simd_double4 __tg_cbrt(simd_double4 x) {
-  return simd_make_double4(__tg_cbrt(x.lo), __tg_cbrt(x.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
-extern simd_double8 _simd_cbrt_d8(simd_double8 x);
-static inline SIMD_CFUNC simd_double8 __tg_cbrt(simd_double8 x) {
-  return _simd_cbrt_d8(x);
-}
-#else
-static inline SIMD_CFUNC simd_double8 __tg_cbrt(simd_double8 x) {
-  return simd_make_double8(__tg_cbrt(x.lo), __tg_cbrt(x.hi));
-}
-#endif
-
-#pragma mark - erf implementation
-static inline SIMD_CFUNC simd_float2 __tg_erf(simd_float2 x) {
-  return simd_make_float2(__tg_erf(simd_make_float4(x)));
-}
-
-static inline SIMD_CFUNC simd_float3 __tg_erf(simd_float3 x) {
-  return simd_make_float3(__tg_erf(simd_make_float4(x)));
-}
-
-#if SIMD_LIBRARY_VERSION >= 3
-extern simd_float4 _simd_erf_f4(simd_float4 x);
-static inline SIMD_CFUNC simd_float4 __tg_erf(simd_float4 x) {
-  return _simd_erf_f4(x);
-}
-#else
-static inline SIMD_CFUNC simd_float4 __tg_erf(simd_float4 x) {
-  return simd_make_float4(erf(x.x), erf(x.y), erf(x.z), erf(x.w));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
-extern simd_float8 _simd_erf_f8(simd_float8 x);
-static inline SIMD_CFUNC simd_float8 __tg_erf(simd_float8 x) {
-  return _simd_erf_f8(x);
-}
-#else
-static inline SIMD_CFUNC simd_float8 __tg_erf(simd_float8 x) {
-  return simd_make_float8(__tg_erf(x.lo), __tg_erf(x.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
-extern simd_float16 _simd_erf_f16(simd_float16 x);
-static inline SIMD_CFUNC simd_float16 __tg_erf(simd_float16 x) {
-  return _simd_erf_f16(x);
-}
-#else
-static inline SIMD_CFUNC simd_float16 __tg_erf(simd_float16 x) {
-  return simd_make_float16(__tg_erf(x.lo), __tg_erf(x.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3
-extern simd_double2 _simd_erf_d2(simd_double2 x);
-static inline SIMD_CFUNC simd_double2 __tg_erf(simd_double2 x) {
-  return _simd_erf_d2(x);
-}
-#else
-static inline SIMD_CFUNC simd_double2 __tg_erf(simd_double2 x) {
-  return simd_make_double2(erf(x.x), erf(x.y));
-}
-#endif
-
-static inline SIMD_CFUNC simd_double3 __tg_erf(simd_double3 x) {
-  return simd_make_double3(__tg_erf(simd_make_double4(x)));
-}
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
-extern simd_double4 _simd_erf_d4(simd_double4 x);
-static inline SIMD_CFUNC simd_double4 __tg_erf(simd_double4 x) {
-  return _simd_erf_d4(x);
-}
-#else
-static inline SIMD_CFUNC simd_double4 __tg_erf(simd_double4 x) {
-  return simd_make_double4(__tg_erf(x.lo), __tg_erf(x.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
-extern simd_double8 _simd_erf_d8(simd_double8 x);
-static inline SIMD_CFUNC simd_double8 __tg_erf(simd_double8 x) {
-  return _simd_erf_d8(x);
-}
-#else
-static inline SIMD_CFUNC simd_double8 __tg_erf(simd_double8 x) {
-  return simd_make_double8(__tg_erf(x.lo), __tg_erf(x.hi));
-}
-#endif
-
-#pragma mark - erfc implementation
-static inline SIMD_CFUNC simd_float2 __tg_erfc(simd_float2 x) {
-  return simd_make_float2(__tg_erfc(simd_make_float4(x)));
-}
-
-static inline SIMD_CFUNC simd_float3 __tg_erfc(simd_float3 x) {
-  return simd_make_float3(__tg_erfc(simd_make_float4(x)));
-}
-
-#if SIMD_LIBRARY_VERSION >= 3
-extern simd_float4 _simd_erfc_f4(simd_float4 x);
-static inline SIMD_CFUNC simd_float4 __tg_erfc(simd_float4 x) {
-  return _simd_erfc_f4(x);
-}
-#else
-static inline SIMD_CFUNC simd_float4 __tg_erfc(simd_float4 x) {
-  return simd_make_float4(erfc(x.x), erfc(x.y), erfc(x.z), erfc(x.w));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
-extern simd_float8 _simd_erfc_f8(simd_float8 x);
-static inline SIMD_CFUNC simd_float8 __tg_erfc(simd_float8 x) {
-  return _simd_erfc_f8(x);
-}
-#else
-static inline SIMD_CFUNC simd_float8 __tg_erfc(simd_float8 x) {
-  return simd_make_float8(__tg_erfc(x.lo), __tg_erfc(x.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
-extern simd_float16 _simd_erfc_f16(simd_float16 x);
-static inline SIMD_CFUNC simd_float16 __tg_erfc(simd_float16 x) {
-  return _simd_erfc_f16(x);
-}
-#else
-static inline SIMD_CFUNC simd_float16 __tg_erfc(simd_float16 x) {
-  return simd_make_float16(__tg_erfc(x.lo), __tg_erfc(x.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3
-extern simd_double2 _simd_erfc_d2(simd_double2 x);
-static inline SIMD_CFUNC simd_double2 __tg_erfc(simd_double2 x) {
-  return _simd_erfc_d2(x);
-}
-#else
-static inline SIMD_CFUNC simd_double2 __tg_erfc(simd_double2 x) {
-  return simd_make_double2(erfc(x.x), erfc(x.y));
-}
-#endif
-
-static inline SIMD_CFUNC simd_double3 __tg_erfc(simd_double3 x) {
-  return simd_make_double3(__tg_erfc(simd_make_double4(x)));
-}
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
-extern simd_double4 _simd_erfc_d4(simd_double4 x);
-static inline SIMD_CFUNC simd_double4 __tg_erfc(simd_double4 x) {
-  return _simd_erfc_d4(x);
-}
-#else
-static inline SIMD_CFUNC simd_double4 __tg_erfc(simd_double4 x) {
-  return simd_make_double4(__tg_erfc(x.lo), __tg_erfc(x.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
-extern simd_double8 _simd_erfc_d8(simd_double8 x);
-static inline SIMD_CFUNC simd_double8 __tg_erfc(simd_double8 x) {
-  return _simd_erfc_d8(x);
-}
-#else
-static inline SIMD_CFUNC simd_double8 __tg_erfc(simd_double8 x) {
-  return simd_make_double8(__tg_erfc(x.lo), __tg_erfc(x.hi));
-}
-#endif
-
-#pragma mark - tgamma implementation
-static inline SIMD_CFUNC simd_float2 __tg_tgamma(simd_float2 x) {
-  return simd_make_float2(__tg_tgamma(simd_make_float4(x)));
-}
-
-static inline SIMD_CFUNC simd_float3 __tg_tgamma(simd_float3 x) {
-  return simd_make_float3(__tg_tgamma(simd_make_float4(x)));
-}
-
-#if SIMD_LIBRARY_VERSION >= 3
-extern simd_float4 _simd_tgamma_f4(simd_float4 x);
-static inline SIMD_CFUNC simd_float4 __tg_tgamma(simd_float4 x) {
-  return _simd_tgamma_f4(x);
-}
-#else
-static inline SIMD_CFUNC simd_float4 __tg_tgamma(simd_float4 x) {
-  return simd_make_float4(tgamma(x.x), tgamma(x.y), tgamma(x.z), tgamma(x.w));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
-extern simd_float8 _simd_tgamma_f8(simd_float8 x);
-static inline SIMD_CFUNC simd_float8 __tg_tgamma(simd_float8 x) {
-  return _simd_tgamma_f8(x);
-}
-#else
-static inline SIMD_CFUNC simd_float8 __tg_tgamma(simd_float8 x) {
-  return simd_make_float8(__tg_tgamma(x.lo), __tg_tgamma(x.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
-extern simd_float16 _simd_tgamma_f16(simd_float16 x);
-static inline SIMD_CFUNC simd_float16 __tg_tgamma(simd_float16 x) {
-  return _simd_tgamma_f16(x);
-}
-#else
-static inline SIMD_CFUNC simd_float16 __tg_tgamma(simd_float16 x) {
-  return simd_make_float16(__tg_tgamma(x.lo), __tg_tgamma(x.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3
-extern simd_double2 _simd_tgamma_d2(simd_double2 x);
-static inline SIMD_CFUNC simd_double2 __tg_tgamma(simd_double2 x) {
-  return _simd_tgamma_d2(x);
-}
-#else
-static inline SIMD_CFUNC simd_double2 __tg_tgamma(simd_double2 x) {
-  return simd_make_double2(tgamma(x.x), tgamma(x.y));
-}
-#endif
-
-static inline SIMD_CFUNC simd_double3 __tg_tgamma(simd_double3 x) {
-  return simd_make_double3(__tg_tgamma(simd_make_double4(x)));
-}
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
-extern simd_double4 _simd_tgamma_d4(simd_double4 x);
-static inline SIMD_CFUNC simd_double4 __tg_tgamma(simd_double4 x) {
-  return _simd_tgamma_d4(x);
-}
-#else
-static inline SIMD_CFUNC simd_double4 __tg_tgamma(simd_double4 x) {
-  return simd_make_double4(__tg_tgamma(x.lo), __tg_tgamma(x.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
-extern simd_double8 _simd_tgamma_d8(simd_double8 x);
-static inline SIMD_CFUNC simd_double8 __tg_tgamma(simd_double8 x) {
-  return _simd_tgamma_d8(x);
-}
-#else
-static inline SIMD_CFUNC simd_double8 __tg_tgamma(simd_double8 x) {
-  return simd_make_double8(__tg_tgamma(x.lo), __tg_tgamma(x.hi));
-}
-#endif
-
-#pragma mark - round implementation
-static inline SIMD_CFUNC simd_float2 __tg_round(simd_float2 x) {
-  return simd_make_float2(__tg_round(simd_make_float4(x)));
-}
-
-static inline SIMD_CFUNC simd_float3 __tg_round(simd_float3 x) {
-  return simd_make_float3(__tg_round(simd_make_float4(x)));
-}
-
-#if SIMD_LIBRARY_VERSION >= 3
-extern simd_float4 _simd_round_f4(simd_float4 x);
-static inline SIMD_CFUNC simd_float4 __tg_round(simd_float4 x) {
-#if defined __arm64__
-  return vrndaq_f32(x);
-#else
-  return _simd_round_f4(x);
-#endif
-}
-#else
-static inline SIMD_CFUNC simd_float4 __tg_round(simd_float4 x) {
-  return simd_make_float4(round(x.x), round(x.y), round(x.z), round(x.w));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
-extern simd_float8 _simd_round_f8(simd_float8 x);
-static inline SIMD_CFUNC simd_float8 __tg_round(simd_float8 x) {
-  return _simd_round_f8(x);
-}
-#else
-static inline SIMD_CFUNC simd_float8 __tg_round(simd_float8 x) {
-  return simd_make_float8(__tg_round(x.lo), __tg_round(x.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
-extern simd_float16 _simd_round_f16(simd_float16 x);
-static inline SIMD_CFUNC simd_float16 __tg_round(simd_float16 x) {
-  return _simd_round_f16(x);
-}
-#else
-static inline SIMD_CFUNC simd_float16 __tg_round(simd_float16 x) {
-  return simd_make_float16(__tg_round(x.lo), __tg_round(x.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3
-extern simd_double2 _simd_round_d2(simd_double2 x);
-static inline SIMD_CFUNC simd_double2 __tg_round(simd_double2 x) {
-#if defined __arm64__
-  return vrndaq_f64(x);
-#else
-  return _simd_round_d2(x);
-#endif
-}
-#else
-static inline SIMD_CFUNC simd_double2 __tg_round(simd_double2 x) {
-  return simd_make_double2(round(x.x), round(x.y));
-}
-#endif
-
-static inline SIMD_CFUNC simd_double3 __tg_round(simd_double3 x) {
-  return simd_make_double3(__tg_round(simd_make_double4(x)));
-}
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
-extern simd_double4 _simd_round_d4(simd_double4 x);
-static inline SIMD_CFUNC simd_double4 __tg_round(simd_double4 x) {
-  return _simd_round_d4(x);
-}
-#else
-static inline SIMD_CFUNC simd_double4 __tg_round(simd_double4 x) {
-  return simd_make_double4(__tg_round(x.lo), __tg_round(x.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
-extern simd_double8 _simd_round_d8(simd_double8 x);
-static inline SIMD_CFUNC simd_double8 __tg_round(simd_double8 x) {
-  return _simd_round_d8(x);
-}
-#else
-static inline SIMD_CFUNC simd_double8 __tg_round(simd_double8 x) {
-  return simd_make_double8(__tg_round(x.lo), __tg_round(x.hi));
-}
-#endif
-
-#pragma mark - atan2 implementation
-static inline SIMD_CFUNC simd_float2 __tg_atan2(simd_float2 y, simd_float2 x) {
-  return simd_make_float2(__tg_atan2(simd_make_float4(y), simd_make_float4(x)));
-}
-
-static inline SIMD_CFUNC simd_float3 __tg_atan2(simd_float3 y, simd_float3 x) {
-  return simd_make_float3(__tg_atan2(simd_make_float4(y), simd_make_float4(x)));
-}
-
-#if SIMD_LIBRARY_VERSION >= 3
-extern simd_float4 _simd_atan2_f4(simd_float4 y, simd_float4 x);
-static inline SIMD_CFUNC simd_float4 __tg_atan2(simd_float4 y, simd_float4 x) {
-  return _simd_atan2_f4(y, x);
-}
-#else
-static inline SIMD_CFUNC simd_float4 __tg_atan2(simd_float4 y, simd_float4 x) {
-  return simd_make_float4(atan2(y.x, x.x), atan2(y.y, x.y), atan2(y.z, x.z), atan2(y.w, x.w));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
-extern simd_float8 _simd_atan2_f8(simd_float8 y, simd_float8 x);
-static inline SIMD_CFUNC simd_float8 __tg_atan2(simd_float8 y, simd_float8 x) {
-  return _simd_atan2_f8(y, x);
-}
-#else
-static inline SIMD_CFUNC simd_float8 __tg_atan2(simd_float8 y, simd_float8 x) {
-  return simd_make_float8(__tg_atan2(y.lo, x.lo), __tg_atan2(y.hi, x.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
-extern simd_float16 _simd_atan2_f16(simd_float16 y, simd_float16 x);
-static inline SIMD_CFUNC simd_float16 __tg_atan2(simd_float16 y, simd_float16 x) {
-  return _simd_atan2_f16(y, x);
-}
-#else
-static inline SIMD_CFUNC simd_float16 __tg_atan2(simd_float16 y, simd_float16 x) {
-  return simd_make_float16(__tg_atan2(y.lo, x.lo), __tg_atan2(y.hi, x.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3
-extern simd_double2 _simd_atan2_d2(simd_double2 y, simd_double2 x);
-static inline SIMD_CFUNC simd_double2 __tg_atan2(simd_double2 y, simd_double2 x) {
-  return _simd_atan2_d2(y, x);
-}
-#else
-static inline SIMD_CFUNC simd_double2 __tg_atan2(simd_double2 y, simd_double2 x) {
-  return simd_make_double2(atan2(y.x, x.x), atan2(y.y, x.y));
-}
-#endif
-
-static inline SIMD_CFUNC simd_double3 __tg_atan2(simd_double3 y, simd_double3 x) {
-  return simd_make_double3(__tg_atan2(simd_make_double4(y), simd_make_double4(x)));
-}
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
-extern simd_double4 _simd_atan2_d4(simd_double4 y, simd_double4 x);
-static inline SIMD_CFUNC simd_double4 __tg_atan2(simd_double4 y, simd_double4 x) {
-  return _simd_atan2_d4(y, x);
-}
-#else
-static inline SIMD_CFUNC simd_double4 __tg_atan2(simd_double4 y, simd_double4 x) {
-  return simd_make_double4(__tg_atan2(y.lo, x.lo), __tg_atan2(y.hi, x.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
-extern simd_double8 _simd_atan2_d8(simd_double8 y, simd_double8 x);
-static inline SIMD_CFUNC simd_double8 __tg_atan2(simd_double8 y, simd_double8 x) {
-  return _simd_atan2_d8(y, x);
-}
-#else
-static inline SIMD_CFUNC simd_double8 __tg_atan2(simd_double8 y, simd_double8 x) {
-  return simd_make_double8(__tg_atan2(y.lo, x.lo), __tg_atan2(y.hi, x.hi));
-}
-#endif
-
-#pragma mark - hypot implementation
-static inline SIMD_CFUNC simd_float2 __tg_hypot(simd_float2 x, simd_float2 y) {
-  return simd_make_float2(__tg_hypot(simd_make_float4(x), simd_make_float4(y)));
-}
-
-static inline SIMD_CFUNC simd_float3 __tg_hypot(simd_float3 x, simd_float3 y) {
-  return simd_make_float3(__tg_hypot(simd_make_float4(x), simd_make_float4(y)));
-}
-
-#if SIMD_LIBRARY_VERSION >= 3
-extern simd_float4 _simd_hypot_f4(simd_float4 x, simd_float4 y);
-static inline SIMD_CFUNC simd_float4 __tg_hypot(simd_float4 x, simd_float4 y) {
-  return _simd_hypot_f4(x, y);
-}
-#else
-static inline SIMD_CFUNC simd_float4 __tg_hypot(simd_float4 x, simd_float4 y) {
-  return simd_make_float4(hypot(x.x, y.x), hypot(x.y, y.y), hypot(x.z, y.z), hypot(x.w, y.w));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
-extern simd_float8 _simd_hypot_f8(simd_float8 x, simd_float8 y);
-static inline SIMD_CFUNC simd_float8 __tg_hypot(simd_float8 x, simd_float8 y) {
-  return _simd_hypot_f8(x, y);
-}
-#else
-static inline SIMD_CFUNC simd_float8 __tg_hypot(simd_float8 x, simd_float8 y) {
-  return simd_make_float8(__tg_hypot(x.lo, y.lo), __tg_hypot(x.hi, y.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
-extern simd_float16 _simd_hypot_f16(simd_float16 x, simd_float16 y);
-static inline SIMD_CFUNC simd_float16 __tg_hypot(simd_float16 x, simd_float16 y) {
-  return _simd_hypot_f16(x, y);
-}
-#else
-static inline SIMD_CFUNC simd_float16 __tg_hypot(simd_float16 x, simd_float16 y) {
-  return simd_make_float16(__tg_hypot(x.lo, y.lo), __tg_hypot(x.hi, y.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3
-extern simd_double2 _simd_hypot_d2(simd_double2 x, simd_double2 y);
-static inline SIMD_CFUNC simd_double2 __tg_hypot(simd_double2 x, simd_double2 y) {
-  return _simd_hypot_d2(x, y);
-}
-#else
-static inline SIMD_CFUNC simd_double2 __tg_hypot(simd_double2 x, simd_double2 y) {
-  return simd_make_double2(hypot(x.x, y.x), hypot(x.y, y.y));
-}
-#endif
-
-static inline SIMD_CFUNC simd_double3 __tg_hypot(simd_double3 x, simd_double3 y) {
-  return simd_make_double3(__tg_hypot(simd_make_double4(x), simd_make_double4(y)));
-}
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
-extern simd_double4 _simd_hypot_d4(simd_double4 x, simd_double4 y);
-static inline SIMD_CFUNC simd_double4 __tg_hypot(simd_double4 x, simd_double4 y) {
-  return _simd_hypot_d4(x, y);
-}
-#else
-static inline SIMD_CFUNC simd_double4 __tg_hypot(simd_double4 x, simd_double4 y) {
-  return simd_make_double4(__tg_hypot(x.lo, y.lo), __tg_hypot(x.hi, y.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
-extern simd_double8 _simd_hypot_d8(simd_double8 x, simd_double8 y);
-static inline SIMD_CFUNC simd_double8 __tg_hypot(simd_double8 x, simd_double8 y) {
-  return _simd_hypot_d8(x, y);
-}
-#else
-static inline SIMD_CFUNC simd_double8 __tg_hypot(simd_double8 x, simd_double8 y) {
-  return simd_make_double8(__tg_hypot(x.lo, y.lo), __tg_hypot(x.hi, y.hi));
-}
-#endif
-
-#pragma mark - pow implementation
-static inline SIMD_CFUNC simd_float2 __tg_pow(simd_float2 x, simd_float2 y) {
-  return simd_make_float2(__tg_pow(simd_make_float4(x), simd_make_float4(y)));
-}
-
-static inline SIMD_CFUNC simd_float3 __tg_pow(simd_float3 x, simd_float3 y) {
-  return simd_make_float3(__tg_pow(simd_make_float4(x), simd_make_float4(y)));
-}
-
-#if SIMD_LIBRARY_VERSION >= 3
-extern simd_float4 _simd_pow_f4(simd_float4 x, simd_float4 y);
-static inline SIMD_CFUNC simd_float4 __tg_pow(simd_float4 x, simd_float4 y) {
-  return _simd_pow_f4(x, y);
-}
-#else
-static inline SIMD_CFUNC simd_float4 __tg_pow(simd_float4 x, simd_float4 y) {
-  return simd_make_float4(pow(x.x, y.x), pow(x.y, y.y), pow(x.z, y.z), pow(x.w, y.w));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
-extern simd_float8 _simd_pow_f8(simd_float8 x, simd_float8 y);
-static inline SIMD_CFUNC simd_float8 __tg_pow(simd_float8 x, simd_float8 y) {
-  return _simd_pow_f8(x, y);
-}
-#else
-static inline SIMD_CFUNC simd_float8 __tg_pow(simd_float8 x, simd_float8 y) {
-  return simd_make_float8(__tg_pow(x.lo, y.lo), __tg_pow(x.hi, y.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
-extern simd_float16 _simd_pow_f16(simd_float16 x, simd_float16 y);
-static inline SIMD_CFUNC simd_float16 __tg_pow(simd_float16 x, simd_float16 y) {
-  return _simd_pow_f16(x, y);
-}
-#else
-static inline SIMD_CFUNC simd_float16 __tg_pow(simd_float16 x, simd_float16 y) {
-  return simd_make_float16(__tg_pow(x.lo, y.lo), __tg_pow(x.hi, y.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3
-extern simd_double2 _simd_pow_d2(simd_double2 x, simd_double2 y);
-static inline SIMD_CFUNC simd_double2 __tg_pow(simd_double2 x, simd_double2 y) {
-  return _simd_pow_d2(x, y);
-}
-#else
-static inline SIMD_CFUNC simd_double2 __tg_pow(simd_double2 x, simd_double2 y) {
-  return simd_make_double2(pow(x.x, y.x), pow(x.y, y.y));
-}
-#endif
-
-static inline SIMD_CFUNC simd_double3 __tg_pow(simd_double3 x, simd_double3 y) {
-  return simd_make_double3(__tg_pow(simd_make_double4(x), simd_make_double4(y)));
-}
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
-extern simd_double4 _simd_pow_d4(simd_double4 x, simd_double4 y);
-static inline SIMD_CFUNC simd_double4 __tg_pow(simd_double4 x, simd_double4 y) {
-  return _simd_pow_d4(x, y);
-}
-#else
-static inline SIMD_CFUNC simd_double4 __tg_pow(simd_double4 x, simd_double4 y) {
-  return simd_make_double4(__tg_pow(x.lo, y.lo), __tg_pow(x.hi, y.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
-extern simd_double8 _simd_pow_d8(simd_double8 x, simd_double8 y);
-static inline SIMD_CFUNC simd_double8 __tg_pow(simd_double8 x, simd_double8 y) {
-  return _simd_pow_d8(x, y);
-}
-#else
-static inline SIMD_CFUNC simd_double8 __tg_pow(simd_double8 x, simd_double8 y) {
-  return simd_make_double8(__tg_pow(x.lo, y.lo), __tg_pow(x.hi, y.hi));
-}
-#endif
-
-#pragma mark - fmod implementation
-static inline SIMD_CFUNC simd_float2 __tg_fmod(simd_float2 x, simd_float2 y) {
-  return simd_make_float2(__tg_fmod(simd_make_float4(x), simd_make_float4(y)));
-}
-
-static inline SIMD_CFUNC simd_float3 __tg_fmod(simd_float3 x, simd_float3 y) {
-  return simd_make_float3(__tg_fmod(simd_make_float4(x), simd_make_float4(y)));
-}
-
-#if SIMD_LIBRARY_VERSION >= 3
-extern simd_float4 _simd_fmod_f4(simd_float4 x, simd_float4 y);
-static inline SIMD_CFUNC simd_float4 __tg_fmod(simd_float4 x, simd_float4 y) {
-  return _simd_fmod_f4(x, y);
-}
-#else
-static inline SIMD_CFUNC simd_float4 __tg_fmod(simd_float4 x, simd_float4 y) {
-  return simd_make_float4(fmod(x.x, y.x), fmod(x.y, y.y), fmod(x.z, y.z), fmod(x.w, y.w));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
-extern simd_float8 _simd_fmod_f8(simd_float8 x, simd_float8 y);
-static inline SIMD_CFUNC simd_float8 __tg_fmod(simd_float8 x, simd_float8 y) {
-  return _simd_fmod_f8(x, y);
-}
-#else
-static inline SIMD_CFUNC simd_float8 __tg_fmod(simd_float8 x, simd_float8 y) {
-  return simd_make_float8(__tg_fmod(x.lo, y.lo), __tg_fmod(x.hi, y.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
-extern simd_float16 _simd_fmod_f16(simd_float16 x, simd_float16 y);
-static inline SIMD_CFUNC simd_float16 __tg_fmod(simd_float16 x, simd_float16 y) {
-  return _simd_fmod_f16(x, y);
-}
-#else
-static inline SIMD_CFUNC simd_float16 __tg_fmod(simd_float16 x, simd_float16 y) {
-  return simd_make_float16(__tg_fmod(x.lo, y.lo), __tg_fmod(x.hi, y.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3
-extern simd_double2 _simd_fmod_d2(simd_double2 x, simd_double2 y);
-static inline SIMD_CFUNC simd_double2 __tg_fmod(simd_double2 x, simd_double2 y) {
-  return _simd_fmod_d2(x, y);
-}
-#else
-static inline SIMD_CFUNC simd_double2 __tg_fmod(simd_double2 x, simd_double2 y) {
-  return simd_make_double2(fmod(x.x, y.x), fmod(x.y, y.y));
-}
-#endif
-
-static inline SIMD_CFUNC simd_double3 __tg_fmod(simd_double3 x, simd_double3 y) {
-  return simd_make_double3(__tg_fmod(simd_make_double4(x), simd_make_double4(y)));
-}
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
-extern simd_double4 _simd_fmod_d4(simd_double4 x, simd_double4 y);
-static inline SIMD_CFUNC simd_double4 __tg_fmod(simd_double4 x, simd_double4 y) {
-  return _simd_fmod_d4(x, y);
-}
-#else
-static inline SIMD_CFUNC simd_double4 __tg_fmod(simd_double4 x, simd_double4 y) {
-  return simd_make_double4(__tg_fmod(x.lo, y.lo), __tg_fmod(x.hi, y.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
-extern simd_double8 _simd_fmod_d8(simd_double8 x, simd_double8 y);
-static inline SIMD_CFUNC simd_double8 __tg_fmod(simd_double8 x, simd_double8 y) {
-  return _simd_fmod_d8(x, y);
-}
-#else
-static inline SIMD_CFUNC simd_double8 __tg_fmod(simd_double8 x, simd_double8 y) {
-  return simd_make_double8(__tg_fmod(x.lo, y.lo), __tg_fmod(x.hi, y.hi));
-}
-#endif
-
-#pragma mark - remainder implementation
-static inline SIMD_CFUNC simd_float2 __tg_remainder(simd_float2 x, simd_float2 y) {
-  return simd_make_float2(__tg_remainder(simd_make_float4(x), simd_make_float4(y)));
-}
-
-static inline SIMD_CFUNC simd_float3 __tg_remainder(simd_float3 x, simd_float3 y) {
-  return simd_make_float3(__tg_remainder(simd_make_float4(x), simd_make_float4(y)));
-}
-
-#if SIMD_LIBRARY_VERSION >= 3
-extern simd_float4 _simd_remainder_f4(simd_float4 x, simd_float4 y);
-static inline SIMD_CFUNC simd_float4 __tg_remainder(simd_float4 x, simd_float4 y) {
-  return _simd_remainder_f4(x, y);
-}
-#else
-static inline SIMD_CFUNC simd_float4 __tg_remainder(simd_float4 x, simd_float4 y) {
-  return simd_make_float4(remainder(x.x, y.x), remainder(x.y, y.y), remainder(x.z, y.z), remainder(x.w, y.w));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
-extern simd_float8 _simd_remainder_f8(simd_float8 x, simd_float8 y);
-static inline SIMD_CFUNC simd_float8 __tg_remainder(simd_float8 x, simd_float8 y) {
-  return _simd_remainder_f8(x, y);
-}
-#else
-static inline SIMD_CFUNC simd_float8 __tg_remainder(simd_float8 x, simd_float8 y) {
-  return simd_make_float8(__tg_remainder(x.lo, y.lo), __tg_remainder(x.hi, y.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
-extern simd_float16 _simd_remainder_f16(simd_float16 x, simd_float16 y);
-static inline SIMD_CFUNC simd_float16 __tg_remainder(simd_float16 x, simd_float16 y) {
-  return _simd_remainder_f16(x, y);
-}
-#else
-static inline SIMD_CFUNC simd_float16 __tg_remainder(simd_float16 x, simd_float16 y) {
-  return simd_make_float16(__tg_remainder(x.lo, y.lo), __tg_remainder(x.hi, y.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3
-extern simd_double2 _simd_remainder_d2(simd_double2 x, simd_double2 y);
-static inline SIMD_CFUNC simd_double2 __tg_remainder(simd_double2 x, simd_double2 y) {
-  return _simd_remainder_d2(x, y);
-}
-#else
-static inline SIMD_CFUNC simd_double2 __tg_remainder(simd_double2 x, simd_double2 y) {
-  return simd_make_double2(remainder(x.x, y.x), remainder(x.y, y.y));
-}
-#endif
-
-static inline SIMD_CFUNC simd_double3 __tg_remainder(simd_double3 x, simd_double3 y) {
-  return simd_make_double3(__tg_remainder(simd_make_double4(x), simd_make_double4(y)));
-}
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
-extern simd_double4 _simd_remainder_d4(simd_double4 x, simd_double4 y);
-static inline SIMD_CFUNC simd_double4 __tg_remainder(simd_double4 x, simd_double4 y) {
-  return _simd_remainder_d4(x, y);
-}
-#else
-static inline SIMD_CFUNC simd_double4 __tg_remainder(simd_double4 x, simd_double4 y) {
-  return simd_make_double4(__tg_remainder(x.lo, y.lo), __tg_remainder(x.hi, y.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
-extern simd_double8 _simd_remainder_d8(simd_double8 x, simd_double8 y);
-static inline SIMD_CFUNC simd_double8 __tg_remainder(simd_double8 x, simd_double8 y) {
-  return _simd_remainder_d8(x, y);
-}
-#else
-static inline SIMD_CFUNC simd_double8 __tg_remainder(simd_double8 x, simd_double8 y) {
-  return simd_make_double8(__tg_remainder(x.lo, y.lo), __tg_remainder(x.hi, y.hi));
-}
-#endif
-
-#pragma mark - nextafter implementation
-static inline SIMD_CFUNC simd_float2 __tg_nextafter(simd_float2 x, simd_float2 y) {
-  return simd_make_float2(__tg_nextafter(simd_make_float4(x), simd_make_float4(y)));
-}
-
-static inline SIMD_CFUNC simd_float3 __tg_nextafter(simd_float3 x, simd_float3 y) {
-  return simd_make_float3(__tg_nextafter(simd_make_float4(x), simd_make_float4(y)));
-}
-
-#if SIMD_LIBRARY_VERSION >= 3
-extern simd_float4 _simd_nextafter_f4(simd_float4 x, simd_float4 y);
-static inline SIMD_CFUNC simd_float4 __tg_nextafter(simd_float4 x, simd_float4 y) {
-  return _simd_nextafter_f4(x, y);
-}
-#else
-static inline SIMD_CFUNC simd_float4 __tg_nextafter(simd_float4 x, simd_float4 y) {
-  return simd_make_float4(nextafter(x.x, y.x), nextafter(x.y, y.y), nextafter(x.z, y.z), nextafter(x.w, y.w));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
-extern simd_float8 _simd_nextafter_f8(simd_float8 x, simd_float8 y);
-static inline SIMD_CFUNC simd_float8 __tg_nextafter(simd_float8 x, simd_float8 y) {
-  return _simd_nextafter_f8(x, y);
-}
-#else
-static inline SIMD_CFUNC simd_float8 __tg_nextafter(simd_float8 x, simd_float8 y) {
-  return simd_make_float8(__tg_nextafter(x.lo, y.lo), __tg_nextafter(x.hi, y.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
-extern simd_float16 _simd_nextafter_f16(simd_float16 x, simd_float16 y);
-static inline SIMD_CFUNC simd_float16 __tg_nextafter(simd_float16 x, simd_float16 y) {
-  return _simd_nextafter_f16(x, y);
-}
-#else
-static inline SIMD_CFUNC simd_float16 __tg_nextafter(simd_float16 x, simd_float16 y) {
-  return simd_make_float16(__tg_nextafter(x.lo, y.lo), __tg_nextafter(x.hi, y.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3
-extern simd_double2 _simd_nextafter_d2(simd_double2 x, simd_double2 y);
-static inline SIMD_CFUNC simd_double2 __tg_nextafter(simd_double2 x, simd_double2 y) {
-  return _simd_nextafter_d2(x, y);
-}
-#else
-static inline SIMD_CFUNC simd_double2 __tg_nextafter(simd_double2 x, simd_double2 y) {
-  return simd_make_double2(nextafter(x.x, y.x), nextafter(x.y, y.y));
-}
-#endif
-
-static inline SIMD_CFUNC simd_double3 __tg_nextafter(simd_double3 x, simd_double3 y) {
-  return simd_make_double3(__tg_nextafter(simd_make_double4(x), simd_make_double4(y)));
-}
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
-extern simd_double4 _simd_nextafter_d4(simd_double4 x, simd_double4 y);
-static inline SIMD_CFUNC simd_double4 __tg_nextafter(simd_double4 x, simd_double4 y) {
-  return _simd_nextafter_d4(x, y);
-}
-#else
-static inline SIMD_CFUNC simd_double4 __tg_nextafter(simd_double4 x, simd_double4 y) {
-  return simd_make_double4(__tg_nextafter(x.lo, y.lo), __tg_nextafter(x.hi, y.hi));
-}
-#endif
-
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
-extern simd_double8 _simd_nextafter_d8(simd_double8 x, simd_double8 y);
-static inline SIMD_CFUNC simd_double8 __tg_nextafter(simd_double8 x, simd_double8 y) {
-  return _simd_nextafter_d8(x, y);
-}
-#else
-static inline SIMD_CFUNC simd_double8 __tg_nextafter(simd_double8 x, simd_double8 y) {
-  return simd_make_double8(__tg_nextafter(x.lo, y.lo), __tg_nextafter(x.hi, y.hi));
-}
-#endif
-
-static inline SIMD_CFUNC simd_float2 __tg_fdim(simd_float2 x, simd_float2 y) { return simd_bitselect(x-y, 0, x<y); }
-static inline SIMD_CFUNC simd_float3 __tg_fdim(simd_float3 x, simd_float3 y) { return simd_bitselect(x-y, 0, x<y); }
-static inline SIMD_CFUNC simd_float4 __tg_fdim(simd_float4 x, simd_float4 y) { return simd_bitselect(x-y, 0, x<y); }
-static inline SIMD_CFUNC simd_float8 __tg_fdim(simd_float8 x, simd_float8 y) { return simd_bitselect(x-y, 0, x<y); }
-static inline SIMD_CFUNC simd_float16 __tg_fdim(simd_float16 x, simd_float16 y) { return simd_bitselect(x-y, 0, x<y); }
-static inline SIMD_CFUNC simd_double2 __tg_fdim(simd_double2 x, simd_double2 y) { return simd_bitselect(x-y, 0, x<y); }
-static inline SIMD_CFUNC simd_double3 __tg_fdim(simd_double3 x, simd_double3 y) { return simd_bitselect(x-y, 0, x<y); }
-static inline SIMD_CFUNC simd_double4 __tg_fdim(simd_double4 x, simd_double4 y) { return simd_bitselect(x-y, 0, x<y); }
-static inline SIMD_CFUNC simd_double8 __tg_fdim(simd_double8 x, simd_double8 y) { return simd_bitselect(x-y, 0, x<y); }
- 
-static inline SIMD_CFUNC simd_float2 __tg_fma(simd_float2 x, simd_float2 y, simd_float2 z) {
-#if defined __arm64__ || defined __ARM_VFPV4__
-  return vfma_f32(z, x, y);
-#else
-  return simd_make_float2(__tg_fma(simd_make_float4_undef(x), simd_make_float4_undef(y), simd_make_float4_undef(z)));
-#endif
-}
-
-static inline SIMD_CFUNC simd_float3 __tg_fma(simd_float3 x, simd_float3 y, simd_float3 z) {
-  return simd_make_float3(__tg_fma(simd_make_float4(x), simd_make_float4(y), simd_make_float4(z)));
-}
-
-#if SIMD_LIBRARY_VERSION >= 3
-extern simd_float4 _simd_fma_f4(simd_float4 x, simd_float4 y, simd_float4 z);
-#endif
-static inline SIMD_CFUNC simd_float4 __tg_fma(simd_float4 x, simd_float4 y, simd_float4 z) {
-#if defined __arm64__ || defined __ARM_VFPV4__
-  return vfmaq_f32(z, x, y);
-#elif (defined __i386__ || defined __x86_64__) && defined __FMA__
-  return _mm_fmadd_ps(x, y, z);
-#elif SIMD_LIBRARY_VERSION >= 3
-  return _simd_fma_f4(x, y, z);
-#else
-  return simd_make_float4(fma(x.x, y.x, z.x), fma(x.y, y.y, z.y), fma(x.z, y.z, z.z), fma(x.w, y.w, z.w));
-#endif
-}
-
-static inline SIMD_CFUNC simd_float8 __tg_fma(simd_float8 x, simd_float8 y, simd_float8 z) {
-#if (defined __i386__ || defined __x86_64__) && defined __FMA__
-  return _mm256_fmadd_ps(x, y, z);
-#else
-  return simd_make_float8(__tg_fma(x.lo, y.lo, z.lo), __tg_fma(x.hi, y.hi, z.hi));
-#endif
-}
-
-static inline SIMD_CFUNC simd_float16 __tg_fma(simd_float16 x, simd_float16 y, simd_float16 z) {
-#if defined __AVX512F__
-  return _mm512_fmadd_ps(x, y, z);
-#else
-  return simd_make_float16(__tg_fma(x.lo, y.lo, z.lo), __tg_fma(x.hi, y.hi, z.hi));
-#endif
-}
-
-#if SIMD_LIBRARY_VERSION >= 3
-extern simd_double2 _simd_fma_d2(simd_double2 x, simd_double2 y, simd_double2 z);
-#endif
-static inline SIMD_CFUNC simd_double2 __tg_fma(simd_double2 x, simd_double2 y, simd_double2 z) {
-#if defined __arm64__
-  return vfmaq_f64(z, x, y);
-#elif (defined __i386__ || defined __x86_64__) && defined __FMA__
-  return _mm_fmadd_pd(x, y, z);
-#elif SIMD_LIBRARY_VERSION >= 3
-  return _simd_fma_d2(x, y, z);
-#else
-  return simd_make_double2(fma(x.x, y.x, z.x), fma(x.y, y.y, z.y));
-#endif
-}
-
-static inline SIMD_CFUNC simd_double3 __tg_fma(simd_double3 x, simd_double3 y, simd_double3 z) {
-  return simd_make_double3(__tg_fma(simd_make_double4(x), simd_make_double4(y), simd_make_double4(z)));
-}
-
-static inline SIMD_CFUNC simd_double4 __tg_fma(simd_double4 x, simd_double4 y, simd_double4 z) {
-#if (defined __i386__ || defined __x86_64__) && defined __FMA__
-  return _mm256_fmadd_pd(x, y, z);
-#else
-  return simd_make_double4(__tg_fma(x.lo, y.lo, z.lo), __tg_fma(x.hi, y.hi, z.hi));
-#endif
-}
-
-static inline SIMD_CFUNC simd_double8 __tg_fma(simd_double8 x, simd_double8 y, simd_double8 z) {
-#if defined __AVX512F__
-  return _mm512_fmadd_pd(x, y, z);
-#else
-  return simd_make_double8(__tg_fma(x.lo, y.lo, z.lo), __tg_fma(x.hi, y.hi, z.hi));
-#endif
-}
-
-static inline SIMD_CFUNC float simd_muladd(float x, float y, float z) {
-#pragma STDC FP_CONTRACT ON
-  return x*y + z;
-}
-static inline SIMD_CFUNC simd_float2 simd_muladd(simd_float2 x, simd_float2 y, simd_float2 z) {
-#pragma STDC FP_CONTRACT ON
-  return x*y + z;
-}
-static inline SIMD_CFUNC simd_float3 simd_muladd(simd_float3 x, simd_float3 y, simd_float3 z) {
-#pragma STDC FP_CONTRACT ON
-  return x*y + z;
-}
-static inline SIMD_CFUNC simd_float4 simd_muladd(simd_float4 x, simd_float4 y, simd_float4 z) {
-#pragma STDC FP_CONTRACT ON
-  return x*y + z;
-}
-static inline SIMD_CFUNC simd_float8 simd_muladd(simd_float8 x, simd_float8 y, simd_float8 z) {
-#pragma STDC FP_CONTRACT ON
-  return x*y + z;
-}
-static inline SIMD_CFUNC simd_float16 simd_muladd(simd_float16 x, simd_float16 y, simd_float16 z) {
-#pragma STDC FP_CONTRACT ON
-  return x*y + z;
-}
-static inline SIMD_CFUNC double simd_muladd(double x, double y, double z) {
-#pragma STDC FP_CONTRACT ON
-  return x*y + z;
-}
-static inline SIMD_CFUNC simd_double2 simd_muladd(simd_double2 x, simd_double2 y, simd_double2 z) {
-#pragma STDC FP_CONTRACT ON
-  return x*y + z;
-}
-static inline SIMD_CFUNC simd_double3 simd_muladd(simd_double3 x, simd_double3 y, simd_double3 z) {
-#pragma STDC FP_CONTRACT ON
-  return x*y + z;
-}
-static inline SIMD_CFUNC simd_double4 simd_muladd(simd_double4 x, simd_double4 y, simd_double4 z) {
-#pragma STDC FP_CONTRACT ON
-  return x*y + z;
-}
-static inline SIMD_CFUNC simd_double8 simd_muladd(simd_double8 x, simd_double8 y, simd_double8 z) {
-#pragma STDC FP_CONTRACT ON
-  return x*y + z;
-}
-#ifdef __cplusplus
-}      /* extern "C" */
-#endif
-#endif /* SIMD_COMPILER_HAS_REQUIRED_FEATURES */
-#endif /* SIMD_MATH_HEADER */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/simd/packed.h b/lib/libc/include/x86_64-macos-gnu/simd/packed.h
deleted file mode 100644
index dfdc199999..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/simd/packed.h
+++ /dev/null
@@ -1,1031 +0,0 @@
-/*! @header
- *  This header defines fixed size vector types with relaxed alignment. For 
- *  each vector type defined by <simd/vector_types.h> that is not a 1- or 3-
- *  element vector, there is a corresponding type defined by this header that
- *  requires only the alignment matching that of the underlying scalar type.
- *
- *  These types should be used to access buffers that may not be sufficiently
- *  aligned to allow them to be accessed using the "normal" simd vector types.
- *  As an example of this usage, suppose that you want to load a vector of
- *  four floats from an array of floats. The type simd_float4 has sixteen byte
- *  alignment, whereas an array of floats has only four byte alignment.
- *  Thus, naively casting a pointer into the array to (simd_float4 *) would 
- *  invoke undefined behavior, and likely produce an alignment fault at
- *  runtime. Instead, use the corresponding packed type to load from the array:
- *
- *  <pre>
- *  @textblock
- *  simd_float4 vector = *(packed_simd_float4 *)&array[i];
- *  // do something with vector ...
- *  @/textblock
- *  </pre>
- *
- *  It's important to note that the packed_ types are only needed to work with
- *  memory; once the data is loaded, we simply operate on it as usual using
- *  the simd_float4 type, as illustrated above.
- *
- *  @copyright 2014-2017 Apple, Inc. All rights reserved.
- *  @unsorted                                                                 */
-
-#ifndef SIMD_PACKED_TYPES
-#define SIMD_PACKED_TYPES
-
-# include <simd/vector_types.h>
-# if SIMD_COMPILER_HAS_REQUIRED_FEATURES
-/*! @abstract A vector of two 8-bit signed (twos-complement) integers with
- *  relaxed alignment.
- *  @description In C++ and Metal, this type is also available as
- *  simd::packed_char2. The alignment of this type is that of the underlying
- *  scalar element type, so you can use it to load or store from an array of
- *  that type.                                                                */
-typedef __attribute__((__ext_vector_type__(2),__aligned__(1))) char simd_packed_char2;
-
-/*! @abstract A vector of four 8-bit signed (twos-complement) integers with
- *  relaxed alignment.
- *  @description In C++ and Metal, this type is also available as
- *  simd::packed_char4. The alignment of this type is that of the underlying
- *  scalar element type, so you can use it to load or store from an array of
- *  that type.                                                                */
-typedef __attribute__((__ext_vector_type__(4),__aligned__(1))) char simd_packed_char4;
-
-/*! @abstract A vector of eight 8-bit signed (twos-complement) integers with
- *  relaxed alignment.
- *  @description In C++ this type is also available as simd::packed_char8.
- *  This type is not available in Metal. The alignment of this type is only
- *  that of the underlying scalar element type, so you can use it to load or
- *  store from an array of that type.                                         */
-typedef __attribute__((__ext_vector_type__(8),__aligned__(1))) char simd_packed_char8;
-
-/*! @abstract A vector of sixteen 8-bit signed (twos-complement) integers
- *  with relaxed alignment.
- *  @description In C++ this type is also available as simd::packed_char16.
- *  This type is not available in Metal. The alignment of this type is only
- *  that of the underlying scalar element type, so you can use it to load or
- *  store from an array of that type.                                         */
-typedef __attribute__((__ext_vector_type__(16),__aligned__(1))) char simd_packed_char16;
-
-/*! @abstract A vector of thirty-two 8-bit signed (twos-complement) integers
- *  with relaxed alignment.
- *  @description In C++ this type is also available as simd::packed_char32.
- *  This type is not available in Metal. The alignment of this type is only
- *  that of the underlying scalar element type, so you can use it to load or
- *  store from an array of that type.                                         */
-typedef __attribute__((__ext_vector_type__(32),__aligned__(1))) char simd_packed_char32;
-
-/*! @abstract A vector of sixty-four 8-bit signed (twos-complement) integers
- *  with relaxed alignment.
- *  @description In C++ this type is also available as simd::packed_char64.
- *  This type is not available in Metal. The alignment of this type is only
- *  that of the underlying scalar element type, so you can use it to load or
- *  store from an array of that type.                                         */
-typedef __attribute__((__ext_vector_type__(64),__aligned__(1))) char simd_packed_char64;
-
-/*! @abstract A vector of two 8-bit unsigned integers with relaxed
- *  alignment.
- *  @description In C++ and Metal, this type is also available as
- *  simd::packed_uchar2. The alignment of this type is that of the
- *  underlying scalar element type, so you can use it to load or store from
- *  an array of that type.                                                    */
-typedef __attribute__((__ext_vector_type__(2),__aligned__(1))) unsigned char simd_packed_uchar2;
-
-/*! @abstract A vector of four 8-bit unsigned integers with relaxed
- *  alignment.
- *  @description In C++ and Metal, this type is also available as
- *  simd::packed_uchar4. The alignment of this type is that of the
- *  underlying scalar element type, so you can use it to load or store from
- *  an array of that type.                                                    */
-typedef __attribute__((__ext_vector_type__(4),__aligned__(1))) unsigned char simd_packed_uchar4;
-
-/*! @abstract A vector of eight 8-bit unsigned integers with relaxed
- *  alignment.
- *  @description In C++ this type is also available as simd::packed_uchar8.
- *  This type is not available in Metal. The alignment of this type is only
- *  that of the underlying scalar element type, so you can use it to load or
- *  store from an array of that type.                                         */
-typedef __attribute__((__ext_vector_type__(8),__aligned__(1))) unsigned char simd_packed_uchar8;
-
-/*! @abstract A vector of sixteen 8-bit unsigned integers with relaxed
- *  alignment.
- *  @description In C++ this type is also available as simd::packed_uchar16.
- *  This type is not available in Metal. The alignment of this type is only
- *  that of the underlying scalar element type, so you can use it to load or
- *  store from an array of that type.                                         */
-typedef __attribute__((__ext_vector_type__(16),__aligned__(1))) unsigned char simd_packed_uchar16;
-
-/*! @abstract A vector of thirty-two 8-bit unsigned integers with relaxed
- *  alignment.
- *  @description In C++ this type is also available as simd::packed_uchar32.
- *  This type is not available in Metal. The alignment of this type is only
- *  that of the underlying scalar element type, so you can use it to load or
- *  store from an array of that type.                                         */
-typedef __attribute__((__ext_vector_type__(32),__aligned__(1))) unsigned char simd_packed_uchar32;
-
-/*! @abstract A vector of sixty-four 8-bit unsigned integers with relaxed
- *  alignment.
- *  @description In C++ this type is also available as simd::packed_uchar64.
- *  This type is not available in Metal. The alignment of this type is only
- *  that of the underlying scalar element type, so you can use it to load or
- *  store from an array of that type.                                         */
-typedef __attribute__((__ext_vector_type__(64),__aligned__(1))) unsigned char simd_packed_uchar64;
-
-/*! @abstract A vector of two 16-bit signed (twos-complement) integers with
- *  relaxed alignment.
- *  @description In C++ and Metal, this type is also available as
- *  simd::packed_short2. The alignment of this type is that of the
- *  underlying scalar element type, so you can use it to load or store from
- *  an array of that type.                                                    */
-typedef __attribute__((__ext_vector_type__(2),__aligned__(2))) short simd_packed_short2;
-
-/*! @abstract A vector of four 16-bit signed (twos-complement) integers with
- *  relaxed alignment.
- *  @description In C++ and Metal, this type is also available as
- *  simd::packed_short4. The alignment of this type is that of the
- *  underlying scalar element type, so you can use it to load or store from
- *  an array of that type.                                                    */
-typedef __attribute__((__ext_vector_type__(4),__aligned__(2))) short simd_packed_short4;
-
-/*! @abstract A vector of eight 16-bit signed (twos-complement) integers
- *  with relaxed alignment.
- *  @description In C++ this type is also available as simd::packed_short8.
- *  This type is not available in Metal. The alignment of this type is only
- *  that of the underlying scalar element type, so you can use it to load or
- *  store from an array of that type.                                         */
-typedef __attribute__((__ext_vector_type__(8),__aligned__(2))) short simd_packed_short8;
-
-/*! @abstract A vector of sixteen 16-bit signed (twos-complement) integers
- *  with relaxed alignment.
- *  @description In C++ this type is also available as simd::packed_short16.
- *  This type is not available in Metal. The alignment of this type is only
- *  that of the underlying scalar element type, so you can use it to load or
- *  store from an array of that type.                                         */
-typedef __attribute__((__ext_vector_type__(16),__aligned__(2))) short simd_packed_short16;
-
-/*! @abstract A vector of thirty-two 16-bit signed (twos-complement)
- *  integers with relaxed alignment.
- *  @description In C++ this type is also available as simd::packed_short32.
- *  This type is not available in Metal. The alignment of this type is only
- *  that of the underlying scalar element type, so you can use it to load or
- *  store from an array of that type.                                         */
-typedef __attribute__((__ext_vector_type__(32),__aligned__(2))) short simd_packed_short32;
-
-/*! @abstract A vector of two 16-bit unsigned integers with relaxed
- *  alignment.
- *  @description In C++ and Metal, this type is also available as
- *  simd::packed_ushort2. The alignment of this type is that of the
- *  underlying scalar element type, so you can use it to load or store from
- *  an array of that type.                                                    */
-typedef __attribute__((__ext_vector_type__(2),__aligned__(2))) unsigned short simd_packed_ushort2;
-
-/*! @abstract A vector of four 16-bit unsigned integers with relaxed
- *  alignment.
- *  @description In C++ and Metal, this type is also available as
- *  simd::packed_ushort4. The alignment of this type is that of the
- *  underlying scalar element type, so you can use it to load or store from
- *  an array of that type.                                                    */
-typedef __attribute__((__ext_vector_type__(4),__aligned__(2))) unsigned short simd_packed_ushort4;
-
-/*! @abstract A vector of eight 16-bit unsigned integers with relaxed
- *  alignment.
- *  @description In C++ this type is also available as simd::packed_ushort8.
- *  This type is not available in Metal. The alignment of this type is only
- *  that of the underlying scalar element type, so you can use it to load or
- *  store from an array of that type.                                         */
-typedef __attribute__((__ext_vector_type__(8),__aligned__(2))) unsigned short simd_packed_ushort8;
-
-/*! @abstract A vector of sixteen 16-bit unsigned integers with relaxed
- *  alignment.
- *  @description In C++ this type is also available as
- *  simd::packed_ushort16. This type is not available in Metal. The
- *  alignment of this type is only that of the underlying scalar element
- *  type, so you can use it to load or store from an array of that type.      */
-typedef __attribute__((__ext_vector_type__(16),__aligned__(2))) unsigned short simd_packed_ushort16;
-
-/*! @abstract A vector of thirty-two 16-bit unsigned integers with relaxed
- *  alignment.
- *  @description In C++ this type is also available as
- *  simd::packed_ushort32. This type is not available in Metal. The
- *  alignment of this type is only that of the underlying scalar element
- *  type, so you can use it to load or store from an array of that type.      */
-typedef __attribute__((__ext_vector_type__(32),__aligned__(2))) unsigned short simd_packed_ushort32;
-
-/*! @abstract A vector of two 32-bit signed (twos-complement) integers with
- *  relaxed alignment.
- *  @description In C++ and Metal, this type is also available as
- *  simd::packed_int2. The alignment of this type is that of the underlying
- *  scalar element type, so you can use it to load or store from an array of
- *  that type.                                                                */
-typedef __attribute__((__ext_vector_type__(2),__aligned__(4))) int simd_packed_int2;
-
-/*! @abstract A vector of four 32-bit signed (twos-complement) integers with
- *  relaxed alignment.
- *  @description In C++ and Metal, this type is also available as
- *  simd::packed_int4. The alignment of this type is that of the underlying
- *  scalar element type, so you can use it to load or store from an array of
- *  that type.                                                                */
-typedef __attribute__((__ext_vector_type__(4),__aligned__(4))) int simd_packed_int4;
-
-/*! @abstract A vector of eight 32-bit signed (twos-complement) integers
- *  with relaxed alignment.
- *  @description In C++ this type is also available as simd::packed_int8.
- *  This type is not available in Metal. The alignment of this type is only
- *  that of the underlying scalar element type, so you can use it to load or
- *  store from an array of that type.                                         */
-typedef __attribute__((__ext_vector_type__(8),__aligned__(4))) int simd_packed_int8;
-
-/*! @abstract A vector of sixteen 32-bit signed (twos-complement) integers
- *  with relaxed alignment.
- *  @description In C++ this type is also available as simd::packed_int16.
- *  This type is not available in Metal. The alignment of this type is only
- *  that of the underlying scalar element type, so you can use it to load or
- *  store from an array of that type.                                         */
-typedef __attribute__((__ext_vector_type__(16),__aligned__(4))) int simd_packed_int16;
-
-/*! @abstract A vector of two 32-bit unsigned integers with relaxed
- *  alignment.
- *  @description In C++ and Metal, this type is also available as
- *  simd::packed_uint2. The alignment of this type is that of the underlying
- *  scalar element type, so you can use it to load or store from an array of
- *  that type.                                                                */
-typedef __attribute__((__ext_vector_type__(2),__aligned__(4))) unsigned int simd_packed_uint2;
-
-/*! @abstract A vector of four 32-bit unsigned integers with relaxed
- *  alignment.
- *  @description In C++ and Metal, this type is also available as
- *  simd::packed_uint4. The alignment of this type is that of the underlying
- *  scalar element type, so you can use it to load or store from an array of
- *  that type.                                                                */
-typedef __attribute__((__ext_vector_type__(4),__aligned__(4))) unsigned int simd_packed_uint4;
-
-/*! @abstract A vector of eight 32-bit unsigned integers with relaxed
- *  alignment.
- *  @description In C++ this type is also available as simd::packed_uint8.
- *  This type is not available in Metal. The alignment of this type is only
- *  that of the underlying scalar element type, so you can use it to load or
- *  store from an array of that type.                                         */
-typedef __attribute__((__ext_vector_type__(8),__aligned__(4))) unsigned int simd_packed_uint8;
-
-/*! @abstract A vector of sixteen 32-bit unsigned integers with relaxed
- *  alignment.
- *  @description In C++ this type is also available as simd::packed_uint16.
- *  This type is not available in Metal. The alignment of this type is only
- *  that of the underlying scalar element type, so you can use it to load or
- *  store from an array of that type.                                         */
-typedef __attribute__((__ext_vector_type__(16),__aligned__(4))) unsigned int simd_packed_uint16;
-
-/*! @abstract A vector of two 32-bit floating-point numbers with relaxed
- *  alignment.
- *  @description In C++ and Metal, this type is also available as
- *  simd::packed_float2. The alignment of this type is that of the
- *  underlying scalar element type, so you can use it to load or store from
- *  an array of that type.                                                    */
-typedef __attribute__((__ext_vector_type__(2),__aligned__(4))) float simd_packed_float2;
-
-/*! @abstract A vector of four 32-bit floating-point numbers with relaxed
- *  alignment.
- *  @description In C++ and Metal, this type is also available as
- *  simd::packed_float4. The alignment of this type is that of the
- *  underlying scalar element type, so you can use it to load or store from
- *  an array of that type.                                                    */
-typedef __attribute__((__ext_vector_type__(4),__aligned__(4))) float simd_packed_float4;
-
-/*! @abstract A vector of eight 32-bit floating-point numbers with relaxed
- *  alignment.
- *  @description In C++ this type is also available as simd::packed_float8.
- *  This type is not available in Metal. The alignment of this type is only
- *  that of the underlying scalar element type, so you can use it to load or
- *  store from an array of that type.                                         */
-typedef __attribute__((__ext_vector_type__(8),__aligned__(4))) float simd_packed_float8;
-
-/*! @abstract A vector of sixteen 32-bit floating-point numbers with relaxed
- *  alignment.
- *  @description In C++ this type is also available as simd::packed_float16.
- *  This type is not available in Metal. The alignment of this type is only
- *  that of the underlying scalar element type, so you can use it to load or
- *  store from an array of that type.                                         */
-typedef __attribute__((__ext_vector_type__(16),__aligned__(4))) float simd_packed_float16;
-
-/*! @abstract A vector of two 64-bit signed (twos-complement) integers with
- *  relaxed alignment.
- *  @description In C++ and Metal, this type is also available as
- *  simd::packed_long2. The alignment of this type is that of the underlying
- *  scalar element type, so you can use it to load or store from an array of
- *  that type.                                                                */
-#if defined __LP64__
-typedef __attribute__((__ext_vector_type__(2),__aligned__(8))) simd_long1 simd_packed_long2;
-#else
-typedef __attribute__((__ext_vector_type__(2),__aligned__(4))) simd_long1 simd_packed_long2;
-#endif
-
-/*! @abstract A vector of four 64-bit signed (twos-complement) integers with
- *  relaxed alignment.
- *  @description In C++ and Metal, this type is also available as
- *  simd::packed_long4. The alignment of this type is that of the underlying
- *  scalar element type, so you can use it to load or store from an array of
- *  that type.                                                                */
-#if defined __LP64__
-typedef __attribute__((__ext_vector_type__(4),__aligned__(8))) simd_long1 simd_packed_long4;
-#else
-typedef __attribute__((__ext_vector_type__(4),__aligned__(4))) simd_long1 simd_packed_long4;
-#endif
-
-/*! @abstract A vector of eight 64-bit signed (twos-complement) integers
- *  with relaxed alignment.
- *  @description In C++ this type is also available as simd::packed_long8.
- *  This type is not available in Metal. The alignment of this type is only
- *  that of the underlying scalar element type, so you can use it to load or
- *  store from an array of that type.                                         */
-#if defined __LP64__
-typedef __attribute__((__ext_vector_type__(8),__aligned__(8))) simd_long1 simd_packed_long8;
-#else
-typedef __attribute__((__ext_vector_type__(8),__aligned__(4))) simd_long1 simd_packed_long8;
-#endif
-
-/*! @abstract A vector of two 64-bit unsigned integers with relaxed
- *  alignment.
- *  @description In C++ and Metal, this type is also available as
- *  simd::packed_ulong2. The alignment of this type is that of the
- *  underlying scalar element type, so you can use it to load or store from
- *  an array of that type.                                                    */
-#if defined __LP64__
-typedef __attribute__((__ext_vector_type__(2),__aligned__(8))) simd_ulong1 simd_packed_ulong2;
-#else
-typedef __attribute__((__ext_vector_type__(2),__aligned__(4))) simd_ulong1 simd_packed_ulong2;
-#endif
-
-/*! @abstract A vector of four 64-bit unsigned integers with relaxed
- *  alignment.
- *  @description In C++ and Metal, this type is also available as
- *  simd::packed_ulong4. The alignment of this type is that of the
- *  underlying scalar element type, so you can use it to load or store from
- *  an array of that type.                                                    */
-#if defined __LP64__
-typedef __attribute__((__ext_vector_type__(4),__aligned__(8))) simd_ulong1 simd_packed_ulong4;
-#else
-typedef __attribute__((__ext_vector_type__(4),__aligned__(4))) simd_ulong1 simd_packed_ulong4;
-#endif
-
-/*! @abstract A vector of eight 64-bit unsigned integers with relaxed
- *  alignment.
- *  @description In C++ this type is also available as simd::packed_ulong8.
- *  This type is not available in Metal. The alignment of this type is only
- *  that of the underlying scalar element type, so you can use it to load or
- *  store from an array of that type.                                         */
-#if defined __LP64__
-typedef __attribute__((__ext_vector_type__(8),__aligned__(8))) simd_ulong1 simd_packed_ulong8;
-#else
-typedef __attribute__((__ext_vector_type__(8),__aligned__(4))) simd_ulong1 simd_packed_ulong8;
-#endif
-
-/*! @abstract A vector of two 64-bit floating-point numbers with relaxed
- *  alignment.
- *  @description In C++ and Metal, this type is also available as
- *  simd::packed_double2. The alignment of this type is that of the
- *  underlying scalar element type, so you can use it to load or store from
- *  an array of that type.                                                    */
-#if defined __LP64__
-typedef __attribute__((__ext_vector_type__(2),__aligned__(8))) double simd_packed_double2;
-#else
-typedef __attribute__((__ext_vector_type__(2),__aligned__(4))) double simd_packed_double2;
-#endif
-
-/*! @abstract A vector of four 64-bit floating-point numbers with relaxed
- *  alignment.
- *  @description In C++ and Metal, this type is also available as
- *  simd::packed_double4. The alignment of this type is that of the
- *  underlying scalar element type, so you can use it to load or store from
- *  an array of that type.                                                    */
-#if defined __LP64__
-typedef __attribute__((__ext_vector_type__(4),__aligned__(8))) double simd_packed_double4;
-#else
-typedef __attribute__((__ext_vector_type__(4),__aligned__(4))) double simd_packed_double4;
-#endif
-
-/*! @abstract A vector of eight 64-bit floating-point numbers with relaxed
- *  alignment.
- *  @description In C++ this type is also available as simd::packed_double8.
- *  This type is not available in Metal. The alignment of this type is only
- *  that of the underlying scalar element type, so you can use it to load or
- *  store from an array of that type.                                         */
-#if defined __LP64__
-typedef __attribute__((__ext_vector_type__(8),__aligned__(8))) double simd_packed_double8;
-#else
-typedef __attribute__((__ext_vector_type__(8),__aligned__(4))) double simd_packed_double8;
-#endif
-
-/*  MARK: C++ vector types                                                    */
-#if defined __cplusplus
-namespace simd {
-  namespace packed {
-    /*! @abstract A vector of two 8-bit signed (twos-complement) integers
-     *  with relaxed alignment.
-     *  @description In C or Objective-C, this type is available as
-     *  simd_packed_char2. The alignment of this type is only that of the
-     *  underlying scalar element type, so you can use it to load or store
-     *  from an array of that type.                                           */
-typedef ::simd_packed_char2 char2;
-  
-    /*! @abstract A vector of four 8-bit signed (twos-complement) integers
-     *  with relaxed alignment.
-     *  @description In C or Objective-C, this type is available as
-     *  simd_packed_char4. The alignment of this type is only that of the
-     *  underlying scalar element type, so you can use it to load or store
-     *  from an array of that type.                                           */
-typedef ::simd_packed_char4 char4;
-  
-    /*! @abstract A vector of eight 8-bit signed (twos-complement) integers
-     *  with relaxed alignment.
-     *  @description This type is not available in Metal. In C or
-     *  Objective-C, this type is available as simd_packed_char8. The
-     *  alignment of this type is only that of the underlying scalar element
-     *  type, so you can use it to load or store from an array of that type.  */
-typedef ::simd_packed_char8 char8;
-  
-    /*! @abstract A vector of sixteen 8-bit signed (twos-complement)
-     *  integers with relaxed alignment.
-     *  @description This type is not available in Metal. In C or
-     *  Objective-C, this type is available as simd_packed_char16. The
-     *  alignment of this type is only that of the underlying scalar element
-     *  type, so you can use it to load or store from an array of that type.  */
-typedef ::simd_packed_char16 char16;
-  
-    /*! @abstract A vector of thirty-two 8-bit signed (twos-complement)
-     *  integers with relaxed alignment.
-     *  @description This type is not available in Metal. In C or
-     *  Objective-C, this type is available as simd_packed_char32. The
-     *  alignment of this type is only that of the underlying scalar element
-     *  type, so you can use it to load or store from an array of that type.  */
-typedef ::simd_packed_char32 char32;
-  
-    /*! @abstract A vector of sixty-four 8-bit signed (twos-complement)
-     *  integers with relaxed alignment.
-     *  @description This type is not available in Metal. In C or
-     *  Objective-C, this type is available as simd_packed_char64. The
-     *  alignment of this type is only that of the underlying scalar element
-     *  type, so you can use it to load or store from an array of that type.  */
-typedef ::simd_packed_char64 char64;
-  
-    /*! @abstract A vector of two 8-bit unsigned integers with relaxed
-     *  alignment.
-     *  @description In C or Objective-C, this type is available as
-     *  simd_packed_uchar2. The alignment of this type is only that of the
-     *  underlying scalar element type, so you can use it to load or store
-     *  from an array of that type.                                           */
-typedef ::simd_packed_uchar2 uchar2;
-  
-    /*! @abstract A vector of four 8-bit unsigned integers with relaxed
-     *  alignment.
-     *  @description In C or Objective-C, this type is available as
-     *  simd_packed_uchar4. The alignment of this type is only that of the
-     *  underlying scalar element type, so you can use it to load or store
-     *  from an array of that type.                                           */
-typedef ::simd_packed_uchar4 uchar4;
-  
-    /*! @abstract A vector of eight 8-bit unsigned integers with relaxed
-     *  alignment.
-     *  @description This type is not available in Metal. In C or
-     *  Objective-C, this type is available as simd_packed_uchar8. The
-     *  alignment of this type is only that of the underlying scalar element
-     *  type, so you can use it to load or store from an array of that type.  */
-typedef ::simd_packed_uchar8 uchar8;
-  
-    /*! @abstract A vector of sixteen 8-bit unsigned integers with relaxed
-     *  alignment.
-     *  @description This type is not available in Metal. In C or
-     *  Objective-C, this type is available as simd_packed_uchar16. The
-     *  alignment of this type is only that of the underlying scalar element
-     *  type, so you can use it to load or store from an array of that type.  */
-typedef ::simd_packed_uchar16 uchar16;
-  
-    /*! @abstract A vector of thirty-two 8-bit unsigned integers with
-     *  relaxed alignment.
-     *  @description This type is not available in Metal. In C or
-     *  Objective-C, this type is available as simd_packed_uchar32. The
-     *  alignment of this type is only that of the underlying scalar element
-     *  type, so you can use it to load or store from an array of that type.  */
-typedef ::simd_packed_uchar32 uchar32;
-  
-    /*! @abstract A vector of sixty-four 8-bit unsigned integers with
-     *  relaxed alignment.
-     *  @description This type is not available in Metal. In C or
-     *  Objective-C, this type is available as simd_packed_uchar64. The
-     *  alignment of this type is only that of the underlying scalar element
-     *  type, so you can use it to load or store from an array of that type.  */
-typedef ::simd_packed_uchar64 uchar64;
-  
-    /*! @abstract A vector of two 16-bit signed (twos-complement) integers
-     *  with relaxed alignment.
-     *  @description In C or Objective-C, this type is available as
-     *  simd_packed_short2. The alignment of this type is only that of the
-     *  underlying scalar element type, so you can use it to load or store
-     *  from an array of that type.                                           */
-typedef ::simd_packed_short2 short2;
-  
-    /*! @abstract A vector of four 16-bit signed (twos-complement) integers
-     *  with relaxed alignment.
-     *  @description In C or Objective-C, this type is available as
-     *  simd_packed_short4. The alignment of this type is only that of the
-     *  underlying scalar element type, so you can use it to load or store
-     *  from an array of that type.                                           */
-typedef ::simd_packed_short4 short4;
-  
-    /*! @abstract A vector of eight 16-bit signed (twos-complement) integers
-     *  with relaxed alignment.
-     *  @description This type is not available in Metal. In C or
-     *  Objective-C, this type is available as simd_packed_short8. The
-     *  alignment of this type is only that of the underlying scalar element
-     *  type, so you can use it to load or store from an array of that type.  */
-typedef ::simd_packed_short8 short8;
-  
-    /*! @abstract A vector of sixteen 16-bit signed (twos-complement)
-     *  integers with relaxed alignment.
-     *  @description This type is not available in Metal. In C or
-     *  Objective-C, this type is available as simd_packed_short16. The
-     *  alignment of this type is only that of the underlying scalar element
-     *  type, so you can use it to load or store from an array of that type.  */
-typedef ::simd_packed_short16 short16;
-  
-    /*! @abstract A vector of thirty-two 16-bit signed (twos-complement)
-     *  integers with relaxed alignment.
-     *  @description This type is not available in Metal. In C or
-     *  Objective-C, this type is available as simd_packed_short32. The
-     *  alignment of this type is only that of the underlying scalar element
-     *  type, so you can use it to load or store from an array of that type.  */
-typedef ::simd_packed_short32 short32;
-  
-    /*! @abstract A vector of two 16-bit unsigned integers with relaxed
-     *  alignment.
-     *  @description In C or Objective-C, this type is available as
-     *  simd_packed_ushort2. The alignment of this type is only that of the
-     *  underlying scalar element type, so you can use it to load or store
-     *  from an array of that type.                                           */
-typedef ::simd_packed_ushort2 ushort2;
-  
-    /*! @abstract A vector of four 16-bit unsigned integers with relaxed
-     *  alignment.
-     *  @description In C or Objective-C, this type is available as
-     *  simd_packed_ushort4. The alignment of this type is only that of the
-     *  underlying scalar element type, so you can use it to load or store
-     *  from an array of that type.                                           */
-typedef ::simd_packed_ushort4 ushort4;
-  
-    /*! @abstract A vector of eight 16-bit unsigned integers with relaxed
-     *  alignment.
-     *  @description This type is not available in Metal. In C or
-     *  Objective-C, this type is available as simd_packed_ushort8. The
-     *  alignment of this type is only that of the underlying scalar element
-     *  type, so you can use it to load or store from an array of that type.  */
-typedef ::simd_packed_ushort8 ushort8;
-  
-    /*! @abstract A vector of sixteen 16-bit unsigned integers with relaxed
-     *  alignment.
-     *  @description This type is not available in Metal. In C or
-     *  Objective-C, this type is available as simd_packed_ushort16. The
-     *  alignment of this type is only that of the underlying scalar element
-     *  type, so you can use it to load or store from an array of that type.  */
-typedef ::simd_packed_ushort16 ushort16;
-  
-    /*! @abstract A vector of thirty-two 16-bit unsigned integers with
-     *  relaxed alignment.
-     *  @description This type is not available in Metal. In C or
-     *  Objective-C, this type is available as simd_packed_ushort32. The
-     *  alignment of this type is only that of the underlying scalar element
-     *  type, so you can use it to load or store from an array of that type.  */
-typedef ::simd_packed_ushort32 ushort32;
-  
-    /*! @abstract A vector of two 32-bit signed (twos-complement) integers
-     *  with relaxed alignment.
-     *  @description In C or Objective-C, this type is available as
-     *  simd_packed_int2. The alignment of this type is only that of the
-     *  underlying scalar element type, so you can use it to load or store
-     *  from an array of that type.                                           */
-typedef ::simd_packed_int2 int2;
-  
-    /*! @abstract A vector of four 32-bit signed (twos-complement) integers
-     *  with relaxed alignment.
-     *  @description In C or Objective-C, this type is available as
-     *  simd_packed_int4. The alignment of this type is only that of the
-     *  underlying scalar element type, so you can use it to load or store
-     *  from an array of that type.                                           */
-typedef ::simd_packed_int4 int4;
-  
-    /*! @abstract A vector of eight 32-bit signed (twos-complement) integers
-     *  with relaxed alignment.
-     *  @description This type is not available in Metal. In C or
-     *  Objective-C, this type is available as simd_packed_int8. The
-     *  alignment of this type is only that of the underlying scalar element
-     *  type, so you can use it to load or store from an array of that type.  */
-typedef ::simd_packed_int8 int8;
-  
-    /*! @abstract A vector of sixteen 32-bit signed (twos-complement)
-     *  integers with relaxed alignment.
-     *  @description This type is not available in Metal. In C or
-     *  Objective-C, this type is available as simd_packed_int16. The
-     *  alignment of this type is only that of the underlying scalar element
-     *  type, so you can use it to load or store from an array of that type.  */
-typedef ::simd_packed_int16 int16;
-  
-    /*! @abstract A vector of two 32-bit unsigned integers with relaxed
-     *  alignment.
-     *  @description In C or Objective-C, this type is available as
-     *  simd_packed_uint2. The alignment of this type is only that of the
-     *  underlying scalar element type, so you can use it to load or store
-     *  from an array of that type.                                           */
-typedef ::simd_packed_uint2 uint2;
-  
-    /*! @abstract A vector of four 32-bit unsigned integers with relaxed
-     *  alignment.
-     *  @description In C or Objective-C, this type is available as
-     *  simd_packed_uint4. The alignment of this type is only that of the
-     *  underlying scalar element type, so you can use it to load or store
-     *  from an array of that type.                                           */
-typedef ::simd_packed_uint4 uint4;
-  
-    /*! @abstract A vector of eight 32-bit unsigned integers with relaxed
-     *  alignment.
-     *  @description This type is not available in Metal. In C or
-     *  Objective-C, this type is available as simd_packed_uint8. The
-     *  alignment of this type is only that of the underlying scalar element
-     *  type, so you can use it to load or store from an array of that type.  */
-typedef ::simd_packed_uint8 uint8;
-  
-    /*! @abstract A vector of sixteen 32-bit unsigned integers with relaxed
-     *  alignment.
-     *  @description This type is not available in Metal. In C or
-     *  Objective-C, this type is available as simd_packed_uint16. The
-     *  alignment of this type is only that of the underlying scalar element
-     *  type, so you can use it to load or store from an array of that type.  */
-typedef ::simd_packed_uint16 uint16;
-  
-    /*! @abstract A vector of two 32-bit floating-point numbers with relaxed
-     *  alignment.
-     *  @description In C or Objective-C, this type is available as
-     *  simd_packed_float2. The alignment of this type is only that of the
-     *  underlying scalar element type, so you can use it to load or store
-     *  from an array of that type.                                           */
-typedef ::simd_packed_float2 float2;
-  
-    /*! @abstract A vector of four 32-bit floating-point numbers with
-     *  relaxed alignment.
-     *  @description In C or Objective-C, this type is available as
-     *  simd_packed_float4. The alignment of this type is only that of the
-     *  underlying scalar element type, so you can use it to load or store
-     *  from an array of that type.                                           */
-typedef ::simd_packed_float4 float4;
-  
-    /*! @abstract A vector of eight 32-bit floating-point numbers with
-     *  relaxed alignment.
-     *  @description This type is not available in Metal. In C or
-     *  Objective-C, this type is available as simd_packed_float8. The
-     *  alignment of this type is only that of the underlying scalar element
-     *  type, so you can use it to load or store from an array of that type.  */
-typedef ::simd_packed_float8 float8;
-  
-    /*! @abstract A vector of sixteen 32-bit floating-point numbers with
-     *  relaxed alignment.
-     *  @description This type is not available in Metal. In C or
-     *  Objective-C, this type is available as simd_packed_float16. The
-     *  alignment of this type is only that of the underlying scalar element
-     *  type, so you can use it to load or store from an array of that type.  */
-typedef ::simd_packed_float16 float16;
-  
-    /*! @abstract A vector of two 64-bit signed (twos-complement) integers
-     *  with relaxed alignment.
-     *  @description In C or Objective-C, this type is available as
-     *  simd_packed_long2. The alignment of this type is only that of the
-     *  underlying scalar element type, so you can use it to load or store
-     *  from an array of that type.                                           */
-typedef ::simd_packed_long2 long2;
-  
-    /*! @abstract A vector of four 64-bit signed (twos-complement) integers
-     *  with relaxed alignment.
-     *  @description In C or Objective-C, this type is available as
-     *  simd_packed_long4. The alignment of this type is only that of the
-     *  underlying scalar element type, so you can use it to load or store
-     *  from an array of that type.                                           */
-typedef ::simd_packed_long4 long4;
-  
-    /*! @abstract A vector of eight 64-bit signed (twos-complement) integers
-     *  with relaxed alignment.
-     *  @description This type is not available in Metal. In C or
-     *  Objective-C, this type is available as simd_packed_long8. The
-     *  alignment of this type is only that of the underlying scalar element
-     *  type, so you can use it to load or store from an array of that type.  */
-typedef ::simd_packed_long8 long8;
-  
-    /*! @abstract A vector of two 64-bit unsigned integers with relaxed
-     *  alignment.
-     *  @description In C or Objective-C, this type is available as
-     *  simd_packed_ulong2. The alignment of this type is only that of the
-     *  underlying scalar element type, so you can use it to load or store
-     *  from an array of that type.                                           */
-typedef ::simd_packed_ulong2 ulong2;
-  
-    /*! @abstract A vector of four 64-bit unsigned integers with relaxed
-     *  alignment.
-     *  @description In C or Objective-C, this type is available as
-     *  simd_packed_ulong4. The alignment of this type is only that of the
-     *  underlying scalar element type, so you can use it to load or store
-     *  from an array of that type.                                           */
-typedef ::simd_packed_ulong4 ulong4;
-  
-    /*! @abstract A vector of eight 64-bit unsigned integers with relaxed
-     *  alignment.
-     *  @description This type is not available in Metal. In C or
-     *  Objective-C, this type is available as simd_packed_ulong8. The
-     *  alignment of this type is only that of the underlying scalar element
-     *  type, so you can use it to load or store from an array of that type.  */
-typedef ::simd_packed_ulong8 ulong8;
-  
-    /*! @abstract A vector of two 64-bit floating-point numbers with relaxed
-     *  alignment.
-     *  @description In C or Objective-C, this type is available as
-     *  simd_packed_double2. The alignment of this type is only that of the
-     *  underlying scalar element type, so you can use it to load or store
-     *  from an array of that type.                                           */
-typedef ::simd_packed_double2 double2;
-  
-    /*! @abstract A vector of four 64-bit floating-point numbers with
-     *  relaxed alignment.
-     *  @description In C or Objective-C, this type is available as
-     *  simd_packed_double4. The alignment of this type is only that of the
-     *  underlying scalar element type, so you can use it to load or store
-     *  from an array of that type.                                           */
-typedef ::simd_packed_double4 double4;
-  
-    /*! @abstract A vector of eight 64-bit floating-point numbers with
-     *  relaxed alignment.
-     *  @description This type is not available in Metal. In C or
-     *  Objective-C, this type is available as simd_packed_double8. The
-     *  alignment of this type is only that of the underlying scalar element
-     *  type, so you can use it to load or store from an array of that type.  */
-typedef ::simd_packed_double8 double8;
-  
-  } /* namespace simd::packed::                                               */
-} /* namespace simd::                                                         */
-#endif /* __cplusplus                                                         */
-
-/*  MARK: Deprecated vector types                                             */
-/*! @group Deprecated vector types
- *  @discussion These are the original types used by earlier versions of the
- *  simd library; they are provided here for compatability with existing source
- *  files. Use the new ("simd_"-prefixed) types for future development.       */
-/*! @abstract A vector of two 8-bit signed (twos-complement) integers with
- *  relaxed alignment.
- *  @description This type is deprecated; you should use simd_packed_char2
- *  or simd::packed_char2 instead.                                            */
-typedef simd_packed_char2 packed_char2;
-
-/*! @abstract A vector of four 8-bit signed (twos-complement) integers with
- *  relaxed alignment.
- *  @description This type is deprecated; you should use simd_packed_char4
- *  or simd::packed_char4 instead.                                            */
-typedef simd_packed_char4 packed_char4;
-
-/*! @abstract A vector of eight 8-bit signed (twos-complement) integers with
- *  relaxed alignment.
- *  @description This type is deprecated; you should use simd_packed_char8
- *  or simd::packed_char8 instead.                                            */
-typedef simd_packed_char8 packed_char8;
-
-/*! @abstract A vector of sixteen 8-bit signed (twos-complement) integers
- *  with relaxed alignment.
- *  @description This type is deprecated; you should use simd_packed_char16
- *  or simd::packed_char16 instead.                                           */
-typedef simd_packed_char16 packed_char16;
-
-/*! @abstract A vector of thirty-two 8-bit signed (twos-complement) integers
- *  with relaxed alignment.
- *  @description This type is deprecated; you should use simd_packed_char32
- *  or simd::packed_char32 instead.                                           */
-typedef simd_packed_char32 packed_char32;
-
-/*! @abstract A vector of sixty-four 8-bit signed (twos-complement) integers
- *  with relaxed alignment.
- *  @description This type is deprecated; you should use simd_packed_char64
- *  or simd::packed_char64 instead.                                           */
-typedef simd_packed_char64 packed_char64;
-
-/*! @abstract A vector of two 8-bit unsigned integers with relaxed
- *  alignment.
- *  @description This type is deprecated; you should use simd_packed_uchar2
- *  or simd::packed_uchar2 instead.                                           */
-typedef simd_packed_uchar2 packed_uchar2;
-
-/*! @abstract A vector of four 8-bit unsigned integers with relaxed
- *  alignment.
- *  @description This type is deprecated; you should use simd_packed_uchar4
- *  or simd::packed_uchar4 instead.                                           */
-typedef simd_packed_uchar4 packed_uchar4;
-
-/*! @abstract A vector of eight 8-bit unsigned integers with relaxed
- *  alignment.
- *  @description This type is deprecated; you should use simd_packed_uchar8
- *  or simd::packed_uchar8 instead.                                           */
-typedef simd_packed_uchar8 packed_uchar8;
-
-/*! @abstract A vector of sixteen 8-bit unsigned integers with relaxed
- *  alignment.
- *  @description This type is deprecated; you should use simd_packed_uchar16
- *  or simd::packed_uchar16 instead.                                          */
-typedef simd_packed_uchar16 packed_uchar16;
-
-/*! @abstract A vector of thirty-two 8-bit unsigned integers with relaxed
- *  alignment.
- *  @description This type is deprecated; you should use simd_packed_uchar32
- *  or simd::packed_uchar32 instead.                                          */
-typedef simd_packed_uchar32 packed_uchar32;
-
-/*! @abstract A vector of sixty-four 8-bit unsigned integers with relaxed
- *  alignment.
- *  @description This type is deprecated; you should use simd_packed_uchar64
- *  or simd::packed_uchar64 instead.                                          */
-typedef simd_packed_uchar64 packed_uchar64;
-
-/*! @abstract A vector of two 16-bit signed (twos-complement) integers with
- *  relaxed alignment.
- *  @description This type is deprecated; you should use simd_packed_short2
- *  or simd::packed_short2 instead.                                           */
-typedef simd_packed_short2 packed_short2;
-
-/*! @abstract A vector of four 16-bit signed (twos-complement) integers with
- *  relaxed alignment.
- *  @description This type is deprecated; you should use simd_packed_short4
- *  or simd::packed_short4 instead.                                           */
-typedef simd_packed_short4 packed_short4;
-
-/*! @abstract A vector of eight 16-bit signed (twos-complement) integers
- *  with relaxed alignment.
- *  @description This type is deprecated; you should use simd_packed_short8
- *  or simd::packed_short8 instead.                                           */
-typedef simd_packed_short8 packed_short8;
-
-/*! @abstract A vector of sixteen 16-bit signed (twos-complement) integers
- *  with relaxed alignment.
- *  @description This type is deprecated; you should use simd_packed_short16
- *  or simd::packed_short16 instead.                                          */
-typedef simd_packed_short16 packed_short16;
-
-/*! @abstract A vector of thirty-two 16-bit signed (twos-complement)
- *  integers with relaxed alignment.
- *  @description This type is deprecated; you should use simd_packed_short32
- *  or simd::packed_short32 instead.                                          */
-typedef simd_packed_short32 packed_short32;
-
-/*! @abstract A vector of two 16-bit unsigned integers with relaxed
- *  alignment.
- *  @description This type is deprecated; you should use simd_packed_ushort2
- *  or simd::packed_ushort2 instead.                                          */
-typedef simd_packed_ushort2 packed_ushort2;
-
-/*! @abstract A vector of four 16-bit unsigned integers with relaxed
- *  alignment.
- *  @description This type is deprecated; you should use simd_packed_ushort4
- *  or simd::packed_ushort4 instead.                                          */
-typedef simd_packed_ushort4 packed_ushort4;
-
-/*! @abstract A vector of eight 16-bit unsigned integers with relaxed
- *  alignment.
- *  @description This type is deprecated; you should use simd_packed_ushort8
- *  or simd::packed_ushort8 instead.                                          */
-typedef simd_packed_ushort8 packed_ushort8;
-
-/*! @abstract A vector of sixteen 16-bit unsigned integers with relaxed
- *  alignment.
- *  @description This type is deprecated; you should use
- *  simd_packed_ushort16 or simd::packed_ushort16 instead.                    */
-typedef simd_packed_ushort16 packed_ushort16;
-
-/*! @abstract A vector of thirty-two 16-bit unsigned integers with relaxed
- *  alignment.
- *  @description This type is deprecated; you should use
- *  simd_packed_ushort32 or simd::packed_ushort32 instead.                    */
-typedef simd_packed_ushort32 packed_ushort32;
-
-/*! @abstract A vector of two 32-bit signed (twos-complement) integers with
- *  relaxed alignment.
- *  @description This type is deprecated; you should use simd_packed_int2 or
- *  simd::packed_int2 instead.                                                */
-typedef simd_packed_int2 packed_int2;
-
-/*! @abstract A vector of four 32-bit signed (twos-complement) integers with
- *  relaxed alignment.
- *  @description This type is deprecated; you should use simd_packed_int4 or
- *  simd::packed_int4 instead.                                                */
-typedef simd_packed_int4 packed_int4;
-
-/*! @abstract A vector of eight 32-bit signed (twos-complement) integers
- *  with relaxed alignment.
- *  @description This type is deprecated; you should use simd_packed_int8 or
- *  simd::packed_int8 instead.                                                */
-typedef simd_packed_int8 packed_int8;
-
-/*! @abstract A vector of sixteen 32-bit signed (twos-complement) integers
- *  with relaxed alignment.
- *  @description This type is deprecated; you should use simd_packed_int16
- *  or simd::packed_int16 instead.                                            */
-typedef simd_packed_int16 packed_int16;
-
-/*! @abstract A vector of two 32-bit unsigned integers with relaxed
- *  alignment.
- *  @description This type is deprecated; you should use simd_packed_uint2
- *  or simd::packed_uint2 instead.                                            */
-typedef simd_packed_uint2 packed_uint2;
-
-/*! @abstract A vector of four 32-bit unsigned integers with relaxed
- *  alignment.
- *  @description This type is deprecated; you should use simd_packed_uint4
- *  or simd::packed_uint4 instead.                                            */
-typedef simd_packed_uint4 packed_uint4;
-
-/*! @abstract A vector of eight 32-bit unsigned integers with relaxed
- *  alignment.
- *  @description This type is deprecated; you should use simd_packed_uint8
- *  or simd::packed_uint8 instead.                                            */
-typedef simd_packed_uint8 packed_uint8;
-
-/*! @abstract A vector of sixteen 32-bit unsigned integers with relaxed
- *  alignment.
- *  @description This type is deprecated; you should use simd_packed_uint16
- *  or simd::packed_uint16 instead.                                           */
-typedef simd_packed_uint16 packed_uint16;
-
-/*! @abstract A vector of two 32-bit floating-point numbers with relaxed
- *  alignment.
- *  @description This type is deprecated; you should use simd_packed_float2
- *  or simd::packed_float2 instead.                                           */
-typedef simd_packed_float2 packed_float2;
-
-/*! @abstract A vector of four 32-bit floating-point numbers with relaxed
- *  alignment.
- *  @description This type is deprecated; you should use simd_packed_float4
- *  or simd::packed_float4 instead.                                           */
-typedef simd_packed_float4 packed_float4;
-
-/*! @abstract A vector of eight 32-bit floating-point numbers with relaxed
- *  alignment.
- *  @description This type is deprecated; you should use simd_packed_float8
- *  or simd::packed_float8 instead.                                           */
-typedef simd_packed_float8 packed_float8;
-
-/*! @abstract A vector of sixteen 32-bit floating-point numbers with relaxed
- *  alignment.
- *  @description This type is deprecated; you should use simd_packed_float16
- *  or simd::packed_float16 instead.                                          */
-typedef simd_packed_float16 packed_float16;
-
-/*! @abstract A vector of two 64-bit signed (twos-complement) integers with
- *  relaxed alignment.
- *  @description This type is deprecated; you should use simd_packed_long2
- *  or simd::packed_long2 instead.                                            */
-typedef simd_packed_long2 packed_long2;
-
-/*! @abstract A vector of four 64-bit signed (twos-complement) integers with
- *  relaxed alignment.
- *  @description This type is deprecated; you should use simd_packed_long4
- *  or simd::packed_long4 instead.                                            */
-typedef simd_packed_long4 packed_long4;
-
-/*! @abstract A vector of eight 64-bit signed (twos-complement) integers
- *  with relaxed alignment.
- *  @description This type is deprecated; you should use simd_packed_long8
- *  or simd::packed_long8 instead.                                            */
-typedef simd_packed_long8 packed_long8;
-
-/*! @abstract A vector of two 64-bit unsigned integers with relaxed
- *  alignment.
- *  @description This type is deprecated; you should use simd_packed_ulong2
- *  or simd::packed_ulong2 instead.                                           */
-typedef simd_packed_ulong2 packed_ulong2;
-
-/*! @abstract A vector of four 64-bit unsigned integers with relaxed
- *  alignment.
- *  @description This type is deprecated; you should use simd_packed_ulong4
- *  or simd::packed_ulong4 instead.                                           */
-typedef simd_packed_ulong4 packed_ulong4;
-
-/*! @abstract A vector of eight 64-bit unsigned integers with relaxed
- *  alignment.
- *  @description This type is deprecated; you should use simd_packed_ulong8
- *  or simd::packed_ulong8 instead.                                           */
-typedef simd_packed_ulong8 packed_ulong8;
-
-/*! @abstract A vector of two 64-bit floating-point numbers with relaxed
- *  alignment.
- *  @description This type is deprecated; you should use simd_packed_double2
- *  or simd::packed_double2 instead.                                          */
-typedef simd_packed_double2 packed_double2;
-
-/*! @abstract A vector of four 64-bit floating-point numbers with relaxed
- *  alignment.
- *  @description This type is deprecated; you should use simd_packed_double4
- *  or simd::packed_double4 instead.                                          */
-typedef simd_packed_double4 packed_double4;
-
-/*! @abstract A vector of eight 64-bit floating-point numbers with relaxed
- *  alignment.
- *  @description This type is deprecated; you should use simd_packed_double8
- *  or simd::packed_double8 instead.                                          */
-typedef simd_packed_double8 packed_double8;
-
-# endif /* SIMD_COMPILER_HAS_REQUIRED_FEATURES */
-#endif
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/simd/quaternion.h b/lib/libc/include/x86_64-macos-gnu/simd/quaternion.h
deleted file mode 100644
index 32158d7e8d..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/simd/quaternion.h
+++ /dev/null
@@ -1,1192 +0,0 @@
-/*! @header
- *  This header defines functions for constructing and using quaternions.
- *  @copyright 2015-2016 Apple, Inc. All rights reserved.
- *  @unsorted                                                                 */
-
-#ifndef SIMD_QUATERNIONS
-#define SIMD_QUATERNIONS
-
-#include <simd/base.h>
-#if SIMD_COMPILER_HAS_REQUIRED_FEATURES
-#include <simd/vector.h>
-#include <simd/types.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-  
-/*  MARK: - C and Objective-C float interfaces                                */
-
-/*! @abstract Constructs a quaternion from four scalar values.
- *
- *  @param ix The first component of the imaginary (vector) part.
- *  @param iy The second component of the imaginary (vector) part.
- *  @param iz The third component of the imaginary (vector) part.
- *
- *  @param r The real (scalar) part.                                          */
-static inline SIMD_CFUNC simd_quatf simd_quaternion(float ix, float iy, float iz, float r) {
-  return (simd_quatf){ { ix, iy, iz, r } };
-}
-  
-/*! @abstract Constructs a quaternion from an array of four scalars.
- *
- *  @discussion Note that the imaginary part of the quaternion comes from 
- *  array elements 0, 1, and 2, and the real part comes from element 3.       */
-static inline SIMD_NONCONST simd_quatf simd_quaternion(const float xyzr[4]) {
-  return (simd_quatf){ *(const simd_packed_float4 *)xyzr };
-}
-  
-/*! @abstract Constructs a quaternion from a four-element vector.
- *
- *  @discussion Note that the imaginary (vector) part of the quaternion comes
- *  from lanes 0, 1, and 2 of the vector, and the real (scalar) part comes from
- *  lane 3.                                                                   */
-static inline SIMD_CFUNC simd_quatf simd_quaternion(simd_float4 xyzr) {
-  return (simd_quatf){ xyzr };
-}
-  
-/*! @abstract Constructs a quaternion that rotates by `angle` radians about
- *  `axis`.                                                                   */
-static inline SIMD_CFUNC simd_quatf simd_quaternion(float angle, simd_float3 axis);
-  
-/*! @abstract Construct a quaternion that rotates from one vector to another.
- *
- *  @param from A normalized three-element vector.
- *  @param to A normalized three-element vector.
- *
- *  @discussion The rotation axis is `simd_cross(from, to)`. If `from` and
- *  `to` point in opposite directions (to within machine precision), an
- *  arbitrary rotation axis is chosen, and the angle is pi radians.           */
-static SIMD_NOINLINE simd_quatf simd_quaternion(simd_float3 from, simd_float3 to);
-
-/*! @abstract Construct a quaternion from a 3x3 rotation `matrix`.
- *
- *  @discussion If `matrix` is not orthogonal with determinant 1, the result
- *  is undefined.                                                             */
-static SIMD_NOINLINE simd_quatf simd_quaternion(simd_float3x3 matrix);
-
-/*! @abstract Construct a quaternion from a 4x4 rotation `matrix`.
- *
- *  @discussion The last row and column of the matrix are ignored. This
- *  function is equivalent to calling simd_quaternion with the upper-left 3x3
- *  submatrix                .                                                */
-static SIMD_NOINLINE simd_quatf simd_quaternion(simd_float4x4 matrix);
-  
-/*! @abstract The real (scalar) part of the quaternion `q`.                   */
-static inline SIMD_CFUNC float simd_real(simd_quatf q) {
-  return q.vector.w;
-}
-  
-/*! @abstract The imaginary (vector) part of the quaternion `q`.              */
-static inline SIMD_CFUNC simd_float3 simd_imag(simd_quatf q) {
-  return q.vector.xyz;
-}
-  
-/*! @abstract The angle (in radians) of rotation represented by `q`.          */
-static inline SIMD_CFUNC float simd_angle(simd_quatf q);
-  
-/*! @abstract The normalized axis (a 3-element vector) around which the
- *  action of the quaternion `q` rotates.                                     */
-static inline SIMD_CFUNC simd_float3 simd_axis(simd_quatf q);
-  
-/*! @abstract The sum of the quaternions `p` and `q`.                         */
-static inline SIMD_CFUNC simd_quatf simd_add(simd_quatf p, simd_quatf q);
-  
-/*! @abstract The difference of the quaternions `p` and `q`.                  */
-static inline SIMD_CFUNC simd_quatf simd_sub(simd_quatf p, simd_quatf q);
-  
-/*! @abstract The product of the quaternions `p` and `q`.                     */
-static inline SIMD_CFUNC simd_quatf simd_mul(simd_quatf p, simd_quatf q);
-  
-/*! @abstract The quaternion `q` scaled by the real value `a`.                */
-static inline SIMD_CFUNC simd_quatf simd_mul(simd_quatf q, float a);
-  
-/*! @abstract The quaternion `q` scaled by the real value `a`.                */
-static inline SIMD_CFUNC simd_quatf simd_mul(float a, simd_quatf q);
-  
-/*! @abstract The conjugate of the quaternion `q`.                            */
-static inline SIMD_CFUNC simd_quatf simd_conjugate(simd_quatf q);
-  
-/*! @abstract The (multiplicative) inverse of the quaternion `q`.             */
-static inline SIMD_CFUNC simd_quatf simd_inverse(simd_quatf q);
-  
-/*! @abstract The negation (additive inverse) of the quaternion `q`.          */
-static inline SIMD_CFUNC simd_quatf simd_negate(simd_quatf q);
-  
-/*! @abstract The dot product of the quaternions `p` and `q` interpreted as
- *  four-dimensional vectors.                                                 */
-static inline SIMD_CFUNC float simd_dot(simd_quatf p, simd_quatf q);
-  
-/*! @abstract The length of the quaternion `q`.                               */
-static inline SIMD_CFUNC float simd_length(simd_quatf q);
-  
-/*! @abstract The unit quaternion obtained by normalizing `q`.                */
-static inline SIMD_CFUNC simd_quatf simd_normalize(simd_quatf q);
-  
-/*! @abstract Rotates the vector `v` by the quaternion `q`.                   */
-static inline SIMD_CFUNC simd_float3 simd_act(simd_quatf q, simd_float3 v);
-  
-/*! @abstract Logarithm of the quaternion `q`.
- *  @discussion Do not call this function directly; use `log(q)` instead.
- *
- *  We can write a quaternion `q` in the form: `r(cos(t) + sin(t)v)` where
- *  `r` is the length of `q`, `t` is an angle, and `v` is a unit 3-vector.
- *  The logarithm of `q` is `log(r) + tv`, just like the logarithm of the
- *  complex number `r*(cos(t) + i sin(t))` is `log(r) + it`.
- *
- *  Note that this function is not robust against poorly-scaled non-unit
- *  quaternions, because it is primarily used for spline interpolation of
- *  unit quaternions. If you need to compute a robust logarithm of general
- *  quaternions, you can use the following approach:
- *
- *    scale = simd_reduce_max(simd_abs(q.vector));
- *    logq = log(simd_recip(scale)*q);
- *    logq.real += log(scale);
- *    return logq;                                                            */
-static SIMD_NOINLINE simd_quatf __tg_log(simd_quatf q);
-    
-/*! @abstract Inverse of `log( )`; the exponential map on quaternions.
- *  @discussion Do not call this function directly; use `exp(q)` instead.     */
-static SIMD_NOINLINE simd_quatf __tg_exp(simd_quatf q);
-  
-/*! @abstract Spherical linear interpolation along the shortest arc between
- *  quaternions `q0` and `q1`.                                                */
-static SIMD_NOINLINE simd_quatf simd_slerp(simd_quatf q0, simd_quatf q1, float t);
-
-/*! @abstract Spherical linear interpolation along the longest arc between
- *  quaternions `q0` and `q1`.                                                */
-static SIMD_NOINLINE simd_quatf simd_slerp_longest(simd_quatf q0, simd_quatf q1, float t);
-
-/*! @abstract Interpolate between quaternions along a spherical cubic spline.
- *
- *  @discussion The function interpolates between q1 and q2. q0 is the left
- *  endpoint of the previous interval, and q3 is the right endpoint of the next
- *  interval. Use this function to smoothly interpolate between a sequence of
- *  rotations.                                                                */
-static SIMD_NOINLINE simd_quatf simd_spline(simd_quatf q0, simd_quatf q1, simd_quatf q2, simd_quatf q3, float t);
-
-/*! @abstract Spherical cubic Bezier interpolation between quaternions.
- *
- *  @discussion The function treats q0 ... q3 as control points and uses slerp
- *  in place of lerp in the De Castlejeau algorithm. The endpoints of
- *  interpolation are thus q0 and q3, and the curve will not generally pass
- *  through q1 or q2. Note that the convex hull property of "standard" Bezier
- *  curve does not hold on the sphere.                                        */
-static SIMD_NOINLINE simd_quatf simd_bezier(simd_quatf q0, simd_quatf q1, simd_quatf q2, simd_quatf q3, float t);
-  
-#ifdef __cplusplus
-} /* extern "C" */
-/*  MARK: - C++ float interfaces                                              */
-
-namespace simd {
-  struct quatf : ::simd_quatf {
-    /*! @abstract The identity quaternion.                                    */
-    quatf( ) : ::simd_quatf(::simd_quaternion((float4){0,0,0,1})) { }
-    
-    /*! @abstract Constructs a C++ quaternion from a C quaternion.            */
-    quatf(::simd_quatf q) : ::simd_quatf(q) { }
-    
-    /*! @abstract Constructs a quaternion from components.                    */
-    quatf(float ix, float iy, float iz, float r) : ::simd_quatf(::simd_quaternion(ix, iy, iz, r)) { }
-    
-    /*! @abstract Constructs a quaternion from an array of scalars.           */
-    quatf(const float xyzr[4]) : ::simd_quatf(::simd_quaternion(xyzr)) { }
-    
-    /*! @abstract Constructs a quaternion from a vector.                      */
-    quatf(float4 xyzr) : ::simd_quatf(::simd_quaternion(xyzr)) { }
-    
-    /*! @abstract Quaternion representing rotation about `axis` by `angle` 
-     *  radians.                                                              */
-    quatf(float angle, float3 axis) : ::simd_quatf(::simd_quaternion(angle, axis)) { }
-    
-    /*! @abstract Quaternion that rotates `from` into `to`.                   */
-    quatf(float3 from, float3 to) : ::simd_quatf(::simd_quaternion(from, to)) { }
-    
-    /*! @abstract Constructs a quaternion from a rotation matrix.             */
-    quatf(::simd_float3x3 matrix) : ::simd_quatf(::simd_quaternion(matrix)) { }
-    
-    /*! @abstract Constructs a quaternion from a rotation matrix.             */
-    quatf(::simd_float4x4 matrix) : ::simd_quatf(::simd_quaternion(matrix)) { }
-  
-    /*! @abstract The real (scalar) part of the quaternion.                   */
-    float real(void) const { return ::simd_real(*this); }
-    
-    /*! @abstract The imaginary (vector) part of the quaternion.              */
-    float3 imag(void) const { return ::simd_imag(*this); }
-    
-    /*! @abstract The angle the quaternion rotates by.                        */
-    float angle(void) const { return ::simd_angle(*this); }
-    
-    /*! @abstract The axis the quaternion rotates about.                      */
-    float3 axis(void) const { return ::simd_axis(*this); }
-    
-    /*! @abstract The length of the quaternion.                               */
-    float length(void) const { return ::simd_length(*this); }
-    
-    /*! @abstract Act on the vector `v` by rotation.                          */
-    float3  operator()(const ::simd_float3 v) const { return ::simd_act(*this, v); }
-  };
-  
-  static SIMD_CPPFUNC quatf operator+(const ::simd_quatf p, const ::simd_quatf q) { return ::simd_add(p, q); }
-  static SIMD_CPPFUNC quatf operator-(const ::simd_quatf p, const ::simd_quatf q) { return ::simd_sub(p, q); }
-  static SIMD_CPPFUNC quatf operator-(const ::simd_quatf p) { return ::simd_negate(p); }
-  static SIMD_CPPFUNC quatf operator*(const float r, const ::simd_quatf p) { return ::simd_mul(r, p); }
-  static SIMD_CPPFUNC quatf operator*(const ::simd_quatf p, const float r) { return ::simd_mul(p, r); }
-  static SIMD_CPPFUNC quatf operator*(const ::simd_quatf p, const ::simd_quatf q) { return ::simd_mul(p, q); }
-  static SIMD_CPPFUNC quatf operator/(const ::simd_quatf p, const ::simd_quatf q) { return ::simd_mul(p, ::simd_inverse(q)); }
-  static SIMD_CPPFUNC quatf operator+=(quatf &p, const ::simd_quatf q) { return p = p+q; }
-  static SIMD_CPPFUNC quatf operator-=(quatf &p, const ::simd_quatf q) { return p = p-q; }
-  static SIMD_CPPFUNC quatf operator*=(quatf &p, const float r) { return p = p*r; }
-  static SIMD_CPPFUNC quatf operator*=(quatf &p, const ::simd_quatf q) { return p = p*q; }
-  static SIMD_CPPFUNC quatf operator/=(quatf &p, const ::simd_quatf q) { return p = p/q; }
-  
-  /*! @abstract The conjugate of the quaternion `q`.                          */
-  static SIMD_CPPFUNC quatf conjugate(const ::simd_quatf p) { return ::simd_conjugate(p); }
-  
-  /*! @abstract The (multiplicative) inverse of the quaternion `q`.           */
-  static SIMD_CPPFUNC quatf inverse(const ::simd_quatf p) { return ::simd_inverse(p); }
-
-  /*! @abstract The dot product of the quaternions `p` and `q` interpreted as
-   *  four-dimensional vectors.                                               */
-  static SIMD_CPPFUNC float dot(const ::simd_quatf p, const ::simd_quatf q) { return ::simd_dot(p, q); }
-  
-  /*! @abstract The unit quaternion obtained by normalizing `q`.              */
-  static SIMD_CPPFUNC quatf normalize(const ::simd_quatf p) { return ::simd_normalize(p); }
-
-  /*! @abstract logarithm of the quaternion `q`.                              */
-  static SIMD_CPPFUNC quatf log(const ::simd_quatf q) { return ::__tg_log(q); }
-
-  /*! @abstract exponential map of quaterion `q`.                             */
-  static SIMD_CPPFUNC quatf exp(const ::simd_quatf q) { return ::__tg_exp(q); }
-  
-  /*! @abstract Spherical linear interpolation along the shortest arc between
-   *  quaternions `q0` and `q1`.                                              */
-  static SIMD_CPPFUNC quatf slerp(const ::simd_quatf p0, const ::simd_quatf p1, float t) { return ::simd_slerp(p0, p1, t); }
-  
-  /*! @abstract Spherical linear interpolation along the longest arc between
-   *  quaternions `q0` and `q1`.                                              */
-  static SIMD_CPPFUNC quatf slerp_longest(const ::simd_quatf p0, const ::simd_quatf p1, float t) { return ::simd_slerp_longest(p0, p1, t); }
-  
-  /*! @abstract Interpolate between quaternions along a spherical cubic spline.
-   *
-   *  @discussion The function interpolates between q1 and q2. q0 is the left
-   *  endpoint of the previous interval, and q3 is the right endpoint of the next
-   *  interval. Use this function to smoothly interpolate between a sequence of
-   *  rotations.                                                              */
-  static SIMD_CPPFUNC quatf spline(const ::simd_quatf p0, const ::simd_quatf p1, const ::simd_quatf p2, const ::simd_quatf p3, float t) { return ::simd_spline(p0, p1, p2, p3, t); }
-  
-  /*! @abstract Spherical cubic Bezier interpolation between quaternions.
-   *
-   *  @discussion The function treats q0 ... q3 as control points and uses slerp
-   *  in place of lerp in the De Castlejeau algorithm. The endpoints of
-   *  interpolation are thus q0 and q3, and the curve will not generally pass
-   *  through q1 or q2. Note that the convex hull property of "standard" Bezier
-   *  curve does not hold on the sphere.                                      */
-  static SIMD_CPPFUNC quatf bezier(const ::simd_quatf p0, const ::simd_quatf p1, const ::simd_quatf p2, const ::simd_quatf p3, float t) { return ::simd_bezier(p0, p1, p2, p3, t); }
-}
-
-extern "C" {
-#endif /* __cplusplus */
-  
-/*  MARK: - float implementations                                             */
-
-#include <simd/math.h>
-#include <simd/geometry.h>
-  
-/*  tg_promote is implementation gobbledygook that enables the compile-time
- *  dispatching in tgmath.h to work its magic.                                */
-static simd_quatf __attribute__((__overloadable__)) __tg_promote(simd_quatf);
-  
-/*! @abstract Constructs a quaternion from imaginary and real parts.
- *  @discussion This function is hidden behind an underscore to avoid confusion
- *  with the angle-axis constructor.                                          */
-static inline SIMD_CFUNC simd_quatf _simd_quaternion(simd_float3 imag, float real) {
-  return simd_quaternion(simd_make_float4(imag, real));
-}
-  
-static inline SIMD_CFUNC simd_quatf simd_quaternion(float angle, simd_float3 axis) {
-  return _simd_quaternion(sin(angle/2) * axis, cos(angle/2));
-}
-  
-static inline SIMD_CFUNC float simd_angle(simd_quatf q) {
-  return 2*atan2(simd_length(q.vector.xyz), q.vector.w);
-}
-  
-static inline SIMD_CFUNC simd_float3 simd_axis(simd_quatf q) {
-  return simd_normalize(q.vector.xyz);
-}
-  
-static inline SIMD_CFUNC simd_quatf simd_add(simd_quatf p, simd_quatf q) {
-  return simd_quaternion(p.vector + q.vector);
-}
-  
-static inline SIMD_CFUNC simd_quatf simd_sub(simd_quatf p, simd_quatf q) {
-  return simd_quaternion(p.vector - q.vector);
-}
-
-static inline SIMD_CFUNC simd_quatf simd_mul(simd_quatf p, simd_quatf q) {
-  #pragma STDC FP_CONTRACT ON
-  return simd_quaternion((p.vector.x * __builtin_shufflevector(q.vector, -q.vector, 3,6,1,4) +
-                          p.vector.y * __builtin_shufflevector(q.vector, -q.vector, 2,3,4,5)) +
-                         (p.vector.z * __builtin_shufflevector(q.vector, -q.vector, 5,0,3,6) +
-                          p.vector.w * q.vector));
-}
-
-static inline SIMD_CFUNC simd_quatf simd_mul(simd_quatf q, float a) {
-  return simd_quaternion(a * q.vector);
-}
-
-static inline SIMD_CFUNC simd_quatf simd_mul(float a, simd_quatf q) {
-  return simd_mul(q,a);
-}
-  
-static inline SIMD_CFUNC simd_quatf simd_conjugate(simd_quatf q) {
-  return simd_quaternion(q.vector * (simd_float4){-1,-1,-1, 1});
-}
-  
-static inline SIMD_CFUNC simd_quatf simd_inverse(simd_quatf q) {
-  return simd_quaternion(simd_conjugate(q).vector * simd_recip(simd_length_squared(q.vector)));
-}
-  
-static inline SIMD_CFUNC simd_quatf simd_negate(simd_quatf q) {
-  return simd_quaternion(-q.vector);
-}
-  
-static inline SIMD_CFUNC float simd_dot(simd_quatf p, simd_quatf q) {
-  return simd_dot(p.vector, q.vector);
-}
-  
-static inline SIMD_CFUNC float simd_length(simd_quatf q) {
-  return simd_length(q.vector);
-}
-  
-static inline SIMD_CFUNC simd_quatf simd_normalize(simd_quatf q) {
-  float length_squared = simd_length_squared(q.vector);
-  if (length_squared == 0) {
-    return simd_quaternion((simd_float4){0,0,0,1});
-  }
-  return simd_quaternion(q.vector * simd_rsqrt(length_squared));
-}
-
-#if defined __arm__ || defined __arm64__
-/*! @abstract Multiplies the vector `v` by the quaternion `q`.
- *  
- *  @discussion This IS NOT the action of `q` on `v` (i.e. this is not rotation
- *  by `q`. That operation is provided by `simd_act(q, v)`. This function is an
- *  implementation detail and you should not call it directly. It may be
- *  removed or modified in future versions of the simd module.                */
-static inline SIMD_CFUNC simd_quatf _simd_mul_vq(simd_float3 v, simd_quatf q) {
-  #pragma STDC FP_CONTRACT ON
-  return simd_quaternion(v.x * __builtin_shufflevector(q.vector, -q.vector, 3,6,1,4) +
-                         v.y * __builtin_shufflevector(q.vector, -q.vector, 2,3,4,5) +
-                         v.z * __builtin_shufflevector(q.vector, -q.vector, 5,0,3,6));
-}
-#endif
-  
-static inline SIMD_CFUNC simd_float3 simd_act(simd_quatf q, simd_float3 v) {
-#if defined __arm__ || defined __arm64__
-  return simd_mul(q, _simd_mul_vq(v, simd_conjugate(q))).vector.xyz;
-#else
-  #pragma STDC FP_CONTRACT ON
-  simd_float3 t = 2*simd_cross(simd_imag(q),v);
-  return v + simd_real(q)*t + simd_cross(simd_imag(q), t);
-#endif
-}
-
-static SIMD_NOINLINE simd_quatf __tg_log(simd_quatf q) {
-  float real = __tg_log(simd_length_squared(q.vector))/2;
-  if (simd_equal(simd_imag(q), 0)) return _simd_quaternion(0, real);
-  simd_float3 imag = __tg_acos(simd_real(q)/simd_length(q)) * simd_normalize(simd_imag(q));
-  return _simd_quaternion(imag, real);
-}
-  
-static SIMD_NOINLINE simd_quatf __tg_exp(simd_quatf q) {
-  //  angle is actually *twice* the angle of the rotation corresponding to
-  //  the resulting quaternion, which is why we don't simply use the (angle,
-  //  axis) constructor to generate `unit`.
-  float angle = simd_length(simd_imag(q));
-  if (angle == 0) return _simd_quaternion(0, exp(simd_real(q)));
-  simd_float3 axis = simd_normalize(simd_imag(q));
-  simd_quatf unit = _simd_quaternion(sin(angle)*axis, cosf(angle));
-  return simd_mul(exp(simd_real(q)), unit);
-}
- 
-/*! @abstract Implementation detail of the `simd_quaternion(from, to)`
- *  initializer.
- *
- *  @discussion Computes the quaternion rotation `from` to `to` if they are
- *  separated by less than 90 degrees. Not numerically stable for larger
- *  angles. This function is an implementation detail and you should not
- *  call it directly. It may be removed or modified in future versions of the
- *  simd module.                                                              */
-static inline SIMD_CFUNC simd_quatf _simd_quaternion_reduced(simd_float3 from, simd_float3 to) {
-  simd_float3 half = simd_normalize(from + to);
-  return _simd_quaternion(simd_cross(from, half), simd_dot(from, half));
-}
-
-static SIMD_NOINLINE simd_quatf simd_quaternion(simd_float3 from, simd_float3 to) {
-  
-  //  If the angle between from and to is not too big, we can compute the
-  //  rotation accurately using a simple implementation.
-  if (simd_dot(from, to) >= 0) {
-    return _simd_quaternion_reduced(from, to);
-  }
-  
-  //  Because from and to are more than 90 degrees apart, we compute the
-  //  rotation in two stages (from -> half), (half -> to) to preserve numerical
-  //  accuracy.
-  simd_float3 half = simd_normalize(from + to);
-  
-  if (simd_length_squared(half) == 0) {
-    //  half is nearly zero, so from and to point in nearly opposite directions
-    //  and the rotation is numerically underspecified. Pick an axis orthogonal
-    //  to the vectors, and use an angle of pi radians.
-    simd_float3 abs_from = simd_abs(from);
-    if (abs_from.x <= abs_from.y && abs_from.x <= abs_from.z)
-      return _simd_quaternion(simd_normalize(simd_cross(from, (simd_float3){1,0,0})), 0.f);
-    else if (abs_from.y <= abs_from.z)
-      return _simd_quaternion(simd_normalize(simd_cross(from, (simd_float3){0,1,0})), 0.f);
-    else
-      return _simd_quaternion(simd_normalize(simd_cross(from, (simd_float3){0,0,1})), 0.f);
-  }
-  
-  //  Compute the two-step rotation.                         */
-  return simd_mul(_simd_quaternion_reduced(from, half),
-                  _simd_quaternion_reduced(half, to));
-}
-
-static SIMD_NOINLINE simd_quatf simd_quaternion(simd_float3x3 matrix) {
-  const simd_float3 *mat = matrix.columns;
-  float trace = mat[0][0] + mat[1][1] + mat[2][2];
-  if (trace >= 0.0) {
-    float r = 2*sqrt(1 + trace);
-    float rinv = simd_recip(r);
-    return simd_quaternion(rinv*(mat[1][2] - mat[2][1]),
-                           rinv*(mat[2][0] - mat[0][2]),
-                           rinv*(mat[0][1] - mat[1][0]),
-                           r/4);
-  } else if (mat[0][0] >= mat[1][1] && mat[0][0] >= mat[2][2]) {
-    float r = 2*sqrt(1 - mat[1][1] - mat[2][2] + mat[0][0]);
-    float rinv = simd_recip(r);
-    return simd_quaternion(r/4,
-                           rinv*(mat[0][1] + mat[1][0]),
-                           rinv*(mat[0][2] + mat[2][0]),
-                           rinv*(mat[1][2] - mat[2][1]));
-  } else if (mat[1][1] >= mat[2][2]) {
-    float r = 2*sqrt(1 - mat[0][0] - mat[2][2] + mat[1][1]);
-    float rinv = simd_recip(r);
-    return simd_quaternion(rinv*(mat[0][1] + mat[1][0]),
-                           r/4,
-                           rinv*(mat[1][2] + mat[2][1]),
-                           rinv*(mat[2][0] - mat[0][2]));
-  } else {
-    float r = 2*sqrt(1 - mat[0][0] - mat[1][1] + mat[2][2]);
-    float rinv = simd_recip(r);
-    return simd_quaternion(rinv*(mat[0][2] + mat[2][0]),
-                           rinv*(mat[1][2] + mat[2][1]),
-                           r/4,
-                           rinv*(mat[0][1] - mat[1][0]));
-  }
-}
-  
-static SIMD_NOINLINE simd_quatf simd_quaternion(simd_float4x4 matrix) {
-  const simd_float4 *mat = matrix.columns;
-  float trace = mat[0][0] + mat[1][1] + mat[2][2];
-  if (trace >= 0.0) {
-    float r = 2*sqrt(1 + trace);
-    float rinv = simd_recip(r);
-    return simd_quaternion(rinv*(mat[1][2] - mat[2][1]),
-                           rinv*(mat[2][0] - mat[0][2]),
-                           rinv*(mat[0][1] - mat[1][0]),
-                           r/4);
-  } else if (mat[0][0] >= mat[1][1] && mat[0][0] >= mat[2][2]) {
-    float r = 2*sqrt(1 - mat[1][1] - mat[2][2] + mat[0][0]);
-    float rinv = simd_recip(r);
-    return simd_quaternion(r/4,
-                           rinv*(mat[0][1] + mat[1][0]),
-                           rinv*(mat[0][2] + mat[2][0]),
-                           rinv*(mat[1][2] - mat[2][1]));
-  } else if (mat[1][1] >= mat[2][2]) {
-    float r = 2*sqrt(1 - mat[0][0] - mat[2][2] + mat[1][1]);
-    float rinv = simd_recip(r);
-    return simd_quaternion(rinv*(mat[0][1] + mat[1][0]),
-                           r/4,
-                           rinv*(mat[1][2] + mat[2][1]),
-                           rinv*(mat[2][0] - mat[0][2]));
-  } else {
-    float r = 2*sqrt(1 - mat[0][0] - mat[1][1] + mat[2][2]);
-    float rinv = simd_recip(r);
-    return simd_quaternion(rinv*(mat[0][2] + mat[2][0]),
-                           rinv*(mat[1][2] + mat[2][1]),
-                           r/4,
-                           rinv*(mat[0][1] - mat[1][0]));
-  }
-}
-  
-/*! @abstract The angle between p and q interpreted as 4-dimensional vectors.
- *
- *  @discussion This function is an implementation detail and you should not
- *  call it directly. It may be removed or modified in future versions of the
- *  simd module.                                                              */
-static SIMD_NOINLINE float _simd_angle(simd_quatf p, simd_quatf q) {
-  return 2*atan2(simd_length(p.vector - q.vector), simd_length(p.vector + q.vector));
-}
-  
-/*! @abstract sin(x)/x.
- *
- *  @discussion This function is an implementation detail and you should not
- *  call it directly. It may be removed or modified in future versions of the
- *  simd module.                                                              */
-static SIMD_CFUNC float _simd_sinc(float x) {
-  if (x == 0) return 1;
-  return sin(x)/x;
-}
- 
-/*! @abstract Spherical lerp between q0 and q1.
- *
- *  @discussion This function may interpolate along either the longer or
- *  shorter path between q0 and q1; it is used as an implementation detail
- *  in `simd_slerp` and `simd_slerp_longest`; you should use those functions
- *  instead of calling this directly.                                         */
-static SIMD_NOINLINE simd_quatf _simd_slerp_internal(simd_quatf q0, simd_quatf q1, float t) {
-  float s = 1 - t;
-  float a = _simd_angle(q0, q1);
-  float r = simd_recip(_simd_sinc(a));
-  return simd_normalize(simd_quaternion(_simd_sinc(s*a)*r*s*q0.vector + _simd_sinc(t*a)*r*t*q1.vector));
-}
-  
-static SIMD_NOINLINE simd_quatf simd_slerp(simd_quatf q0, simd_quatf q1, float t) {
-  if (simd_dot(q0, q1) >= 0)
-    return _simd_slerp_internal(q0, q1, t);
-  return _simd_slerp_internal(q0, simd_negate(q1), t);
-}
-
-static SIMD_NOINLINE simd_quatf simd_slerp_longest(simd_quatf q0, simd_quatf q1, float t) {
-  if (simd_dot(q0, q1) >= 0)
-    return _simd_slerp_internal(q0, simd_negate(q1), t);
-  return _simd_slerp_internal(q0, q1, t);
-}
-  
-/*! @discussion This function is an implementation detail and you should not
- *  call it directly. It may be removed or modified in future versions of the
- *  simd module.                                                              */
-static SIMD_NOINLINE simd_quatf _simd_intermediate(simd_quatf q0, simd_quatf q1, simd_quatf q2) {
-  simd_quatf p0 = __tg_log(simd_mul(q0, simd_inverse(q1)));
-  simd_quatf p2 = __tg_log(simd_mul(q2, simd_inverse(q1)));
-  return simd_normalize(simd_mul(q1, __tg_exp(simd_mul(-0.25, simd_add(p0,p2)))));
-}
-
-/*! @discussion This function is an implementation detail and you should not
- *  call it directly. It may be removed or modified in future versions of the
- *  simd module.                                                              */
-static SIMD_NOINLINE simd_quatf _simd_squad(simd_quatf q0, simd_quatf qa, simd_quatf qb, simd_quatf q1, float t) {
-  simd_quatf r0 = _simd_slerp_internal(q0, q1, t);
-  simd_quatf r1 = _simd_slerp_internal(qa, qb, t);
-  return _simd_slerp_internal(r0, r1, 2*t*(1 - t));
-}
-  
-static SIMD_NOINLINE simd_quatf simd_spline(simd_quatf q0, simd_quatf q1, simd_quatf q2, simd_quatf q3, float t) {
-  simd_quatf qa = _simd_intermediate(q0, q1, q2);
-  simd_quatf qb = _simd_intermediate(q1, q2, q3);
-  return _simd_squad(q1, qa, qb, q2, t);
-}
-  
-static SIMD_NOINLINE simd_quatf simd_bezier(simd_quatf q0, simd_quatf q1, simd_quatf q2, simd_quatf q3, float t) {
-  simd_quatf q01 = _simd_slerp_internal(q0, q1, t);
-  simd_quatf q12 = _simd_slerp_internal(q1, q2, t);
-  simd_quatf q23 = _simd_slerp_internal(q2, q3, t);
-  simd_quatf q012 = _simd_slerp_internal(q01, q12, t);
-  simd_quatf q123 = _simd_slerp_internal(q12, q23, t);
-  return _simd_slerp_internal(q012, q123, t);
-}
-
-/*  MARK: - C and Objective-C double interfaces                                */
-
-/*! @abstract Constructs a quaternion from four scalar values.
- *
- *  @param ix The first component of the imaginary (vector) part.
- *  @param iy The second component of the imaginary (vector) part.
- *  @param iz The third component of the imaginary (vector) part.
- *
- *  @param r The real (scalar) part.                                          */
-static inline SIMD_CFUNC simd_quatd simd_quaternion(double ix, double iy, double iz, double r) {
-  return (simd_quatd){ { ix, iy, iz, r } };
-}
-  
-/*! @abstract Constructs a quaternion from an array of four scalars.
- *
- *  @discussion Note that the imaginary part of the quaternion comes from 
- *  array elements 0, 1, and 2, and the real part comes from element 3.       */
-static inline SIMD_NONCONST simd_quatd simd_quaternion(const double xyzr[4]) {
-  return (simd_quatd){ *(const simd_packed_double4 *)xyzr };
-}
-  
-/*! @abstract Constructs a quaternion from a four-element vector.
- *
- *  @discussion Note that the imaginary (vector) part of the quaternion comes
- *  from lanes 0, 1, and 2 of the vector, and the real (scalar) part comes from
- *  lane 3.                                                                   */
-static inline SIMD_CFUNC simd_quatd simd_quaternion(simd_double4 xyzr) {
-  return (simd_quatd){ xyzr };
-}
-  
-/*! @abstract Constructs a quaternion that rotates by `angle` radians about
- *  `axis`.                                                                   */
-static inline SIMD_CFUNC simd_quatd simd_quaternion(double angle, simd_double3 axis);
-  
-/*! @abstract Construct a quaternion that rotates from one vector to another.
- *
- *  @param from A normalized three-element vector.
- *  @param to A normalized three-element vector.
- *
- *  @discussion The rotation axis is `simd_cross(from, to)`. If `from` and
- *  `to` point in opposite directions (to within machine precision), an
- *  arbitrary rotation axis is chosen, and the angle is pi radians.           */
-static SIMD_NOINLINE simd_quatd simd_quaternion(simd_double3 from, simd_double3 to);
-
-/*! @abstract Construct a quaternion from a 3x3 rotation `matrix`.
- *
- *  @discussion If `matrix` is not orthogonal with determinant 1, the result
- *  is undefined.                                                             */
-static SIMD_NOINLINE simd_quatd simd_quaternion(simd_double3x3 matrix);
-
-/*! @abstract Construct a quaternion from a 4x4 rotation `matrix`.
- *
- *  @discussion The last row and column of the matrix are ignored. This
- *  function is equivalent to calling simd_quaternion with the upper-left 3x3
- *  submatrix                .                                                */
-static SIMD_NOINLINE simd_quatd simd_quaternion(simd_double4x4 matrix);
-  
-/*! @abstract The real (scalar) part of the quaternion `q`.                   */
-static inline SIMD_CFUNC double simd_real(simd_quatd q) {
-  return q.vector.w;
-}
-  
-/*! @abstract The imaginary (vector) part of the quaternion `q`.              */
-static inline SIMD_CFUNC simd_double3 simd_imag(simd_quatd q) {
-  return q.vector.xyz;
-}
-  
-/*! @abstract The angle (in radians) of rotation represented by `q`.          */
-static inline SIMD_CFUNC double simd_angle(simd_quatd q);
-  
-/*! @abstract The normalized axis (a 3-element vector) around which the
- *  action of the quaternion `q` rotates.                                     */
-static inline SIMD_CFUNC simd_double3 simd_axis(simd_quatd q);
-  
-/*! @abstract The sum of the quaternions `p` and `q`.                         */
-static inline SIMD_CFUNC simd_quatd simd_add(simd_quatd p, simd_quatd q);
-  
-/*! @abstract The difference of the quaternions `p` and `q`.                  */
-static inline SIMD_CFUNC simd_quatd simd_sub(simd_quatd p, simd_quatd q);
-  
-/*! @abstract The product of the quaternions `p` and `q`.                     */
-static inline SIMD_CFUNC simd_quatd simd_mul(simd_quatd p, simd_quatd q);
-  
-/*! @abstract The quaternion `q` scaled by the real value `a`.                */
-static inline SIMD_CFUNC simd_quatd simd_mul(simd_quatd q, double a);
-  
-/*! @abstract The quaternion `q` scaled by the real value `a`.                */
-static inline SIMD_CFUNC simd_quatd simd_mul(double a, simd_quatd q);
-  
-/*! @abstract The conjugate of the quaternion `q`.                            */
-static inline SIMD_CFUNC simd_quatd simd_conjugate(simd_quatd q);
-  
-/*! @abstract The (multiplicative) inverse of the quaternion `q`.             */
-static inline SIMD_CFUNC simd_quatd simd_inverse(simd_quatd q);
-  
-/*! @abstract The negation (additive inverse) of the quaternion `q`.          */
-static inline SIMD_CFUNC simd_quatd simd_negate(simd_quatd q);
-  
-/*! @abstract The dot product of the quaternions `p` and `q` interpreted as
- *  four-dimensional vectors.                                                 */
-static inline SIMD_CFUNC double simd_dot(simd_quatd p, simd_quatd q);
-  
-/*! @abstract The length of the quaternion `q`.                               */
-static inline SIMD_CFUNC double simd_length(simd_quatd q);
-  
-/*! @abstract The unit quaternion obtained by normalizing `q`.                */
-static inline SIMD_CFUNC simd_quatd simd_normalize(simd_quatd q);
-  
-/*! @abstract Rotates the vector `v` by the quaternion `q`.                   */
-static inline SIMD_CFUNC simd_double3 simd_act(simd_quatd q, simd_double3 v);
-  
-/*! @abstract Logarithm of the quaternion `q`.
- *  @discussion Do not call this function directly; use `log(q)` instead.
- *
- *  We can write a quaternion `q` in the form: `r(cos(t) + sin(t)v)` where
- *  `r` is the length of `q`, `t` is an angle, and `v` is a unit 3-vector.
- *  The logarithm of `q` is `log(r) + tv`, just like the logarithm of the
- *  complex number `r*(cos(t) + i sin(t))` is `log(r) + it`.
- *
- *  Note that this function is not robust against poorly-scaled non-unit
- *  quaternions, because it is primarily used for spline interpolation of
- *  unit quaternions. If you need to compute a robust logarithm of general
- *  quaternions, you can use the following approach:
- *
- *    scale = simd_reduce_max(simd_abs(q.vector));
- *    logq = log(simd_recip(scale)*q);
- *    logq.real += log(scale);
- *    return logq;                                                            */
-static SIMD_NOINLINE simd_quatd __tg_log(simd_quatd q);
-    
-/*! @abstract Inverse of `log( )`; the exponential map on quaternions.
- *  @discussion Do not call this function directly; use `exp(q)` instead.     */
-static SIMD_NOINLINE simd_quatd __tg_exp(simd_quatd q);
-  
-/*! @abstract Spherical linear interpolation along the shortest arc between
- *  quaternions `q0` and `q1`.                                                */
-static SIMD_NOINLINE simd_quatd simd_slerp(simd_quatd q0, simd_quatd q1, double t);
-
-/*! @abstract Spherical linear interpolation along the longest arc between
- *  quaternions `q0` and `q1`.                                                */
-static SIMD_NOINLINE simd_quatd simd_slerp_longest(simd_quatd q0, simd_quatd q1, double t);
-
-/*! @abstract Interpolate between quaternions along a spherical cubic spline.
- *
- *  @discussion The function interpolates between q1 and q2. q0 is the left
- *  endpoint of the previous interval, and q3 is the right endpoint of the next
- *  interval. Use this function to smoothly interpolate between a sequence of
- *  rotations.                                                                */
-static SIMD_NOINLINE simd_quatd simd_spline(simd_quatd q0, simd_quatd q1, simd_quatd q2, simd_quatd q3, double t);
-
-/*! @abstract Spherical cubic Bezier interpolation between quaternions.
- *
- *  @discussion The function treats q0 ... q3 as control points and uses slerp
- *  in place of lerp in the De Castlejeau algorithm. The endpoints of
- *  interpolation are thus q0 and q3, and the curve will not generally pass
- *  through q1 or q2. Note that the convex hull property of "standard" Bezier
- *  curve does not hold on the sphere.                                        */
-static SIMD_NOINLINE simd_quatd simd_bezier(simd_quatd q0, simd_quatd q1, simd_quatd q2, simd_quatd q3, double t);
-  
-#ifdef __cplusplus
-} /* extern "C" */
-/*  MARK: - C++ double interfaces                                              */
-
-namespace simd {
-  struct quatd : ::simd_quatd {
-    /*! @abstract The identity quaternion.                                    */
-    quatd( ) : ::simd_quatd(::simd_quaternion((double4){0,0,0,1})) { }
-    
-    /*! @abstract Constructs a C++ quaternion from a C quaternion.            */
-    quatd(::simd_quatd q) : ::simd_quatd(q) { }
-    
-    /*! @abstract Constructs a quaternion from components.                    */
-    quatd(double ix, double iy, double iz, double r) : ::simd_quatd(::simd_quaternion(ix, iy, iz, r)) { }
-    
-    /*! @abstract Constructs a quaternion from an array of scalars.           */
-    quatd(const double xyzr[4]) : ::simd_quatd(::simd_quaternion(xyzr)) { }
-    
-    /*! @abstract Constructs a quaternion from a vector.                      */
-    quatd(double4 xyzr) : ::simd_quatd(::simd_quaternion(xyzr)) { }
-    
-    /*! @abstract Quaternion representing rotation about `axis` by `angle` 
-     *  radians.                                                              */
-    quatd(double angle, double3 axis) : ::simd_quatd(::simd_quaternion(angle, axis)) { }
-    
-    /*! @abstract Quaternion that rotates `from` into `to`.                   */
-    quatd(double3 from, double3 to) : ::simd_quatd(::simd_quaternion(from, to)) { }
-    
-    /*! @abstract Constructs a quaternion from a rotation matrix.             */
-    quatd(::simd_double3x3 matrix) : ::simd_quatd(::simd_quaternion(matrix)) { }
-    
-    /*! @abstract Constructs a quaternion from a rotation matrix.             */
-    quatd(::simd_double4x4 matrix) : ::simd_quatd(::simd_quaternion(matrix)) { }
-  
-    /*! @abstract The real (scalar) part of the quaternion.                   */
-    double real(void) const { return ::simd_real(*this); }
-    
-    /*! @abstract The imaginary (vector) part of the quaternion.              */
-    double3 imag(void) const { return ::simd_imag(*this); }
-    
-    /*! @abstract The angle the quaternion rotates by.                        */
-    double angle(void) const { return ::simd_angle(*this); }
-    
-    /*! @abstract The axis the quaternion rotates about.                      */
-    double3 axis(void) const { return ::simd_axis(*this); }
-    
-    /*! @abstract The length of the quaternion.                               */
-    double length(void) const { return ::simd_length(*this); }
-    
-    /*! @abstract Act on the vector `v` by rotation.                          */
-    double3  operator()(const ::simd_double3 v) const { return ::simd_act(*this, v); }
-  };
-  
-  static SIMD_CPPFUNC quatd operator+(const ::simd_quatd p, const ::simd_quatd q) { return ::simd_add(p, q); }
-  static SIMD_CPPFUNC quatd operator-(const ::simd_quatd p, const ::simd_quatd q) { return ::simd_sub(p, q); }
-  static SIMD_CPPFUNC quatd operator-(const ::simd_quatd p) { return ::simd_negate(p); }
-  static SIMD_CPPFUNC quatd operator*(const double r, const ::simd_quatd p) { return ::simd_mul(r, p); }
-  static SIMD_CPPFUNC quatd operator*(const ::simd_quatd p, const double r) { return ::simd_mul(p, r); }
-  static SIMD_CPPFUNC quatd operator*(const ::simd_quatd p, const ::simd_quatd q) { return ::simd_mul(p, q); }
-  static SIMD_CPPFUNC quatd operator/(const ::simd_quatd p, const ::simd_quatd q) { return ::simd_mul(p, ::simd_inverse(q)); }
-  static SIMD_CPPFUNC quatd operator+=(quatd &p, const ::simd_quatd q) { return p = p+q; }
-  static SIMD_CPPFUNC quatd operator-=(quatd &p, const ::simd_quatd q) { return p = p-q; }
-  static SIMD_CPPFUNC quatd operator*=(quatd &p, const double r) { return p = p*r; }
-  static SIMD_CPPFUNC quatd operator*=(quatd &p, const ::simd_quatd q) { return p = p*q; }
-  static SIMD_CPPFUNC quatd operator/=(quatd &p, const ::simd_quatd q) { return p = p/q; }
-  
-  /*! @abstract The conjugate of the quaternion `q`.                          */
-  static SIMD_CPPFUNC quatd conjugate(const ::simd_quatd p) { return ::simd_conjugate(p); }
-  
-  /*! @abstract The (multiplicative) inverse of the quaternion `q`.           */
-  static SIMD_CPPFUNC quatd inverse(const ::simd_quatd p) { return ::simd_inverse(p); }
-
-  /*! @abstract The dot product of the quaternions `p` and `q` interpreted as
-   *  four-dimensional vectors.                                               */
-  static SIMD_CPPFUNC double dot(const ::simd_quatd p, const ::simd_quatd q) { return ::simd_dot(p, q); }
-  
-  /*! @abstract The unit quaternion obtained by normalizing `q`.              */
-  static SIMD_CPPFUNC quatd normalize(const ::simd_quatd p) { return ::simd_normalize(p); }
-
-  /*! @abstract logarithm of the quaternion `q`.                              */
-  static SIMD_CPPFUNC quatd log(const ::simd_quatd q) { return ::__tg_log(q); }
-
-  /*! @abstract exponential map of quaterion `q`.                             */
-  static SIMD_CPPFUNC quatd exp(const ::simd_quatd q) { return ::__tg_exp(q); }
-  
-  /*! @abstract Spherical linear interpolation along the shortest arc between
-   *  quaternions `q0` and `q1`.                                              */
-  static SIMD_CPPFUNC quatd slerp(const ::simd_quatd p0, const ::simd_quatd p1, double t) { return ::simd_slerp(p0, p1, t); }
-  
-  /*! @abstract Spherical linear interpolation along the longest arc between
-   *  quaternions `q0` and `q1`.                                              */
-  static SIMD_CPPFUNC quatd slerp_longest(const ::simd_quatd p0, const ::simd_quatd p1, double t) { return ::simd_slerp_longest(p0, p1, t); }
-  
-  /*! @abstract Interpolate between quaternions along a spherical cubic spline.
-   *
-   *  @discussion The function interpolates between q1 and q2. q0 is the left
-   *  endpoint of the previous interval, and q3 is the right endpoint of the next
-   *  interval. Use this function to smoothly interpolate between a sequence of
-   *  rotations.                                                              */
-  static SIMD_CPPFUNC quatd spline(const ::simd_quatd p0, const ::simd_quatd p1, const ::simd_quatd p2, const ::simd_quatd p3, double t) { return ::simd_spline(p0, p1, p2, p3, t); }
-  
-  /*! @abstract Spherical cubic Bezier interpolation between quaternions.
-   *
-   *  @discussion The function treats q0 ... q3 as control points and uses slerp
-   *  in place of lerp in the De Castlejeau algorithm. The endpoints of
-   *  interpolation are thus q0 and q3, and the curve will not generally pass
-   *  through q1 or q2. Note that the convex hull property of "standard" Bezier
-   *  curve does not hold on the sphere.                                      */
-  static SIMD_CPPFUNC quatd bezier(const ::simd_quatd p0, const ::simd_quatd p1, const ::simd_quatd p2, const ::simd_quatd p3, double t) { return ::simd_bezier(p0, p1, p2, p3, t); }
-}
-
-extern "C" {
-#endif /* __cplusplus */
-  
-/*  MARK: - double implementations                                             */
-
-#include <simd/math.h>
-#include <simd/geometry.h>
-  
-/*  tg_promote is implementation gobbledygook that enables the compile-time
- *  dispatching in tgmath.h to work its magic.                                */
-static simd_quatd __attribute__((__overloadable__)) __tg_promote(simd_quatd);
-  
-/*! @abstract Constructs a quaternion from imaginary and real parts.
- *  @discussion This function is hidden behind an underscore to avoid confusion
- *  with the angle-axis constructor.                                          */
-static inline SIMD_CFUNC simd_quatd _simd_quaternion(simd_double3 imag, double real) {
-  return simd_quaternion(simd_make_double4(imag, real));
-}
-  
-static inline SIMD_CFUNC simd_quatd simd_quaternion(double angle, simd_double3 axis) {
-  return _simd_quaternion(sin(angle/2) * axis, cos(angle/2));
-}
-  
-static inline SIMD_CFUNC double simd_angle(simd_quatd q) {
-  return 2*atan2(simd_length(q.vector.xyz), q.vector.w);
-}
-  
-static inline SIMD_CFUNC simd_double3 simd_axis(simd_quatd q) {
-  return simd_normalize(q.vector.xyz);
-}
-  
-static inline SIMD_CFUNC simd_quatd simd_add(simd_quatd p, simd_quatd q) {
-  return simd_quaternion(p.vector + q.vector);
-}
-  
-static inline SIMD_CFUNC simd_quatd simd_sub(simd_quatd p, simd_quatd q) {
-  return simd_quaternion(p.vector - q.vector);
-}
-
-static inline SIMD_CFUNC simd_quatd simd_mul(simd_quatd p, simd_quatd q) {
-  #pragma STDC FP_CONTRACT ON
-  return simd_quaternion((p.vector.x * __builtin_shufflevector(q.vector, -q.vector, 3,6,1,4) +
-                          p.vector.y * __builtin_shufflevector(q.vector, -q.vector, 2,3,4,5)) +
-                         (p.vector.z * __builtin_shufflevector(q.vector, -q.vector, 5,0,3,6) +
-                          p.vector.w * q.vector));
-}
-
-static inline SIMD_CFUNC simd_quatd simd_mul(simd_quatd q, double a) {
-  return simd_quaternion(a * q.vector);
-}
-
-static inline SIMD_CFUNC simd_quatd simd_mul(double a, simd_quatd q) {
-  return simd_mul(q,a);
-}
-  
-static inline SIMD_CFUNC simd_quatd simd_conjugate(simd_quatd q) {
-  return simd_quaternion(q.vector * (simd_double4){-1,-1,-1, 1});
-}
-  
-static inline SIMD_CFUNC simd_quatd simd_inverse(simd_quatd q) {
-  return simd_quaternion(simd_conjugate(q).vector * simd_recip(simd_length_squared(q.vector)));
-}
-  
-static inline SIMD_CFUNC simd_quatd simd_negate(simd_quatd q) {
-  return simd_quaternion(-q.vector);
-}
-  
-static inline SIMD_CFUNC double simd_dot(simd_quatd p, simd_quatd q) {
-  return simd_dot(p.vector, q.vector);
-}
-  
-static inline SIMD_CFUNC double simd_length(simd_quatd q) {
-  return simd_length(q.vector);
-}
-  
-static inline SIMD_CFUNC simd_quatd simd_normalize(simd_quatd q) {
-  double length_squared = simd_length_squared(q.vector);
-  if (length_squared == 0) {
-    return simd_quaternion((simd_double4){0,0,0,1});
-  }
-  return simd_quaternion(q.vector * simd_rsqrt(length_squared));
-}
-
-#if defined __arm__ || defined __arm64__
-/*! @abstract Multiplies the vector `v` by the quaternion `q`.
- *  
- *  @discussion This IS NOT the action of `q` on `v` (i.e. this is not rotation
- *  by `q`. That operation is provided by `simd_act(q, v)`. This function is an
- *  implementation detail and you should not call it directly. It may be
- *  removed or modified in future versions of the simd module.                */
-static inline SIMD_CFUNC simd_quatd _simd_mul_vq(simd_double3 v, simd_quatd q) {
-  #pragma STDC FP_CONTRACT ON
-  return simd_quaternion(v.x * __builtin_shufflevector(q.vector, -q.vector, 3,6,1,4) +
-                         v.y * __builtin_shufflevector(q.vector, -q.vector, 2,3,4,5) +
-                         v.z * __builtin_shufflevector(q.vector, -q.vector, 5,0,3,6));
-}
-#endif
-  
-static inline SIMD_CFUNC simd_double3 simd_act(simd_quatd q, simd_double3 v) {
-#if defined __arm__ || defined __arm64__
-  return simd_mul(q, _simd_mul_vq(v, simd_conjugate(q))).vector.xyz;
-#else
-  #pragma STDC FP_CONTRACT ON
-  simd_double3 t = 2*simd_cross(simd_imag(q),v);
-  return v + simd_real(q)*t + simd_cross(simd_imag(q), t);
-#endif
-}
-
-static SIMD_NOINLINE simd_quatd __tg_log(simd_quatd q) {
-  double real = __tg_log(simd_length_squared(q.vector))/2;
-  if (simd_equal(simd_imag(q), 0)) return _simd_quaternion(0, real);
-  simd_double3 imag = __tg_acos(simd_real(q)/simd_length(q)) * simd_normalize(simd_imag(q));
-  return _simd_quaternion(imag, real);
-}
-  
-static SIMD_NOINLINE simd_quatd __tg_exp(simd_quatd q) {
-  //  angle is actually *twice* the angle of the rotation corresponding to
-  //  the resulting quaternion, which is why we don't simply use the (angle,
-  //  axis) constructor to generate `unit`.
-  double angle = simd_length(simd_imag(q));
-  if (angle == 0) return _simd_quaternion(0, exp(simd_real(q)));
-  simd_double3 axis = simd_normalize(simd_imag(q));
-  simd_quatd unit = _simd_quaternion(sin(angle)*axis, cosf(angle));
-  return simd_mul(exp(simd_real(q)), unit);
-}
- 
-/*! @abstract Implementation detail of the `simd_quaternion(from, to)`
- *  initializer.
- *
- *  @discussion Computes the quaternion rotation `from` to `to` if they are
- *  separated by less than 90 degrees. Not numerically stable for larger
- *  angles. This function is an implementation detail and you should not
- *  call it directly. It may be removed or modified in future versions of the
- *  simd module.                                                              */
-static inline SIMD_CFUNC simd_quatd _simd_quaternion_reduced(simd_double3 from, simd_double3 to) {
-  simd_double3 half = simd_normalize(from + to);
-  return _simd_quaternion(simd_cross(from, half), simd_dot(from, half));
-}
-
-static SIMD_NOINLINE simd_quatd simd_quaternion(simd_double3 from, simd_double3 to) {
-  
-  //  If the angle between from and to is not too big, we can compute the
-  //  rotation accurately using a simple implementation.
-  if (simd_dot(from, to) >= 0) {
-    return _simd_quaternion_reduced(from, to);
-  }
-  
-  //  Because from and to are more than 90 degrees apart, we compute the
-  //  rotation in two stages (from -> half), (half -> to) to preserve numerical
-  //  accuracy.
-  simd_double3 half = simd_normalize(from + to);
-  
-  if (simd_length_squared(half) == 0) {
-    //  half is nearly zero, so from and to point in nearly opposite directions
-    //  and the rotation is numerically underspecified. Pick an axis orthogonal
-    //  to the vectors, and use an angle of pi radians.
-    simd_double3 abs_from = simd_abs(from);
-    if (abs_from.x <= abs_from.y && abs_from.x <= abs_from.z)
-      return _simd_quaternion(simd_normalize(simd_cross(from, (simd_double3){1,0,0})), 0.f);
-    else if (abs_from.y <= abs_from.z)
-      return _simd_quaternion(simd_normalize(simd_cross(from, (simd_double3){0,1,0})), 0.f);
-    else
-      return _simd_quaternion(simd_normalize(simd_cross(from, (simd_double3){0,0,1})), 0.f);
-  }
-  
-  //  Compute the two-step rotation.                         */
-  return simd_mul(_simd_quaternion_reduced(from, half),
-                  _simd_quaternion_reduced(half, to));
-}
-
-static SIMD_NOINLINE simd_quatd simd_quaternion(simd_double3x3 matrix) {
-  const simd_double3 *mat = matrix.columns;
-  double trace = mat[0][0] + mat[1][1] + mat[2][2];
-  if (trace >= 0.0) {
-    double r = 2*sqrt(1 + trace);
-    double rinv = simd_recip(r);
-    return simd_quaternion(rinv*(mat[1][2] - mat[2][1]),
-                           rinv*(mat[2][0] - mat[0][2]),
-                           rinv*(mat[0][1] - mat[1][0]),
-                           r/4);
-  } else if (mat[0][0] >= mat[1][1] && mat[0][0] >= mat[2][2]) {
-    double r = 2*sqrt(1 - mat[1][1] - mat[2][2] + mat[0][0]);
-    double rinv = simd_recip(r);
-    return simd_quaternion(r/4,
-                           rinv*(mat[0][1] + mat[1][0]),
-                           rinv*(mat[0][2] + mat[2][0]),
-                           rinv*(mat[1][2] - mat[2][1]));
-  } else if (mat[1][1] >= mat[2][2]) {
-    double r = 2*sqrt(1 - mat[0][0] - mat[2][2] + mat[1][1]);
-    double rinv = simd_recip(r);
-    return simd_quaternion(rinv*(mat[0][1] + mat[1][0]),
-                           r/4,
-                           rinv*(mat[1][2] + mat[2][1]),
-                           rinv*(mat[2][0] - mat[0][2]));
-  } else {
-    double r = 2*sqrt(1 - mat[0][0] - mat[1][1] + mat[2][2]);
-    double rinv = simd_recip(r);
-    return simd_quaternion(rinv*(mat[0][2] + mat[2][0]),
-                           rinv*(mat[1][2] + mat[2][1]),
-                           r/4,
-                           rinv*(mat[0][1] - mat[1][0]));
-  }
-}
-  
-static SIMD_NOINLINE simd_quatd simd_quaternion(simd_double4x4 matrix) {
-  const simd_double4 *mat = matrix.columns;
-  double trace = mat[0][0] + mat[1][1] + mat[2][2];
-  if (trace >= 0.0) {
-    double r = 2*sqrt(1 + trace);
-    double rinv = simd_recip(r);
-    return simd_quaternion(rinv*(mat[1][2] - mat[2][1]),
-                           rinv*(mat[2][0] - mat[0][2]),
-                           rinv*(mat[0][1] - mat[1][0]),
-                           r/4);
-  } else if (mat[0][0] >= mat[1][1] && mat[0][0] >= mat[2][2]) {
-    double r = 2*sqrt(1 - mat[1][1] - mat[2][2] + mat[0][0]);
-    double rinv = simd_recip(r);
-    return simd_quaternion(r/4,
-                           rinv*(mat[0][1] + mat[1][0]),
-                           rinv*(mat[0][2] + mat[2][0]),
-                           rinv*(mat[1][2] - mat[2][1]));
-  } else if (mat[1][1] >= mat[2][2]) {
-    double r = 2*sqrt(1 - mat[0][0] - mat[2][2] + mat[1][1]);
-    double rinv = simd_recip(r);
-    return simd_quaternion(rinv*(mat[0][1] + mat[1][0]),
-                           r/4,
-                           rinv*(mat[1][2] + mat[2][1]),
-                           rinv*(mat[2][0] - mat[0][2]));
-  } else {
-    double r = 2*sqrt(1 - mat[0][0] - mat[1][1] + mat[2][2]);
-    double rinv = simd_recip(r);
-    return simd_quaternion(rinv*(mat[0][2] + mat[2][0]),
-                           rinv*(mat[1][2] + mat[2][1]),
-                           r/4,
-                           rinv*(mat[0][1] - mat[1][0]));
-  }
-}
-  
-/*! @abstract The angle between p and q interpreted as 4-dimensional vectors.
- *
- *  @discussion This function is an implementation detail and you should not
- *  call it directly. It may be removed or modified in future versions of the
- *  simd module.                                                              */
-static SIMD_NOINLINE double _simd_angle(simd_quatd p, simd_quatd q) {
-  return 2*atan2(simd_length(p.vector - q.vector), simd_length(p.vector + q.vector));
-}
-  
-/*! @abstract sin(x)/x.
- *
- *  @discussion This function is an implementation detail and you should not
- *  call it directly. It may be removed or modified in future versions of the
- *  simd module.                                                              */
-static SIMD_CFUNC double _simd_sinc(double x) {
-  if (x == 0) return 1;
-  return sin(x)/x;
-}
- 
-/*! @abstract Spherical lerp between q0 and q1.
- *
- *  @discussion This function may interpolate along either the longer or
- *  shorter path between q0 and q1; it is used as an implementation detail
- *  in `simd_slerp` and `simd_slerp_longest`; you should use those functions
- *  instead of calling this directly.                                         */
-static SIMD_NOINLINE simd_quatd _simd_slerp_internal(simd_quatd q0, simd_quatd q1, double t) {
-  double s = 1 - t;
-  double a = _simd_angle(q0, q1);
-  double r = simd_recip(_simd_sinc(a));
-  return simd_normalize(simd_quaternion(_simd_sinc(s*a)*r*s*q0.vector + _simd_sinc(t*a)*r*t*q1.vector));
-}
-  
-static SIMD_NOINLINE simd_quatd simd_slerp(simd_quatd q0, simd_quatd q1, double t) {
-  if (simd_dot(q0, q1) >= 0)
-    return _simd_slerp_internal(q0, q1, t);
-  return _simd_slerp_internal(q0, simd_negate(q1), t);
-}
-
-static SIMD_NOINLINE simd_quatd simd_slerp_longest(simd_quatd q0, simd_quatd q1, double t) {
-  if (simd_dot(q0, q1) >= 0)
-    return _simd_slerp_internal(q0, simd_negate(q1), t);
-  return _simd_slerp_internal(q0, q1, t);
-}
-  
-/*! @discussion This function is an implementation detail and you should not
- *  call it directly. It may be removed or modified in future versions of the
- *  simd module.                                                              */
-static SIMD_NOINLINE simd_quatd _simd_intermediate(simd_quatd q0, simd_quatd q1, simd_quatd q2) {
-  simd_quatd p0 = __tg_log(simd_mul(q0, simd_inverse(q1)));
-  simd_quatd p2 = __tg_log(simd_mul(q2, simd_inverse(q1)));
-  return simd_normalize(simd_mul(q1, __tg_exp(simd_mul(-0.25, simd_add(p0,p2)))));
-}
-
-/*! @discussion This function is an implementation detail and you should not
- *  call it directly. It may be removed or modified in future versions of the
- *  simd module.                                                              */
-static SIMD_NOINLINE simd_quatd _simd_squad(simd_quatd q0, simd_quatd qa, simd_quatd qb, simd_quatd q1, double t) {
-  simd_quatd r0 = _simd_slerp_internal(q0, q1, t);
-  simd_quatd r1 = _simd_slerp_internal(qa, qb, t);
-  return _simd_slerp_internal(r0, r1, 2*t*(1 - t));
-}
-  
-static SIMD_NOINLINE simd_quatd simd_spline(simd_quatd q0, simd_quatd q1, simd_quatd q2, simd_quatd q3, double t) {
-  simd_quatd qa = _simd_intermediate(q0, q1, q2);
-  simd_quatd qb = _simd_intermediate(q1, q2, q3);
-  return _simd_squad(q1, qa, qb, q2, t);
-}
-  
-static SIMD_NOINLINE simd_quatd simd_bezier(simd_quatd q0, simd_quatd q1, simd_quatd q2, simd_quatd q3, double t) {
-  simd_quatd q01 = _simd_slerp_internal(q0, q1, t);
-  simd_quatd q12 = _simd_slerp_internal(q1, q2, t);
-  simd_quatd q23 = _simd_slerp_internal(q2, q3, t);
-  simd_quatd q012 = _simd_slerp_internal(q01, q12, t);
-  simd_quatd q123 = _simd_slerp_internal(q12, q23, t);
-  return _simd_slerp_internal(q012, q123, t);
-}
-
-#ifdef __cplusplus
-}      /* extern "C"  */
-#endif /* __cplusplus */
-#endif /* SIMD_COMPILER_HAS_REQUIRED_FEATURES */
-#endif /* SIMD_QUATERNIONS */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/spawn.h b/lib/libc/include/x86_64-macos-gnu/spawn.h
deleted file mode 100644
index 8441df3abe..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/spawn.h
+++ /dev/null
@@ -1,165 +0,0 @@
-/*
- * Copyright (c) 2006, 2010 Apple Inc. All rights reserved.
- *
- * @APPLE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this
- * file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_LICENSE_HEADER_END@
- */
-
-
-#ifndef _SPAWN_H_
-#define _SPAWN_H_
-
-/*
- * [SPN] Support for _POSIX_SPAWN
- */
-
-#include <sys/cdefs.h>
-#include <_types.h>
-#include <sys/spawn.h> /* shared types */
-
-#include <Availability.h>
-
-/*
- * [SPN] Inclusion of the <spawn.h> header may make visible symbols defined
- * in the <sched.h>, <signal.h>, and <sys/types.h> headers.
- */
-#include <sys/_types/_pid_t.h>
-#include <sys/_types/_sigset_t.h>
-#include <sys/_types/_mode_t.h>
-
-/*
- * Opaque types for use with posix_spawn() family functions.  Internals are
- * not defined, and should not be accessed directly.  Types are defined as
- * mandated by POSIX.
- */
-typedef  void *posix_spawnattr_t;
-typedef  void *posix_spawn_file_actions_t;
-
-__BEGIN_DECLS
-/*
- * gcc under c99 mode won't compile "[ __restrict]" by itself.  As a workaround,
- * a dummy argument name is added.
- */
-
-int     posix_spawn(pid_t * __restrict, const char * __restrict,
-    const posix_spawn_file_actions_t *,
-    const posix_spawnattr_t * __restrict,
-    char *const __argv[__restrict],
-    char *const __envp[__restrict]) __API_AVAILABLE(macos(10.5), ios(2.0)) __API_UNAVAILABLE(watchos, tvos);
-
-int     posix_spawnp(pid_t * __restrict, const char * __restrict,
-    const posix_spawn_file_actions_t *,
-    const posix_spawnattr_t * __restrict,
-    char *const __argv[__restrict],
-    char *const __envp[__restrict]) __API_AVAILABLE(macos(10.5), ios(2.0));
-
-int     posix_spawn_file_actions_addclose(posix_spawn_file_actions_t *, int) __API_AVAILABLE(macos(10.5), ios(2.0)) __API_UNAVAILABLE(watchos, tvos);
-
-int     posix_spawn_file_actions_adddup2(posix_spawn_file_actions_t *, int,
-    int) __API_AVAILABLE(macos(10.5), ios(2.0)) __API_UNAVAILABLE(watchos, tvos);
-
-int     posix_spawn_file_actions_addopen(
-	posix_spawn_file_actions_t * __restrict, int,
-	const char * __restrict, int, mode_t) __API_AVAILABLE(macos(10.5), ios(2.0)) __API_UNAVAILABLE(watchos, tvos);
-
-int     posix_spawn_file_actions_destroy(posix_spawn_file_actions_t *) __API_AVAILABLE(macos(10.5), ios(2.0)) __API_UNAVAILABLE(watchos, tvos);
-
-int     posix_spawn_file_actions_init(posix_spawn_file_actions_t *) __API_AVAILABLE(macos(10.5), ios(2.0)) __API_UNAVAILABLE(watchos, tvos);
-
-int     posix_spawnattr_destroy(posix_spawnattr_t *) __API_AVAILABLE(macos(10.5), ios(2.0)) __API_UNAVAILABLE(watchos, tvos);
-
-int     posix_spawnattr_getsigdefault(const posix_spawnattr_t * __restrict,
-    sigset_t * __restrict) __API_AVAILABLE(macos(10.5), ios(2.0)) __API_UNAVAILABLE(watchos, tvos);
-
-int     posix_spawnattr_getflags(const posix_spawnattr_t * __restrict,
-    short * __restrict) __API_AVAILABLE(macos(10.5), ios(2.0)) __API_UNAVAILABLE(watchos, tvos);
-
-int     posix_spawnattr_getpgroup(const posix_spawnattr_t * __restrict,
-    pid_t * __restrict) __API_AVAILABLE(macos(10.5), ios(2.0)) __API_UNAVAILABLE(watchos, tvos);
-
-int     posix_spawnattr_getsigmask(const posix_spawnattr_t * __restrict,
-    sigset_t * __restrict) __API_AVAILABLE(macos(10.5), ios(2.0)) __API_UNAVAILABLE(watchos, tvos);
-
-int     posix_spawnattr_init(posix_spawnattr_t *) __API_AVAILABLE(macos(10.5), ios(2.0)) __API_UNAVAILABLE(watchos, tvos);
-
-int     posix_spawnattr_setsigdefault(posix_spawnattr_t * __restrict,
-    const sigset_t * __restrict) __API_AVAILABLE(macos(10.5), ios(2.0)) __API_UNAVAILABLE(watchos, tvos);
-
-int     posix_spawnattr_setflags(posix_spawnattr_t *, short) __API_AVAILABLE(macos(10.5), ios(2.0)) __API_UNAVAILABLE(watchos, tvos);
-
-int     posix_spawnattr_setpgroup(posix_spawnattr_t *, pid_t) __API_AVAILABLE(macos(10.5), ios(2.0)) __API_UNAVAILABLE(watchos, tvos);
-
-int     posix_spawnattr_setsigmask(posix_spawnattr_t * __restrict,
-    const sigset_t * __restrict) __API_AVAILABLE(macos(10.5), ios(2.0)) __API_UNAVAILABLE(watchos, tvos);
-
-#if 0   /* _POSIX_PRIORITY_SCHEDULING [PS] : not supported */
-int     posix_spawnattr_setschedparam(posix_spawnattr_t * __restrict,
-    const struct sched_param * __restrict);
-int     posix_spawnattr_setschedpolicy(posix_spawnattr_t *, int);
-int     posix_spawnattr_getschedparam(const posix_spawnattr_t * __restrict,
-    struct sched_param * __restrict);
-int     posix_spawnattr_getschedpolicy(const posix_spawnattr_t * __restrict,
-    int * __restrict);
-#endif  /* 0 */
-
-__END_DECLS
-
-#if     !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-/*
- * Darwin-specific extensions below
- */
-#include <mach/exception_types.h>
-#include <mach/machine.h>
-#include <mach/port.h>
-
-#include <sys/_types/_size_t.h>
-
-__BEGIN_DECLS
-
-int     posix_spawnattr_getbinpref_np(const posix_spawnattr_t * __restrict,
-    size_t, cpu_type_t *__restrict, size_t *__restrict) __API_AVAILABLE(macos(10.5), ios(2.0)) __API_UNAVAILABLE(watchos, tvos);
-
-int     posix_spawnattr_setauditsessionport_np(posix_spawnattr_t * __restrict,
-    mach_port_t) __API_AVAILABLE(macos(10.6), ios(3.2));
-
-int     posix_spawnattr_setbinpref_np(posix_spawnattr_t * __restrict,
-    size_t, cpu_type_t *__restrict, size_t *__restrict) __API_AVAILABLE(macos(10.5), ios(2.0)) __API_UNAVAILABLE(watchos, tvos);
-
-int     posix_spawnattr_setexceptionports_np(posix_spawnattr_t * __restrict,
-    exception_mask_t, mach_port_t,
-    exception_behavior_t, thread_state_flavor_t) __API_AVAILABLE(macos(10.5), ios(2.0)) __API_UNAVAILABLE(watchos, tvos);
-
-int     posix_spawnattr_setspecialport_np(posix_spawnattr_t * __restrict,
-    mach_port_t, int) __API_AVAILABLE(macos(10.5), ios(2.0)) __API_UNAVAILABLE(watchos, tvos);
-
-int     posix_spawnattr_setsuidcredport_np(posix_spawnattr_t * __restrict, mach_port_t) __API_UNAVAILABLE(ios, macos);
-
-int     posix_spawn_file_actions_addinherit_np(posix_spawn_file_actions_t *,
-    int) __API_AVAILABLE(macos(10.7), ios(4.3)) __API_UNAVAILABLE(watchos, tvos);
-
-int     posix_spawn_file_actions_addchdir_np(posix_spawn_file_actions_t *,
-    const char * __restrict) __API_AVAILABLE(macos(10.15)) __API_UNAVAILABLE(ios, tvos, watchos);
-
-int     posix_spawn_file_actions_addfchdir_np(posix_spawn_file_actions_t *,
-    int) __API_AVAILABLE(macos(10.15)) __API_UNAVAILABLE(ios, tvos, watchos);
-
-__END_DECLS
-
-#endif /* (!_POSIX_C_SOURCE || _DARWIN_C_SOURCE) */
-#endif  /* _SPAWN_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/stdio.h b/lib/libc/include/x86_64-macos-gnu/stdio.h
deleted file mode 100644
index 0a756d415d..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/stdio.h
+++ /dev/null
@@ -1,410 +0,0 @@
-/*
- * Copyright (c) 2000, 2005, 2007, 2009, 2010 Apple Inc. All rights reserved.
- *
- * @APPLE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this
- * file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_LICENSE_HEADER_END@
- */
-/*-
- * Copyright (c) 1990, 1993
- *	The Regents of the University of California.  All rights reserved.
- *
- * This code is derived from software contributed to Berkeley by
- * Chris Torek.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *	This product includes software developed by the University of
- *	California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *	@(#)stdio.h	8.5 (Berkeley) 4/29/95
- */
-
-#ifndef	_STDIO_H_
-#define	_STDIO_H_
-
-#include <_stdio.h>
-
-__BEGIN_DECLS
-extern FILE *__stdinp;
-extern FILE *__stdoutp;
-extern FILE *__stderrp;
-__END_DECLS
-
-#define	__SLBF	0x0001		/* line buffered */
-#define	__SNBF	0x0002		/* unbuffered */
-#define	__SRD	0x0004		/* OK to read */
-#define	__SWR	0x0008		/* OK to write */
-	/* RD and WR are never simultaneously asserted */
-#define	__SRW	0x0010		/* open for reading & writing */
-#define	__SEOF	0x0020		/* found EOF */
-#define	__SERR	0x0040		/* found error */
-#define	__SMBF	0x0080		/* _buf is from malloc */
-#define	__SAPP	0x0100		/* fdopen()ed in append mode */
-#define	__SSTR	0x0200		/* this is an sprintf/snprintf string */
-#define	__SOPT	0x0400		/* do fseek() optimisation */
-#define	__SNPT	0x0800		/* do not do fseek() optimisation */
-#define	__SOFF	0x1000		/* set iff _offset is in fact correct */
-#define	__SMOD	0x2000		/* true => fgetln modified _p text */
-#define __SALC  0x4000		/* allocate string space dynamically */
-#define __SIGN  0x8000		/* ignore this file in _fwalk */
-
-/*
- * The following three definitions are for ANSI C, which took them
- * from System V, which brilliantly took internal interface macros and
- * made them official arguments to setvbuf(), without renaming them.
- * Hence, these ugly _IOxxx names are *supposed* to appear in user code.
- *
- * Although numbered as their counterparts above, the implementation
- * does not rely on this.
- */
-#define	_IOFBF	0		/* setvbuf should set fully buffered */
-#define	_IOLBF	1		/* setvbuf should set line buffered */
-#define	_IONBF	2		/* setvbuf should set unbuffered */
-
-#define	BUFSIZ	1024		/* size of buffer used by setbuf */
-#define	EOF	(-1)
-
-				/* must be == _POSIX_STREAM_MAX <limits.h> */
-#define	FOPEN_MAX	20	/* must be <= OPEN_MAX <sys/syslimits.h> */
-#define	FILENAME_MAX	1024	/* must be <= PATH_MAX <sys/syslimits.h> */
-
-/* System V/ANSI C; this is the wrong way to do this, do *not* use these. */
-#ifndef _ANSI_SOURCE
-#define	P_tmpdir	"/var/tmp/"
-#endif
-#define	L_tmpnam	1024	/* XXX must be == PATH_MAX */
-#define	TMP_MAX		308915776
-
-#ifndef SEEK_SET
-#define	SEEK_SET	0	/* set file offset to offset */
-#endif
-#ifndef SEEK_CUR
-#define	SEEK_CUR	1	/* set file offset to current plus offset */
-#endif
-#ifndef SEEK_END
-#define	SEEK_END	2	/* set file offset to EOF plus offset */
-#endif
-
-#define	stdin	__stdinp
-#define	stdout	__stdoutp
-#define	stderr	__stderrp
-
-#ifdef _DARWIN_UNLIMITED_STREAMS
-#if defined(__IPHONE_OS_VERSION_MIN_REQUIRED) && __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_3_2
-#error "_DARWIN_UNLIMITED_STREAMS specified, but -miphoneos-version-min version does not support it."
-#elif defined(__MAC_OS_X_VERSION_MIN_REQUIRED) && __MAC_OS_X_VERSION_MIN_REQUIRED < __MAC_10_6
-#error "_DARWIN_UNLIMITED_STREAMS specified, but -mmacosx-version-min version does not support it."
-#endif
-#endif
-
-/* ANSI-C */
-
-__BEGIN_DECLS
-void	 clearerr(FILE *);
-int	 fclose(FILE *);
-int	 feof(FILE *);
-int	 ferror(FILE *);
-int	 fflush(FILE *);
-int	 fgetc(FILE *);
-int	 fgetpos(FILE * __restrict, fpos_t *);
-char	*fgets(char * __restrict, int, FILE *);
-#if defined(_DARWIN_UNLIMITED_STREAMS) || defined(_DARWIN_C_SOURCE)
-FILE	*fopen(const char * __restrict __filename, const char * __restrict __mode) __DARWIN_ALIAS_STARTING(__MAC_10_6, __IPHONE_3_2, __DARWIN_EXTSN(fopen));
-#else /* !_DARWIN_UNLIMITED_STREAMS && !_DARWIN_C_SOURCE */
-FILE	*fopen(const char * __restrict __filename, const char * __restrict __mode) __DARWIN_ALIAS_STARTING(__MAC_10_6, __IPHONE_2_0, __DARWIN_ALIAS(fopen));
-#endif /* (DARWIN_UNLIMITED_STREAMS || _DARWIN_C_SOURCE) */
-int	 fprintf(FILE * __restrict, const char * __restrict, ...) __printflike(2, 3);
-int	 fputc(int, FILE *);
-int	 fputs(const char * __restrict, FILE * __restrict) __DARWIN_ALIAS(fputs);
-size_t	 fread(void * __restrict __ptr, size_t __size, size_t __nitems, FILE * __restrict __stream);
-FILE	*freopen(const char * __restrict, const char * __restrict,
-                 FILE * __restrict) __DARWIN_ALIAS(freopen);
-int	 fscanf(FILE * __restrict, const char * __restrict, ...) __scanflike(2, 3);
-int	 fseek(FILE *, long, int);
-int	 fsetpos(FILE *, const fpos_t *);
-long	 ftell(FILE *);
-size_t	 fwrite(const void * __restrict __ptr, size_t __size, size_t __nitems, FILE * __restrict __stream) __DARWIN_ALIAS(fwrite);
-int	 getc(FILE *);
-int	 getchar(void);
-char	*gets(char *);
-void	 perror(const char *) __cold;
-int	 printf(const char * __restrict, ...) __printflike(1, 2);
-int	 putc(int, FILE *);
-int	 putchar(int);
-int	 puts(const char *);
-int	 remove(const char *);
-int	 rename (const char *__old, const char *__new);
-void	 rewind(FILE *);
-int	 scanf(const char * __restrict, ...) __scanflike(1, 2);
-void	 setbuf(FILE * __restrict, char * __restrict);
-int	 setvbuf(FILE * __restrict, char * __restrict, int, size_t);
-int	 sprintf(char * __restrict, const char * __restrict, ...) __printflike(2, 3) __swift_unavailable("Use snprintf instead.");
-int	 sscanf(const char * __restrict, const char * __restrict, ...) __scanflike(2, 3);
-FILE	*tmpfile(void);
-
-__swift_unavailable("Use mkstemp(3) instead.")
-#if !defined(_POSIX_C_SOURCE)
-__deprecated_msg("This function is provided for compatibility reasons only.  Due to security concerns inherent in the design of tmpnam(3), it is highly recommended that you use mkstemp(3) instead.")
-#endif
-char	*tmpnam(char *);
-int	 ungetc(int, FILE *);
-int	 vfprintf(FILE * __restrict, const char * __restrict, va_list) __printflike(2, 0);
-int	 vprintf(const char * __restrict, va_list) __printflike(1, 0);
-int	 vsprintf(char * __restrict, const char * __restrict, va_list) __printflike(2, 0) __swift_unavailable("Use vsnprintf instead.");
-__END_DECLS
-
-
-
-/* Additional functionality provided by:
- * POSIX.1-1988
- */
-
-#if __DARWIN_C_LEVEL >= 198808L
-#define	L_ctermid	1024	/* size for ctermid(); PATH_MAX */
-
-__BEGIN_DECLS
-#include <_ctermid.h>
-
-#if defined(_DARWIN_UNLIMITED_STREAMS) || defined(_DARWIN_C_SOURCE)
-FILE	*fdopen(int, const char *) __DARWIN_ALIAS_STARTING(__MAC_10_6, __IPHONE_3_2, __DARWIN_EXTSN(fdopen));
-#else /* !_DARWIN_UNLIMITED_STREAMS && !_DARWIN_C_SOURCE */
-FILE	*fdopen(int, const char *) __DARWIN_ALIAS_STARTING(__MAC_10_6, __IPHONE_2_0, __DARWIN_ALIAS(fdopen));
-#endif /* (DARWIN_UNLIMITED_STREAMS || _DARWIN_C_SOURCE) */
-int	 fileno(FILE *);
-__END_DECLS
-#endif /* __DARWIN_C_LEVEL >= 198808L */
-
-
-/* Additional functionality provided by:
- * POSIX.2-1992 C Language Binding Option
- */
-#if TARGET_OS_EMBEDDED
-#define __swift_unavailable_on(osx_msg, ios_msg) __swift_unavailable(ios_msg)
-#else
-#define __swift_unavailable_on(osx_msg, ios_msg) __swift_unavailable(osx_msg)
-#endif
-
-#if __DARWIN_C_LEVEL >= 199209L
-__BEGIN_DECLS
-int	 pclose(FILE *) __swift_unavailable_on("Use posix_spawn APIs or NSTask instead.", "Process spawning is unavailable.");
-#if defined(_DARWIN_UNLIMITED_STREAMS) || defined(_DARWIN_C_SOURCE)
-FILE	*popen(const char *, const char *) __DARWIN_ALIAS_STARTING(__MAC_10_6, __IPHONE_3_2, __DARWIN_EXTSN(popen)) __swift_unavailable_on("Use posix_spawn APIs or NSTask instead.", "Process spawning is unavailable.");
-#else /* !_DARWIN_UNLIMITED_STREAMS && !_DARWIN_C_SOURCE */
-FILE	*popen(const char *, const char *) __DARWIN_ALIAS_STARTING(__MAC_10_6, __IPHONE_2_0, __DARWIN_ALIAS(popen)) __swift_unavailable_on("Use posix_spawn APIs or NSTask instead.", "Process spawning is unavailable.");
-#endif /* (DARWIN_UNLIMITED_STREAMS || _DARWIN_C_SOURCE) */
-__END_DECLS
-#endif /* __DARWIN_C_LEVEL >= 199209L */
-
-#undef __swift_unavailable_on
-
-/* Additional functionality provided by:
- * POSIX.1c-1995,
- * POSIX.1i-1995,
- * and the omnibus ISO/IEC 9945-1: 1996
- */
-
-#if __DARWIN_C_LEVEL >= 199506L
-
-/* Functions internal to the implementation. */
-__BEGIN_DECLS
-int	__srget(FILE *);
-int	__svfscanf(FILE *, const char *, va_list) __scanflike(2, 0);
-int	__swbuf(int, FILE *);
-__END_DECLS
-
-/*
- * The __sfoo macros are here so that we can
- * define function versions in the C library.
- */
-#define	__sgetc(p) (--(p)->_r < 0 ? __srget(p) : (int)(*(p)->_p++))
-#if defined(__GNUC__) && defined(__STDC__)
-__header_always_inline int __sputc(int _c, FILE *_p) {
-	if (--_p->_w >= 0 || (_p->_w >= _p->_lbfsize && (char)_c != '\n'))
-		return (*_p->_p++ = _c);
-	else
-		return (__swbuf(_c, _p));
-}
-#else
-/*
- * This has been tuned to generate reasonable code on the vax using pcc.
- */
-#define	__sputc(c, p) \
-	(--(p)->_w < 0 ? \
-		(p)->_w >= (p)->_lbfsize ? \
-			(*(p)->_p = (c)), *(p)->_p != '\n' ? \
-				(int)*(p)->_p++ : \
-				__swbuf('\n', p) : \
-			__swbuf((int)(c), p) : \
-		(*(p)->_p = (c), (int)*(p)->_p++))
-#endif
-
-#define	__sfeof(p)	(((p)->_flags & __SEOF) != 0)
-#define	__sferror(p)	(((p)->_flags & __SERR) != 0)
-#define	__sclearerr(p)	((void)((p)->_flags &= ~(__SERR|__SEOF)))
-#define	__sfileno(p)	((p)->_file)
-
-__BEGIN_DECLS
-void	 flockfile(FILE *);
-int	 ftrylockfile(FILE *);
-void	 funlockfile(FILE *);
-int	 getc_unlocked(FILE *);
-int	 getchar_unlocked(void);
-int	 putc_unlocked(int, FILE *);
-int	 putchar_unlocked(int);
-
-/* Removed in Issue 6 */
-#if !defined(_POSIX_C_SOURCE) || _POSIX_C_SOURCE < 200112L
-int	 getw(FILE *);
-int	 putw(int, FILE *);
-#endif
-
-__swift_unavailable("Use mkstemp(3) instead.")
-#if !defined(_POSIX_C_SOURCE)
-__deprecated_msg("This function is provided for compatibility reasons only.  Due to security concerns inherent in the design of tempnam(3), it is highly recommended that you use mkstemp(3) instead.")
-#endif
-char	*tempnam(const char *__dir, const char *__prefix) __DARWIN_ALIAS(tempnam);
-__END_DECLS
-
-#ifndef lint
-#define	getc_unlocked(fp)	__sgetc(fp)
-#define putc_unlocked(x, fp)	__sputc(x, fp)
-#endif /* lint */
-
-#define	getchar_unlocked()	getc_unlocked(stdin)
-#define	putchar_unlocked(x)	putc_unlocked(x, stdout)
-#endif /* __DARWIN_C_LEVEL >= 199506L */
-
-
-
-/* Additional functionality provided by:
- * POSIX.1-2001
- * ISO C99
- */
-
-#if __DARWIN_C_LEVEL >= 200112L
-#include <sys/_types/_off_t.h>
-
-__BEGIN_DECLS
-int	 fseeko(FILE * __stream, off_t __offset, int __whence);
-off_t	 ftello(FILE * __stream);
-__END_DECLS
-#endif /* __DARWIN_C_LEVEL >= 200112L */
-
-#if __DARWIN_C_LEVEL >= 200112L || defined(_C99_SOURCE) || defined(__cplusplus)
-__BEGIN_DECLS
-int	 snprintf(char * __restrict __str, size_t __size, const char * __restrict __format, ...) __printflike(3, 4);
-int	 vfscanf(FILE * __restrict __stream, const char * __restrict __format, va_list) __scanflike(2, 0);
-int	 vscanf(const char * __restrict __format, va_list) __scanflike(1, 0);
-int	 vsnprintf(char * __restrict __str, size_t __size, const char * __restrict __format, va_list) __printflike(3, 0);
-int	 vsscanf(const char * __restrict __str, const char * __restrict __format, va_list) __scanflike(2, 0);
-__END_DECLS
-#endif /* __DARWIN_C_LEVEL >= 200112L || defined(_C99_SOURCE) || defined(__cplusplus) */
-
-
-
-/* Additional functionality provided by:
- * POSIX.1-2008
- */
-
-#if __DARWIN_C_LEVEL >= 200809L
-#include <sys/_types/_ssize_t.h>
-
-__BEGIN_DECLS
-int	dprintf(int, const char * __restrict, ...) __printflike(2, 3) __OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_4_3);
-int	vdprintf(int, const char * __restrict, va_list) __printflike(2, 0) __OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_4_3);
-ssize_t getdelim(char ** __restrict __linep, size_t * __restrict __linecapp, int __delimiter, FILE * __restrict __stream) __OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_4_3);
-ssize_t getline(char ** __restrict __linep, size_t * __restrict __linecapp, FILE * __restrict __stream) __OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_4_3);
-FILE *fmemopen(void * __restrict __buf, size_t __size, const char * __restrict __mode) __API_AVAILABLE(macos(10.13), ios(11.0), tvos(11.0), watchos(4.0));
-FILE *open_memstream(char **__bufp, size_t *__sizep) __API_AVAILABLE(macos(10.13), ios(11.0), tvos(11.0), watchos(4.0));
-__END_DECLS
-#endif /* __DARWIN_C_LEVEL >= 200809L */
-
-
-
-/* Darwin extensions */
-
-#if __DARWIN_C_LEVEL >= __DARWIN_C_FULL
-__BEGIN_DECLS
-extern __const int sys_nerr;		/* perror(3) external variables */
-extern __const char *__const sys_errlist[];
-
-int	 asprintf(char ** __restrict, const char * __restrict, ...) __printflike(2, 3);
-char	*ctermid_r(char *);
-char	*fgetln(FILE *, size_t *);
-__const char *fmtcheck(const char *, const char *);
-int	 fpurge(FILE *);
-void	 setbuffer(FILE *, char *, int);
-int	 setlinebuf(FILE *);
-int	 vasprintf(char ** __restrict, const char * __restrict, va_list) __printflike(2, 0);
-FILE	*zopen(const char *, const char *, int);
-
-
-/*
- * Stdio function-access interface.
- */
-FILE	*funopen(const void *,
-                 int (* _Nullable)(void *, char *, int),
-                 int (* _Nullable)(void *, const char *, int),
-                 fpos_t (* _Nullable)(void *, fpos_t, int),
-                 int (* _Nullable)(void *));
-__END_DECLS
-#define	fropen(cookie, fn) funopen(cookie, fn, 0, 0, 0)
-#define	fwopen(cookie, fn) funopen(cookie, 0, fn, 0, 0)
-
-#define	feof_unlocked(p)	__sfeof(p)
-#define	ferror_unlocked(p)	__sferror(p)
-#define	clearerr_unlocked(p)	__sclearerr(p)
-#define	fileno_unlocked(p)	__sfileno(p)
-
-#endif /* __DARWIN_C_LEVEL >= __DARWIN_C_FULL */
-
-
-#ifdef _USE_EXTENDED_LOCALES_
-#include <xlocale/_stdio.h>
-#endif /* _USE_EXTENDED_LOCALES_ */
-
-#if defined (__GNUC__) && _FORTIFY_SOURCE > 0 && !defined (__cplusplus)
-/* Security checking functions.  */
-#include <secure/_stdio.h>
-#endif
-
-#endif /* _STDIO_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/stdlib.h b/lib/libc/include/x86_64-macos-gnu/stdlib.h
deleted file mode 100644
index a5b61930fd..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/stdlib.h
+++ /dev/null
@@ -1,370 +0,0 @@
-/*
- * Copyright (c) 2000, 2002 - 2008 Apple Inc. All rights reserved.
- *
- * @APPLE_LICENSE_HEADER_START@
- * 
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this
- * file.
- * 
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- * 
- * @APPLE_LICENSE_HEADER_END@
- */
-/*-
- * Copyright (c) 1990, 1993
- *	The Regents of the University of California.  All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *	This product includes software developed by the University of
- *	California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *	@(#)stdlib.h	8.5 (Berkeley) 5/19/95
- */
-
-#ifndef _STDLIB_H_
-#define _STDLIB_H_
-
-#include <Availability.h>
-#include <sys/cdefs.h>
-
-#include <_types.h>
-#if !defined(_ANSI_SOURCE)
-#include <sys/wait.h>
-#if (!defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE))
-#include <alloca.h>
-#endif /* (!_POSIX_C_SOURCE || _DARWIN_C_SOURCE) */
-#endif /* !_ANSI_SOURCE */
-
-/* DO NOT REMOVE THIS COMMENT: fixincludes needs to see:
- * _GCC_SIZE_T */
-#include <sys/_types/_size_t.h>
-
-#if !defined(_ANSI_SOURCE) && (!defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE))
-#include <sys/_types/_ct_rune_t.h>
-#include <sys/_types/_rune_t.h>
-#endif	/* !_ANSI_SOURCE && (!_POSIX_C_SOURCE || _DARWIN_C_SOURCE) */
-
-#include <sys/_types/_wchar_t.h>
-
-typedef struct {
-	int quot;		/* quotient */
-	int rem;		/* remainder */
-} div_t;
-
-typedef struct {
-	long quot;		/* quotient */
-	long rem;		/* remainder */
-} ldiv_t;
-
-#if !__DARWIN_NO_LONG_LONG
-typedef struct {
-	long long quot;
-	long long rem;
-} lldiv_t;
-#endif /* !__DARWIN_NO_LONG_LONG */
-
-#include <sys/_types/_null.h>
-
-#define	EXIT_FAILURE	1
-#define	EXIT_SUCCESS	0
-
-#define	RAND_MAX	0x7fffffff
-
-#ifdef _USE_EXTENDED_LOCALES_
-#include <_xlocale.h>
-#endif /* _USE_EXTENDED_LOCALES_ */
-
-#ifndef MB_CUR_MAX
-#ifdef _USE_EXTENDED_LOCALES_
-#define	MB_CUR_MAX	(___mb_cur_max())
-#ifndef MB_CUR_MAX_L
-#define	MB_CUR_MAX_L(x)	(___mb_cur_max_l(x))
-#endif /* !MB_CUR_MAX_L */
-#else /* !_USE_EXTENDED_LOCALES_ */
-extern int __mb_cur_max;
-#define	MB_CUR_MAX	__mb_cur_max
-#endif /* _USE_EXTENDED_LOCALES_ */
-#endif /* MB_CUR_MAX */
-
-#if !defined(_ANSI_SOURCE) && (!defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)) \
-    && defined(_USE_EXTENDED_LOCALES_) && !defined(MB_CUR_MAX_L)
-#define	MB_CUR_MAX_L(x)	(___mb_cur_max_l(x))
-#endif
-
-#include <malloc/_malloc.h>
-
-__BEGIN_DECLS
-void	 abort(void) __cold __dead2;
-int	 abs(int) __pure2;
-int	 atexit(void (* _Nonnull)(void));
-double	 atof(const char *);
-int	 atoi(const char *);
-long	 atol(const char *);
-#if !__DARWIN_NO_LONG_LONG
-long long
-	 atoll(const char *);
-#endif /* !__DARWIN_NO_LONG_LONG */
-void	*bsearch(const void *__key, const void *__base, size_t __nel,
-	    size_t __width, int (* _Nonnull __compar)(const void *, const void *));
-/* calloc is now declared in _malloc.h */
-div_t	 div(int, int) __pure2;
-void	 exit(int) __dead2;
-/* free is now declared in _malloc.h */
-char	*getenv(const char *);
-long	 labs(long) __pure2;
-ldiv_t	 ldiv(long, long) __pure2;
-#if !__DARWIN_NO_LONG_LONG
-long long
-	 llabs(long long);
-lldiv_t	 lldiv(long long, long long);
-#endif /* !__DARWIN_NO_LONG_LONG */
-/* malloc is now declared in _malloc.h */
-int	 mblen(const char *__s, size_t __n);
-size_t	 mbstowcs(wchar_t * __restrict , const char * __restrict, size_t);
-int	 mbtowc(wchar_t * __restrict, const char * __restrict, size_t);
-/* posix_memalign is now declared in _malloc.h */
-void	 qsort(void *__base, size_t __nel, size_t __width,
-	    int (* _Nonnull __compar)(const void *, const void *));
-int	 rand(void) __swift_unavailable("Use arc4random instead.");
-/* realloc is now declared in _malloc.h */
-void	 srand(unsigned) __swift_unavailable("Use arc4random instead.");
-double	 strtod(const char *, char **) __DARWIN_ALIAS(strtod);
-float	 strtof(const char *, char **) __DARWIN_ALIAS(strtof);
-long	 strtol(const char *__str, char **__endptr, int __base);
-long double
-	 strtold(const char *, char **);
-#if !__DARWIN_NO_LONG_LONG
-long long 
-	 strtoll(const char *__str, char **__endptr, int __base);
-#endif /* !__DARWIN_NO_LONG_LONG */
-unsigned long
-	 strtoul(const char *__str, char **__endptr, int __base);
-#if !__DARWIN_NO_LONG_LONG
-unsigned long long
-	 strtoull(const char *__str, char **__endptr, int __base);
-#endif /* !__DARWIN_NO_LONG_LONG */
-
-#if TARGET_OS_EMBEDDED
-#define __swift_unavailable_on(osx_msg, ios_msg) __swift_unavailable(ios_msg)
-#else
-#define __swift_unavailable_on(osx_msg, ios_msg) __swift_unavailable(osx_msg)
-#endif
-
-__swift_unavailable_on("Use posix_spawn APIs or NSTask instead.", "Process spawning is unavailable")
-__API_AVAILABLE(macos(10.0)) __IOS_PROHIBITED
-__WATCHOS_PROHIBITED __TVOS_PROHIBITED
-int	 system(const char *) __DARWIN_ALIAS_C(system);
-
-#undef __swift_unavailable_on
-
-size_t	 wcstombs(char * __restrict, const wchar_t * __restrict, size_t);
-int	 wctomb(char *, wchar_t);
-
-#ifndef _ANSI_SOURCE
-void	_Exit(int) __dead2;
-long	 a64l(const char *);
-double	 drand48(void);
-char	*ecvt(double, int, int *__restrict, int *__restrict); /* LEGACY */
-double	 erand48(unsigned short[3]);
-char	*fcvt(double, int, int *__restrict, int *__restrict); /* LEGACY */
-char	*gcvt(double, int, char *); /* LEGACY */
-int	 getsubopt(char **, char * const *, char **);
-int	 grantpt(int);
-#if __DARWIN_UNIX03
-char	*initstate(unsigned, char *, size_t); /* no  __DARWIN_ALIAS needed */
-#else /* !__DARWIN_UNIX03 */
-char	*initstate(unsigned long, char *, long);
-#endif /* __DARWIN_UNIX03 */
-long	 jrand48(unsigned short[3]) __swift_unavailable("Use arc4random instead.");
-char	*l64a(long);
-void	 lcong48(unsigned short[7]);
-long	 lrand48(void) __swift_unavailable("Use arc4random instead.");
-char	*mktemp(char *);
-int	 mkstemp(char *);
-long	 mrand48(void) __swift_unavailable("Use arc4random instead.");
-long	 nrand48(unsigned short[3]) __swift_unavailable("Use arc4random instead.");
-int	 posix_openpt(int);
-char	*ptsname(int);
-
-#if (!defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE))
-int ptsname_r(int fildes, char *buffer, size_t buflen) __API_AVAILABLE(macos(10.13.4), ios(11.3), tvos(11.3), watchos(4.3));
-#endif
-
-int	 putenv(char *) __DARWIN_ALIAS(putenv);
-long	 random(void) __swift_unavailable("Use arc4random instead.");
-int	 rand_r(unsigned *) __swift_unavailable("Use arc4random instead.");
-#if (__DARWIN_UNIX03 && !defined(_POSIX_C_SOURCE)) || defined(_DARWIN_C_SOURCE) || defined(_DARWIN_BETTER_REALPATH)
-char	*realpath(const char * __restrict, char * __restrict) __DARWIN_EXTSN(realpath);
-#else /* (!__DARWIN_UNIX03 || _POSIX_C_SOURCE) && !_DARWIN_C_SOURCE && !_DARWIN_BETTER_REALPATH */
-char	*realpath(const char * __restrict, char * __restrict) __DARWIN_ALIAS(realpath);
-#endif /* (__DARWIN_UNIX03 && _POSIX_C_SOURCE) || _DARWIN_C_SOURCE || _DARWIN_BETTER_REALPATH */
-unsigned short
-	*seed48(unsigned short[3]);
-int	 setenv(const char * __name, const char * __value, int __overwrite) __DARWIN_ALIAS(setenv);
-#if __DARWIN_UNIX03
-void	 setkey(const char *) __DARWIN_ALIAS(setkey);
-#else /* !__DARWIN_UNIX03 */
-int	 setkey(const char *);
-#endif /* __DARWIN_UNIX03 */
-char	*setstate(const char *);
-void	 srand48(long);
-#if __DARWIN_UNIX03
-void	 srandom(unsigned);
-#else /* !__DARWIN_UNIX03 */
-void	 srandom(unsigned long);
-#endif /* __DARWIN_UNIX03 */
-int	 unlockpt(int);
-#if __DARWIN_UNIX03
-int	 unsetenv(const char *) __DARWIN_ALIAS(unsetenv);
-#else /* !__DARWIN_UNIX03 */
-void	 unsetenv(const char *);
-#endif /* __DARWIN_UNIX03 */
-#endif	/* !_ANSI_SOURCE */
-
-#if !defined(_ANSI_SOURCE) && (!defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE))
-#include <machine/types.h>
-#include <sys/_types/_dev_t.h>
-#include <sys/_types/_mode_t.h>
-#include <_types/_uint32_t.h>
-
-uint32_t arc4random(void);
-void	 arc4random_addrandom(unsigned char * /*dat*/, int /*datlen*/)
-    __OSX_DEPRECATED(10.0, 10.12, "use arc4random_stir")
-    __IOS_DEPRECATED(2.0, 10.0, "use arc4random_stir")
-    __TVOS_DEPRECATED(2.0, 10.0, "use arc4random_stir")
-    __WATCHOS_DEPRECATED(1.0, 3.0, "use arc4random_stir");
-void	 arc4random_buf(void * __buf, size_t __nbytes) __OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_4_3);
-void	 arc4random_stir(void);
-uint32_t
-	 arc4random_uniform(uint32_t __upper_bound) __OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_4_3);
-#ifdef __BLOCKS__
-int	 atexit_b(void (^ _Nonnull)(void)) __OSX_AVAILABLE_STARTING(__MAC_10_6, __IPHONE_3_2);
-void	*bsearch_b(const void *__key, const void *__base, size_t __nel,
-	    size_t __width, int (^ _Nonnull __compar)(const void *, const void *)) __OSX_AVAILABLE_STARTING(__MAC_10_6, __IPHONE_3_2);
-#endif /* __BLOCKS__ */
-
-	 /* getcap(3) functions */
-char	*cgetcap(char *, const char *, int);
-int	 cgetclose(void);
-int	 cgetent(char **, char **, const char *);
-int	 cgetfirst(char **, char **);
-int	 cgetmatch(const char *, const char *);
-int	 cgetnext(char **, char **);
-int	 cgetnum(char *, const char *, long *);
-int	 cgetset(const char *);
-int	 cgetstr(char *, const char *, char **);
-int	 cgetustr(char *, const char *, char **);
-
-int	 daemon(int, int) __DARWIN_1050(daemon) __OSX_AVAILABLE_BUT_DEPRECATED_MSG(__MAC_10_0, __MAC_10_5, __IPHONE_2_0, __IPHONE_2_0, "Use posix_spawn APIs instead.") __WATCHOS_PROHIBITED __TVOS_PROHIBITED;
-char	*devname(dev_t, mode_t);
-char	*devname_r(dev_t, mode_t, char *buf, int len);
-char	*getbsize(int *, long *);
-int	 getloadavg(double [], int);
-const char
-	*getprogname(void);
-void	 setprogname(const char *);
-
-#ifdef __BLOCKS__
-#if __has_attribute(noescape)
-#define __sort_noescape __attribute__((__noescape__))
-#else
-#define __sort_noescape
-#endif
-#endif /* __BLOCKS__ */
-
-int	 heapsort(void *__base, size_t __nel, size_t __width,
-	    int (* _Nonnull __compar)(const void *, const void *));
-#ifdef __BLOCKS__
-int	 heapsort_b(void *__base, size_t __nel, size_t __width,
-	    int (^ _Nonnull __compar)(const void *, const void *) __sort_noescape)
-	    __OSX_AVAILABLE_STARTING(__MAC_10_6, __IPHONE_3_2);
-#endif /* __BLOCKS__ */
-int	 mergesort(void *__base, size_t __nel, size_t __width,
-	    int (* _Nonnull __compar)(const void *, const void *));
-#ifdef __BLOCKS__
-int	 mergesort_b(void *__base, size_t __nel, size_t __width,
-	    int (^ _Nonnull __compar)(const void *, const void *) __sort_noescape)
-	    __OSX_AVAILABLE_STARTING(__MAC_10_6, __IPHONE_3_2);
-#endif /* __BLOCKS__ */
-void	 psort(void *__base, size_t __nel, size_t __width,
-	    int (* _Nonnull __compar)(const void *, const void *))
-	    __OSX_AVAILABLE_STARTING(__MAC_10_6, __IPHONE_3_2);
-#ifdef __BLOCKS__
-void	 psort_b(void *__base, size_t __nel, size_t __width,
-	    int (^ _Nonnull __compar)(const void *, const void *) __sort_noescape)
-	    __OSX_AVAILABLE_STARTING(__MAC_10_6, __IPHONE_3_2);
-#endif /* __BLOCKS__ */
-void	 psort_r(void *__base, size_t __nel, size_t __width, void *,
-	    int (* _Nonnull __compar)(void *, const void *, const void *))
-	    __OSX_AVAILABLE_STARTING(__MAC_10_6, __IPHONE_3_2);
-#ifdef __BLOCKS__
-void	 qsort_b(void *__base, size_t __nel, size_t __width,
-	    int (^ _Nonnull __compar)(const void *, const void *) __sort_noescape)
-	    __OSX_AVAILABLE_STARTING(__MAC_10_6, __IPHONE_3_2);
-#endif /* __BLOCKS__ */
-void	 qsort_r(void *__base, size_t __nel, size_t __width, void *,
-	    int (* _Nonnull __compar)(void *, const void *, const void *));
-int	 radixsort(const unsigned char **__base, int __nel, const unsigned char *__table,
-	    unsigned __endbyte);
-int	rpmatch(const char *)
-	__API_AVAILABLE(macos(10.15), ios(13.0), tvos(13.0), watchos(6.0));
-int	 sradixsort(const unsigned char **__base, int __nel, const unsigned char *__table,
-	    unsigned __endbyte);
-void	 sranddev(void);
-void	 srandomdev(void);
-void	*reallocf(void *__ptr, size_t __size) __alloc_size(2);
-#if !__DARWIN_NO_LONG_LONG
-long long
-	 strtoq(const char *__str, char **__endptr, int __base);
-unsigned long long
-	 strtouq(const char *__str, char **__endptr, int __base);
-#endif /* !__DARWIN_NO_LONG_LONG */
-extern char *suboptarg;		/* getsubopt(3) external variable */
-/* valloc is now declared in _malloc.h */
-#endif	/* !_ANSI_SOURCE && !_POSIX_SOURCE */
-
-/* Poison the following routines if -fshort-wchar is set */
-#if !defined(__cplusplus) && defined(__WCHAR_MAX__) && __WCHAR_MAX__ <= 0xffffU
-#pragma GCC poison mbstowcs mbtowc wcstombs wctomb
-#endif
-__END_DECLS
-
-#ifdef _USE_EXTENDED_LOCALES_
-#include <xlocale/_stdlib.h>
-#endif /* _USE_EXTENDED_LOCALES_ */
-
-#endif /* _STDLIB_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/string.h b/lib/libc/include/x86_64-macos-gnu/string.h
deleted file mode 100644
index bca8f8c881..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/string.h
+++ /dev/null
@@ -1,193 +0,0 @@
-/*
- * Copyright (c) 2000, 2007, 2010 Apple Inc. All rights reserved.
- *
- * @APPLE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this
- * file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_LICENSE_HEADER_END@
- */
-/*-
- * Copyright (c) 1990, 1993
- *	The Regents of the University of California.  All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *	This product includes software developed by the University of
- *	California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *	@(#)string.h	8.1 (Berkeley) 6/2/93
- */
-
-#ifndef _STRING_H_
-#define	_STRING_H_
-
-#include <_types.h>
-#include <sys/cdefs.h>
-#include <Availability.h>
-#include <sys/_types/_size_t.h>
-#include <sys/_types/_null.h>
-
-/* ANSI-C */
-
-__BEGIN_DECLS
-void	*memchr(const void *__s, int __c, size_t __n);
-int	 memcmp(const void *__s1, const void *__s2, size_t __n);
-void	*memcpy(void *__dst, const void *__src, size_t __n);
-void	*memmove(void *__dst, const void *__src, size_t __len);
-void	*memset(void *__b, int __c, size_t __len);
-char	*strcat(char *__s1, const char *__s2);
-char	*strchr(const char *__s, int __c);
-int	 strcmp(const char *__s1, const char *__s2);
-int	 strcoll(const char *__s1, const char *__s2);
-char	*strcpy(char *__dst, const char *__src);
-size_t	 strcspn(const char *__s, const char *__charset);
-char	*strerror(int __errnum) __DARWIN_ALIAS(strerror);
-size_t	 strlen(const char *__s);
-char	*strncat(char *__s1, const char *__s2, size_t __n);
-int	 strncmp(const char *__s1, const char *__s2, size_t __n);
-char	*strncpy(char *__dst, const char *__src, size_t __n);
-char	*strpbrk(const char *__s, const char *__charset);
-char	*strrchr(const char *__s, int __c);
-size_t	 strspn(const char *__s, const char *__charset);
-char	*strstr(const char *__big, const char *__little);
-char	*strtok(char *__str, const char *__sep);
-size_t	 strxfrm(char *__s1, const char *__s2, size_t __n);
-__END_DECLS
-
-
-
-/* Additional functionality provided by:
- * POSIX.1c-1995,
- * POSIX.1i-1995,
- * and the omnibus ISO/IEC 9945-1: 1996
- */
-
-#if __DARWIN_C_LEVEL >= 199506L
-__BEGIN_DECLS
-char	*strtok_r(char *__str, const char *__sep, char **__lasts);
-__END_DECLS
-#endif /* __DARWIN_C_LEVEL >= 199506L */
-
-
-
-/* Additional functionality provided by:
- * POSIX.1-2001
- */
-
-#if __DARWIN_C_LEVEL >= 200112L
-__BEGIN_DECLS
-int	 strerror_r(int __errnum, char *__strerrbuf, size_t __buflen);
-char	*strdup(const char *__s1);
-void	*memccpy(void *__dst, const void *__src, int __c, size_t __n);
-__END_DECLS
-#endif /* __DARWIN_C_LEVEL >= 200112L */
-
-
-
-/* Additional functionality provided by:
- * POSIX.1-2008
- */
-
-#if __DARWIN_C_LEVEL >= 200809L
-__BEGIN_DECLS
-char	*stpcpy(char *__dst, const char *__src);
-char    *stpncpy(char *__dst, const char *__src, size_t __n) __OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_4_3);
-char	*strndup(const char *__s1, size_t __n) __OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_4_3);
-size_t   strnlen(const char *__s1, size_t __n) __OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_4_3);
-char	*strsignal(int __sig);
-__END_DECLS
-#endif /* __DARWIN_C_LEVEL >= 200809L */
-
-/* C11 Annex K */
-
-#if defined(__STDC_WANT_LIB_EXT1__) && __STDC_WANT_LIB_EXT1__ >= 1
-#include <sys/_types/_rsize_t.h>
-#include <sys/_types/_errno_t.h>
-
-__BEGIN_DECLS
-errno_t	memset_s(void *__s, rsize_t __smax, int __c, rsize_t __n) __OSX_AVAILABLE_STARTING(__MAC_10_9, __IPHONE_7_0);
-__END_DECLS
-#endif
-
-/* Darwin extensions */
-
-#if __DARWIN_C_LEVEL >= __DARWIN_C_FULL
-#include <sys/_types/_ssize_t.h>
-
-__BEGIN_DECLS
-void	*memmem(const void *__big, size_t __big_len, const void *__little, size_t __little_len) __OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_4_3);
-void     memset_pattern4(void *__b, const void *__pattern4, size_t __len) __OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_3_0);
-void     memset_pattern8(void *__b, const void *__pattern8, size_t __len) __OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_3_0);
-void     memset_pattern16(void *__b, const void *__pattern16, size_t __len) __OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_3_0);
-
-char	*strcasestr(const char *__big, const char *__little);
-char	*strnstr(const char *__big, const char *__little, size_t __len);
-size_t	 strlcat(char *__dst, const char *__source, size_t __size);
-size_t	 strlcpy(char *__dst, const char *__source, size_t __size);
-void	 strmode(int __mode, char *__bp);
-char	*strsep(char **__stringp, const char *__delim);
-
-/* SUS places swab() in unistd.h.  It is listed here for source compatibility */
-void	 swab(const void * __restrict, void * __restrict, ssize_t);
-
-__OSX_AVAILABLE(10.12.1) __IOS_AVAILABLE(10.1)
-__TVOS_AVAILABLE(10.0.1) __WATCHOS_AVAILABLE(3.1)
-int	timingsafe_bcmp(const void *__b1, const void *__b2, size_t __len);
-__END_DECLS
-
-/* Some functions historically defined in string.h were placed in strings.h
- * by SUS.  We are using "strings.h" instead of <strings.h> to avoid an issue
- * where /Developer/Headers/FlatCarbon/Strings.h could be included instead on
- * case-insensitive file systems.
- */
-#include "strings.h"
-#endif /* __DARWIN_C_LEVEL >= __DARWIN_C_FULL */
-
-
-#ifdef _USE_EXTENDED_LOCALES_
-#include <xlocale/_string.h>
-#endif /* _USE_EXTENDED_LOCALES_ */
-
-#if defined (__GNUC__) && _FORTIFY_SOURCE > 0 && !defined (__cplusplus)
-/* Security checking functions.  */
-#include <secure/_string.h>
-#endif
-
-#endif /* _STRING_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/sys/_pthread/_pthread_attr_t.h b/lib/libc/include/x86_64-macos-gnu/sys/_pthread/_pthread_attr_t.h
deleted file mode 100644
index a71842cb99..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/sys/_pthread/_pthread_attr_t.h
+++ /dev/null
@@ -1,32 +0,0 @@
-/*
- * Copyright (c) 2003-2012 Apple Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- * 
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- * 
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- * 
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- * 
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-#ifndef _PTHREAD_ATTR_T 
-#define _PTHREAD_ATTR_T 
-#include <sys/_pthread/_pthread_types.h> /* __darwin_pthread_attr_t */
-typedef __darwin_pthread_attr_t pthread_attr_t;
-#endif  /* _PTHREAD_ATTR_T */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/sys/_pthread/_pthread_cond_t.h b/lib/libc/include/x86_64-macos-gnu/sys/_pthread/_pthread_cond_t.h
deleted file mode 100644
index 3eceff6274..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/sys/_pthread/_pthread_cond_t.h
+++ /dev/null
@@ -1,32 +0,0 @@
-/*
- * Copyright (c) 2003-2012 Apple Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- * 
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- * 
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- * 
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- * 
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-#ifndef _PTHREAD_COND_T
-#define _PTHREAD_COND_T
-#include <sys/_pthread/_pthread_types.h> /* __darwin_pthread_cond_t */
-typedef __darwin_pthread_cond_t pthread_cond_t;
-#endif /* _PTHREAD_COND_T */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/sys/_pthread/_pthread_condattr_t.h b/lib/libc/include/x86_64-macos-gnu/sys/_pthread/_pthread_condattr_t.h
deleted file mode 100644
index 7fd62badd7..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/sys/_pthread/_pthread_condattr_t.h
+++ /dev/null
@@ -1,32 +0,0 @@
-/*
- * Copyright (c) 2003-2012 Apple Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- * 
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- * 
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- * 
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- * 
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-#ifndef _PTHREAD_CONDATTR_T
-#define _PTHREAD_CONDATTR_T
-#include <sys/_pthread/_pthread_types.h> /* __darwin_pthread_condattr_t */
-typedef __darwin_pthread_condattr_t pthread_condattr_t;
-#endif /* _PTHREAD_CONDATTR_T */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/sys/_pthread/_pthread_rwlock_t.h b/lib/libc/include/x86_64-macos-gnu/sys/_pthread/_pthread_rwlock_t.h
deleted file mode 100644
index dc1f013f3b..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/sys/_pthread/_pthread_rwlock_t.h
+++ /dev/null
@@ -1,32 +0,0 @@
-/*
- * Copyright (c) 2003-2012 Apple Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- * 
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- * 
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- * 
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- * 
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-#ifndef _PTHREAD_RWLOCK_T
-#define _PTHREAD_RWLOCK_T
-#include <sys/_pthread/_pthread_types.h> /* __darwin_pthread_rwlock_t */
-typedef __darwin_pthread_rwlock_t pthread_rwlock_t;
-#endif /* _PTHREAD_RWLOCK_T */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/sys/_pthread/_pthread_rwlockattr_t.h b/lib/libc/include/x86_64-macos-gnu/sys/_pthread/_pthread_rwlockattr_t.h
deleted file mode 100644
index 99fda712f4..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/sys/_pthread/_pthread_rwlockattr_t.h
+++ /dev/null
@@ -1,32 +0,0 @@
-/*
- * Copyright (c) 2003-2012 Apple Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- * 
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- * 
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- * 
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- * 
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-#ifndef _PTHREAD_RWLOCKATTR_T
-#define _PTHREAD_RWLOCKATTR_T
-#include <sys/_pthread/_pthread_types.h> /* __darwin_pthread_rwlockattr_t */
-typedef __darwin_pthread_rwlockattr_t pthread_rwlockattr_t;
-#endif /* _PTHREAD_RWLOCKATTR_T */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/sys/_pthread/_pthread_t.h b/lib/libc/include/x86_64-macos-gnu/sys/_pthread/_pthread_t.h
deleted file mode 100644
index 87f42ee9aa..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/sys/_pthread/_pthread_t.h
+++ /dev/null
@@ -1,32 +0,0 @@
-/*
- * Copyright (c) 2003-2012 Apple Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- * 
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- * 
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- * 
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- * 
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-#ifndef _PTHREAD_T
-#define _PTHREAD_T
-#include <sys/_pthread/_pthread_types.h> /* __darwin_pthread_t */
-typedef __darwin_pthread_t pthread_t;
-#endif /* _PTHREAD_T */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/sys/_pthread/_pthread_types.h b/lib/libc/include/x86_64-macos-gnu/sys/_pthread/_pthread_types.h
deleted file mode 100644
index 7aa42bdff1..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/sys/_pthread/_pthread_types.h
+++ /dev/null
@@ -1,120 +0,0 @@
-/*
- * Copyright (c) 2003-2013 Apple Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- * 
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- * 
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- * 
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- * 
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-
-#ifndef _SYS__PTHREAD_TYPES_H_
-#define _SYS__PTHREAD_TYPES_H_
-
-#include <sys/cdefs.h>
-
-// pthread opaque structures
-#if defined(__LP64__)
-#define __PTHREAD_SIZE__		8176
-#define __PTHREAD_ATTR_SIZE__		56
-#define __PTHREAD_MUTEXATTR_SIZE__	8
-#define __PTHREAD_MUTEX_SIZE__		56
-#define __PTHREAD_CONDATTR_SIZE__	8
-#define __PTHREAD_COND_SIZE__		40
-#define __PTHREAD_ONCE_SIZE__		8
-#define __PTHREAD_RWLOCK_SIZE__		192
-#define __PTHREAD_RWLOCKATTR_SIZE__	16
-#else // !__LP64__
-#define __PTHREAD_SIZE__		4088
-#define __PTHREAD_ATTR_SIZE__		36
-#define __PTHREAD_MUTEXATTR_SIZE__	8
-#define __PTHREAD_MUTEX_SIZE__		40
-#define __PTHREAD_CONDATTR_SIZE__	4
-#define __PTHREAD_COND_SIZE__		24
-#define __PTHREAD_ONCE_SIZE__		4
-#define __PTHREAD_RWLOCK_SIZE__		124
-#define __PTHREAD_RWLOCKATTR_SIZE__	12
-#endif // !__LP64__
-
-struct __darwin_pthread_handler_rec {
-	void (*__routine)(void *);	// Routine to call
-	void *__arg;			// Argument to pass
-	struct __darwin_pthread_handler_rec *__next;
-};
-
-struct _opaque_pthread_attr_t {
-	long __sig;
-	char __opaque[__PTHREAD_ATTR_SIZE__];
-};
-
-struct _opaque_pthread_cond_t {
-	long __sig;
-	char __opaque[__PTHREAD_COND_SIZE__];
-};
-
-struct _opaque_pthread_condattr_t {
-	long __sig;
-	char __opaque[__PTHREAD_CONDATTR_SIZE__];
-};
-
-struct _opaque_pthread_mutex_t {
-	long __sig;
-	char __opaque[__PTHREAD_MUTEX_SIZE__];
-};
-
-struct _opaque_pthread_mutexattr_t {
-	long __sig;
-	char __opaque[__PTHREAD_MUTEXATTR_SIZE__];
-};
-
-struct _opaque_pthread_once_t {
-	long __sig;
-	char __opaque[__PTHREAD_ONCE_SIZE__];
-};
-
-struct _opaque_pthread_rwlock_t {
-	long __sig;
-	char __opaque[__PTHREAD_RWLOCK_SIZE__];
-};
-
-struct _opaque_pthread_rwlockattr_t {
-	long __sig;
-	char __opaque[__PTHREAD_RWLOCKATTR_SIZE__];
-};
-
-struct _opaque_pthread_t {
-	long __sig;
-	struct __darwin_pthread_handler_rec  *__cleanup_stack;
-	char __opaque[__PTHREAD_SIZE__];
-};
-
-typedef struct _opaque_pthread_attr_t __darwin_pthread_attr_t;
-typedef struct _opaque_pthread_cond_t __darwin_pthread_cond_t;
-typedef struct _opaque_pthread_condattr_t __darwin_pthread_condattr_t;
-typedef unsigned long __darwin_pthread_key_t;
-typedef struct _opaque_pthread_mutex_t __darwin_pthread_mutex_t;
-typedef struct _opaque_pthread_mutexattr_t __darwin_pthread_mutexattr_t;
-typedef struct _opaque_pthread_once_t __darwin_pthread_once_t;
-typedef struct _opaque_pthread_rwlock_t __darwin_pthread_rwlock_t;
-typedef struct _opaque_pthread_rwlockattr_t __darwin_pthread_rwlockattr_t;
-typedef struct _opaque_pthread_t *__darwin_pthread_t;
-
-#endif // _SYS__PTHREAD_TYPES_H_
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/sys/_select.h b/lib/libc/include/x86_64-macos-gnu/sys/_select.h
deleted file mode 100644
index 70842ca2f5..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/sys/_select.h
+++ /dev/null
@@ -1,52 +0,0 @@
-/*
- * Copyright (c) 2005, 2007 Apple Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-
-/*
- * This is called from sys/select.h and sys/time.h for the common prototype
- * of select().  Setting _DARWIN_C_SOURCE or _DARWIN_UNLIMITED_SELECT uses
- * the version of select() that does not place a limit on the first argument
- * (nfds).  In the UNIX conformance case, values of nfds greater than
- * FD_SETSIZE will return an error of EINVAL.
- */
-#ifndef _SYS__SELECT_H_
-#define _SYS__SELECT_H_
-
-int      select(int, fd_set * __restrict, fd_set * __restrict,
-    fd_set * __restrict, struct timeval * __restrict)
-#if defined(_DARWIN_C_SOURCE) || defined(_DARWIN_UNLIMITED_SELECT)
-__DARWIN_EXTSN_C(select)
-#else /* !_DARWIN_C_SOURCE && !_DARWIN_UNLIMITED_SELECT */
-#  if defined(__LP64__) && !__DARWIN_NON_CANCELABLE
-__DARWIN_1050(select)
-#  else /* !__LP64__ || __DARWIN_NON_CANCELABLE */
-__DARWIN_ALIAS_C(select)
-#  endif /* __LP64__ && !__DARWIN_NON_CANCELABLE */
-#endif /* _DARWIN_C_SOURCE || _DARWIN_UNLIMITED_SELECT */
-;
-
-#endif /* !_SYS__SELECT_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/sys/_symbol_aliasing.h b/lib/libc/include/x86_64-macos-gnu/sys/_symbol_aliasing.h
deleted file mode 100644
index 17b4d6fe37..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/sys/_symbol_aliasing.h
+++ /dev/null
@@ -1,498 +0,0 @@
-/* Copyright (c) 2010 Apple Inc. All rights reserved.
- * 
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- * 
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- * 
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- * 
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- * 
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-
-#ifndef _CDEFS_H_
-# error "Never use <sys/_symbol_aliasing.h> directly.  Use <sys/cdefs.h> instead."
-#endif
-
-#if defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ >= 20000
-#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_2_0(x) x
-#else
-#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_2_0(x)
-#endif
-
-#if defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ >= 20100
-#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_2_1(x) x
-#else
-#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_2_1(x)
-#endif
-
-#if defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ >= 20200
-#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_2_2(x) x
-#else
-#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_2_2(x)
-#endif
-
-#if defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ >= 30000
-#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_3_0(x) x
-#else
-#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_3_0(x)
-#endif
-
-#if defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ >= 30100
-#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_3_1(x) x
-#else
-#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_3_1(x)
-#endif
-
-#if defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ >= 30200
-#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_3_2(x) x
-#else
-#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_3_2(x)
-#endif
-
-#if defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ >= 40000
-#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_4_0(x) x
-#else
-#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_4_0(x)
-#endif
-
-#if defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ >= 40100
-#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_4_1(x) x
-#else
-#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_4_1(x)
-#endif
-
-#if defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ >= 40200
-#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_4_2(x) x
-#else
-#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_4_2(x)
-#endif
-
-#if defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ >= 40300
-#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_4_3(x) x
-#else
-#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_4_3(x)
-#endif
-
-#if defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ >= 50000
-#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_5_0(x) x
-#else
-#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_5_0(x)
-#endif
-
-#if defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ >= 50100
-#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_5_1(x) x
-#else
-#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_5_1(x)
-#endif
-
-#if defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ >= 60000
-#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_6_0(x) x
-#else
-#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_6_0(x)
-#endif
-
-#if defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ >= 60100
-#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_6_1(x) x
-#else
-#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_6_1(x)
-#endif
-
-#if defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ >= 70000
-#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_7_0(x) x
-#else
-#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_7_0(x)
-#endif
-
-#if defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ >= 70100
-#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_7_1(x) x
-#else
-#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_7_1(x)
-#endif
-
-#if defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ >= 80000
-#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_8_0(x) x
-#else
-#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_8_0(x)
-#endif
-
-#if defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ >= 80100
-#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_8_1(x) x
-#else
-#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_8_1(x)
-#endif
-
-#if defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ >= 80200
-#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_8_2(x) x
-#else
-#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_8_2(x)
-#endif
-
-#if defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ >= 80300
-#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_8_3(x) x
-#else
-#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_8_3(x)
-#endif
-
-#if defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ >= 80400
-#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_8_4(x) x
-#else
-#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_8_4(x)
-#endif
-
-#if defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ >= 90000
-#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_9_0(x) x
-#else
-#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_9_0(x)
-#endif
-
-#if defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ >= 90100
-#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_9_1(x) x
-#else
-#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_9_1(x)
-#endif
-
-#if defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ >= 90200
-#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_9_2(x) x
-#else
-#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_9_2(x)
-#endif
-
-#if defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ >= 90300
-#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_9_3(x) x
-#else
-#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_9_3(x)
-#endif
-
-#if defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ >= 100000
-#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_10_0(x) x
-#else
-#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_10_0(x)
-#endif
-
-#if defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ >= 100100
-#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_10_1(x) x
-#else
-#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_10_1(x)
-#endif
-
-#if defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ >= 100200
-#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_10_2(x) x
-#else
-#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_10_2(x)
-#endif
-
-#if defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ >= 100300
-#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_10_3(x) x
-#else
-#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_10_3(x)
-#endif
-
-#if defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ >= 110000
-#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_11_0(x) x
-#else
-#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_11_0(x)
-#endif
-
-#if defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ >= 110100
-#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_11_1(x) x
-#else
-#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_11_1(x)
-#endif
-
-#if defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ >= 110200
-#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_11_2(x) x
-#else
-#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_11_2(x)
-#endif
-
-#if defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ >= 110300
-#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_11_3(x) x
-#else
-#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_11_3(x)
-#endif
-
-#if defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ >= 110400
-#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_11_4(x) x
-#else
-#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_11_4(x)
-#endif
-
-#if defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ >= 120000
-#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_12_0(x) x
-#else
-#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_12_0(x)
-#endif
-
-#if defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ >= 120100
-#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_12_1(x) x
-#else
-#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_12_1(x)
-#endif
-
-#if defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ >= 120200
-#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_12_2(x) x
-#else
-#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_12_2(x)
-#endif
-
-#if defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ >= 120300
-#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_12_3(x) x
-#else
-#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_12_3(x)
-#endif
-
-#if defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ >= 120400
-#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_12_4(x) x
-#else
-#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_12_4(x)
-#endif
-
-#if defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ >= 130000
-#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_13_0(x) x
-#else
-#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_13_0(x)
-#endif
-
-#if defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ >= 130100
-#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_13_1(x) x
-#else
-#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_13_1(x)
-#endif
-
-#if defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ >= 130200
-#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_13_2(x) x
-#else
-#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_13_2(x)
-#endif
-
-#if defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ >= 130300
-#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_13_3(x) x
-#else
-#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_13_3(x)
-#endif
-
-#if defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ >= 130400
-#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_13_4(x) x
-#else
-#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_13_4(x)
-#endif
-
-#if defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ >= 130500
-#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_13_5(x) x
-#else
-#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_13_5(x)
-#endif
-
-#if defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ >= 130600
-#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_13_6(x) x
-#else
-#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_13_6(x)
-#endif
-
-#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 1000
-#define __DARWIN_ALIAS_STARTING_MAC___MAC_10_0(x) x
-#else
-#define __DARWIN_ALIAS_STARTING_MAC___MAC_10_0(x)
-#endif
-
-#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 1010
-#define __DARWIN_ALIAS_STARTING_MAC___MAC_10_1(x) x
-#else
-#define __DARWIN_ALIAS_STARTING_MAC___MAC_10_1(x)
-#endif
-
-#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 1020
-#define __DARWIN_ALIAS_STARTING_MAC___MAC_10_2(x) x
-#else
-#define __DARWIN_ALIAS_STARTING_MAC___MAC_10_2(x)
-#endif
-
-#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 1030
-#define __DARWIN_ALIAS_STARTING_MAC___MAC_10_3(x) x
-#else
-#define __DARWIN_ALIAS_STARTING_MAC___MAC_10_3(x)
-#endif
-
-#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 1040
-#define __DARWIN_ALIAS_STARTING_MAC___MAC_10_4(x) x
-#else
-#define __DARWIN_ALIAS_STARTING_MAC___MAC_10_4(x)
-#endif
-
-#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 1050
-#define __DARWIN_ALIAS_STARTING_MAC___MAC_10_5(x) x
-#else
-#define __DARWIN_ALIAS_STARTING_MAC___MAC_10_5(x)
-#endif
-
-#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 1060
-#define __DARWIN_ALIAS_STARTING_MAC___MAC_10_6(x) x
-#else
-#define __DARWIN_ALIAS_STARTING_MAC___MAC_10_6(x)
-#endif
-
-#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 1070
-#define __DARWIN_ALIAS_STARTING_MAC___MAC_10_7(x) x
-#else
-#define __DARWIN_ALIAS_STARTING_MAC___MAC_10_7(x)
-#endif
-
-#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 1080
-#define __DARWIN_ALIAS_STARTING_MAC___MAC_10_8(x) x
-#else
-#define __DARWIN_ALIAS_STARTING_MAC___MAC_10_8(x)
-#endif
-
-#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 1090
-#define __DARWIN_ALIAS_STARTING_MAC___MAC_10_9(x) x
-#else
-#define __DARWIN_ALIAS_STARTING_MAC___MAC_10_9(x)
-#endif
-
-#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 101000
-#define __DARWIN_ALIAS_STARTING_MAC___MAC_10_10(x) x
-#else
-#define __DARWIN_ALIAS_STARTING_MAC___MAC_10_10(x)
-#endif
-
-#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 101002
-#define __DARWIN_ALIAS_STARTING_MAC___MAC_10_10_2(x) x
-#else
-#define __DARWIN_ALIAS_STARTING_MAC___MAC_10_10_2(x)
-#endif
-
-#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 101003
-#define __DARWIN_ALIAS_STARTING_MAC___MAC_10_10_3(x) x
-#else
-#define __DARWIN_ALIAS_STARTING_MAC___MAC_10_10_3(x)
-#endif
-
-#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 101100
-#define __DARWIN_ALIAS_STARTING_MAC___MAC_10_11(x) x
-#else
-#define __DARWIN_ALIAS_STARTING_MAC___MAC_10_11(x)
-#endif
-
-#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 101102
-#define __DARWIN_ALIAS_STARTING_MAC___MAC_10_11_2(x) x
-#else
-#define __DARWIN_ALIAS_STARTING_MAC___MAC_10_11_2(x)
-#endif
-
-#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 101103
-#define __DARWIN_ALIAS_STARTING_MAC___MAC_10_11_3(x) x
-#else
-#define __DARWIN_ALIAS_STARTING_MAC___MAC_10_11_3(x)
-#endif
-
-#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 101104
-#define __DARWIN_ALIAS_STARTING_MAC___MAC_10_11_4(x) x
-#else
-#define __DARWIN_ALIAS_STARTING_MAC___MAC_10_11_4(x)
-#endif
-
-#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 101200
-#define __DARWIN_ALIAS_STARTING_MAC___MAC_10_12(x) x
-#else
-#define __DARWIN_ALIAS_STARTING_MAC___MAC_10_12(x)
-#endif
-
-#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 101201
-#define __DARWIN_ALIAS_STARTING_MAC___MAC_10_12_1(x) x
-#else
-#define __DARWIN_ALIAS_STARTING_MAC___MAC_10_12_1(x)
-#endif
-
-#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 101202
-#define __DARWIN_ALIAS_STARTING_MAC___MAC_10_12_2(x) x
-#else
-#define __DARWIN_ALIAS_STARTING_MAC___MAC_10_12_2(x)
-#endif
-
-#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 101204
-#define __DARWIN_ALIAS_STARTING_MAC___MAC_10_12_4(x) x
-#else
-#define __DARWIN_ALIAS_STARTING_MAC___MAC_10_12_4(x)
-#endif
-
-#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 101300
-#define __DARWIN_ALIAS_STARTING_MAC___MAC_10_13(x) x
-#else
-#define __DARWIN_ALIAS_STARTING_MAC___MAC_10_13(x)
-#endif
-
-#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 101301
-#define __DARWIN_ALIAS_STARTING_MAC___MAC_10_13_1(x) x
-#else
-#define __DARWIN_ALIAS_STARTING_MAC___MAC_10_13_1(x)
-#endif
-
-#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 101302
-#define __DARWIN_ALIAS_STARTING_MAC___MAC_10_13_2(x) x
-#else
-#define __DARWIN_ALIAS_STARTING_MAC___MAC_10_13_2(x)
-#endif
-
-#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 101304
-#define __DARWIN_ALIAS_STARTING_MAC___MAC_10_13_4(x) x
-#else
-#define __DARWIN_ALIAS_STARTING_MAC___MAC_10_13_4(x)
-#endif
-
-#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 101400
-#define __DARWIN_ALIAS_STARTING_MAC___MAC_10_14(x) x
-#else
-#define __DARWIN_ALIAS_STARTING_MAC___MAC_10_14(x)
-#endif
-
-#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 101401
-#define __DARWIN_ALIAS_STARTING_MAC___MAC_10_14_1(x) x
-#else
-#define __DARWIN_ALIAS_STARTING_MAC___MAC_10_14_1(x)
-#endif
-
-#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 101404
-#define __DARWIN_ALIAS_STARTING_MAC___MAC_10_14_4(x) x
-#else
-#define __DARWIN_ALIAS_STARTING_MAC___MAC_10_14_4(x)
-#endif
-
-#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 101405
-#define __DARWIN_ALIAS_STARTING_MAC___MAC_10_14_5(x) x
-#else
-#define __DARWIN_ALIAS_STARTING_MAC___MAC_10_14_5(x)
-#endif
-
-#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 101406
-#define __DARWIN_ALIAS_STARTING_MAC___MAC_10_14_6(x) x
-#else
-#define __DARWIN_ALIAS_STARTING_MAC___MAC_10_14_6(x)
-#endif
-
-#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 101500
-#define __DARWIN_ALIAS_STARTING_MAC___MAC_10_15(x) x
-#else
-#define __DARWIN_ALIAS_STARTING_MAC___MAC_10_15(x)
-#endif
-
-#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 101501
-#define __DARWIN_ALIAS_STARTING_MAC___MAC_10_15_1(x) x
-#else
-#define __DARWIN_ALIAS_STARTING_MAC___MAC_10_15_1(x)
-#endif
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/sys/_types/_fd_def.h b/lib/libc/include/x86_64-macos-gnu/sys/_types/_fd_def.h
deleted file mode 100644
index ec0bad4289..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/sys/_types/_fd_def.h
+++ /dev/null
@@ -1,114 +0,0 @@
-/*
- * Copyright (c) 2003-2012 Apple Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-#ifndef _FD_SET
-#define _FD_SET
-
-#include <machine/types.h> /* __int32_t and uintptr_t */
-#include <Availability.h>
-
-/*
- * Select uses bit masks of file descriptors in longs.  These macros
- * manipulate such bit fields (the filesystem macros use chars).  The
- * extra protection here is to permit application redefinition above
- * the default size.
- */
-#ifdef FD_SETSIZE
-#define __DARWIN_FD_SETSIZE     FD_SETSIZE
-#else /* !FD_SETSIZE */
-#define __DARWIN_FD_SETSIZE     1024
-#endif /* FD_SETSIZE */
-#define __DARWIN_NBBY           8                               /* bits in a byte */
-#define __DARWIN_NFDBITS        (sizeof(__int32_t) * __DARWIN_NBBY) /* bits per mask */
-#define __DARWIN_howmany(x, y)  ((((x) % (y)) == 0) ? ((x) / (y)) : (((x) / (y)) + 1)) /* # y's == x bits? */
-
-__BEGIN_DECLS
-typedef struct fd_set {
-	__int32_t       fds_bits[__DARWIN_howmany(__DARWIN_FD_SETSIZE, __DARWIN_NFDBITS)];
-} fd_set;
-
-int __darwin_check_fd_set_overflow(int, const void *, int) __attribute__((__weak_import__));
-__END_DECLS
-
-__header_always_inline int
-__darwin_check_fd_set(int _a, const void *_b)
-{
-	if ((uintptr_t)&__darwin_check_fd_set_overflow != (uintptr_t) 0) {
-#if defined(_DARWIN_UNLIMITED_SELECT) || defined(_DARWIN_C_SOURCE)
-		return __darwin_check_fd_set_overflow(_a, _b, 1);
-#else
-		return __darwin_check_fd_set_overflow(_a, _b, 0);
-#endif
-	} else {
-		return 1;
-	}
-}
-
-/* This inline avoids argument side-effect issues with FD_ISSET() */
-__header_always_inline int
-__darwin_fd_isset(int _fd, const struct fd_set *_p)
-{
-	if (__darwin_check_fd_set(_fd, (const void *) _p)) {
-		return _p->fds_bits[(unsigned long)_fd / __DARWIN_NFDBITS] & ((__int32_t)(((unsigned long)1) << ((unsigned long)_fd % __DARWIN_NFDBITS)));
-	}
-
-	return 0;
-}
-
-__header_always_inline void
-__darwin_fd_set(int _fd, struct fd_set *const _p)
-{
-	if (__darwin_check_fd_set(_fd, (const void *) _p)) {
-		(_p->fds_bits[(unsigned long)_fd / __DARWIN_NFDBITS] |= ((__int32_t)(((unsigned long)1) << ((unsigned long)_fd % __DARWIN_NFDBITS))));
-	}
-}
-
-__header_always_inline void
-__darwin_fd_clr(int _fd, struct fd_set *const _p)
-{
-	if (__darwin_check_fd_set(_fd, (const void *) _p)) {
-		(_p->fds_bits[(unsigned long)_fd / __DARWIN_NFDBITS] &= ~((__int32_t)(((unsigned long)1) << ((unsigned long)_fd % __DARWIN_NFDBITS))));
-	}
-}
-
-
-#define __DARWIN_FD_SET(n, p)   __darwin_fd_set((n), (p))
-#define __DARWIN_FD_CLR(n, p)   __darwin_fd_clr((n), (p))
-#define __DARWIN_FD_ISSET(n, p) __darwin_fd_isset((n), (p))
-
-#if __GNUC__ > 3 || __GNUC__ == 3 && __GNUC_MINOR__ >= 3
-/*
- * Use the built-in bzero function instead of the library version so that
- * we do not pollute the namespace or introduce prototype warnings.
- */
-#define __DARWIN_FD_ZERO(p)     __builtin_bzero(p, sizeof(*(p)))
-#else
-#define __DARWIN_FD_ZERO(p)     bzero(p, sizeof(*(p)))
-#endif
-
-#define __DARWIN_FD_COPY(f, t)  bcopy(f, t, sizeof(*(f)))
-#endif /* _FD_SET */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/sys/_types/_int8_t.h b/lib/libc/include/x86_64-macos-gnu/sys/_types/_int8_t.h
deleted file mode 100644
index 15b281d533..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/sys/_types/_int8_t.h
+++ /dev/null
@@ -1,31 +0,0 @@
-/*
- * Copyright (c) 2012 Apple Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-#ifndef _INT8_T
-#define _INT8_T
-typedef __signed char           int8_t;
-#endif /* _INT8_T */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/sys/_types/_ucontext.h b/lib/libc/include/x86_64-macos-gnu/sys/_types/_ucontext.h
deleted file mode 100644
index 1e563f4581..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/sys/_types/_ucontext.h
+++ /dev/null
@@ -1,58 +0,0 @@
-/*
- * Copyright (c) 2003-2012 Apple Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-#ifndef _STRUCT_UCONTEXT
-
-#include <sys/cdefs.h> /* __DARWIN_UNIX03 */
-
-#if __DARWIN_UNIX03
-#define _STRUCT_UCONTEXT        struct __darwin_ucontext
-#else /* !__DARWIN_UNIX03 */
-#define _STRUCT_UCONTEXT        struct ucontext
-#endif /* __DARWIN_UNIX03 */
-
-#include <machine/types.h> /* __darwin_size_t */
-#include <machine/_mcontext.h> /* _STRUCT_MCONTEXT */
-#include <sys/_types.h> /* __darwin_sigset_t */
-
-_STRUCT_UCONTEXT
-{
-	int                     uc_onstack;
-	__darwin_sigset_t       uc_sigmask;     /* signal mask used by this context */
-	_STRUCT_SIGALTSTACK     uc_stack;       /* stack used by this context */
-	_STRUCT_UCONTEXT        *uc_link;       /* pointer to resuming context */
-	__darwin_size_t         uc_mcsize;      /* size of the machine context passed in */
-	_STRUCT_MCONTEXT        *uc_mcontext;   /* pointer to machine specific context */
-#ifdef _XOPEN_SOURCE
-	_STRUCT_MCONTEXT        __mcontext_data;
-#endif /* _XOPEN_SOURCE */
-};
-
-/* user context */
-typedef _STRUCT_UCONTEXT        ucontext_t;     /* [???] user context */
-
-#endif /* _STRUCT_UCONTEXT */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/sys/acl.h b/lib/libc/include/x86_64-macos-gnu/sys/acl.h
deleted file mode 100644
index dc134613d1..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/sys/acl.h
+++ /dev/null
@@ -1,211 +0,0 @@
-/*
- * Copyright (c) 2004, 2010 Apple Inc. All rights reserved.
- *
- * @APPLE_LICENSE_HEADER_START@
- * 
- * The contents of this file constitute Original Code as defined in and
- * are subject to the Apple Public Source License Version 1.1 (the
- * "License").  You may not use this file except in compliance with the
- * License.  Please obtain a copy of the License at
- * http://www.apple.com/publicsource and read it before using this file.
- * 
- * This Original Code and all software distributed under the License are
- * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT.  Please see the
- * License for the specific language governing rights and limitations
- * under the License.
- * 
- * @APPLE_LICENSE_HEADER_END@
- */
-
-#ifndef _SYS_ACL_H
-#define _SYS_ACL_H
-
-#include <Availability.h>
-#include <sys/kauth.h>
-
-#define __DARWIN_ACL_READ_DATA			(1<<1)
-#define __DARWIN_ACL_LIST_DIRECTORY		__DARWIN_ACL_READ_DATA
-#define __DARWIN_ACL_WRITE_DATA			(1<<2)
-#define __DARWIN_ACL_ADD_FILE			__DARWIN_ACL_WRITE_DATA
-#define __DARWIN_ACL_EXECUTE			(1<<3)
-#define __DARWIN_ACL_SEARCH			__DARWIN_ACL_EXECUTE
-#define __DARWIN_ACL_DELETE			(1<<4)
-#define __DARWIN_ACL_APPEND_DATA		(1<<5)
-#define __DARWIN_ACL_ADD_SUBDIRECTORY		__DARWIN_ACL_APPEND_DATA
-#define __DARWIN_ACL_DELETE_CHILD		(1<<6)
-#define __DARWIN_ACL_READ_ATTRIBUTES		(1<<7)
-#define __DARWIN_ACL_WRITE_ATTRIBUTES		(1<<8)
-#define __DARWIN_ACL_READ_EXTATTRIBUTES		(1<<9)
-#define __DARWIN_ACL_WRITE_EXTATTRIBUTES	(1<<10)
-#define __DARWIN_ACL_READ_SECURITY		(1<<11)
-#define __DARWIN_ACL_WRITE_SECURITY		(1<<12)
-#define __DARWIN_ACL_CHANGE_OWNER		(1<<13)
-#define __DARWIN_ACL_SYNCHRONIZE		(1<<20)
-
-#define __DARWIN_ACL_EXTENDED_ALLOW		1
-#define __DARWIN_ACL_EXTENDED_DENY		2
-
-#define __DARWIN_ACL_ENTRY_INHERITED		(1<<4)
-#define __DARWIN_ACL_ENTRY_FILE_INHERIT		(1<<5)
-#define __DARWIN_ACL_ENTRY_DIRECTORY_INHERIT	(1<<6)
-#define __DARWIN_ACL_ENTRY_LIMIT_INHERIT	(1<<7)
-#define __DARWIN_ACL_ENTRY_ONLY_INHERIT		(1<<8)
-#define __DARWIN_ACL_FLAG_NO_INHERIT		(1<<17)
-
-/*
- * Implementation constants.
- *
- * The ACL_TYPE_EXTENDED binary format permits 169 entries plus
- * the ACL header in a page.  Give ourselves some room to grow;
- * this limit is arbitrary.
- */
-#define ACL_MAX_ENTRIES		128
-
-/* 23.2.2 Individual object access permissions - nonstandard */
-typedef enum {
-	ACL_READ_DATA		= __DARWIN_ACL_READ_DATA,
-	ACL_LIST_DIRECTORY	= __DARWIN_ACL_LIST_DIRECTORY,
-	ACL_WRITE_DATA		= __DARWIN_ACL_WRITE_DATA,
-	ACL_ADD_FILE		= __DARWIN_ACL_ADD_FILE,
-	ACL_EXECUTE		= __DARWIN_ACL_EXECUTE,
-	ACL_SEARCH		= __DARWIN_ACL_SEARCH,
-	ACL_DELETE		= __DARWIN_ACL_DELETE,
-	ACL_APPEND_DATA		= __DARWIN_ACL_APPEND_DATA,
-	ACL_ADD_SUBDIRECTORY	= __DARWIN_ACL_ADD_SUBDIRECTORY,
-	ACL_DELETE_CHILD	= __DARWIN_ACL_DELETE_CHILD,
-	ACL_READ_ATTRIBUTES	= __DARWIN_ACL_READ_ATTRIBUTES,
-	ACL_WRITE_ATTRIBUTES	= __DARWIN_ACL_WRITE_ATTRIBUTES,
-	ACL_READ_EXTATTRIBUTES	= __DARWIN_ACL_READ_EXTATTRIBUTES,
-	ACL_WRITE_EXTATTRIBUTES	= __DARWIN_ACL_WRITE_EXTATTRIBUTES,
-	ACL_READ_SECURITY	= __DARWIN_ACL_READ_SECURITY,
-	ACL_WRITE_SECURITY	= __DARWIN_ACL_WRITE_SECURITY,
-	ACL_CHANGE_OWNER	= __DARWIN_ACL_CHANGE_OWNER,
-	ACL_SYNCHRONIZE		= __DARWIN_ACL_SYNCHRONIZE,
-} acl_perm_t;
-
-/* 23.2.5 ACL entry tag type bits - nonstandard */
-typedef enum {
-	ACL_UNDEFINED_TAG	= 0,
-	ACL_EXTENDED_ALLOW	= __DARWIN_ACL_EXTENDED_ALLOW,
-	ACL_EXTENDED_DENY	= __DARWIN_ACL_EXTENDED_DENY
-} acl_tag_t;
-
-/* 23.2.6 Individual ACL types */
-typedef enum {
-	ACL_TYPE_EXTENDED	= 0x00000100,
-/* Posix 1003.1e types - not supported */
-	ACL_TYPE_ACCESS         = 0x00000000,
-	ACL_TYPE_DEFAULT        = 0x00000001,
-/* The following types are defined on FreeBSD/Linux - not supported */
-	ACL_TYPE_AFS            = 0x00000002,
-	ACL_TYPE_CODA           = 0x00000003,
-	ACL_TYPE_NTFS           = 0x00000004,
-	ACL_TYPE_NWFS           = 0x00000005
-} acl_type_t;
-
-/* 23.2.7 ACL qualifier constants */
-
-#define ACL_UNDEFINED_ID	NULL	/* XXX ? */
-
-/* 23.2.8 ACL Entry Constants */
-typedef enum {
-	ACL_FIRST_ENTRY		= 0,
-	ACL_NEXT_ENTRY		= -1,
-	ACL_LAST_ENTRY		= -2
-} acl_entry_id_t;
-
-/* nonstandard ACL / entry flags */
-typedef enum {
-	ACL_FLAG_DEFER_INHERIT		= (1 << 0),	/* tentative */
-	ACL_FLAG_NO_INHERIT		= __DARWIN_ACL_FLAG_NO_INHERIT,
-	ACL_ENTRY_INHERITED		= __DARWIN_ACL_ENTRY_INHERITED,
-	ACL_ENTRY_FILE_INHERIT		= __DARWIN_ACL_ENTRY_FILE_INHERIT,
-	ACL_ENTRY_DIRECTORY_INHERIT	= __DARWIN_ACL_ENTRY_DIRECTORY_INHERIT,
-	ACL_ENTRY_LIMIT_INHERIT		= __DARWIN_ACL_ENTRY_LIMIT_INHERIT,
-	ACL_ENTRY_ONLY_INHERIT		= __DARWIN_ACL_ENTRY_ONLY_INHERIT
-} acl_flag_t;
-
-/* "External" ACL types */
-
-struct _acl;
-struct _acl_entry;
-struct _acl_permset;
-struct _acl_flagset;
-
-typedef struct _acl		*acl_t;
-typedef struct _acl_entry	*acl_entry_t;
-typedef struct _acl_permset	*acl_permset_t;
-typedef struct _acl_flagset	*acl_flagset_t;
-
-typedef u_int64_t		acl_permset_mask_t;
-
-__BEGIN_DECLS
-/* 23.1.6.1 ACL Storage Management */
-extern acl_t	acl_dup(acl_t acl);
-extern int	acl_free(void *obj_p);
-extern acl_t	acl_init(int count);
-
-/* 23.1.6.2 (1) ACL Entry manipulation */
-extern int	acl_copy_entry(acl_entry_t dest_d, acl_entry_t src_d);
-extern int	acl_create_entry(acl_t *acl_p, acl_entry_t *entry_p);
-extern int	acl_create_entry_np(acl_t *acl_p, acl_entry_t *entry_p, int entry_index);
-extern int	acl_delete_entry(acl_t acl, acl_entry_t entry_d);
-extern int	acl_get_entry(acl_t acl, int entry_id, acl_entry_t *entry_p);
-extern int	acl_valid(acl_t acl);
-extern int	acl_valid_fd_np(int fd, acl_type_t type, acl_t acl);
-extern int	acl_valid_file_np(const char *path, acl_type_t type, acl_t acl);
-extern int	acl_valid_link_np(const char *path, acl_type_t type, acl_t acl);
-
-/* 23.1.6.2 (2) Manipulate permissions within an ACL entry */
-extern int	acl_add_perm(acl_permset_t permset_d, acl_perm_t perm);
-extern int	acl_calc_mask(acl_t *acl_p);	/* not supported */
-extern int	acl_clear_perms(acl_permset_t permset_d);
-extern int	acl_delete_perm(acl_permset_t permset_d, acl_perm_t perm);
-extern int	acl_get_perm_np(acl_permset_t permset_d, acl_perm_t perm);
-extern int 	acl_get_permset(acl_entry_t entry_d, acl_permset_t *permset_p);
-extern int	acl_set_permset(acl_entry_t entry_d, acl_permset_t permset_d);
-
-/* nonstandard - manipulate permissions within an ACL entry using bitmasks */
-extern int	acl_maximal_permset_mask_np(acl_permset_mask_t * mask_p) __OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_4_3);
-extern int	acl_get_permset_mask_np(acl_entry_t entry_d, acl_permset_mask_t * mask_p) __OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_4_3);
-extern int	acl_set_permset_mask_np(acl_entry_t entry_d, acl_permset_mask_t mask) __OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_4_3);
-
-/* nonstandard - manipulate flags on ACLs and entries */
-extern int	acl_add_flag_np(acl_flagset_t flagset_d, acl_flag_t flag);
-extern int	acl_clear_flags_np(acl_flagset_t flagset_d);
-extern int	acl_delete_flag_np(acl_flagset_t flagset_d, acl_flag_t flag);
-extern int	acl_get_flag_np(acl_flagset_t flagset_d, acl_flag_t flag);
-extern int	acl_get_flagset_np(void *obj_p, acl_flagset_t *flagset_p);
-extern int	acl_set_flagset_np(void *obj_p, acl_flagset_t flagset_d);
-
-/* 23.1.6.2 (3) Manipulate ACL entry tag type and qualifier */
-extern void	*acl_get_qualifier(acl_entry_t entry_d);
-extern int	acl_get_tag_type(acl_entry_t entry_d, acl_tag_t *tag_type_p);
-extern int	acl_set_qualifier(acl_entry_t entry_d, const void *tag_qualifier_p);
-extern int	acl_set_tag_type(acl_entry_t entry_d, acl_tag_t tag_type);
-
-/* 23.1.6.3 ACL manipulation on an Object */
-extern int	acl_delete_def_file(const char *path_p); /* not supported */
-extern acl_t 	acl_get_fd(int fd);
-extern acl_t	acl_get_fd_np(int fd, acl_type_t type);
-extern acl_t	acl_get_file(const char *path_p, acl_type_t type);
-extern acl_t	acl_get_link_np(const char *path_p, acl_type_t type);
-extern int	acl_set_fd(int fd, acl_t acl);
-extern int	acl_set_fd_np(int fd, acl_t acl, acl_type_t acl_type);
-extern int	acl_set_file(const char *path_p, acl_type_t type, acl_t acl);
-extern int	acl_set_link_np(const char *path_p, acl_type_t type, acl_t acl);
-
-/* 23.1.6.4 ACL Format translation */
-extern ssize_t	acl_copy_ext(void *buf_p, acl_t acl, ssize_t size);
-extern ssize_t	acl_copy_ext_native(void *buf_p, acl_t acl, ssize_t size);
-extern acl_t	acl_copy_int(const void *buf_p);
-extern acl_t	acl_copy_int_native(const void *buf_p);
-extern acl_t	acl_from_text(const char *buf_p);
-extern ssize_t	acl_size(acl_t acl);
-extern char	*acl_to_text(acl_t acl, ssize_t *len_p);
-__END_DECLS
-
-#endif /* _SYS_ACL_H */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/sys/attr.h b/lib/libc/include/x86_64-macos-gnu/sys/attr.h
deleted file mode 100644
index 7de047ec5b..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/sys/attr.h
+++ /dev/null
@@ -1,579 +0,0 @@
-/*
- * Copyright (c) 2000-2018 Apple Computer, Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-
-/*
- * attr.h - attribute data structures and interfaces
- *
- * Copyright (c) 1998, Apple Computer, Inc.  All Rights Reserved.
- */
-
-#ifndef _SYS_ATTR_H_
-#define _SYS_ATTR_H_
-
-#include <sys/appleapiopts.h>
-
-#ifdef __APPLE_API_UNSTABLE
-#include <sys/types.h>
-#include <sys/ucred.h>
-#include <sys/time.h>
-#include <sys/cdefs.h>
-
-#define FSOPT_NOFOLLOW          0x00000001
-#define FSOPT_NOINMEMUPDATE     0x00000002
-#define FSOPT_REPORT_FULLSIZE   0x00000004
-/* The following option only valid when requesting ATTR_CMN_RETURNED_ATTRS */
-#define FSOPT_PACK_INVAL_ATTRS  0x00000008
-
-
-#define FSOPT_ATTR_CMN_EXTENDED 0x00000020
-
-/* we currently aren't anywhere near this amount for a valid
- * fssearchblock.sizeofsearchparams1 or fssearchblock.sizeofsearchparams2
- * but we put a sanity check in to avoid abuse of the value passed in from
- * user land.
- */
-#define SEARCHFS_MAX_SEARCHPARMS  4096
-
-typedef u_int32_t text_encoding_t;
-
-typedef u_int32_t fsobj_type_t;
-
-typedef u_int32_t fsobj_tag_t;
-
-typedef u_int32_t fsfile_type_t;
-
-typedef u_int32_t fsvolid_t;
-
-#include <sys/_types/_fsobj_id_t.h> /* file object id type */
-
-typedef u_int32_t attrgroup_t;
-
-struct attrlist {
-	u_short bitmapcount;                    /* number of attr. bit sets in list (should be 5) */
-	u_int16_t reserved;                     /* (to maintain 4-byte alignment) */
-	attrgroup_t commonattr;                 /* common attribute group */
-	attrgroup_t volattr;                    /* Volume attribute group */
-	attrgroup_t dirattr;                    /* directory attribute group */
-	attrgroup_t fileattr;                   /* file attribute group */
-	attrgroup_t forkattr;                   /* fork attribute group */
-};
-#define ATTR_BIT_MAP_COUNT 5
-
-typedef struct attribute_set {
-	attrgroup_t commonattr;                 /* common attribute group */
-	attrgroup_t volattr;                    /* Volume attribute group */
-	attrgroup_t dirattr;                    /* directory attribute group */
-	attrgroup_t fileattr;                   /* file attribute group */
-	attrgroup_t forkattr;                   /* fork attribute group */
-} attribute_set_t;
-
-typedef struct attrreference {
-	int32_t     attr_dataoffset;
-	u_int32_t   attr_length;
-} attrreference_t;
-
-/* XXX PPD This is derived from HFSVolumePriv.h and should perhaps be referenced from there? */
-
-struct diskextent {
-	u_int32_t                                       startblock;                             /* first block allocated */
-	u_int32_t                                       blockcount;                             /* number of blocks allocated */
-};
-
-typedef struct diskextent extentrecord[8];
-
-typedef u_int32_t vol_capabilities_set_t[4];
-
-#define VOL_CAPABILITIES_FORMAT 0
-#define VOL_CAPABILITIES_INTERFACES 1
-#define VOL_CAPABILITIES_RESERVED1 2
-#define VOL_CAPABILITIES_RESERVED2 3
-
-typedef struct vol_capabilities_attr {
-	vol_capabilities_set_t capabilities;
-	vol_capabilities_set_t valid;
-} vol_capabilities_attr_t;
-
-/*
- * XXX this value needs to be raised - 3893388
- */
-#define ATTR_MAX_BUFFER         8192
-
-/*
- * VOL_CAP_FMT_PERSISTENTOBJECTIDS: When set, the volume has object IDs
- * that are persistent (retain their values even when the volume is
- * unmounted and remounted), and a file or directory can be looked up
- * by ID.  Volumes that support VolFS and can support Carbon File ID
- * references should set this bit.
- *
- * VOL_CAP_FMT_SYMBOLICLINKS: When set, the volume supports symbolic
- * links.  The symlink(), readlink(), and lstat() calls all use this
- * symbolic link.
- *
- * VOL_CAP_FMT_HARDLINKS: When set, the volume supports hard links.
- * The link() call creates hard links.
- *
- * VOL_CAP_FMT_JOURNAL: When set, the volume is capable of supporting
- * a journal used to speed recovery in case of unplanned shutdown
- * (such as a power outage or crash).  This bit does not necessarily
- * mean the volume is actively using a journal for recovery.
- *
- * VOL_CAP_FMT_JOURNAL_ACTIVE: When set, the volume is currently using
- * a journal for use in speeding recovery after an unplanned shutdown.
- * This bit can be set only if VOL_CAP_FMT_JOURNAL is also set.
- *
- * VOL_CAP_FMT_NO_ROOT_TIMES: When set, the volume format does not
- * store reliable times for the root directory, so you should not
- * depend on them to detect changes, etc.
- *
- * VOL_CAP_FMT_SPARSE_FILES: When set, the volume supports sparse files.
- * That is, files which can have "holes" that have never been written
- * to, and are not allocated on disk.  Sparse files may have an
- * allocated size that is less than the file's logical length.
- *
- * VOL_CAP_FMT_ZERO_RUNS: For security reasons, parts of a file (runs)
- * that have never been written to must appear to contain zeroes.  When
- * this bit is set, the volume keeps track of allocated but unwritten
- * runs of a file so that it can substitute zeroes without actually
- * writing zeroes to the media.  This provides performance similar to
- * sparse files, but not the space savings.
- *
- * VOL_CAP_FMT_CASE_SENSITIVE: When set, file and directory names are
- * case sensitive (upper and lower case are different).  When clear,
- * an upper case character is equivalent to a lower case character,
- * and you can't have two names that differ solely in the case of
- * the characters.
- *
- * VOL_CAP_FMT_CASE_PRESERVING: When set, file and directory names
- * preserve the difference between upper and lower case.  If clear,
- * the volume may change the case of some characters (typically
- * making them all upper or all lower case).  A volume that sets
- * VOL_CAP_FMT_CASE_SENSITIVE should also set VOL_CAP_FMT_CASE_PRESERVING.
- *
- * VOL_CAP_FMT_FAST_STATFS: This bit is used as a hint to upper layers
- * (especially Carbon) that statfs() is fast enough that its results
- * need not be cached by those upper layers.  A volume that caches
- * the statfs information in its in-memory structures should set this bit.
- * A volume that must always read from disk or always perform a network
- * transaction should not set this bit.
- *
- * VOL_CAP_FMT_2TB_FILESIZE: If this bit is set the volume format supports
- * file sizes larger than 4GB, and potentially up to 2TB; it does not
- * indicate whether the filesystem supports files larger than that.
- *
- * VOL_CAP_FMT_OPENDENYMODES: When set, the volume supports open deny
- * modes (e.g. "open for read write, deny write"; effectively, mandatory
- * file locking based on open modes).
- *
- * VOL_CAP_FMT_HIDDEN_FILES: When set, the volume supports the UF_HIDDEN
- * file flag, and the UF_HIDDEN flag is mapped to that volume's native
- * "hidden" or "invisible" bit (which may be the invisible bit from the
- * Finder Info extended attribute).
- *
- * VOL_CAP_FMT_PATH_FROM_ID:  When set, the volume supports the ability
- * to derive a pathname to the root of the file system given only the
- * id of an object.  This also implies that object ids on this file
- * system are persistent and not recycled.  This is a very specialized
- * capability and it is assumed that most file systems will not support
- * it.  Its use is for legacy non-posix APIs like ResolveFileIDRef.
- *
- * VOL_CAP_FMT_NO_VOLUME_SIZES: When set, the volume does not support
- * returning values for total data blocks, available blocks, or free blocks
- * (as in f_blocks, f_bavail, or f_bfree in "struct statfs").  Historically,
- * those values were set to 0xFFFFFFFF for volumes that did not support them.
- *
- * VOL_CAP_FMT_DECMPFS_COMPRESSION: When set, the volume supports transparent
- * decompression of compressed files using decmpfs.
- *
- * VOL_CAP_FMT_64BIT_OBJECT_IDS: When set, the volume uses object IDs that
- * are 64-bit. This means that ATTR_CMN_FILEID and ATTR_CMN_PARENTID are the
- * only legitimate attributes for obtaining object IDs from this volume and the
- * 32-bit fid_objno fields of the fsobj_id_t returned by ATTR_CMN_OBJID,
- * ATTR_CMN_OBJPERMID, and ATTR_CMN_PAROBJID are undefined.
- *
- * VOL_CAP_FMT_DIR_HARDLINKS: When set, the volume supports directory
- * hard links.
- *
- * VOL_CAP_FMT_DOCUMENT_ID: When set, the volume supports document IDs
- * (an ID which persists across object ID changes) for document revisions.
- *
- * VOL_CAP_FMT_WRITE_GENERATION_COUNT: When set, the volume supports write
- * generation counts (a count of how many times an object has been modified)
- *
- * VOL_CAP_FMT_NO_IMMUTABLE_FILES: When set, the volume does not support
- * setting the UF_IMMUTABLE flag.
- *
- * VOL_CAP_FMT_NO_PERMISSIONS: When set, the volume does not support setting
- * permissions.
- *
- * VOL_CAP_FMT_SHARED_SPACE: When set, the volume supports sharing space with
- * other filesystems i.e. multiple logical filesystems can exist in the same
- * "partition". An implication of this is that the filesystem which sets
- * this capability treats waitfor arguments to VFS_SYNC as bit flags.
- *
- * VOL_CAP_FMT_VOL_GROUPS: When set, this volume is part of a volume-group
- * that implies multiple volumes must be mounted in order to boot and root the
- * operating system. Typically, this means a read-only system volume and a
- * writable data volume.
- */
-#define VOL_CAP_FMT_PERSISTENTOBJECTIDS         0x00000001
-#define VOL_CAP_FMT_SYMBOLICLINKS               0x00000002
-#define VOL_CAP_FMT_HARDLINKS                   0x00000004
-#define VOL_CAP_FMT_JOURNAL                     0x00000008
-#define VOL_CAP_FMT_JOURNAL_ACTIVE              0x00000010
-#define VOL_CAP_FMT_NO_ROOT_TIMES               0x00000020
-#define VOL_CAP_FMT_SPARSE_FILES                0x00000040
-#define VOL_CAP_FMT_ZERO_RUNS                   0x00000080
-#define VOL_CAP_FMT_CASE_SENSITIVE              0x00000100
-#define VOL_CAP_FMT_CASE_PRESERVING             0x00000200
-#define VOL_CAP_FMT_FAST_STATFS                 0x00000400
-#define VOL_CAP_FMT_2TB_FILESIZE                0x00000800
-#define VOL_CAP_FMT_OPENDENYMODES               0x00001000
-#define VOL_CAP_FMT_HIDDEN_FILES                0x00002000
-#define VOL_CAP_FMT_PATH_FROM_ID                0x00004000
-#define VOL_CAP_FMT_NO_VOLUME_SIZES             0x00008000
-#define VOL_CAP_FMT_DECMPFS_COMPRESSION         0x00010000
-#define VOL_CAP_FMT_64BIT_OBJECT_IDS            0x00020000
-#define VOL_CAP_FMT_DIR_HARDLINKS               0x00040000
-#define VOL_CAP_FMT_DOCUMENT_ID                 0x00080000
-#define VOL_CAP_FMT_WRITE_GENERATION_COUNT      0x00100000
-#define VOL_CAP_FMT_NO_IMMUTABLE_FILES          0x00200000
-#define VOL_CAP_FMT_NO_PERMISSIONS              0x00400000
-#define VOL_CAP_FMT_SHARED_SPACE                0x00800000
-#define VOL_CAP_FMT_VOL_GROUPS                  0x01000000
-
-/*
- * VOL_CAP_INT_SEARCHFS: When set, the volume implements the
- * searchfs() system call (the vnop_searchfs vnode operation).
- *
- * VOL_CAP_INT_ATTRLIST: When set, the volume implements the
- * getattrlist() and setattrlist() system calls (vnop_getattrlist
- * and vnop_setattrlist vnode operations) for the volume, files,
- * and directories.  The volume may or may not implement the
- * readdirattr() system call.  XXX Is there any minimum set
- * of attributes that should be supported?  To determine the
- * set of supported attributes, get the ATTR_VOL_ATTRIBUTES
- * attribute of the volume.
- *
- * VOL_CAP_INT_NFSEXPORT: When set, the volume implements exporting
- * of NFS volumes.
- *
- * VOL_CAP_INT_READDIRATTR: When set, the volume implements the
- * readdirattr() system call (vnop_readdirattr vnode operation).
- *
- * VOL_CAP_INT_EXCHANGEDATA: When set, the volume implements the
- * exchangedata() system call (VNOP_EXCHANGE vnode operation).
- *
- * VOL_CAP_INT_COPYFILE: When set, the volume implements the
- * VOP_COPYFILE vnode operation.  (XXX There should be a copyfile()
- * system call in <unistd.h>.)
- *
- * VOL_CAP_INT_ALLOCATE: When set, the volume implements the
- * VNOP_ALLOCATE vnode operation, which means it implements the
- * F_PREALLOCATE selector of fcntl(2).
- *
- * VOL_CAP_INT_VOL_RENAME: When set, the volume implements the
- * ATTR_VOL_NAME attribute for both getattrlist() and setattrlist().
- * The volume can be renamed by setting ATTR_VOL_NAME with setattrlist().
- *
- * VOL_CAP_INT_ADVLOCK: When set, the volume implements POSIX style
- * byte range locks via vnop_advlock (accessible from fcntl(2)).
- *
- * VOL_CAP_INT_FLOCK: When set, the volume implements whole-file flock(2)
- * style locks via vnop_advlock.  This includes the O_EXLOCK and O_SHLOCK
- * flags of the open(2) call.
- *
- * VOL_CAP_INT_EXTENDED_SECURITY: When set, the volume implements
- * extended security (ACLs).
- *
- * VOL_CAP_INT_USERACCESS:  When set, the volume supports the
- * ATTR_CMN_USERACCESS attribute (used to get the user's access
- * mode to the file).
- *
- * VOL_CAP_INT_MANLOCK: When set, the volume supports AFP-style
- * mandatory byte range locks via an ioctl().
- *
- * VOL_CAP_INT_EXTENDED_ATTR: When set, the volume implements
- * native extended attribues.
- *
- * VOL_CAP_INT_NAMEDSTREAMS: When set, the volume supports
- * native named streams.
- *
- * VOL_CAP_INT_CLONE: When set, the volume supports clones.
- *
- * VOL_CAP_INT_SNAPSHOT: When set, the volume supports snapshots.
- *
- * VOL_CAP_INT_RENAME_SWAP: When set, the volume supports swapping
- * file system objects.
- *
- * VOL_CAP_INT_RENAME_EXCL: When set, the volume supports an
- * exclusive rename operation.
- *
- * VOL_CAP_INT_RENAME_OPENFAIL: When set, the volume may fail rename
- * operations on files that are open.
- */
-#define VOL_CAP_INT_SEARCHFS                    0x00000001
-#define VOL_CAP_INT_ATTRLIST                    0x00000002
-#define VOL_CAP_INT_NFSEXPORT                   0x00000004
-#define VOL_CAP_INT_READDIRATTR                 0x00000008
-#define VOL_CAP_INT_EXCHANGEDATA                0x00000010
-#define VOL_CAP_INT_COPYFILE                    0x00000020
-#define VOL_CAP_INT_ALLOCATE                    0x00000040
-#define VOL_CAP_INT_VOL_RENAME                  0x00000080
-#define VOL_CAP_INT_ADVLOCK                     0x00000100
-#define VOL_CAP_INT_FLOCK                       0x00000200
-#define VOL_CAP_INT_EXTENDED_SECURITY           0x00000400
-#define VOL_CAP_INT_USERACCESS                  0x00000800
-#define VOL_CAP_INT_MANLOCK                     0x00001000
-#define VOL_CAP_INT_NAMEDSTREAMS                0x00002000
-#define VOL_CAP_INT_EXTENDED_ATTR               0x00004000
-#define VOL_CAP_INT_CLONE                       0x00010000
-#define VOL_CAP_INT_SNAPSHOT                    0x00020000
-#define VOL_CAP_INT_RENAME_SWAP                 0x00040000
-#define VOL_CAP_INT_RENAME_EXCL                 0x00080000
-#define VOL_CAP_INT_RENAME_OPENFAIL             0x00100000
-
-typedef struct vol_attributes_attr {
-	attribute_set_t validattr;
-	attribute_set_t nativeattr;
-} vol_attributes_attr_t;
-
-#define ATTR_CMN_NAME                           0x00000001
-#define ATTR_CMN_DEVID                          0x00000002
-#define ATTR_CMN_FSID                           0x00000004
-#define ATTR_CMN_OBJTYPE                        0x00000008
-#define ATTR_CMN_OBJTAG                         0x00000010
-#define ATTR_CMN_OBJID                          0x00000020
-#define ATTR_CMN_OBJPERMANENTID                 0x00000040
-#define ATTR_CMN_PAROBJID                       0x00000080
-#define ATTR_CMN_SCRIPT                         0x00000100
-#define ATTR_CMN_CRTIME                         0x00000200
-#define ATTR_CMN_MODTIME                        0x00000400
-#define ATTR_CMN_CHGTIME                        0x00000800
-#define ATTR_CMN_ACCTIME                        0x00001000
-#define ATTR_CMN_BKUPTIME                       0x00002000
-#define ATTR_CMN_FNDRINFO                       0x00004000
-#define ATTR_CMN_OWNERID                        0x00008000
-#define ATTR_CMN_GRPID                          0x00010000
-#define ATTR_CMN_ACCESSMASK                     0x00020000
-#define ATTR_CMN_FLAGS                          0x00040000
-
-/* The following were defined as:				*/
-/*      #define ATTR_CMN_NAMEDATTRCOUNT		0x00080000	*/
-/*      #define ATTR_CMN_NAMEDATTRLIST		0x00100000	*/
-/* These bits have been salvaged for use as:			*/
-/*	#define ATTR_CMN_GEN_COUNT		0x00080000	*/
-/*	#define ATTR_CMN_DOCUMENT_ID		0x00100000	*/
-/* They can only be used with the  FSOPT_ATTR_CMN_EXTENDED	*/
-/* option flag.                                                 */
-
-#define ATTR_CMN_GEN_COUNT                      0x00080000
-#define ATTR_CMN_DOCUMENT_ID                    0x00100000
-
-#define ATTR_CMN_USERACCESS                     0x00200000
-#define ATTR_CMN_EXTENDED_SECURITY              0x00400000
-#define ATTR_CMN_UUID                           0x00800000
-#define ATTR_CMN_GRPUUID                        0x01000000
-#define ATTR_CMN_FILEID                         0x02000000
-#define ATTR_CMN_PARENTID                       0x04000000
-#define ATTR_CMN_FULLPATH                       0x08000000
-#define ATTR_CMN_ADDEDTIME                      0x10000000
-#define ATTR_CMN_ERROR                          0x20000000
-#define ATTR_CMN_DATA_PROTECT_FLAGS             0x40000000
-
-/*
- * ATTR_CMN_RETURNED_ATTRS is only valid with getattrlist(2) and
- * getattrlistbulk(2). It is always the first attribute in the return buffer.
- */
-#define ATTR_CMN_RETURNED_ATTRS                 0x80000000
-
-#define ATTR_CMN_VALIDMASK                      0xFFFFFFFF
-/*
- * The settable ATTR_CMN_* attributes include the following:
- * ATTR_CMN_SCRIPT
- * ATTR_CMN_CRTIME
- * ATTR_CMN_MODTIME
- * ATTR_CMN_CHGTIME
- *
- * ATTR_CMN_ACCTIME
- * ATTR_CMN_BKUPTIME
- * ATTR_CMN_FNDRINFO
- * ATTR_CMN_OWNERID
- *
- * ATTR_CMN_GRPID
- * ATTR_CMN_ACCESSMASK
- * ATTR_CMN_FLAGS
- *
- * ATTR_CMN_EXTENDED_SECURITY
- * ATTR_CMN_UUID
- *
- * ATTR_CMN_GRPUUID
- *
- * ATTR_CMN_DATA_PROTECT_FLAGS
- */
-#define ATTR_CMN_SETMASK                        0x51C7FF00
-#define ATTR_CMN_VOLSETMASK                     0x00006700
-
-#define ATTR_VOL_FSTYPE                         0x00000001
-#define ATTR_VOL_SIGNATURE                      0x00000002
-#define ATTR_VOL_SIZE                           0x00000004
-#define ATTR_VOL_SPACEFREE                      0x00000008
-#define ATTR_VOL_SPACEAVAIL                     0x00000010
-#define ATTR_VOL_MINALLOCATION                  0x00000020
-#define ATTR_VOL_ALLOCATIONCLUMP                0x00000040
-#define ATTR_VOL_IOBLOCKSIZE                    0x00000080
-#define ATTR_VOL_OBJCOUNT                       0x00000100
-#define ATTR_VOL_FILECOUNT                      0x00000200
-#define ATTR_VOL_DIRCOUNT                       0x00000400
-#define ATTR_VOL_MAXOBJCOUNT                    0x00000800
-#define ATTR_VOL_MOUNTPOINT                     0x00001000
-#define ATTR_VOL_NAME                           0x00002000
-#define ATTR_VOL_MOUNTFLAGS                     0x00004000
-#define ATTR_VOL_MOUNTEDDEVICE                  0x00008000
-#define ATTR_VOL_ENCODINGSUSED                  0x00010000
-#define ATTR_VOL_CAPABILITIES                   0x00020000
-#define ATTR_VOL_UUID                           0x00040000
-#define ATTR_VOL_QUOTA_SIZE                     0x10000000
-#define ATTR_VOL_RESERVED_SIZE          0x20000000
-#define ATTR_VOL_ATTRIBUTES                     0x40000000
-#define ATTR_VOL_INFO                           0x80000000
-
-#define ATTR_VOL_VALIDMASK                      0xF007FFFF
-
-/*
- * The list of settable ATTR_VOL_* attributes include the following:
- * ATTR_VOL_NAME
- * ATTR_VOL_INFO
- */
-#define ATTR_VOL_SETMASK                        0x80002000
-
-
-/* File/directory attributes: */
-#define ATTR_DIR_LINKCOUNT                      0x00000001
-#define ATTR_DIR_ENTRYCOUNT                     0x00000002
-#define ATTR_DIR_MOUNTSTATUS                    0x00000004
-#define ATTR_DIR_ALLOCSIZE                      0x00000008
-#define ATTR_DIR_IOBLOCKSIZE                    0x00000010
-#define ATTR_DIR_DATALENGTH                     0x00000020
-
-/* ATTR_DIR_MOUNTSTATUS Flags: */
-#define   DIR_MNTSTATUS_MNTPOINT                0x00000001
-#define   DIR_MNTSTATUS_TRIGGER                 0x00000002
-
-#define ATTR_DIR_VALIDMASK                      0x0000003f
-#define ATTR_DIR_SETMASK                        0x00000000
-
-#define ATTR_FILE_LINKCOUNT                     0x00000001
-#define ATTR_FILE_TOTALSIZE                     0x00000002
-#define ATTR_FILE_ALLOCSIZE                     0x00000004
-#define ATTR_FILE_IOBLOCKSIZE                   0x00000008
-#define ATTR_FILE_DEVTYPE                       0x00000020
-#define ATTR_FILE_FORKCOUNT                     0x00000080
-#define ATTR_FILE_FORKLIST                      0x00000100
-#define ATTR_FILE_DATALENGTH                    0x00000200
-#define ATTR_FILE_DATAALLOCSIZE                 0x00000400
-#define ATTR_FILE_RSRCLENGTH                    0x00001000
-#define ATTR_FILE_RSRCALLOCSIZE                 0x00002000
-
-#define ATTR_FILE_VALIDMASK                     0x000037FF
-/*
- * Settable ATTR_FILE_* attributes include:
- * ATTR_FILE_DEVTYPE
- */
-#define ATTR_FILE_SETMASK                       0x00000020
-
-/* CMNEXT attributes extend the common attributes, but in the forkattr field */
-#define ATTR_CMNEXT_RELPATH     0x00000004
-#define ATTR_CMNEXT_PRIVATESIZE 0x00000008
-#define ATTR_CMNEXT_LINKID      0x00000010
-#define ATTR_CMNEXT_NOFIRMLINKPATH     0x00000020
-#define ATTR_CMNEXT_REALDEVID   0x00000040
-#define ATTR_CMNEXT_REALFSID    0x00000080
-#define ATTR_CMNEXT_CLONEID     0x00000100
-#define ATTR_CMNEXT_EXT_FLAGS   0x00000200
-
-#define ATTR_CMNEXT_VALIDMASK   0x000003fc
-#define ATTR_CMNEXT_SETMASK             0x00000000
-
-/* Deprecated fork attributes */
-#define ATTR_FORK_TOTALSIZE                     0x00000001
-#define ATTR_FORK_ALLOCSIZE                     0x00000002
-#define ATTR_FORK_RESERVED                      0xffffffff
-
-#define ATTR_FORK_VALIDMASK                     0x00000003
-#define ATTR_FORK_SETMASK                       0x00000000
-
-/* Obsolete, implemented, not supported */
-#define ATTR_CMN_NAMEDATTRCOUNT                 0x00080000
-#define ATTR_CMN_NAMEDATTRLIST                  0x00100000
-#define ATTR_FILE_CLUMPSIZE                     0x00000010      /* obsolete */
-#define ATTR_FILE_FILETYPE                      0x00000040      /* always zero */
-#define ATTR_FILE_DATAEXTENTS                   0x00000800      /* obsolete, HFS-specific */
-#define ATTR_FILE_RSRCEXTENTS                   0x00004000      /* obsolete, HFS-specific */
-
-/* Required attributes for getattrlistbulk(2) */
-#define ATTR_BULK_REQUIRED (ATTR_CMN_NAME | ATTR_CMN_RETURNED_ATTRS)
-
-/*
- * Searchfs
- */
-#define SRCHFS_START                            0x00000001
-#define SRCHFS_MATCHPARTIALNAMES                0x00000002
-#define SRCHFS_MATCHDIRS                        0x00000004
-#define SRCHFS_MATCHFILES                       0x00000008
-#define SRCHFS_SKIPLINKS                        0x00000010
-#define SRCHFS_SKIPINVISIBLE                    0x00000020
-#define SRCHFS_SKIPPACKAGES                     0x00000040
-#define SRCHFS_SKIPINAPPROPRIATE                0x00000080
-
-#define SRCHFS_NEGATEPARAMS                     0x80000000
-#define SRCHFS_VALIDOPTIONSMASK                 0x800000FF
-
-struct fssearchblock {
-	struct attrlist         *returnattrs;
-	void                            *returnbuffer;
-	size_t                          returnbuffersize;
-	u_long                          maxmatches;
-	struct timeval          timelimit;
-	void                            *searchparams1;
-	size_t                          sizeofsearchparams1;
-	void                            *searchparams2;
-	size_t                          sizeofsearchparams2;
-	struct attrlist         searchattrs;
-};
-
-
-struct searchstate {
-	uint32_t                        ss_union_flags;         // for SRCHFS_START
-	uint32_t                        ss_union_layer;         // 0 = top
-	u_char                          ss_fsstate[548];        // fs private
-} __attribute__((packed));
-
-#define FST_EOF (-1)                            /* end-of-file offset */
-
-#endif /* __APPLE_API_UNSTABLE */
-#endif /* !_SYS_ATTR_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/sys/cdefs.h b/lib/libc/include/x86_64-macos-gnu/sys/cdefs.h
deleted file mode 100644
index b2b091e28e..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/sys/cdefs.h
+++ /dev/null
@@ -1,855 +0,0 @@
-/*
- * Copyright (c) 2000-2018 Apple Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-/* Copyright 1995 NeXT Computer, Inc. All rights reserved. */
-/*
- * Copyright (c) 1991, 1993
- *	The Regents of the University of California.  All rights reserved.
- *
- * This code is derived from software contributed to Berkeley by
- * Berkeley Software Design, Inc.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *	This product includes software developed by the University of
- *	California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *	@(#)cdefs.h	8.8 (Berkeley) 1/9/95
- */
-
-#ifndef _CDEFS_H_
-#define _CDEFS_H_
-
-#if defined(__cplusplus)
-#define __BEGIN_DECLS   extern "C" {
-#define __END_DECLS     }
-#else
-#define __BEGIN_DECLS
-#define __END_DECLS
-#endif
-
-/* This SDK is designed to work with clang and specific versions of
- * gcc >= 4.0 with Apple's patch sets */
-#if !defined(__GNUC__) || __GNUC__ < 4
-#warning "Unsupported compiler detected"
-#endif
-
-/*
- * Compatibility with compilers and environments that don't support compiler
- * feature checking function-like macros.
- */
-#ifndef __has_builtin
-#define __has_builtin(x) 0
-#endif
-#ifndef __has_include
-#define __has_include(x) 0
-#endif
-#ifndef __has_feature
-#define __has_feature(x) 0
-#endif
-#ifndef __has_attribute
-#define __has_attribute(x) 0
-#endif
-#ifndef __has_extension
-#define __has_extension(x) 0
-#endif
-
-/*
- * The __CONCAT macro is used to concatenate parts of symbol names, e.g.
- * with "#define OLD(foo) __CONCAT(old,foo)", OLD(foo) produces oldfoo.
- * The __CONCAT macro is a bit tricky -- make sure you don't put spaces
- * in between its arguments.  __CONCAT can also concatenate double-quoted
- * strings produced by the __STRING macro, but this only works with ANSI C.
- */
-#if defined(__STDC__) || defined(__cplusplus)
-#define __P(protos)     protos          /* full-blown ANSI C */
-#define __CONCAT(x, y)   x ## y
-#define __STRING(x)     #x
-
-#define __const         const           /* define reserved names to standard */
-#define __signed        signed
-#define __volatile      volatile
-#if defined(__cplusplus)
-#define __inline        inline          /* convert to C++ keyword */
-#else
-#ifndef __GNUC__
-#define __inline                        /* delete GCC keyword */
-#endif /* !__GNUC__ */
-#endif /* !__cplusplus */
-
-#else   /* !(__STDC__ || __cplusplus) */
-#define __P(protos)     ()              /* traditional C preprocessor */
-#define __CONCAT(x, y)   x /**/ y
-#define __STRING(x)     "x"
-
-#ifndef __GNUC__
-#define __const                         /* delete pseudo-ANSI C keywords */
-#define __inline
-#define __signed
-#define __volatile
-#endif  /* !__GNUC__ */
-
-/*
- * In non-ANSI C environments, new programs will want ANSI-only C keywords
- * deleted from the program and old programs will want them left alone.
- * When using a compiler other than gcc, programs using the ANSI C keywords
- * const, inline etc. as normal identifiers should define -DNO_ANSI_KEYWORDS.
- * When using "gcc -traditional", we assume that this is the intent; if
- * __GNUC__ is defined but __STDC__ is not, we leave the new keywords alone.
- */
-#ifndef NO_ANSI_KEYWORDS
-#define const           __const                 /* convert ANSI C keywords */
-#define inline          __inline
-#define signed          __signed
-#define volatile        __volatile
-#endif /* !NO_ANSI_KEYWORDS */
-#endif /* !(__STDC__ || __cplusplus) */
-
-#define __dead2         __attribute__((__noreturn__))
-#define __pure2         __attribute__((__const__))
-
-/* __unused denotes variables and functions that may not be used, preventing
- * the compiler from warning about it if not used.
- */
-#define __unused        __attribute__((__unused__))
-
-/* __used forces variables and functions to be included even if it appears
- * to the compiler that they are not used (and would thust be discarded).
- */
-#define __used          __attribute__((__used__))
-
-/* __cold marks code used for debugging or that is rarely taken
- * and tells the compiler to optimize for size and outline code.
- */
-#if __has_attribute(cold)
-#define __cold          __attribute__((__cold__))
-#else
-#define __cold
-#endif
-
-/* __deprecated causes the compiler to produce a warning when encountering
- * code using the deprecated functionality.
- * __deprecated_msg() does the same, and compilers that support it will print
- * a message along with the deprecation warning.
- * This may require turning on such warning with the -Wdeprecated flag.
- * __deprecated_enum_msg() should be used on enums, and compilers that support
- * it will print the deprecation warning.
- * __kpi_deprecated() specifically indicates deprecation of kernel programming
- * interfaces in Kernel.framework used by KEXTs.
- */
-#define __deprecated    __attribute__((__deprecated__))
-
-#if __has_extension(attribute_deprecated_with_message) || \
-        (defined(__GNUC__) && ((__GNUC__ >= 5) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 5))))
-	#define __deprecated_msg(_msg) __attribute__((__deprecated__(_msg)))
-#else
-	#define __deprecated_msg(_msg) __attribute__((__deprecated__))
-#endif
-
-#if __has_extension(enumerator_attributes)
-	#define __deprecated_enum_msg(_msg) __deprecated_msg(_msg)
-#else
-	#define __deprecated_enum_msg(_msg)
-#endif
-
-#define __kpi_deprecated(_msg)
-
-/* __unavailable causes the compiler to error out when encountering
- * code using the tagged function of variable.
- */
-#define __unavailable   __attribute__((__unavailable__))
-
-/* Delete pseudo-keywords wherever they are not available or needed. */
-#ifndef __dead
-#define __dead
-#define __pure
-#endif
-
-/*
- * We use `__restrict' as a way to define the `restrict' type qualifier
- * without disturbing older software that is unaware of C99 keywords.
- */
-#if __STDC_VERSION__ < 199901
-#define __restrict
-#else
-#define __restrict      restrict
-#endif
-
-/* Compatibility with compilers and environments that don't support the
- * nullability feature.
- */
-
-#if !__has_feature(nullability)
-#ifndef __nullable
-#define __nullable
-#endif
-#ifndef __nonnull
-#define __nonnull
-#endif
-#ifndef __null_unspecified
-#define __null_unspecified
-#endif
-#ifndef _Nullable
-#define _Nullable
-#endif
-#ifndef _Nonnull
-#define _Nonnull
-#endif
-#ifndef _Null_unspecified
-#define _Null_unspecified
-#endif
-#endif
-
-/*
- * __disable_tail_calls causes the compiler to not perform tail call
- * optimization inside the marked function.
- */
-#if __has_attribute(disable_tail_calls)
-#define __disable_tail_calls    __attribute__((__disable_tail_calls__))
-#else
-#define __disable_tail_calls
-#endif
-
-/*
- * __not_tail_called causes the compiler to prevent tail call optimization
- * on statically bound calls to the function.  It has no effect on indirect
- * calls.  Virtual functions, objective-c methods, and functions marked as
- * "always_inline" cannot be marked as __not_tail_called.
- */
-#if __has_attribute(not_tail_called)
-#define __not_tail_called       __attribute__((__not_tail_called__))
-#else
-#define __not_tail_called
-#endif
-
-/*
- * __result_use_check warns callers of a function that not using the function
- * return value is a bug, i.e. dismissing malloc() return value results in a
- * memory leak.
- */
-#if __has_attribute(warn_unused_result)
-#define __result_use_check __attribute__((__warn_unused_result__))
-#else
-#define __result_use_check
-#endif
-
-/*
- * __swift_unavailable causes the compiler to mark a symbol as specifically
- * unavailable in Swift, regardless of any other availability in C.
- */
-#if __has_feature(attribute_availability_swift)
-#define __swift_unavailable(_msg)       __attribute__((__availability__(swift, unavailable, message=_msg)))
-#else
-#define __swift_unavailable(_msg)
-#endif
-
-/*
- * __abortlike is the attribute to put on functions like abort() that are
- * typically used to mark assertions. These optimize the codegen
- * for outlining while still maintaining debugability.
- */
-#ifndef __abortlike
-#define __abortlike __dead2 __cold __not_tail_called
-#endif
-
-/* Declaring inline functions within headers is error-prone due to differences
- * across various versions of the C language and extensions.  __header_inline
- * can be used to declare inline functions within system headers.  In cases
- * where you want to force inlining instead of letting the compiler make
- * the decision, you can use __header_always_inline.
- *
- * Be aware that using inline for functions which compilers may also provide
- * builtins can behave differently under various compilers.  If you intend to
- * provide an inline version of such a function, you may want to use a macro
- * instead.
- *
- * The check for !__GNUC__ || __clang__ is because gcc doesn't correctly
- * support c99 inline in some cases:
- * http://gcc.gnu.org/bugzilla/show_bug.cgi?id=55965
- */
-
-#if defined(__cplusplus) || \
-        (__STDC_VERSION__ >= 199901L && \
-        !defined(__GNUC_GNU_INLINE__) && \
-        (!defined(__GNUC__) || defined(__clang__)))
-# define __header_inline           inline
-#elif defined(__GNUC__) && defined(__GNUC_STDC_INLINE__)
-# define __header_inline           extern __inline __attribute__((__gnu_inline__))
-#elif defined(__GNUC__)
-# define __header_inline           extern __inline
-#else
-/* If we land here, we've encountered an unsupported compiler,
- * so hopefully it understands static __inline as a fallback.
- */
-# define __header_inline           static __inline
-#endif
-
-#ifdef __GNUC__
-# define __header_always_inline    __header_inline __attribute__ ((__always_inline__))
-#else
-/* Unfortunately, we're using a compiler that we don't know how to force to
- * inline.  Oh well.
- */
-# define __header_always_inline    __header_inline
-#endif
-
-/*
- * Compiler-dependent macros that bracket portions of code where the
- * "-Wunreachable-code" warning should be ignored. Please use sparingly.
- */
-#if defined(__clang__)
-# define __unreachable_ok_push \
-	 _Pragma("clang diagnostic push") \
-	 _Pragma("clang diagnostic ignored \"-Wunreachable-code\"")
-# define __unreachable_ok_pop \
-	 _Pragma("clang diagnostic pop")
-#elif defined(__GNUC__) && ((__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
-# define __unreachable_ok_push \
-	 _Pragma("GCC diagnostic push") \
-	 _Pragma("GCC diagnostic ignored \"-Wunreachable-code\"")
-# define __unreachable_ok_pop \
-	 _Pragma("GCC diagnostic pop")
-#else
-# define __unreachable_ok_push
-# define __unreachable_ok_pop
-#endif
-
-/*
- * Compiler-dependent macros to declare that functions take printf-like
- * or scanf-like arguments.  They are null except for versions of gcc
- * that are known to support the features properly.  Functions declared
- * with these attributes will cause compilation warnings if there is a
- * mismatch between the format string and subsequent function parameter
- * types.
- */
-#define __printflike(fmtarg, firstvararg) \
-	        __attribute__((__format__ (__printf__, fmtarg, firstvararg)))
-#define __printf0like(fmtarg, firstvararg) \
-	        __attribute__((__format__ (__printf0__, fmtarg, firstvararg)))
-#define __scanflike(fmtarg, firstvararg) \
-	        __attribute__((__format__ (__scanf__, fmtarg, firstvararg)))
-
-#define __IDSTRING(name, string) static const char name[] __used = string
-
-#ifndef __COPYRIGHT
-#define __COPYRIGHT(s) __IDSTRING(copyright,s)
-#endif
-
-#ifndef __RCSID
-#define __RCSID(s) __IDSTRING(rcsid,s)
-#endif
-
-#ifndef __SCCSID
-#define __SCCSID(s) __IDSTRING(sccsid,s)
-#endif
-
-#ifndef __PROJECT_VERSION
-#define __PROJECT_VERSION(s) __IDSTRING(project_version,s)
-#endif
-
-/* Source compatibility only, ID string not emitted in object file */
-#ifndef __FBSDID
-#define __FBSDID(s)
-#endif
-
-#ifndef __DECONST
-#define __DECONST(type, var)    __CAST_AWAY_QUALIFIER(var, const, type)
-#endif
-
-#ifndef __DEVOLATILE
-#define __DEVOLATILE(type, var) __CAST_AWAY_QUALIFIER(var, volatile, type)
-#endif
-
-#ifndef __DEQUALIFY
-#define __DEQUALIFY(type, var)  __CAST_AWAY_QUALIFIER(var, const volatile, type)
-#endif
-
-/*
- * __alloc_size can be used to label function arguments that represent the
- * size of memory that the function allocates and returns. The one-argument
- * form labels a single argument that gives the allocation size (where the
- * arguments are numbered from 1):
- *
- * void	*malloc(size_t __size) __alloc_size(1);
- *
- * The two-argument form handles the case where the size is calculated as the
- * product of two arguments:
- *
- * void	*calloc(size_t __count, size_t __size) __alloc_size(1,2);
- */
-#ifndef __alloc_size
-#if __has_attribute(alloc_size)
-#define __alloc_size(...) __attribute__((alloc_size(__VA_ARGS__)))
-#else
-#define __alloc_size(...)
-#endif
-#endif // __alloc_size
-
-/*
- * COMPILATION ENVIRONMENTS -- see compat(5) for additional detail
- *
- * DEFAULT	By default newly complied code will get POSIX APIs plus
- *		Apple API extensions in scope.
- *
- *		Most users will use this compilation environment to avoid
- *		behavioral differences between 32 and 64 bit code.
- *
- * LEGACY	Defining _NONSTD_SOURCE will get pre-POSIX APIs plus Apple
- *		API extensions in scope.
- *
- *		This is generally equivalent to the Tiger release compilation
- *		environment, except that it cannot be applied to 64 bit code;
- *		its use is discouraged.
- *
- *		We expect this environment to be deprecated in the future.
- *
- * STRICT	Defining _POSIX_C_SOURCE or _XOPEN_SOURCE restricts the
- *		available APIs to exactly the set of APIs defined by the
- *		corresponding standard, based on the value defined.
- *
- *		A correct, portable definition for _POSIX_C_SOURCE is 200112L.
- *		A correct, portable definition for _XOPEN_SOURCE is 600L.
- *
- *		Apple API extensions are not visible in this environment,
- *		which can cause Apple specific code to fail to compile,
- *		or behave incorrectly if prototypes are not in scope or
- *		warnings about missing prototypes are not enabled or ignored.
- *
- * In any compilation environment, for correct symbol resolution to occur,
- * function prototypes must be in scope.  It is recommended that all Apple
- * tools users add either the "-Wall" or "-Wimplicit-function-declaration"
- * compiler flags to their projects to be warned when a function is being
- * used without a prototype in scope.
- */
-
-/* These settings are particular to each product. */
-/* Platform: MacOSX */
-#define __DARWIN_ONLY_64_BIT_INO_T      0
-/* #undef __DARWIN_ONLY_UNIX_CONFORMANCE (automatically set for 64-bit) */
-#define __DARWIN_ONLY_VERS_1050         0
-
-/*
- * The __DARWIN_ALIAS macros are used to do symbol renaming; they allow
- * legacy code to use the old symbol, thus maintaining binary compatibility
- * while new code can use a standards compliant version of the same function.
- *
- * __DARWIN_ALIAS is used by itself if the function signature has not
- * changed, it is used along with a #ifdef check for __DARWIN_UNIX03
- * if the signature has changed.  Because the __LP64__ environment
- * only supports UNIX03 semantics it causes __DARWIN_UNIX03 to be
- * defined, but causes __DARWIN_ALIAS to do no symbol mangling.
- *
- * As a special case, when XCode is used to target a specific version of the
- * OS, the manifest constant __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__
- * will be defined by the compiler, with the digits representing major version
- * time 100 + minor version times 10 (e.g. 10.5 := 1050).  If we are targeting
- * pre-10.5, and it is the default compilation environment, revert the
- * compilation environment to pre-__DARWIN_UNIX03.
- */
-#if !defined(__DARWIN_ONLY_UNIX_CONFORMANCE)
-#  if defined(__LP64__)
-#    define __DARWIN_ONLY_UNIX_CONFORMANCE 1
-#  else /* !__LP64__ */
-#    define __DARWIN_ONLY_UNIX_CONFORMANCE 0
-#  endif /* __LP64__ */
-#endif /* !__DARWIN_ONLY_UNIX_CONFORMANCE */
-
-#if !defined(__DARWIN_UNIX03)
-#  if   __DARWIN_ONLY_UNIX_CONFORMANCE
-#    if defined(_NONSTD_SOURCE)
-#      error "Can't define _NONSTD_SOURCE when only UNIX conformance is available."
-#    endif /* _NONSTD_SOURCE */
-#    define __DARWIN_UNIX03     1
-#  elif defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && ((__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ - 0) < 1040)
-#    define __DARWIN_UNIX03     0
-#  elif defined(_DARWIN_C_SOURCE) || defined(_XOPEN_SOURCE) || defined(_POSIX_C_SOURCE)
-#    if defined(_NONSTD_SOURCE)
-#      error "Can't define both _NONSTD_SOURCE and any of _DARWIN_C_SOURCE, _XOPEN_SOURCE or _POSIX_C_SOURCE."
-#    endif /* _NONSTD_SOURCE */
-#    define __DARWIN_UNIX03     1
-#  elif defined(_NONSTD_SOURCE)
-#    define __DARWIN_UNIX03     0
-#  else /* default */
-#    if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && ((__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ - 0) < 1050)
-#      define __DARWIN_UNIX03   0
-#    else /* __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 1050 */
-#      define __DARWIN_UNIX03   1
-#    endif /* __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 1050 */
-#  endif /* _DARWIN_C_SOURCE || _XOPEN_SOURCE || _POSIX_C_SOURCE || __LP64__ */
-#endif /* !__DARWIN_UNIX03 */
-
-#if !defined(__DARWIN_64_BIT_INO_T)
-#  if   defined(_DARWIN_USE_64_BIT_INODE)
-#    if defined(_DARWIN_NO_64_BIT_INODE)
-#      error "Can't define both _DARWIN_USE_64_BIT_INODE and _DARWIN_NO_64_BIT_INODE."
-#    endif /* _DARWIN_NO_64_BIT_INODE */
-#    define __DARWIN_64_BIT_INO_T 1
-#  elif defined(_DARWIN_NO_64_BIT_INODE)
-#    if __DARWIN_ONLY_64_BIT_INO_T
-#      error "Can't define _DARWIN_NO_64_BIT_INODE when only 64-bit inodes are available."
-#    endif /* __DARWIN_ONLY_64_BIT_INO_T */
-#    define __DARWIN_64_BIT_INO_T 0
-#  else /* default */
-#    if __DARWIN_ONLY_64_BIT_INO_T
-#      define __DARWIN_64_BIT_INO_T 1
-#    elif defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && ((__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ - 0) < 1060) || __DARWIN_UNIX03 == 0
-#      define __DARWIN_64_BIT_INO_T 0
-#    else /* default */
-#      define __DARWIN_64_BIT_INO_T 1
-#    endif /* __DARWIN_ONLY_64_BIT_INO_T */
-#  endif
-#endif /* !__DARWIN_64_BIT_INO_T */
-
-#if !defined(__DARWIN_VERS_1050)
-#  if   __DARWIN_ONLY_VERS_1050
-#    define __DARWIN_VERS_1050 1
-#  elif defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && ((__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ - 0) < 1050) || __DARWIN_UNIX03 == 0
-#    define __DARWIN_VERS_1050 0
-#  else /* default */
-#    define __DARWIN_VERS_1050 1
-#  endif
-#endif /* !__DARWIN_VERS_1050 */
-
-#if !defined(__DARWIN_NON_CANCELABLE)
-#    define __DARWIN_NON_CANCELABLE 0
-#endif /* !__DARWIN_NON_CANCELABLE */
-
-/*
- * symbol suffixes used for symbol versioning
- */
-#if __DARWIN_UNIX03
-#  if __DARWIN_ONLY_UNIX_CONFORMANCE
-#    define __DARWIN_SUF_UNIX03         /* nothing */
-#  else /* !__DARWIN_ONLY_UNIX_CONFORMANCE */
-#    define __DARWIN_SUF_UNIX03         "$UNIX2003"
-#  endif /* __DARWIN_ONLY_UNIX_CONFORMANCE */
-
-#  if __DARWIN_64_BIT_INO_T
-#    if __DARWIN_ONLY_64_BIT_INO_T
-#      define __DARWIN_SUF_64_BIT_INO_T /* nothing */
-#    else /* !__DARWIN_ONLY_64_BIT_INO_T */
-#      define __DARWIN_SUF_64_BIT_INO_T "$INODE64"
-#    endif /* __DARWIN_ONLY_64_BIT_INO_T */
-#  else /* !__DARWIN_64_BIT_INO_T */
-#    define __DARWIN_SUF_64_BIT_INO_T   /* nothing */
-#  endif /* __DARWIN_64_BIT_INO_T */
-
-#  if __DARWIN_VERS_1050
-#    if __DARWIN_ONLY_VERS_1050
-#      define __DARWIN_SUF_1050         /* nothing */
-#    else /* !__DARWIN_ONLY_VERS_1050 */
-#      define __DARWIN_SUF_1050         "$1050"
-#    endif /* __DARWIN_ONLY_VERS_1050 */
-#  else /* !__DARWIN_VERS_1050 */
-#    define __DARWIN_SUF_1050           /* nothing */
-#  endif /* __DARWIN_VERS_1050 */
-
-#  if __DARWIN_NON_CANCELABLE
-#    define __DARWIN_SUF_NON_CANCELABLE "$NOCANCEL"
-#  else /* !__DARWIN_NON_CANCELABLE */
-#    define __DARWIN_SUF_NON_CANCELABLE /* nothing */
-#  endif /* __DARWIN_NON_CANCELABLE */
-
-#else /* !__DARWIN_UNIX03 */
-#  define __DARWIN_SUF_UNIX03           /* nothing */
-#  define __DARWIN_SUF_64_BIT_INO_T     /* nothing */
-#  define __DARWIN_SUF_NON_CANCELABLE   /* nothing */
-#  define __DARWIN_SUF_1050             /* nothing */
-#endif /* __DARWIN_UNIX03 */
-
-#define __DARWIN_SUF_EXTSN              "$DARWIN_EXTSN"
-
-/*
- * symbol versioning macros
- */
-#define __DARWIN_ALIAS(sym)             __asm("_" __STRING(sym) __DARWIN_SUF_UNIX03)
-#define __DARWIN_ALIAS_C(sym)           __asm("_" __STRING(sym) __DARWIN_SUF_NON_CANCELABLE __DARWIN_SUF_UNIX03)
-#define __DARWIN_ALIAS_I(sym)           __asm("_" __STRING(sym) __DARWIN_SUF_64_BIT_INO_T __DARWIN_SUF_UNIX03)
-#define __DARWIN_NOCANCEL(sym)          __asm("_" __STRING(sym) __DARWIN_SUF_NON_CANCELABLE)
-#define __DARWIN_INODE64(sym)           __asm("_" __STRING(sym) __DARWIN_SUF_64_BIT_INO_T)
-
-#define __DARWIN_1050(sym)              __asm("_" __STRING(sym) __DARWIN_SUF_1050)
-#define __DARWIN_1050ALIAS(sym)         __asm("_" __STRING(sym) __DARWIN_SUF_1050 __DARWIN_SUF_UNIX03)
-#define __DARWIN_1050ALIAS_C(sym)       __asm("_" __STRING(sym) __DARWIN_SUF_1050 __DARWIN_SUF_NON_CANCELABLE __DARWIN_SUF_UNIX03)
-#define __DARWIN_1050ALIAS_I(sym)       __asm("_" __STRING(sym) __DARWIN_SUF_1050 __DARWIN_SUF_64_BIT_INO_T __DARWIN_SUF_UNIX03)
-#define __DARWIN_1050INODE64(sym)       __asm("_" __STRING(sym) __DARWIN_SUF_1050 __DARWIN_SUF_64_BIT_INO_T)
-
-#define __DARWIN_EXTSN(sym)             __asm("_" __STRING(sym) __DARWIN_SUF_EXTSN)
-#define __DARWIN_EXTSN_C(sym)           __asm("_" __STRING(sym) __DARWIN_SUF_EXTSN __DARWIN_SUF_NON_CANCELABLE)
-
-/*
- * symbol release macros
- */
-#include <sys/_symbol_aliasing.h>
-
-#if defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__)
-#define __DARWIN_ALIAS_STARTING(_mac, _iphone, x)   __DARWIN_ALIAS_STARTING_IPHONE_##_iphone(x)
-#elif defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__)
-#define __DARWIN_ALIAS_STARTING(_mac, _iphone, x)   __DARWIN_ALIAS_STARTING_MAC_##_mac(x)
-#else
-#define __DARWIN_ALIAS_STARTING(_mac, _iphone, x)   x
-#endif
-
-
-/*
- * POSIX.1 requires that the macros we test be defined before any standard
- * header file is included.  This permits us to convert values for feature
- * testing, as necessary, using only _POSIX_C_SOURCE.
- *
- * Here's a quick run-down of the versions:
- *  defined(_POSIX_SOURCE)		1003.1-1988
- *  _POSIX_C_SOURCE == 1L		1003.1-1990
- *  _POSIX_C_SOURCE == 2L		1003.2-1992 C Language Binding Option
- *  _POSIX_C_SOURCE == 199309L		1003.1b-1993
- *  _POSIX_C_SOURCE == 199506L		1003.1c-1995, 1003.1i-1995,
- *					and the omnibus ISO/IEC 9945-1: 1996
- *  _POSIX_C_SOURCE == 200112L		1003.1-2001
- *  _POSIX_C_SOURCE == 200809L		1003.1-2008
- *
- * In addition, the X/Open Portability Guide, which is now the Single UNIX
- * Specification, defines a feature-test macro which indicates the version of
- * that specification, and which subsumes _POSIX_C_SOURCE.
- */
-
-/* Deal with IEEE Std. 1003.1-1990, in which _POSIX_C_SOURCE == 1L. */
-#if defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE == 1L
-#undef _POSIX_C_SOURCE
-#define _POSIX_C_SOURCE         199009L
-#endif
-
-/* Deal with IEEE Std. 1003.2-1992, in which _POSIX_C_SOURCE == 2L. */
-#if defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE == 2L
-#undef _POSIX_C_SOURCE
-#define _POSIX_C_SOURCE         199209L
-#endif
-
-/* Deal with various X/Open Portability Guides and Single UNIX Spec. */
-#ifdef _XOPEN_SOURCE
-#if _XOPEN_SOURCE - 0L >= 700L && (!defined(_POSIX_C_SOURCE) || _POSIX_C_SOURCE - 0L < 200809L)
-#undef _POSIX_C_SOURCE
-#define _POSIX_C_SOURCE         200809L
-#elif _XOPEN_SOURCE - 0L >= 600L && (!defined(_POSIX_C_SOURCE) || _POSIX_C_SOURCE - 0L < 200112L)
-#undef _POSIX_C_SOURCE
-#define _POSIX_C_SOURCE         200112L
-#elif _XOPEN_SOURCE - 0L >= 500L && (!defined(_POSIX_C_SOURCE) || _POSIX_C_SOURCE - 0L < 199506L)
-#undef _POSIX_C_SOURCE
-#define _POSIX_C_SOURCE         199506L
-#endif
-#endif
-
-/*
- * Deal with all versions of POSIX.  The ordering relative to the tests above is
- * important.
- */
-#if defined(_POSIX_SOURCE) && !defined(_POSIX_C_SOURCE)
-#define _POSIX_C_SOURCE         198808L
-#endif
-
-/* POSIX C deprecation macros */
-#include <sys/_posix_availability.h>
-
-#define __POSIX_C_DEPRECATED(ver) ___POSIX_C_DEPRECATED_STARTING_##ver
-
-/*
- * Set a single macro which will always be defined and can be used to determine
- * the appropriate namespace.  For POSIX, these values will correspond to
- * _POSIX_C_SOURCE value.  Currently there are two additional levels corresponding
- * to ANSI (_ANSI_SOURCE) and Darwin extensions (_DARWIN_C_SOURCE)
- */
-#define __DARWIN_C_ANSI         010000L
-#define __DARWIN_C_FULL         900000L
-
-#if   defined(_ANSI_SOURCE)
-#define __DARWIN_C_LEVEL        __DARWIN_C_ANSI
-#elif defined(_POSIX_C_SOURCE) && !defined(_DARWIN_C_SOURCE) && !defined(_NONSTD_SOURCE)
-#define __DARWIN_C_LEVEL        _POSIX_C_SOURCE
-#else
-#define __DARWIN_C_LEVEL        __DARWIN_C_FULL
-#endif
-
-/* If the developer has neither requested a strict language mode nor a version
- * of POSIX, turn on functionality provided by __STDC_WANT_LIB_EXT1__ as part
- * of __DARWIN_C_FULL.
- */
-#if !defined(__STDC_WANT_LIB_EXT1__) && !defined(__STRICT_ANSI__) && __DARWIN_C_LEVEL >= __DARWIN_C_FULL
-#define __STDC_WANT_LIB_EXT1__ 1
-#endif
-
-/*
- * long long is not supported in c89 (__STRICT_ANSI__), but g++ -ansi and
- * c99 still want long longs.  While not perfect, we allow long longs for
- * g++.
- */
-#if (defined(__STRICT_ANSI__) && (__STDC_VERSION__ - 0 < 199901L) && !defined(__GNUG__))
-#define __DARWIN_NO_LONG_LONG 1
-#else
-#define __DARWIN_NO_LONG_LONG 0
-#endif
-
-/*****************************************
-*  Public darwin-specific feature macros
-*****************************************/
-
-/*
- * _DARWIN_FEATURE_64_BIT_INODE indicates that the ino_t type is 64-bit, and
- * structures modified for 64-bit inodes (like struct stat) will be used.
- */
-#if __DARWIN_64_BIT_INO_T
-#define _DARWIN_FEATURE_64_BIT_INODE            1
-#endif
-
-/*
- * _DARWIN_FEATURE_64_ONLY_BIT_INODE indicates that the ino_t type may only
- * be 64-bit; there is no support for 32-bit ino_t when this macro is defined
- * (and non-zero).  There is no struct stat64 either, as the regular
- * struct stat will already be the 64-bit version.
- */
-#if __DARWIN_ONLY_64_BIT_INO_T
-#define _DARWIN_FEATURE_ONLY_64_BIT_INODE       1
-#endif
-
-/*
- * _DARWIN_FEATURE_ONLY_VERS_1050 indicates that only those APIs updated
- * in 10.5 exists; no pre-10.5 variants are available.
- */
-#if __DARWIN_ONLY_VERS_1050
-#define _DARWIN_FEATURE_ONLY_VERS_1050          1
-#endif
-
-/*
- * _DARWIN_FEATURE_ONLY_UNIX_CONFORMANCE indicates only UNIX conforming API
- * are available (the legacy BSD APIs are not available)
- */
-#if __DARWIN_ONLY_UNIX_CONFORMANCE
-#define _DARWIN_FEATURE_ONLY_UNIX_CONFORMANCE   1
-#endif
-
-/*
- * _DARWIN_FEATURE_UNIX_CONFORMANCE indicates whether UNIX conformance is on,
- * and specifies the conformance level (3 is SUSv3)
- */
-#if __DARWIN_UNIX03
-#define _DARWIN_FEATURE_UNIX_CONFORMANCE        3
-#endif
-
-
-/*
- * This macro casts away the qualifier from the variable
- *
- * Note: use at your own risk, removing qualifiers can result in
- * catastrophic run-time failures.
- */
-#ifndef __CAST_AWAY_QUALIFIER
-#define __CAST_AWAY_QUALIFIER(variable, qualifier, type)  (type) (long)(variable)
-#endif
-
-/*
- * __XNU_PRIVATE_EXTERN is a linkage decoration indicating that a symbol can be
- * used from other compilation units, but not other libraries or executables.
- */
-#ifndef __XNU_PRIVATE_EXTERN
-#define __XNU_PRIVATE_EXTERN __attribute__((visibility("hidden")))
-#endif
-
-/*
- * Architecture validation for current SDK
- */
-#if !defined(__sys_cdefs_arch_unknown__) && defined(__i386__)
-#elif !defined(__sys_cdefs_arch_unknown__) && defined(__x86_64__)
-#else
-#error Unsupported architecture
-#endif
-
-
-
-#define __compiler_barrier() __asm__ __volatile__("" ::: "memory")
-
-#if __has_attribute(enum_extensibility)
-#define __enum_open __attribute__((__enum_extensibility__(open)))
-#define __enum_closed __attribute__((__enum_extensibility__(closed)))
-#else
-#define __enum_open
-#define __enum_closed
-#endif // __has_attribute(enum_extensibility)
-
-#if __has_attribute(flag_enum)
-#define __enum_options __attribute__((__flag_enum__))
-#else
-#define __enum_options
-#endif
-
-/*
- * Similar to OS_ENUM/OS_CLOSED_ENUM/OS_OPTIONS/OS_CLOSED_OPTIONS
- *
- * This provides more advanced type checking on compilers supporting
- * the proper extensions, even in C.
- */
-#if __has_feature(objc_fixed_enum) || __has_extension(cxx_fixed_enum) || \
-        __has_extension(cxx_strong_enums)
-#define __enum_decl(_name, _type, ...) \
-	        typedef enum : _type __VA_ARGS__ __enum_open _name
-#define __enum_closed_decl(_name, _type, ...) \
-	        typedef enum : _type __VA_ARGS__ __enum_closed _name
-#define __options_decl(_name, _type, ...) \
-	        typedef enum : _type __VA_ARGS__ __enum_open __enum_options _name
-#define __options_closed_decl(_name, _type, ...) \
-	        typedef enum : _type __VA_ARGS__ __enum_closed __enum_options _name
-#else
-#define __enum_decl(_name, _type, ...) \
-	        typedef _type _name; enum __VA_ARGS__ __enum_open
-#define __enum_closed_decl(_name, _type, ...) \
-	        typedef _type _name; enum __VA_ARGS__ __enum_closed
-#define __options_decl(_name, _type, ...) \
-	        typedef _type _name; enum __VA_ARGS__ __enum_open __enum_options
-#define __options_closed_decl(_name, _type, ...) \
-	        typedef _type _name; enum __VA_ARGS__ __enum_closed __enum_options
-#endif
-
-#endif /* !_CDEFS_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/sys/event.h b/lib/libc/include/x86_64-macos-gnu/sys/event.h
deleted file mode 100644
index 1fbce9a75c..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/sys/event.h
+++ /dev/null
@@ -1,396 +0,0 @@
-/*
- * Copyright (c) 2003-2019 Apple Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-/*-
- * Copyright (c) 1999,2000,2001 Jonathan Lemon <jlemon@FreeBSD.org>
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *	$FreeBSD: src/sys/sys/event.h,v 1.5.2.5 2001/12/14 19:21:22 jlemon Exp $
- */
-
-#ifndef _SYS_EVENT_H_
-#define _SYS_EVENT_H_
-
-#include <machine/types.h>
-#include <sys/cdefs.h>
-#include <stdint.h>
-
-/*
- * Filter types
- */
-#define EVFILT_READ             (-1)
-#define EVFILT_WRITE            (-2)
-#define EVFILT_AIO              (-3)    /* attached to aio requests */
-#define EVFILT_VNODE            (-4)    /* attached to vnodes */
-#define EVFILT_PROC             (-5)    /* attached to struct proc */
-#define EVFILT_SIGNAL           (-6)    /* attached to struct proc */
-#define EVFILT_TIMER            (-7)    /* timers */
-#define EVFILT_MACHPORT         (-8)    /* Mach portsets */
-#define EVFILT_FS               (-9)    /* Filesystem events */
-#define EVFILT_USER             (-10)   /* User events */
-#define EVFILT_VM               (-12)   /* Virtual memory events */
-#define EVFILT_EXCEPT           (-15)   /* Exception events */
-
-#define EVFILT_SYSCOUNT         17
-#define EVFILT_THREADMARKER     EVFILT_SYSCOUNT /* Internal use only */
-
-#pragma pack(4)
-
-struct kevent {
-	uintptr_t       ident;  /* identifier for this event */
-	int16_t         filter; /* filter for event */
-	uint16_t        flags;  /* general flags */
-	uint32_t        fflags; /* filter-specific flags */
-	intptr_t        data;   /* filter-specific data */
-	void            *udata; /* opaque user data identifier */
-};
-
-
-#pragma pack()
-
-struct kevent64_s {
-	uint64_t        ident;          /* identifier for this event */
-	int16_t         filter;         /* filter for event */
-	uint16_t        flags;          /* general flags */
-	uint32_t        fflags;         /* filter-specific flags */
-	int64_t         data;           /* filter-specific data */
-	uint64_t        udata;          /* opaque user data identifier */
-	uint64_t        ext[2];         /* filter-specific extensions */
-};
-
-
-#define EV_SET(kevp, a, b, c, d, e, f) do {     \
-	struct kevent *__kevp__ = (kevp);       \
-	__kevp__->ident = (a);                  \
-	__kevp__->filter = (b);                 \
-	__kevp__->flags = (c);                  \
-	__kevp__->fflags = (d);                 \
-	__kevp__->data = (e);                   \
-	__kevp__->udata = (f);                  \
-} while(0)
-
-#define EV_SET64(kevp, a, b, c, d, e, f, g, h) do {     \
-	struct kevent64_s *__kevp__ = (kevp);           \
-	__kevp__->ident = (a);                          \
-	__kevp__->filter = (b);                         \
-	__kevp__->flags = (c);                          \
-	__kevp__->fflags = (d);                         \
-	__kevp__->data = (e);                           \
-	__kevp__->udata = (f);                          \
-	__kevp__->ext[0] = (g);                         \
-	__kevp__->ext[1] = (h);                         \
-} while(0)
-
-
-/* kevent system call flags */
-#define KEVENT_FLAG_NONE                         0x000000       /* no flag value */
-#define KEVENT_FLAG_IMMEDIATE                    0x000001       /* immediate timeout */
-#define KEVENT_FLAG_ERROR_EVENTS                 0x000002       /* output events only include change errors */
-
-
-/* actions */
-#define EV_ADD              0x0001      /* add event to kq (implies enable) */
-#define EV_DELETE           0x0002      /* delete event from kq */
-#define EV_ENABLE           0x0004      /* enable event */
-#define EV_DISABLE          0x0008      /* disable event (not reported) */
-
-/* flags */
-#define EV_ONESHOT          0x0010      /* only report one occurrence */
-#define EV_CLEAR            0x0020      /* clear event state after reporting */
-#define EV_RECEIPT          0x0040      /* force immediate event output */
-                                        /* ... with or without EV_ERROR */
-                                        /* ... use KEVENT_FLAG_ERROR_EVENTS */
-                                        /*     on syscalls supporting flags */
-
-#define EV_DISPATCH         0x0080      /* disable event after reporting */
-#define EV_UDATA_SPECIFIC   0x0100      /* unique kevent per udata value */
-
-#define EV_DISPATCH2        (EV_DISPATCH | EV_UDATA_SPECIFIC)
-/* ... in combination with EV_DELETE */
-/* will defer delete until udata-specific */
-/* event enabled. EINPROGRESS will be */
-/* returned to indicate the deferral */
-
-#define EV_VANISHED         0x0200      /* report that source has vanished  */
-                                        /* ... only valid with EV_DISPATCH2 */
-
-#define EV_SYSFLAGS         0xF000      /* reserved by system */
-#define EV_FLAG0            0x1000      /* filter-specific flag */
-#define EV_FLAG1            0x2000      /* filter-specific flag */
-
-/* returned values */
-#define EV_EOF              0x8000      /* EOF detected */
-#define EV_ERROR            0x4000      /* error, data contains errno */
-
-/*
- * Filter specific flags for EVFILT_READ
- *
- * The default behavior for EVFILT_READ is to make the "read" determination
- * relative to the current file descriptor read pointer.
- *
- * The EV_POLL flag indicates the determination should be made via poll(2)
- * semantics. These semantics dictate always returning true for regular files,
- * regardless of the amount of unread data in the file.
- *
- * On input, EV_OOBAND specifies that filter should actively return in the
- * presence of OOB on the descriptor. It implies that filter will return
- * if there is OOB data available to read OR when any other condition
- * for the read are met (for example number of bytes regular data becomes >=
- * low-watermark).
- * If EV_OOBAND is not set on input, it implies that the filter should not actively
- * return for out of band data on the descriptor. The filter will then only return
- * when some other condition for read is met (ex: when number of regular data bytes
- * >=low-watermark OR when socket can't receive more data (SS_CANTRCVMORE)).
- *
- * On output, EV_OOBAND indicates the presence of OOB data on the descriptor.
- * If it was not specified as an input parameter, then the data count is the
- * number of bytes before the current OOB marker, else data count is the number
- * of bytes beyond OOB marker.
- */
-#define EV_POLL         EV_FLAG0
-#define EV_OOBAND       EV_FLAG1
-
-/*
- * data/hint fflags for EVFILT_USER, shared with userspace
- */
-
-/*
- * On input, NOTE_TRIGGER causes the event to be triggered for output.
- */
-#define NOTE_TRIGGER    0x01000000
-
-/*
- * On input, the top two bits of fflags specifies how the lower twenty four
- * bits should be applied to the stored value of fflags.
- *
- * On output, the top two bits will always be set to NOTE_FFNOP and the
- * remaining twenty four bits will contain the stored fflags value.
- */
-#define NOTE_FFNOP      0x00000000              /* ignore input fflags */
-#define NOTE_FFAND      0x40000000              /* and fflags */
-#define NOTE_FFOR       0x80000000              /* or fflags */
-#define NOTE_FFCOPY     0xc0000000              /* copy fflags */
-#define NOTE_FFCTRLMASK 0xc0000000              /* mask for operations */
-#define NOTE_FFLAGSMASK 0x00ffffff
-
-
-/*
- * data/hint fflags for EVFILT_{READ|WRITE}, shared with userspace
- *
- * The default behavior for EVFILT_READ is to make the determination
- * realtive to the current file descriptor read pointer.
- */
-#define NOTE_LOWAT      0x00000001              /* low water mark */
-
-/* data/hint flags for EVFILT_EXCEPT, shared with userspace */
-#define NOTE_OOB        0x00000002              /* OOB data */
-
-/*
- * data/hint fflags for EVFILT_VNODE, shared with userspace
- */
-#define NOTE_DELETE     0x00000001              /* vnode was removed */
-#define NOTE_WRITE      0x00000002              /* data contents changed */
-#define NOTE_EXTEND     0x00000004              /* size increased */
-#define NOTE_ATTRIB     0x00000008              /* attributes changed */
-#define NOTE_LINK       0x00000010              /* link count changed */
-#define NOTE_RENAME     0x00000020              /* vnode was renamed */
-#define NOTE_REVOKE     0x00000040              /* vnode access was revoked */
-#define NOTE_NONE       0x00000080              /* No specific vnode event: to test for EVFILT_READ activation*/
-#define NOTE_FUNLOCK    0x00000100              /* vnode was unlocked by flock(2) */
-
-/*
- * data/hint fflags for EVFILT_PROC, shared with userspace
- *
- * Please note that EVFILT_PROC and EVFILT_SIGNAL share the same knote list
- * that hangs off the proc structure. They also both play games with the hint
- * passed to KNOTE(). If NOTE_SIGNAL is passed as a hint, then the lower bits
- * of the hint contain the signal. IF NOTE_FORK is passed, then the lower bits
- * contain the PID of the child (but the pid does not get passed through in
- * the actual kevent).
- */
-enum {
-	eNoteReapDeprecated __deprecated_enum_msg("This kqueue(2) EVFILT_PROC flag is deprecated") = 0x10000000
-};
-
-#define NOTE_EXIT               0x80000000      /* process exited */
-#define NOTE_FORK               0x40000000      /* process forked */
-#define NOTE_EXEC               0x20000000      /* process exec'd */
-#define NOTE_REAP               ((unsigned int)eNoteReapDeprecated /* 0x10000000 */ )   /* process reaped */
-#define NOTE_SIGNAL             0x08000000      /* shared with EVFILT_SIGNAL */
-#define NOTE_EXITSTATUS         0x04000000      /* exit status to be returned, valid for child process only */
-#define NOTE_EXIT_DETAIL        0x02000000      /* provide details on reasons for exit */
-
-#define NOTE_PDATAMASK  0x000fffff              /* mask for signal & exit status */
-#define NOTE_PCTRLMASK  (~NOTE_PDATAMASK)
-
-/*
- * If NOTE_EXITSTATUS is present, provide additional info about exiting process.
- */
-enum {
-	eNoteExitReparentedDeprecated __deprecated_enum_msg("This kqueue(2) EVFILT_PROC flag is no longer sent") = 0x00080000
-};
-#define NOTE_EXIT_REPARENTED    ((unsigned int)eNoteExitReparentedDeprecated)   /* exited while reparented */
-
-/*
- * If NOTE_EXIT_DETAIL is present, these bits indicate specific reasons for exiting.
- */
-#define NOTE_EXIT_DETAIL_MASK           0x00070000
-#define NOTE_EXIT_DECRYPTFAIL           0x00010000
-#define NOTE_EXIT_MEMORY                0x00020000
-#define NOTE_EXIT_CSERROR               0x00040000
-
-
-/*
- * data/hint fflags for EVFILT_VM, shared with userspace.
- */
-#define NOTE_VM_PRESSURE                        0x80000000              /* will react on memory pressure */
-#define NOTE_VM_PRESSURE_TERMINATE              0x40000000              /* will quit on memory pressure, possibly after cleaning up dirty state */
-#define NOTE_VM_PRESSURE_SUDDEN_TERMINATE       0x20000000              /* will quit immediately on memory pressure */
-#define NOTE_VM_ERROR                           0x10000000              /* there was an error */
-
-
-/*
- * data/hint fflags for EVFILT_TIMER, shared with userspace.
- * The default is a (repeating) interval timer with the data
- * specifying the timeout interval in milliseconds.
- *
- * All timeouts are implicitly EV_CLEAR events.
- */
-#define NOTE_SECONDS    0x00000001              /* data is seconds         */
-#define NOTE_USECONDS   0x00000002              /* data is microseconds    */
-#define NOTE_NSECONDS   0x00000004              /* data is nanoseconds     */
-#define NOTE_ABSOLUTE   0x00000008              /* absolute timeout        */
-/* ... implicit EV_ONESHOT, timeout uses the gettimeofday epoch */
-#define NOTE_LEEWAY             0x00000010              /* ext[1] holds leeway for power aware timers */
-#define NOTE_CRITICAL   0x00000020              /* system does minimal timer coalescing */
-#define NOTE_BACKGROUND 0x00000040              /* system does maximum timer coalescing */
-#define NOTE_MACH_CONTINUOUS_TIME       0x00000080
-/*
- * NOTE_MACH_CONTINUOUS_TIME:
- * with NOTE_ABSOLUTE: causes the timer to continue to tick across sleep,
- *      still uses gettimeofday epoch
- * with NOTE_MACHTIME and NOTE_ABSOLUTE: uses mach continuous time epoch
- * without NOTE_ABSOLUTE (interval timer mode): continues to tick across sleep
- */
-#define NOTE_MACHTIME   0x00000100              /* data is mach absolute time units */
-/* timeout uses the mach absolute time epoch */
-
-
-/*
- * data/hint fflags for EVFILT_MACHPORT, shared with userspace.
- *
- * Only portsets are supported at this time.
- *
- * The fflags field can optionally contain the MACH_RCV_MSG, MACH_RCV_LARGE,
- * and related trailer receive options as defined in <mach/message.h>.
- * The presence of these flags directs the kevent64() call to attempt to receive
- * the message during kevent delivery, rather than just indicate that a message exists.
- * On setup, The ext[0] field contains the receive buffer pointer and ext[1] contains
- * the receive buffer length.  Upon event delivery, the actual received message size
- * is returned in ext[1].  As with mach_msg(), the buffer must be large enough to
- * receive the message and the requested (or default) message trailers.  In addition,
- * the fflags field contains the return code normally returned by mach_msg().
- *
- * If MACH_RCV_MSG is specified, and the ext[1] field specifies a zero length, the
- * system call argument specifying an ouput area (kevent_qos) will be consulted. If
- * the system call specified an output data area, the user-space address
- * of the received message is carved from that provided output data area (if enough
- * space remains there). The address and length of each received message is
- * returned in the ext[0] and ext[1] fields (respectively) of the corresponding kevent.
- *
- * IF_MACH_RCV_VOUCHER_CONTENT is specified, the contents of the message voucher is
- * extracted (as specified in the xflags field) and stored in ext[2] up to ext[3]
- * length.  If the input length is zero, and the system call provided a data area,
- * the space for the voucher content is carved from the provided space and its
- * address and length is returned in ext[2] and ext[3] respectively.
- *
- * If no message receipt options were provided in the fflags field on setup, no
- * message is received by this call. Instead, on output, the data field simply
- * contains the name of the actual port detected with a message waiting.
- */
-
-/*
- * DEPRECATED!!!!!!!!!
- * NOTE_TRACK, NOTE_TRACKERR, and NOTE_CHILD are no longer supported as of 10.5
- */
-/* additional flags for EVFILT_PROC */
-#define NOTE_TRACK      0x00000001              /* follow across forks */
-#define NOTE_TRACKERR   0x00000002              /* could not track child */
-#define NOTE_CHILD      0x00000004              /* am a child process */
-
-
-
-/* Temporay solution for BootX to use inode.h till kqueue moves to vfs layer */
-#include <sys/queue.h>
-struct knote;
-SLIST_HEAD(klist, knote);
-
-
-#include <sys/types.h>
-
-struct timespec;
-
-__BEGIN_DECLS
-int     kqueue(void);
-int     kevent(int kq,
-    const struct kevent *changelist, int nchanges,
-    struct kevent *eventlist, int nevents,
-    const struct timespec *timeout);
-int     kevent64(int kq,
-    const struct kevent64_s *changelist, int nchanges,
-    struct kevent64_s *eventlist, int nevents,
-    unsigned int flags,
-    const struct timespec *timeout);
-
-
-__END_DECLS
-
-
-
-
-#endif /* !_SYS_EVENT_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/sys/fcntl.h b/lib/libc/include/x86_64-macos-gnu/sys/fcntl.h
deleted file mode 100644
index 9326ed0dab..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/sys/fcntl.h
+++ /dev/null
@@ -1,557 +0,0 @@
-/*
- * Copyright (c) 2000-2013 Apple Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-/* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */
-/*-
- * Copyright (c) 1983, 1990, 1993
- *	The Regents of the University of California.  All rights reserved.
- * (c) UNIX System Laboratories, Inc.
- * All or some portions of this file are derived from material licensed
- * to the University of California by American Telephone and Telegraph
- * Co. or Unix System Laboratories, Inc. and are reproduced herein with
- * the permission of UNIX System Laboratories, Inc.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *	This product includes software developed by the University of
- *	California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *	@(#)fcntl.h	8.3 (Berkeley) 1/21/94
- */
-
-
-#ifndef _SYS_FCNTL_H_
-#define _SYS_FCNTL_H_
-
-/*
- * This file includes the definitions for open and fcntl
- * described by POSIX for <fcntl.h>; it also includes
- * related kernel definitions.
- */
-#include <sys/_types.h>
-#include <sys/cdefs.h>
-#include <Availability.h>
-
-/* We should not be exporting size_t here.  Temporary for gcc bootstrapping. */
-#include <sys/_types/_size_t.h>
-#include <sys/_types/_mode_t.h>
-#include <sys/_types/_off_t.h>
-#include <sys/_types/_pid_t.h>
-
-/*
- * File status flags: these are used by open(2), fcntl(2).
- * They are also used (indirectly) in the kernel file structure f_flags,
- * which is a superset of the open/fcntl flags.  Open flags and f_flags
- * are inter-convertible using OFLAGS(fflags) and FFLAGS(oflags).
- * Open/fcntl flags begin with O_; kernel-internal flags begin with F.
- */
-/* open-only flags */
-#define O_RDONLY        0x0000          /* open for reading only */
-#define O_WRONLY        0x0001          /* open for writing only */
-#define O_RDWR          0x0002          /* open for reading and writing */
-#define O_ACCMODE       0x0003          /* mask for above modes */
-
-/*
- * Kernel encoding of open mode; separate read and write bits that are
- * independently testable: 1 greater than the above.
- *
- * XXX
- * FREAD and FWRITE are excluded from the #ifdef KERNEL so that TIOCFLUSH,
- * which was documented to use FREAD/FWRITE, continues to work.
- */
-#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-#define FREAD           0x0001
-#define FWRITE          0x0002
-#endif
-#define O_NONBLOCK      0x0004          /* no delay */
-#define O_APPEND        0x0008          /* set append mode */
-
-#include <sys/_types/_o_sync.h>
-
-#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-#define O_SHLOCK        0x0010          /* open with shared file lock */
-#define O_EXLOCK        0x0020          /* open with exclusive file lock */
-#define O_ASYNC         0x0040          /* signal pgrp when data ready */
-#define O_FSYNC         O_SYNC          /* source compatibility: do not use */
-#define O_NOFOLLOW  0x0100      /* don't follow symlinks */
-#endif /* (_POSIX_C_SOURCE && !_DARWIN_C_SOURCE) */
-#define O_CREAT         0x0200          /* create if nonexistant */
-#define O_TRUNC         0x0400          /* truncate to zero length */
-#define O_EXCL          0x0800          /* error if already exists */
-
-#if __DARWIN_C_LEVEL >= 200809L
-/*
- * Descriptor value for the current working directory
- */
-#define AT_FDCWD        -2
-
-/*
- * Flags for the at functions
- */
-#define AT_EACCESS              0x0010  /* Use effective ids in access check */
-#define AT_SYMLINK_NOFOLLOW     0x0020  /* Act on the symlink itself not the target */
-#define AT_SYMLINK_FOLLOW       0x0040  /* Act on target of symlink */
-#define AT_REMOVEDIR            0x0080  /* Path refers to directory */
-#if __DARWIN_C_LEVEL >= __DARWIN_C_FULL
-#define AT_REALDEV              0x0200  /* Return real device inodes resides on for fstatat(2) */
-#define AT_FDONLY               0x0400  /* Use only the fd and Ignore the path for fstatat(2) */
-#endif
-#endif
-
-#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-#define O_EVTONLY       0x8000          /* descriptor requested for event notifications only */
-#endif
-
-
-#define O_NOCTTY        0x20000         /* don't assign controlling terminal */
-
-
-#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-#define O_DIRECTORY     0x100000
-#define O_SYMLINK       0x200000        /* allow open of a symlink */
-#endif
-
-#include <sys/_types/_o_dsync.h>
-
-
-#if __DARWIN_C_LEVEL >= 200809L
-#define O_CLOEXEC       0x1000000       /* implicitly set FD_CLOEXEC */
-#endif
-
-
-
-
-
-/* Data Protection Flags */
-#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-#define O_DP_GETRAWENCRYPTED    0x0001
-#define O_DP_GETRAWUNENCRYPTED  0x0002
-#endif
-
-
-
-/*
- * The O_* flags used to have only F* names, which were used in the kernel
- * and by fcntl.  We retain the F* names for the kernel f_flags field
- * and for backward compatibility for fcntl.
- */
-#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-#define FAPPEND         O_APPEND        /* kernel/compat */
-#define FASYNC          O_ASYNC         /* kernel/compat */
-#define FFSYNC          O_FSYNC         /* kernel */
-#define FFDSYNC         O_DSYNC         /* kernel */
-#define FNONBLOCK       O_NONBLOCK      /* kernel */
-#define FNDELAY         O_NONBLOCK      /* compat */
-#define O_NDELAY        O_NONBLOCK      /* compat */
-#endif
-
-/*
- * Flags used for copyfile(2)
- */
-
-#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-#define CPF_OVERWRITE    0x0001
-#define CPF_IGNORE_MODE  0x0002
-#define CPF_MASK (CPF_OVERWRITE|CPF_IGNORE_MODE)
-#endif
-
-/*
- * Constants used for fcntl(2)
- */
-
-/* command values */
-#define F_DUPFD         0               /* duplicate file descriptor */
-#define F_GETFD         1               /* get file descriptor flags */
-#define F_SETFD         2               /* set file descriptor flags */
-#define F_GETFL         3               /* get file status flags */
-#define F_SETFL         4               /* set file status flags */
-#define F_GETOWN        5               /* get SIGIO/SIGURG proc/pgrp */
-#define F_SETOWN        6               /* set SIGIO/SIGURG proc/pgrp */
-#define F_GETLK         7               /* get record locking information */
-#define F_SETLK         8               /* set record locking information */
-#define F_SETLKW        9               /* F_SETLK; wait if blocked */
-#if __DARWIN_C_LEVEL >= __DARWIN_C_FULL
-#define F_SETLKWTIMEOUT 10              /* F_SETLK; wait if blocked, return on timeout */
-#endif /* __DARWIN_C_LEVEL >= __DARWIN_C_FULL */
-#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-#define F_FLUSH_DATA    40
-#define F_CHKCLEAN      41              /* Used for regression test */
-#define F_PREALLOCATE   42              /* Preallocate storage */
-#define F_SETSIZE       43              /* Truncate a file without zeroing space */
-#define F_RDADVISE      44              /* Issue an advisory read async with no copy to user */
-#define F_RDAHEAD       45              /* turn read ahead off/on for this fd */
-/*
- * 46,47 used to be F_READBOOTSTRAP and F_WRITEBOOTSTRAP
- */
-#define F_NOCACHE       48              /* turn data caching off/on for this fd */
-#define F_LOG2PHYS      49              /* file offset to device offset */
-#define F_GETPATH       50              /* return the full path of the fd */
-#define F_FULLFSYNC     51              /* fsync + ask the drive to flush to the media */
-#define F_PATHPKG_CHECK 52              /* find which component (if any) is a package */
-#define F_FREEZE_FS     53              /* "freeze" all fs operations */
-#define F_THAW_FS       54              /* "thaw" all fs operations */
-#define F_GLOBAL_NOCACHE 55             /* turn data caching off/on (globally) for this file */
-
-
-#define F_ADDSIGS       59              /* add detached signatures */
-
-
-#define F_ADDFILESIGS   61              /* add signature from same file (used by dyld for shared libs) */
-
-#define F_NODIRECT      62              /* used in conjunction with F_NOCACHE to indicate that DIRECT, synchonous writes */
-                                        /* should not be used (i.e. its ok to temporaily create cached pages) */
-
-#define F_GETPROTECTIONCLASS    63              /* Get the protection class of a file from the EA, returns int */
-#define F_SETPROTECTIONCLASS    64              /* Set the protection class of a file for the EA, requires int */
-
-#define F_LOG2PHYS_EXT  65              /* file offset to device offset, extended */
-
-#define F_GETLKPID              66              /* get record locking information, per-process */
-
-/* See F_DUPFD_CLOEXEC below for 67 */
-
-
-#define F_SETBACKINGSTORE       70      /* Mark the file as being the backing store for another filesystem */
-#define F_GETPATH_MTMINFO       71      /* return the full path of the FD, but error in specific mtmd circumstances */
-
-#define F_GETCODEDIR            72      /* Returns the code directory, with associated hashes, to the caller */
-
-#define F_SETNOSIGPIPE          73      /* No SIGPIPE generated on EPIPE */
-#define F_GETNOSIGPIPE          74      /* Status of SIGPIPE for this fd */
-
-#define F_TRANSCODEKEY          75      /* For some cases, we need to rewrap the key for AKS/MKB */
-
-#define F_SINGLE_WRITER         76      /* file being written to a by single writer... if throttling enabled, writes */
-                                        /* may be broken into smaller chunks with throttling in between */
-
-#define F_GETPROTECTIONLEVEL    77      /* Get the protection version number for this filesystem */
-
-#define F_FINDSIGS              78      /* Add detached code signatures (used by dyld for shared libs) */
-
-
-#define F_ADDFILESIGS_FOR_DYLD_SIM 83   /* Add signature from same file, only if it is signed by Apple (used by dyld for simulator) */
-
-
-#define F_BARRIERFSYNC          85      /* fsync + issue barrier to drive */
-
-
-#define F_ADDFILESIGS_RETURN    97      /* Add signature from same file, return end offset in structure on success */
-#define F_CHECK_LV              98      /* Check if Library Validation allows this Mach-O file to be mapped into the calling process */
-
-#define F_PUNCHHOLE     99              /* Deallocate a range of the file */
-
-#define F_TRIM_ACTIVE_FILE      100     /* Trim an active file */
-
-#define F_SPECULATIVE_READ     101      /* Synchronous advisory read fcntl for regular and compressed file */
-
-#define F_GETPATH_NOFIRMLINK       102              /* return the full path without firmlinks of the fd */
-
-// FS-specific fcntl()'s numbers begin at 0x00010000 and go up
-#define FCNTL_FS_SPECIFIC_BASE  0x00010000
-
-#endif /* (_POSIX_C_SOURCE && !_DARWIN_C_SOURCE) */
-
-#if __DARWIN_C_LEVEL >= 200809L
-#define F_DUPFD_CLOEXEC         67      /* mark the dup with FD_CLOEXEC */
-#endif
-
-/* file descriptor flags (F_GETFD, F_SETFD) */
-#define FD_CLOEXEC      1               /* close-on-exec flag */
-
-/* record locking flags (F_GETLK, F_SETLK, F_SETLKW) */
-#define F_RDLCK         1               /* shared or read lock */
-#define F_UNLCK         2               /* unlock */
-#define F_WRLCK         3               /* exclusive or write lock */
-
-
-/*
- * [XSI] The values used for l_whence shall be defined as described
- * in <unistd.h>
- */
-#include <sys/_types/_seek_set.h>
-
-/*
- * [XSI] The symbolic names for file modes for use as values of mode_t
- * shall be defined as described in <sys/stat.h>
- */
-#include <sys/_types/_s_ifmt.h>
-
-#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-/* allocate flags (F_PREALLOCATE) */
-
-#define F_ALLOCATECONTIG  0x00000002    /* allocate contigious space */
-#define F_ALLOCATEALL     0x00000004    /* allocate all requested space or no space at all */
-
-/* Position Modes (fst_posmode) for F_PREALLOCATE */
-
-#define F_PEOFPOSMODE 3                 /* Make it past all of the SEEK pos modes so that */
-                                        /* we can keep them in sync should we desire */
-#define F_VOLPOSMODE    4               /* specify volume starting postion */
-#endif /* (_POSIX_C_SOURCE && !_DARWIN_C_SOURCE) */
-
-/*
- * Advisory file segment locking data type -
- * information passed to system by user
- */
-struct flock {
-	off_t   l_start;        /* starting offset */
-	off_t   l_len;          /* len = 0 means until end of file */
-	pid_t   l_pid;          /* lock owner */
-	short   l_type;         /* lock type: read/write, etc. */
-	short   l_whence;       /* type of l_start */
-};
-
-#include <sys/_types/_timespec.h>
-
-#if __DARWIN_C_LEVEL >= __DARWIN_C_FULL
-/*
- * Advisory file segment locking with time out -
- * Information passed to system by user for F_SETLKWTIMEOUT
- */
-struct flocktimeout {
-	struct flock    fl;             /* flock passed for file locking */
-	struct timespec timeout;        /* timespec struct for timeout */
-};
-#endif /* __DARWIN_C_LEVEL >= __DARWIN_C_FULL */
-
-#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-/*
- * advisory file read data type -
- * information passed by user to system
- */
-
-
-struct radvisory {
-	off_t   ra_offset;
-	int     ra_count;
-};
-
-
-/** Information the user passes in to get the codeblobs out of the kernel */
-typedef struct fcodeblobs {
-	void            *f_cd_hash;
-	size_t          f_hash_size;
-	void            *f_cd_buffer;
-	size_t          f_cd_size;
-	unsigned int    *f_out_size;
-	int             f_arch;
-	int             __padding;
-} fcodeblobs_t;
-
-
-/*
- * detached code signatures data type -
- * information passed by user to system used by F_ADDSIGS and F_ADDFILESIGS.
- * F_ADDFILESIGS is a shortcut for files that contain their own signature and
- * doesn't require mapping of the file in order to load the signature.
- */
-typedef struct fsignatures {
-	off_t           fs_file_start;
-	void            *fs_blob_start;
-	size_t          fs_blob_size;
-} fsignatures_t;
-
-/*
- * DYLD needs to check if the object is allowed to be combined
- * into the main binary. This is done between the code signature
- * is loaded and dyld is doing all the work to process the LOAD commands.
- *
- * While this could be done in F_ADDFILESIGS.* family the hook into
- * the MAC module doesn't say no when LV isn't enabled and then that
- * is cached on the vnode, and the MAC module never gets change once
- * a process that library validation enabled.
- */
-typedef struct fchecklv {
-	off_t           lv_file_start;
-	size_t          lv_error_message_size;
-	void            *lv_error_message;
-} fchecklv_t;
-
-
-
-/* lock operations for flock(2) */
-#define LOCK_SH         0x01            /* shared file lock */
-#define LOCK_EX         0x02            /* exclusive file lock */
-#define LOCK_NB         0x04            /* don't block when locking */
-#define LOCK_UN         0x08            /* unlock file */
-
-/* fstore_t type used by F_PREALLOCATE command */
-
-typedef struct fstore {
-	unsigned int fst_flags; /* IN: flags word */
-	int     fst_posmode;    /* IN: indicates use of offset field */
-	off_t   fst_offset;     /* IN: start of the region */
-	off_t   fst_length;     /* IN: size of the region */
-	off_t   fst_bytesalloc; /* OUT: number of bytes allocated */
-} fstore_t;
-
-/* fpunchhole_t used by F_PUNCHHOLE */
-typedef struct fpunchhole {
-	unsigned int fp_flags; /* unused */
-	unsigned int reserved; /* (to maintain 8-byte alignment) */
-	off_t fp_offset; /* IN: start of the region */
-	off_t fp_length; /* IN: size of the region */
-} fpunchhole_t;
-
-/* factive_file_trim_t used by F_TRIM_ACTIVE_FILE */
-typedef struct ftrimactivefile {
-	off_t fta_offset;  /* IN: start of the region */
-	off_t fta_length; /* IN: size of the region */
-} ftrimactivefile_t;
-
-/* fspecread_t used by F_SPECULATIVE_READ */
-typedef struct fspecread {
-	unsigned int fsr_flags;  /* IN: flags word */
-	unsigned int reserved;   /* to maintain 8-byte alignment */
-	off_t fsr_offset;        /* IN: start of the region */
-	off_t fsr_length;        /* IN: size of the region */
-} fspecread_t;
-
-/* fbootstraptransfer_t used by F_READBOOTSTRAP and F_WRITEBOOTSTRAP commands */
-
-typedef struct fbootstraptransfer {
-	off_t fbt_offset;       /* IN: offset to start read/write */
-	size_t fbt_length;    /* IN: number of bytes to transfer */
-	void *fbt_buffer;       /* IN: buffer to be read/written */
-} fbootstraptransfer_t;
-
-
-/*
- * For F_LOG2PHYS this information is passed back to user
- * Currently only devoffset is returned - that is the VOP_BMAP
- * result - the disk device address corresponding to the
- * current file offset (likely set with an lseek).
- *
- * The flags could hold an indication of whether the # of
- * contiguous bytes reflects the true extent length on disk,
- * or is an advisory value that indicates there is at least that
- * many bytes contiguous.  For some filesystems it might be too
- * inefficient to provide anything beyond the advisory value.
- * Flags and contiguous bytes return values are not yet implemented.
- * For them the fcntl will nedd to switch from using BMAP to CMAP
- * and a per filesystem type flag will be needed to interpret the
- * contiguous bytes count result from CMAP.
- *
- * F_LOG2PHYS_EXT is a variant of F_LOG2PHYS that uses a passed in
- * file offset and length instead of the current file offset.
- * F_LOG2PHYS_EXT operates on the same structure as F_LOG2PHYS, but
- * treats it as an in/out.
- */
-#pragma pack(4)
-
-struct log2phys {
-	unsigned int    l2p_flags;       /* unused so far */
-	off_t           l2p_contigbytes; /* F_LOG2PHYS:     unused so far */
-	                                 /* F_LOG2PHYS_EXT: IN:  number of bytes to be queried */
-	                                 /*                 OUT: number of contiguous bytes at this position */
-	off_t           l2p_devoffset;   /* F_LOG2PHYS:     OUT: bytes into device */
-	                                 /* F_LOG2PHYS_EXT: IN:  bytes into file */
-	                                 /*                 OUT: bytes into device */
-};
-
-#pragma pack()
-
-#define O_POPUP    0x80000000   /* force window to popup on open */
-#define O_ALERT    0x20000000   /* small, clean popup window */
-
-
-#endif /* (_POSIX_C_SOURCE && !_DARWIN_C_SOURCE) */
-
-
-#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-
-#include <sys/_types/_filesec_t.h>
-
-typedef enum {
-	FILESEC_OWNER = 1,
-	FILESEC_GROUP = 2,
-	FILESEC_UUID = 3,
-	FILESEC_MODE = 4,
-	FILESEC_ACL = 5,
-	FILESEC_GRPUUID = 6,
-
-/* XXX these are private to the implementation */
-	FILESEC_ACL_RAW = 100,
-	FILESEC_ACL_ALLOCSIZE = 101
-} filesec_property_t;
-
-/* XXX backwards compatibility */
-#define FILESEC_GUID FILESEC_UUID
-#endif /* (_POSIX_C_SOURCE && !_DARWIN_C_SOURCE) */
-
-__BEGIN_DECLS
-int     open(const char *, int, ...) __DARWIN_ALIAS_C(open);
-#if __DARWIN_C_LEVEL >= 200809L
-int     openat(int, const char *, int, ...) __DARWIN_NOCANCEL(openat) __OSX_AVAILABLE_STARTING(__MAC_10_10, __IPHONE_8_0);
-#endif
-int     creat(const char *, mode_t) __DARWIN_ALIAS_C(creat);
-int     fcntl(int, int, ...) __DARWIN_ALIAS_C(fcntl);
-#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-
-int     openx_np(const char *, int, filesec_t);
-/*
- * data-protected non-portable open(2) :
- *  int open_dprotected_np(user_addr_t path, int flags, int class, int dpflags, int mode)
- */
-int open_dprotected_np( const char *, int, int, int, ...);
-int     flock(int, int);
-filesec_t filesec_init(void);
-filesec_t filesec_dup(filesec_t);
-void    filesec_free(filesec_t);
-int     filesec_get_property(filesec_t, filesec_property_t, void *);
-int     filesec_query_property(filesec_t, filesec_property_t, int *);
-int     filesec_set_property(filesec_t, filesec_property_t, const void *);
-int     filesec_unset_property(filesec_t, filesec_property_t) __OSX_AVAILABLE_STARTING(__MAC_10_6, __IPHONE_3_2);
-#define _FILESEC_UNSET_PROPERTY ((void *)0)
-#define _FILESEC_REMOVE_ACL     ((void *)1)
-#endif /* (!_POSIX_C_SOURCE || _DARWIN_C_SOURCE) */
-__END_DECLS
-
-#endif /* !_SYS_FCNTL_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/sys/ioccom.h b/lib/libc/include/x86_64-macos-gnu/sys/ioccom.h
deleted file mode 100644
index 39c6964568..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/sys/ioccom.h
+++ /dev/null
@@ -1,99 +0,0 @@
-/*
- * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-/* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */
-/*-
- * Copyright (c) 1982, 1986, 1990, 1993, 1994
- *	The Regents of the University of California.  All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *	This product includes software developed by the University of
- *	California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *	@(#)ioccom.h	8.2 (Berkeley) 3/28/94
- */
-
-#ifndef _SYS_IOCCOM_H_
-#define _SYS_IOCCOM_H_
-
-#include <sys/_types.h>
-
-/*
- * Ioctl's have the command encoded in the lower word, and the size of
- * any in or out parameters in the upper word.  The high 3 bits of the
- * upper word are used to encode the in/out status of the parameter.
- */
-#define IOCPARM_MASK    0x1fff          /* parameter length, at most 13 bits */
-#define IOCPARM_LEN(x)  (((x) >> 16) & IOCPARM_MASK)
-#define IOCBASECMD(x)   ((x) & ~(IOCPARM_MASK << 16))
-#define IOCGROUP(x)     (((x) >> 8) & 0xff)
-
-#define IOCPARM_MAX     (IOCPARM_MASK + 1)      /* max size of ioctl args */
-/* no parameters */
-#define IOC_VOID        (__uint32_t)0x20000000
-/* copy parameters out */
-#define IOC_OUT         (__uint32_t)0x40000000
-/* copy parameters in */
-#define IOC_IN          (__uint32_t)0x80000000
-/* copy paramters in and out */
-#define IOC_INOUT       (IOC_IN|IOC_OUT)
-/* mask for IN/OUT/VOID */
-#define IOC_DIRMASK     (__uint32_t)0xe0000000
-
-#define _IOC(inout, group, num, len) \
-	(inout | ((len & IOCPARM_MASK) << 16) | ((group) << 8) | (num))
-#define _IO(g, n)        _IOC(IOC_VOID,	(g), (n), 0)
-#define _IOR(g, n, t)     _IOC(IOC_OUT,	(g), (n), sizeof(t))
-#define _IOW(g, n, t)     _IOC(IOC_IN,	(g), (n), sizeof(t))
-/* this should be _IORW, but stdio got there first */
-#define _IOWR(g, n, t)    _IOC(IOC_INOUT,	(g), (n), sizeof(t))
-
-#endif /* !_SYS_IOCCOM_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/sys/kauth.h b/lib/libc/include/x86_64-macos-gnu/sys/kauth.h
deleted file mode 100644
index 99784e35c8..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/sys/kauth.h
+++ /dev/null
@@ -1,407 +0,0 @@
-/*
- * Copyright (c) 2004-2010 Apple Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-/*
- * NOTICE: This file was modified by SPARTA, Inc. in 2005 to introduce
- * support for mandatory and extensible security protections.  This notice
- * is included in support of clause 2.2 (b) of the Apple Public License,
- * Version 2.0.
- */
-
-#ifndef _SYS_KAUTH_H
-#define _SYS_KAUTH_H
-
-#include <sys/appleapiopts.h>
-#include <sys/cdefs.h>
-#include <mach/boolean.h>
-#include <sys/_types.h>         /* __offsetof() */
-#include <sys/syslimits.h>      /* NGROUPS_MAX */
-
-#ifdef __APPLE_API_EVOLVING
-
-/*
- * Identities.
- */
-
-#define KAUTH_UID_NONE  (~(uid_t)0 - 100)       /* not a valid UID */
-#define KAUTH_GID_NONE  (~(gid_t)0 - 100)       /* not a valid GID */
-
-#include <sys/_types/_guid_t.h>
-
-/* NT Security Identifier, structure as defined by Microsoft */
-#pragma pack(1)    /* push packing of 1 byte */
-typedef struct {
-	u_int8_t                sid_kind;
-	u_int8_t                sid_authcount;
-	u_int8_t                sid_authority[6];
-#define KAUTH_NTSID_MAX_AUTHORITIES 16
-	u_int32_t       sid_authorities[KAUTH_NTSID_MAX_AUTHORITIES];
-} ntsid_t;
-#pragma pack()    /* pop packing to previous packing level */
-#define _NTSID_T
-
-/* valid byte count inside a SID structure */
-#define KAUTH_NTSID_HDRSIZE     (8)
-#define KAUTH_NTSID_SIZE(_s)    (KAUTH_NTSID_HDRSIZE + ((_s)->sid_authcount * sizeof(u_int32_t)))
-
-/*
- * External lookup message payload; this structure is shared between the
- * kernel group membership resolver, and the user space group membership
- * resolver daemon, and is use to communicate resolution requests from the
- * kernel to user space, and the result of that request from user space to
- * the kernel.
- */
-struct kauth_identity_extlookup {
-	u_int32_t       el_seqno;       /* request sequence number */
-	u_int32_t       el_result;      /* lookup result */
-#define KAUTH_EXTLOOKUP_SUCCESS         0       /* results here are good */
-#define KAUTH_EXTLOOKUP_BADRQ           1       /* request badly formatted */
-#define KAUTH_EXTLOOKUP_FAILURE         2       /* transient failure during lookup */
-#define KAUTH_EXTLOOKUP_FATAL           3       /* permanent failure during lookup */
-#define KAUTH_EXTLOOKUP_INPROG          100     /* request in progress */
-	u_int32_t       el_flags;
-#define KAUTH_EXTLOOKUP_VALID_UID       (1<<0)
-#define KAUTH_EXTLOOKUP_VALID_UGUID     (1<<1)
-#define KAUTH_EXTLOOKUP_VALID_USID      (1<<2)
-#define KAUTH_EXTLOOKUP_VALID_GID       (1<<3)
-#define KAUTH_EXTLOOKUP_VALID_GGUID     (1<<4)
-#define KAUTH_EXTLOOKUP_VALID_GSID      (1<<5)
-#define KAUTH_EXTLOOKUP_WANT_UID        (1<<6)
-#define KAUTH_EXTLOOKUP_WANT_UGUID      (1<<7)
-#define KAUTH_EXTLOOKUP_WANT_USID       (1<<8)
-#define KAUTH_EXTLOOKUP_WANT_GID        (1<<9)
-#define KAUTH_EXTLOOKUP_WANT_GGUID      (1<<10)
-#define KAUTH_EXTLOOKUP_WANT_GSID       (1<<11)
-#define KAUTH_EXTLOOKUP_WANT_MEMBERSHIP (1<<12)
-#define KAUTH_EXTLOOKUP_VALID_MEMBERSHIP (1<<13)
-#define KAUTH_EXTLOOKUP_ISMEMBER        (1<<14)
-#define KAUTH_EXTLOOKUP_VALID_PWNAM     (1<<15)
-#define KAUTH_EXTLOOKUP_WANT_PWNAM      (1<<16)
-#define KAUTH_EXTLOOKUP_VALID_GRNAM     (1<<17)
-#define KAUTH_EXTLOOKUP_WANT_GRNAM      (1<<18)
-#define KAUTH_EXTLOOKUP_VALID_SUPGRPS   (1<<19)
-#define KAUTH_EXTLOOKUP_WANT_SUPGRPS    (1<<20)
-
-	__darwin_pid_t  el_info_pid;            /* request on behalf of PID */
-	u_int64_t       el_extend;              /* extension field */
-	u_int32_t       el_info_reserved_1;     /* reserved (APPLE) */
-
-	uid_t           el_uid;         /* user ID */
-	guid_t          el_uguid;       /* user GUID */
-	u_int32_t       el_uguid_valid; /* TTL on translation result (seconds) */
-	ntsid_t         el_usid;        /* user NT SID */
-	u_int32_t       el_usid_valid;  /* TTL on translation result (seconds) */
-	gid_t           el_gid;         /* group ID */
-	guid_t          el_gguid;       /* group GUID */
-	u_int32_t       el_gguid_valid; /* TTL on translation result (seconds) */
-	ntsid_t         el_gsid;        /* group SID */
-	u_int32_t       el_gsid_valid;  /* TTL on translation result (seconds) */
-	u_int32_t       el_member_valid; /* TTL on group lookup result */
-	u_int32_t       el_sup_grp_cnt;  /* count of supplemental groups up to NGROUPS */
-	gid_t           el_sup_groups[NGROUPS_MAX];     /* supplemental group list */
-};
-
-struct kauth_cache_sizes {
-	u_int32_t kcs_group_size;
-	u_int32_t kcs_id_size;
-};
-
-#define KAUTH_EXTLOOKUP_REGISTER        (0)
-#define KAUTH_EXTLOOKUP_RESULT          (1<<0)
-#define KAUTH_EXTLOOKUP_WORKER          (1<<1)
-#define KAUTH_EXTLOOKUP_DEREGISTER      (1<<2)
-#define KAUTH_GET_CACHE_SIZES           (1<<3)
-#define KAUTH_SET_CACHE_SIZES           (1<<4)
-#define KAUTH_CLEAR_CACHES              (1<<5)
-
-#define IDENTITYSVC_ENTITLEMENT         "com.apple.private.identitysvc"
-
-
-
-/*
- * Generic Access Control Lists.
- */
-#if defined(KERNEL) || defined (_SYS_ACL_H)
-
-typedef u_int32_t kauth_ace_rights_t;
-
-/* Access Control List Entry (ACE) */
-struct kauth_ace {
-	guid_t          ace_applicable;
-	u_int32_t       ace_flags;
-#define KAUTH_ACE_KINDMASK              0xf
-#define KAUTH_ACE_PERMIT                1
-#define KAUTH_ACE_DENY                  2
-#define KAUTH_ACE_AUDIT                 3       /* not implemented */
-#define KAUTH_ACE_ALARM                 4       /* not implemented */
-#define KAUTH_ACE_INHERITED             (1<<4)
-#define KAUTH_ACE_FILE_INHERIT          (1<<5)
-#define KAUTH_ACE_DIRECTORY_INHERIT     (1<<6)
-#define KAUTH_ACE_LIMIT_INHERIT         (1<<7)
-#define KAUTH_ACE_ONLY_INHERIT          (1<<8)
-#define KAUTH_ACE_SUCCESS               (1<<9)  /* not implemented (AUDIT/ALARM) */
-#define KAUTH_ACE_FAILURE               (1<<10) /* not implemented (AUDIT/ALARM) */
-/* All flag bits controlling ACE inheritance */
-#define KAUTH_ACE_INHERIT_CONTROL_FLAGS         \
-	        (KAUTH_ACE_FILE_INHERIT |       \
-	         KAUTH_ACE_DIRECTORY_INHERIT |  \
-	         KAUTH_ACE_LIMIT_INHERIT |      \
-	         KAUTH_ACE_ONLY_INHERIT)
-	kauth_ace_rights_t ace_rights;          /* scope specific */
-	/* These rights are never tested, but may be present in an ACL */
-#define KAUTH_ACE_GENERIC_ALL           (1<<21)
-#define KAUTH_ACE_GENERIC_EXECUTE       (1<<22)
-#define KAUTH_ACE_GENERIC_WRITE         (1<<23)
-#define KAUTH_ACE_GENERIC_READ          (1<<24)
-};
-
-#ifndef _KAUTH_ACE
-#define _KAUTH_ACE
-typedef struct kauth_ace *kauth_ace_t;
-#endif
-
-
-/* Access Control List */
-struct kauth_acl {
-	u_int32_t       acl_entrycount;
-	u_int32_t       acl_flags;
-
-	struct kauth_ace acl_ace[1];
-};
-
-/*
- * XXX this value needs to be raised - 3893388
- */
-#define KAUTH_ACL_MAX_ENTRIES           128
-
-/*
- * The low 16 bits of the flags field are reserved for filesystem
- * internal use and must be preserved by all APIs.  This includes
- * round-tripping flags through user-space interfaces.
- */
-#define KAUTH_ACL_FLAGS_PRIVATE (0xffff)
-
-/*
- * The high 16 bits of the flags are used to store attributes and
- * to request specific handling of the ACL.
- */
-
-/* inheritance will be deferred until the first rename operation */
-#define KAUTH_ACL_DEFER_INHERIT (1<<16)
-/* this ACL must not be overwritten as part of an inheritance operation */
-#define KAUTH_ACL_NO_INHERIT    (1<<17)
-
-/* acl_entrycount that tells us the ACL is not valid */
-#define KAUTH_FILESEC_NOACL ((u_int32_t)(-1))
-
-/*
- * If the acl_entrycount field is KAUTH_FILESEC_NOACL, then the size is the
- * same as a kauth_acl structure; the intent is to put an actual entrycount of
- * KAUTH_FILESEC_NOACL on disk to distinguish a kauth_filesec_t with an empty
- * entry (Windows treats this as "deny all") from one that merely indicates a
- * file group and/or owner guid values.
- */
-#define KAUTH_ACL_SIZE(c)       (__offsetof(struct kauth_acl, acl_ace) + ((u_int32_t)(c) != KAUTH_FILESEC_NOACL ? ((c) * sizeof(struct kauth_ace)) : 0))
-#define KAUTH_ACL_COPYSIZE(p)   KAUTH_ACL_SIZE((p)->acl_entrycount)
-
-
-#ifndef _KAUTH_ACL
-#define _KAUTH_ACL
-typedef struct kauth_acl *kauth_acl_t;
-#endif
-
-
-
-/*
- * Extended File Security.
- */
-
-/* File Security information */
-struct kauth_filesec {
-	u_int32_t       fsec_magic;
-#define KAUTH_FILESEC_MAGIC     0x012cc16d
-	guid_t          fsec_owner;
-	guid_t          fsec_group;
-
-	struct kauth_acl fsec_acl;
-};
-
-/* backwards compatibility */
-#define fsec_entrycount fsec_acl.acl_entrycount
-#define fsec_flags      fsec_acl.acl_flags
-#define fsec_ace        fsec_acl.acl_ace
-#define KAUTH_FILESEC_FLAGS_PRIVATE     KAUTH_ACL_FLAGS_PRIVATE
-#define KAUTH_FILESEC_DEFER_INHERIT     KAUTH_ACL_DEFER_INHERIT
-#define KAUTH_FILESEC_NO_INHERIT        KAUTH_ACL_NO_INHERIT
-#define KAUTH_FILESEC_NONE      ((kauth_filesec_t)0)
-#define KAUTH_FILESEC_WANTED    ((kauth_filesec_t)1)
-
-#ifndef _KAUTH_FILESEC
-#define _KAUTH_FILESEC
-typedef struct kauth_filesec *kauth_filesec_t;
-#endif
-
-#define KAUTH_FILESEC_SIZE(c)           (__offsetof(struct kauth_filesec, fsec_acl) + __offsetof(struct kauth_acl, acl_ace) + (c) * sizeof(struct kauth_ace))
-#define KAUTH_FILESEC_COPYSIZE(p)       KAUTH_FILESEC_SIZE(((p)->fsec_entrycount == KAUTH_FILESEC_NOACL) ? 0 : (p)->fsec_entrycount)
-#define KAUTH_FILESEC_COUNT(s)          (((s)  - KAUTH_FILESEC_SIZE(0)) / sizeof(struct kauth_ace))
-#define KAUTH_FILESEC_VALID(s)          ((s) >= KAUTH_FILESEC_SIZE(0) && (((s) - KAUTH_FILESEC_SIZE(0)) % sizeof(struct kauth_ace)) == 0)
-
-#define KAUTH_FILESEC_XATTR     "com.apple.system.Security"
-
-/* Allowable first arguments to kauth_filesec_acl_setendian() */
-#define KAUTH_ENDIAN_HOST       0x00000001      /* set host endianness */
-#define KAUTH_ENDIAN_DISK       0x00000002      /* set disk endianness */
-
-#endif /* KERNEL || <sys/acl.h> */
-
-
-
-/* Actions, also rights bits in an ACE */
-
-#if defined(KERNEL) || defined (_SYS_ACL_H)
-#define KAUTH_VNODE_READ_DATA                   (1U<<1)
-#define KAUTH_VNODE_LIST_DIRECTORY              KAUTH_VNODE_READ_DATA
-#define KAUTH_VNODE_WRITE_DATA                  (1U<<2)
-#define KAUTH_VNODE_ADD_FILE                    KAUTH_VNODE_WRITE_DATA
-#define KAUTH_VNODE_EXECUTE                     (1U<<3)
-#define KAUTH_VNODE_SEARCH                      KAUTH_VNODE_EXECUTE
-#define KAUTH_VNODE_DELETE                      (1U<<4)
-#define KAUTH_VNODE_APPEND_DATA                 (1U<<5)
-#define KAUTH_VNODE_ADD_SUBDIRECTORY            KAUTH_VNODE_APPEND_DATA
-#define KAUTH_VNODE_DELETE_CHILD                (1U<<6)
-#define KAUTH_VNODE_READ_ATTRIBUTES             (1U<<7)
-#define KAUTH_VNODE_WRITE_ATTRIBUTES            (1U<<8)
-#define KAUTH_VNODE_READ_EXTATTRIBUTES          (1U<<9)
-#define KAUTH_VNODE_WRITE_EXTATTRIBUTES         (1U<<10)
-#define KAUTH_VNODE_READ_SECURITY               (1U<<11)
-#define KAUTH_VNODE_WRITE_SECURITY              (1U<<12)
-#define KAUTH_VNODE_TAKE_OWNERSHIP              (1U<<13)
-
-/* backwards compatibility only */
-#define KAUTH_VNODE_CHANGE_OWNER                KAUTH_VNODE_TAKE_OWNERSHIP
-
-/* For Windows interoperability only */
-#define KAUTH_VNODE_SYNCHRONIZE                 (1U<<20)
-
-/* (1<<21) - (1<<24) are reserved for generic rights bits */
-
-/* Actions not expressed as rights bits */
-/*
- * Authorizes the vnode as the target of a hard link.
- */
-#define KAUTH_VNODE_LINKTARGET                  (1U<<25)
-
-/*
- * Indicates that other steps have been taken to authorise the action,
- * but authorisation should be denied for immutable objects.
- */
-#define KAUTH_VNODE_CHECKIMMUTABLE              (1U<<26)
-
-/* Action modifiers */
-/*
- * The KAUTH_VNODE_ACCESS bit is passed to the callback if the authorisation
- * request in progress is advisory, rather than authoritative.  Listeners
- * performing consequential work (i.e. not strictly checking authorisation)
- * may test this flag to avoid performing unnecessary work.
- *
- * This bit will never be present in an ACE.
- */
-#define KAUTH_VNODE_ACCESS                      (1U<<31)
-
-/*
- * The KAUTH_VNODE_NOIMMUTABLE bit is passed to the callback along with the
- * KAUTH_VNODE_WRITE_SECURITY bit (and no others) to indicate that the
- * caller wishes to change one or more of the immutable flags, and the
- * state of these flags should not be considered when authorizing the request.
- * The system immutable flags are only ignored when the system securelevel
- * is low enough to allow their removal.
- */
-#define KAUTH_VNODE_NOIMMUTABLE                 (1U<<30)
-
-
-/*
- * fake right that is composed by the following...
- * vnode must have search for owner, group and world allowed
- * plus there must be no deny modes present for SEARCH... this fake
- * right is used by the fast lookup path to avoid checking
- * for an exact match on the last credential to lookup
- * the component being acted on
- */
-#define KAUTH_VNODE_SEARCHBYANYONE              (1U<<29)
-
-
-/*
- * when passed as an 'action' to "vnode_uncache_authorized_actions"
- * it indicates that all of the cached authorizations for that
- * vnode should be invalidated
- */
-#define KAUTH_INVALIDATE_CACHED_RIGHTS          ((kauth_action_t)~0)
-
-
-
-/* The expansions of the GENERIC bits at evaluation time */
-#define KAUTH_VNODE_GENERIC_READ_BITS   (KAUTH_VNODE_READ_DATA |                \
-	                                KAUTH_VNODE_READ_ATTRIBUTES |           \
-	                                KAUTH_VNODE_READ_EXTATTRIBUTES |        \
-	                                KAUTH_VNODE_READ_SECURITY)
-
-#define KAUTH_VNODE_GENERIC_WRITE_BITS  (KAUTH_VNODE_WRITE_DATA |               \
-	                                KAUTH_VNODE_APPEND_DATA |               \
-	                                KAUTH_VNODE_DELETE |                    \
-	                                KAUTH_VNODE_DELETE_CHILD |              \
-	                                KAUTH_VNODE_WRITE_ATTRIBUTES |          \
-	                                KAUTH_VNODE_WRITE_EXTATTRIBUTES |       \
-	                                KAUTH_VNODE_WRITE_SECURITY)
-
-#define KAUTH_VNODE_GENERIC_EXECUTE_BITS (KAUTH_VNODE_EXECUTE)
-
-#define KAUTH_VNODE_GENERIC_ALL_BITS    (KAUTH_VNODE_GENERIC_READ_BITS |        \
-	                                KAUTH_VNODE_GENERIC_WRITE_BITS |        \
-	                                KAUTH_VNODE_GENERIC_EXECUTE_BITS)
-
-/*
- * Some sets of bits, defined here for convenience.
- */
-#define KAUTH_VNODE_WRITE_RIGHTS        (KAUTH_VNODE_ADD_FILE |                         \
-	                                KAUTH_VNODE_ADD_SUBDIRECTORY |                  \
-	                                KAUTH_VNODE_DELETE_CHILD |                      \
-	                                KAUTH_VNODE_WRITE_DATA |                        \
-	                                KAUTH_VNODE_APPEND_DATA |                       \
-	                                KAUTH_VNODE_DELETE |                            \
-	                                KAUTH_VNODE_WRITE_ATTRIBUTES |                  \
-	                                KAUTH_VNODE_WRITE_EXTATTRIBUTES |               \
-	                                KAUTH_VNODE_WRITE_SECURITY |                    \
-	                                KAUTH_VNODE_TAKE_OWNERSHIP |                    \
-	                                KAUTH_VNODE_LINKTARGET |                        \
-	                                KAUTH_VNODE_CHECKIMMUTABLE)
-
-
-#endif /* KERNEL || <sys/acl.h> */
-
-
-#endif /* __APPLE_API_EVOLVING */
-#endif /* _SYS_KAUTH_H */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/sys/kern_control.h b/lib/libc/include/x86_64-macos-gnu/sys/kern_control.h
deleted file mode 100644
index be74e7d09e..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/sys/kern_control.h
+++ /dev/null
@@ -1,151 +0,0 @@
-/*
- * Copyright (c) 2000-2004, 2012-2016 Apple Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-/*!
- *       @header kern_control.h
- *       This header defines an API to communicate between a kernel
- *       extension and a process outside of the kernel.
- */
-
-#ifndef KPI_KERN_CONTROL_H
-#define KPI_KERN_CONTROL_H
-
-
-#include <sys/appleapiopts.h>
-#include <sys/_types/_u_char.h>
-#include <sys/_types/_u_int16_t.h>
-#include <sys/_types/_u_int32_t.h>
-
-/*
- * Define Controller event subclass, and associated events.
- * Subclass of KEV_SYSTEM_CLASS
- */
-
-/*!
- *       @defined KEV_CTL_SUBCLASS
- *   @discussion The kernel event subclass for kernel control events.
- */
-#define KEV_CTL_SUBCLASS        2
-
-/*!
- *       @defined KEV_CTL_REGISTERED
- *   @discussion The event code indicating a new controller was
- *       registered. The data portion will contain a ctl_event_data.
- */
-#define KEV_CTL_REGISTERED      1       /* a new controller appears */
-
-/*!
- *       @defined KEV_CTL_DEREGISTERED
- *   @discussion The event code indicating a controller was unregistered.
- *       The data portion will contain a ctl_event_data.
- */
-#define KEV_CTL_DEREGISTERED    2       /* a controller disappears */
-
-/*!
- *       @struct ctl_event_data
- *       @discussion This structure is used for KEV_CTL_SUBCLASS kernel
- *               events.
- *       @field ctl_id The kernel control id.
- *       @field ctl_unit The kernel control unit.
- */
-struct ctl_event_data {
-	u_int32_t   ctl_id;             /* Kernel Controller ID */
-	u_int32_t   ctl_unit;
-};
-
-/*
- * Controls destined to the Controller Manager.
- */
-
-/*!
- *       @defined CTLIOCGCOUNT
- *   @discussion The CTLIOCGCOUNT ioctl can be used to determine the
- *       number of kernel controllers registered.
- */
-#define CTLIOCGCOUNT    _IOR('N', 2, int)               /* get number of control structures registered */
-
-/*!
- *       @defined CTLIOCGINFO
- *   @discussion The CTLIOCGINFO ioctl can be used to convert a kernel
- *       control name to a kernel control id.
- */
-#define CTLIOCGINFO     _IOWR('N', 3, struct ctl_info)  /* get id from name */
-
-
-/*!
- *       @defined MAX_KCTL_NAME
- *   @discussion Kernel control names must be no longer than
- *       MAX_KCTL_NAME.
- */
-#define MAX_KCTL_NAME   96
-
-/*
- * Controls destined to the Controller Manager.
- */
-
-/*!
- *       @struct ctl_info
- *       @discussion This structure is used with the CTLIOCGINFO ioctl to
- *               translate from a kernel control name to a control id.
- *       @field ctl_id The kernel control id, filled out upon return.
- *       @field ctl_name The kernel control name to find.
- */
-struct ctl_info {
-	u_int32_t   ctl_id;                             /* Kernel Controller ID  */
-	char        ctl_name[MAX_KCTL_NAME];            /* Kernel Controller Name (a C string) */
-};
-
-
-/*!
- *       @struct sockaddr_ctl
- *       @discussion The controller address structure is used to establish
- *               contact between a user client and a kernel controller. The
- *               sc_id/sc_unit uniquely identify each controller. sc_id is a
- *               unique identifier assigned to the controller. The identifier can
- *               be assigned by the system at registration time or be a 32-bit
- *               creator code obtained from Apple Computer. sc_unit is a unit
- *               number for this sc_id, and is privately used by the kernel
- *               controller to identify several instances of the controller.
- *       @field sc_len The length of the structure.
- *       @field sc_family AF_SYSTEM.
- *       @field ss_sysaddr AF_SYS_KERNCONTROL.
- *       @field sc_id Controller unique identifier.
- *       @field sc_unit Kernel controller private unit number.
- *       @field sc_reserved Reserved, must be set to zero.
- */
-struct sockaddr_ctl {
-	u_char      sc_len;     /* depends on size of bundle ID string */
-	u_char      sc_family;  /* AF_SYSTEM */
-	u_int16_t   ss_sysaddr; /* AF_SYS_KERNCONTROL */
-	u_int32_t   sc_id;      /* Controller unique identifier  */
-	u_int32_t   sc_unit;    /* Developer private unit number */
-	u_int32_t   sc_reserved[5];
-};
-
-
-
-#endif /* KPI_KERN_CONTROL_H */
diff --git a/lib/libc/include/x86_64-macos-gnu/sys/mman.h b/lib/libc/include/x86_64-macos-gnu/sys/mman.h
deleted file mode 100644
index fec1caac71..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/sys/mman.h
+++ /dev/null
@@ -1,250 +0,0 @@
-/*
- * Copyright (c) 2000-2019 Apple Computer, Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-/* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */
-/*-
- * Copyright (c) 1982, 1986, 1993
- *	The Regents of the University of California.  All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *	This product includes software developed by the University of
- *	California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *	@(#)mman.h	8.1 (Berkeley) 6/2/93
- */
-
-/*
- * Currently unsupported:
- *
- * [TYM]	POSIX_TYPED_MEM_ALLOCATE
- * [TYM]	POSIX_TYPED_MEM_ALLOCATE_CONTIG
- * [TYM]	POSIX_TYPED_MEM_MAP_ALLOCATABLE
- * [TYM]	struct posix_typed_mem_info
- * [TYM]	posix_mem_offset()
- * [TYM]	posix_typed_mem_get_info()
- * [TYM]	posix_typed_mem_open()
- */
-
-#ifndef _SYS_MMAN_H_
-#define _SYS_MMAN_H_
-
-#include <sys/appleapiopts.h>
-#include <sys/cdefs.h>
-
-#include <sys/_types.h>
-
-/*
- * [various] The mode_t, off_t, and size_t types shall be defined as
- * described in <sys/types.h>
- */
-#include <sys/_types/_mode_t.h>
-#include <sys/_types/_off_t.h>
-#include <sys/_types/_size_t.h>
-
-/*
- * Protections are chosen from these bits, or-ed together
- */
-#define PROT_NONE       0x00    /* [MC2] no permissions */
-#define PROT_READ       0x01    /* [MC2] pages can be read */
-#define PROT_WRITE      0x02    /* [MC2] pages can be written */
-#define PROT_EXEC       0x04    /* [MC2] pages can be executed */
-
-/*
- * Flags contain sharing type and options.
- * Sharing types; choose one.
- */
-#define MAP_SHARED      0x0001          /* [MF|SHM] share changes */
-#define MAP_PRIVATE     0x0002          /* [MF|SHM] changes are private */
-#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-#define MAP_COPY        MAP_PRIVATE     /* Obsolete */
-#endif  /* (!_POSIX_C_SOURCE || _DARWIN_C_SOURCE) */
-
-/*
- * Other flags
- */
-#define MAP_FIXED        0x0010 /* [MF|SHM] interpret addr exactly */
-#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-#define MAP_RENAME       0x0020 /* Sun: rename private pages to file */
-#define MAP_NORESERVE    0x0040 /* Sun: don't reserve needed swap area */
-#define MAP_RESERVED0080 0x0080 /* previously unimplemented MAP_INHERIT */
-#define MAP_NOEXTEND     0x0100 /* for MAP_FILE, don't change file size */
-#define MAP_HASSEMAPHORE 0x0200 /* region may contain semaphores */
-#define MAP_NOCACHE      0x0400 /* don't cache pages for this mapping */
-#define MAP_JIT          0x0800 /* Allocate a region that will be used for JIT purposes */
-
-/*
- * Mapping type
- */
-#define MAP_FILE        0x0000  /* map from file (default) */
-#define MAP_ANON        0x1000  /* allocated from memory, swap space */
-#define MAP_ANONYMOUS   MAP_ANON
-
-/*
- * The MAP_RESILIENT_* flags can be used when the caller wants to map some
- * possibly unreliable memory and be able to access it safely, possibly
- * getting the wrong contents rather than raising any exception.
- * For safety reasons, such mappings have to be read-only (PROT_READ access
- * only).
- *
- * MAP_RESILIENT_CODESIGN:
- *      accessing this mapping will not generate code-signing violations,
- *	even if the contents are tainted.
- * MAP_RESILIENT_MEDIA:
- *	accessing this mapping will not generate an exception if the contents
- *	are not available (unreachable removable or remote media, access beyond
- *	end-of-file, ...).  Missing contents will be replaced with zeroes.
- */
-#define MAP_RESILIENT_CODESIGN  0x2000 /* no code-signing failures */
-#define MAP_RESILIENT_MEDIA     0x4000 /* no backing-store failures */
-
-#if !defined(CONFIG_EMBEDDED)
-#define MAP_32BIT       0x8000          /* Return virtual addresses <4G only: Requires entitlement */
-#endif  /* !defined(CONFIG_EMBEDDED) */
-
-#endif  /* (!_POSIX_C_SOURCE || _DARWIN_C_SOURCE) */
-
-/*
- * Process memory locking
- */
-#define MCL_CURRENT     0x0001  /* [ML] Lock only current memory */
-#define MCL_FUTURE      0x0002  /* [ML] Lock all future memory as well */
-
-/*
- * Error return from mmap()
- */
-#define MAP_FAILED      ((void *)-1)    /* [MF|SHM] mmap failed */
-
-/*
- * msync() flags
- */
-#define MS_ASYNC        0x0001  /* [MF|SIO] return immediately */
-#define MS_INVALIDATE   0x0002  /* [MF|SIO] invalidate all cached data */
-#define MS_SYNC         0x0010  /* [MF|SIO] msync synchronously */
-
-#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-#define MS_KILLPAGES    0x0004  /* invalidate pages, leave mapped */
-#define MS_DEACTIVATE   0x0008  /* deactivate pages, leave mapped */
-
-#endif  /* (!_POSIX_C_SOURCE || _DARWIN_C_SOURCE) */
-
-
-/*
- * Advice to madvise
- */
-#define POSIX_MADV_NORMAL       0       /* [MC1] no further special treatment */
-#define POSIX_MADV_RANDOM       1       /* [MC1] expect random page refs */
-#define POSIX_MADV_SEQUENTIAL   2       /* [MC1] expect sequential page refs */
-#define POSIX_MADV_WILLNEED     3       /* [MC1] will need these pages */
-#define POSIX_MADV_DONTNEED     4       /* [MC1] dont need these pages */
-
-#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-#define MADV_NORMAL             POSIX_MADV_NORMAL
-#define MADV_RANDOM             POSIX_MADV_RANDOM
-#define MADV_SEQUENTIAL         POSIX_MADV_SEQUENTIAL
-#define MADV_WILLNEED           POSIX_MADV_WILLNEED
-#define MADV_DONTNEED           POSIX_MADV_DONTNEED
-#define MADV_FREE               5       /* pages unneeded, discard contents */
-#define MADV_ZERO_WIRED_PAGES   6       /* zero the wired pages that have not been unwired before the entry is deleted */
-#define MADV_FREE_REUSABLE      7       /* pages can be reused (by anyone) */
-#define MADV_FREE_REUSE         8       /* caller wants to reuse those pages */
-#define MADV_CAN_REUSE          9
-#define MADV_PAGEOUT            10      /* page out now (internal only) */
-
-/*
- * Return bits from mincore
- */
-#define MINCORE_INCORE           0x1     /* Page is incore */
-#define MINCORE_REFERENCED       0x2     /* Page has been referenced by us */
-#define MINCORE_MODIFIED         0x4     /* Page has been modified by us */
-#define MINCORE_REFERENCED_OTHER 0x8     /* Page has been referenced */
-#define MINCORE_MODIFIED_OTHER  0x10     /* Page has been modified */
-#define MINCORE_PAGED_OUT       0x20     /* Page has been paged out */
-#define MINCORE_COPIED          0x40     /* Page has been copied */
-#define MINCORE_ANONYMOUS       0x80     /* Page belongs to an anonymous object */
-#endif  /* (!_POSIX_C_SOURCE || _DARWIN_C_SOURCE) */
-
-
-
-__BEGIN_DECLS
-/* [ML] */
-int     mlockall(int);
-int     munlockall(void);
-/* [MR] */
-int     mlock(const void *, size_t);
-#ifndef _MMAP
-#define _MMAP
-/* [MC3]*/
-void *  mmap(void *, size_t, int, int, int, off_t) __DARWIN_ALIAS(mmap);
-#endif
-/* [MPR] */
-int     mprotect(void *, size_t, int) __DARWIN_ALIAS(mprotect);
-/* [MF|SIO] */
-int     msync(void *, size_t, int) __DARWIN_ALIAS_C(msync);
-/* [MR] */
-int     munlock(const void *, size_t);
-/* [MC3]*/
-int     munmap(void *, size_t) __DARWIN_ALIAS(munmap);
-/* [SHM] */
-int     shm_open(const char *, int, ...);
-int     shm_unlink(const char *);
-/* [ADV] */
-int     posix_madvise(void *, size_t, int);
-
-#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-int     madvise(void *, size_t, int);
-int     mincore(const void *, size_t, char *);
-int     minherit(void *, size_t, int);
-#endif
-
-
-__END_DECLS
-
-#endif /* !_SYS_MMAN_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/sys/mount.h b/lib/libc/include/x86_64-macos-gnu/sys/mount.h
deleted file mode 100644
index 0a77b455a6..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/sys/mount.h
+++ /dev/null
@@ -1,423 +0,0 @@
-/*
- * Copyright (c) 2000-2018 Apple Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-/* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */
-/*
- * Copyright (c) 1989, 1991, 1993
- *	The Regents of the University of California.  All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *	This product includes software developed by the University of
- *	California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *	@(#)mount.h	8.21 (Berkeley) 5/20/95
- */
-/*
- * NOTICE: This file was modified by SPARTA, Inc. in 2005 to introduce
- * support for mandatory and extensible security protections.  This notice
- * is included in support of clause 2.2 (b) of the Apple Public License,
- * Version 2.0.
- */
-
-
-#ifndef _SYS_MOUNT_H_
-#define _SYS_MOUNT_H_
-
-#include <sys/appleapiopts.h>
-#include <sys/cdefs.h>
-#include <sys/attr.h>           /* needed for vol_capabilities_attr_t */
-#include <os/base.h>
-
-#include <stdint.h>
-#include <sys/ucred.h>
-#include <sys/queue.h>          /* XXX needed for user builds */
-#include <Availability.h>
-
-#include <sys/_types/_fsid_t.h> /* file system id type */
-
-/*
- * file system statistics
- */
-
-#define MFSNAMELEN      15      /* length of fs type name, not inc. null */
-#define MFSTYPENAMELEN  16      /* length of fs type name including null */
-
-#if __DARWIN_64_BIT_INO_T
-#define MNAMELEN        MAXPATHLEN      /* length of buffer for returned name */
-#else /* ! __DARWIN_64_BIT_INO_T */
-#define MNAMELEN        90              /* length of buffer for returned name */
-#endif /* __DARWIN_64_BIT_INO_T */
-
-#define MNT_EXT_ROOT_DATA_VOL      0x00000001      /* Data volume of root volume group */
-
-#define __DARWIN_STRUCT_STATFS64 { \
-	uint32_t	f_bsize;        /* fundamental file system block size */ \
-	int32_t		f_iosize;       /* optimal transfer block size */ \
-	uint64_t	f_blocks;       /* total data blocks in file system */ \
-	uint64_t	f_bfree;        /* free blocks in fs */ \
-	uint64_t	f_bavail;       /* free blocks avail to non-superuser */ \
-	uint64_t	f_files;        /* total file nodes in file system */ \
-	uint64_t	f_ffree;        /* free file nodes in fs */ \
-	fsid_t		f_fsid;         /* file system id */ \
-	uid_t		f_owner;        /* user that mounted the filesystem */ \
-	uint32_t	f_type;         /* type of filesystem */ \
-	uint32_t	f_flags;        /* copy of mount exported flags */ \
-	uint32_t	f_fssubtype;    /* fs sub-type (flavor) */ \
-	char		f_fstypename[MFSTYPENAMELEN];   /* fs type name */ \
-	char		f_mntonname[MAXPATHLEN];        /* directory on which mounted */ \
-	char		f_mntfromname[MAXPATHLEN];      /* mounted filesystem */ \
-	uint32_t    f_flags_ext;    /* extended flags */ \
-	uint32_t	f_reserved[7];  /* For future use */ \
-}
-
-#if !__DARWIN_ONLY_64_BIT_INO_T
-
-struct statfs64 __DARWIN_STRUCT_STATFS64;
-
-#endif /* !__DARWIN_ONLY_64_BIT_INO_T */
-
-#if __DARWIN_64_BIT_INO_T
-
-struct statfs __DARWIN_STRUCT_STATFS64;
-
-#else /* !__DARWIN_64_BIT_INO_T */
-
-/*
- * LP64 - WARNING - must be kept in sync with struct user_statfs in mount_internal.h.
- */
-struct statfs {
-	short   f_otype;                /* TEMPORARY SHADOW COPY OF f_type */
-	short   f_oflags;               /* TEMPORARY SHADOW COPY OF f_flags */
-	long    f_bsize;                /* fundamental file system block size */
-	long    f_iosize;               /* optimal transfer block size */
-	long    f_blocks;               /* total data blocks in file system */
-	long    f_bfree;                /* free blocks in fs */
-	long    f_bavail;               /* free blocks avail to non-superuser */
-	long    f_files;                /* total file nodes in file system */
-	long    f_ffree;                /* free file nodes in fs */
-	fsid_t  f_fsid;                 /* file system id */
-	uid_t   f_owner;                /* user that mounted the filesystem */
-	short   f_reserved1;    /* spare for later */
-	short   f_type;                 /* type of filesystem */
-	long    f_flags;                /* copy of mount exported flags */
-	long    f_reserved2[2]; /* reserved for future use */
-	char    f_fstypename[MFSNAMELEN]; /* fs type name */
-	char    f_mntonname[MNAMELEN];  /* directory on which mounted */
-	char    f_mntfromname[MNAMELEN];/* mounted filesystem */
-	char    f_reserved3;    /* For alignment */
-	long    f_reserved4[4]; /* For future use */
-};
-
-#endif /* __DARWIN_64_BIT_INO_T */
-
-#pragma pack(4)
-
-struct vfsstatfs {
-	uint32_t        f_bsize;        /* fundamental file system block size */
-	size_t          f_iosize;       /* optimal transfer block size */
-	uint64_t        f_blocks;       /* total data blocks in file system */
-	uint64_t        f_bfree;        /* free blocks in fs */
-	uint64_t        f_bavail;       /* free blocks avail to non-superuser */
-	uint64_t        f_bused;        /* free blocks avail to non-superuser */
-	uint64_t        f_files;        /* total file nodes in file system */
-	uint64_t        f_ffree;        /* free file nodes in fs */
-	fsid_t          f_fsid;         /* file system id */
-	uid_t           f_owner;        /* user that mounted the filesystem */
-	uint64_t        f_flags;        /* copy of mount exported flags */
-	char            f_fstypename[MFSTYPENAMELEN];/* fs type name inclus */
-	char            f_mntonname[MAXPATHLEN];/* directory on which mounted */
-	char            f_mntfromname[MAXPATHLEN];/* mounted filesystem */
-	uint32_t        f_fssubtype;     /* fs sub-type (flavor) */
-	void            *f_reserved[2];         /* For future use == 0 */
-};
-
-#pragma pack()
-
-
-/*
- * User specifiable flags.
- *
- * Unmount uses MNT_FORCE flag.
- */
-#define MNT_RDONLY      0x00000001      /* read only filesystem */
-#define MNT_SYNCHRONOUS 0x00000002      /* file system written synchronously */
-#define MNT_NOEXEC      0x00000004      /* can't exec from filesystem */
-#define MNT_NOSUID      0x00000008      /* don't honor setuid bits on fs */
-#define MNT_NODEV       0x00000010      /* don't interpret special files */
-#define MNT_UNION       0x00000020      /* union with underlying filesystem */
-#define MNT_ASYNC       0x00000040      /* file system written asynchronously */
-#define MNT_CPROTECT    0x00000080      /* file system supports content protection */
-
-/*
- * NFS export related mount flags.
- */
-#define MNT_EXPORTED    0x00000100      /* file system is exported */
-
-/*
- * Denotes storage which can be removed from the system by the user.
- */
-
-#define MNT_REMOVABLE   0x00000200
-
-/*
- * MAC labeled / "quarantined" flag
- */
-#define MNT_QUARANTINE  0x00000400      /* file system is quarantined */
-
-/*
- * Flags set by internal operations.
- */
-#define MNT_LOCAL       0x00001000      /* filesystem is stored locally */
-#define MNT_QUOTA       0x00002000      /* quotas are enabled on filesystem */
-#define MNT_ROOTFS      0x00004000      /* identifies the root filesystem */
-#define MNT_DOVOLFS     0x00008000      /* FS supports volfs (deprecated flag in Mac OS X 10.5) */
-
-
-#define MNT_DONTBROWSE  0x00100000      /* file system is not appropriate path to user data */
-#define MNT_IGNORE_OWNERSHIP 0x00200000 /* VFS will ignore ownership information on filesystem objects */
-#define MNT_AUTOMOUNTED 0x00400000      /* filesystem was mounted by automounter */
-#define MNT_JOURNALED   0x00800000      /* filesystem is journaled */
-#define MNT_NOUSERXATTR 0x01000000      /* Don't allow user extended attributes */
-#define MNT_DEFWRITE    0x02000000      /* filesystem should defer writes */
-#define MNT_MULTILABEL  0x04000000      /* MAC support for individual labels */
-#define MNT_NOATIME             0x10000000      /* disable update of file access time */
-#define MNT_SNAPSHOT    0x40000000 /* The mount is a snapshot */
-#define MNT_STRICTATIME 0x80000000      /* enable strict update of file access time */
-
-/* backwards compatibility only */
-#define MNT_UNKNOWNPERMISSIONS MNT_IGNORE_OWNERSHIP
-
-
-/*
- * XXX I think that this could now become (~(MNT_CMDFLAGS))
- * but the 'mount' program may need changing to handle this.
- */
-#define MNT_VISFLAGMASK (MNT_RDONLY	| MNT_SYNCHRONOUS | MNT_NOEXEC	| \
-	                MNT_NOSUID	| MNT_NODEV	| MNT_UNION	| \
-	                MNT_ASYNC	| MNT_EXPORTED	| MNT_QUARANTINE | \
-	                MNT_LOCAL	| MNT_QUOTA | MNT_REMOVABLE | \
-	                MNT_ROOTFS	| MNT_DOVOLFS	| MNT_DONTBROWSE | \
-	                MNT_IGNORE_OWNERSHIP | MNT_AUTOMOUNTED | MNT_JOURNALED | \
-	                MNT_NOUSERXATTR | MNT_DEFWRITE	| MNT_MULTILABEL | \
-	                MNT_NOATIME | MNT_STRICTATIME | MNT_SNAPSHOT | MNT_CPROTECT)
-/*
- * External filesystem command modifier flags.
- * Unmount can use the MNT_FORCE flag.
- * XXX These are not STATES and really should be somewhere else.
- * External filesystem control flags.
- */
-#define MNT_UPDATE      0x00010000      /* not a real mount, just an update */
-#define MNT_NOBLOCK     0x00020000      /* don't block unmount if not responding */
-#define MNT_RELOAD      0x00040000      /* reload filesystem data */
-#define MNT_FORCE       0x00080000      /* force unmount or readonly change */
-#define MNT_CMDFLAGS    (MNT_UPDATE|MNT_NOBLOCK|MNT_RELOAD|MNT_FORCE)
-
-
-
-/*
- * Sysctl CTL_VFS definitions.
- *
- * Second level identifier specifies which filesystem. Second level
- * identifier VFS_GENERIC returns information about all filesystems.
- */
-#define VFS_GENERIC             0       /* generic filesystem information */
-#define VFS_NUMMNTOPS           1       /* int: total num of vfs mount/unmount operations */
-/*
- * Third level identifiers for VFS_GENERIC are given below; third
- * level identifiers for specific filesystems are given in their
- * mount specific header files.
- */
-#define VFS_MAXTYPENUM  1       /* int: highest defined filesystem type */
-#define VFS_CONF        2       /* struct: vfsconf for filesystem given
-	                         *  as next argument */
-
-/*
- * Flags for various system call interfaces.
- *
- * waitfor flags to vfs_sync() and getfsstat()
- */
-#define MNT_WAIT        1       /* synchronized I/O file integrity completion */
-#define MNT_NOWAIT      2       /* start all I/O, but do not wait for it */
-#define MNT_DWAIT       4       /* synchronized I/O data integrity completion */
-
-
-#if !defined(KERNEL) && !defined(_KERN_SYS_KERNELTYPES_H_) /* also defined in kernel_types.h */
-struct mount;
-typedef struct mount * mount_t;
-struct vnode;
-typedef struct vnode * vnode_t;
-#endif
-
-/* Reserved fields preserve binary compatibility */
-struct vfsconf {
-	uint32_t vfc_reserved1;         /* opaque */
-	char    vfc_name[MFSNAMELEN];   /* filesystem type name */
-	int     vfc_typenum;            /* historic filesystem type number */
-	int     vfc_refcount;           /* number mounted of this type */
-	int     vfc_flags;              /* permanent flags */
-	uint32_t vfc_reserved2;         /* opaque */
-	uint32_t vfc_reserved3;         /* opaque */
-};
-
-struct vfsidctl {
-	int             vc_vers;        /* should be VFSIDCTL_VERS1 (below) */
-	fsid_t          vc_fsid;        /* fsid to operate on. */
-	void            *vc_ptr;        /* pointer to data structure. */
-	size_t          vc_len;         /* sizeof said structure. */
-	u_int32_t       vc_spare[12];   /* spare (must be zero). */
-};
-
-
-/* vfsidctl API version. */
-#define VFS_CTL_VERS1   0x01
-
-
-/*
- * New style VFS sysctls, do not reuse/conflict with the namespace for
- * private sysctls.
- */
-#define VFS_CTL_STATFS  0x00010001      /* statfs */
-#define VFS_CTL_UMOUNT  0x00010002      /* unmount */
-#define VFS_CTL_QUERY   0x00010003      /* anything wrong? (vfsquery) */
-#define VFS_CTL_NEWADDR 0x00010004      /* reconnect to new address */
-#define VFS_CTL_TIMEO   0x00010005      /* set timeout for vfs notification */
-#define VFS_CTL_NOLOCKS 0x00010006      /* disable file locking */
-#define VFS_CTL_SADDR   0x00010007      /* get server address */
-#define VFS_CTL_DISC    0x00010008      /* server disconnected */
-#define VFS_CTL_SERVERINFO  0x00010009  /* information about fs server */
-#define VFS_CTL_NSTATUS 0x0001000A      /* netfs mount status */
-
-struct vfsquery {
-	u_int32_t       vq_flags;
-	u_int32_t       vq_spare[31];
-};
-
-struct vfs_server {
-	int32_t  vs_minutes;                    /* minutes until server goes down. */
-	u_int8_t vs_server_name[MAXHOSTNAMELEN * 3]; /* UTF8 server name to display (null terminated) */
-};
-
-/*
- * NetFS mount status - returned by VFS_CTL_NSTATUS
- */
-struct netfs_status {
-	u_int32_t       ns_status;              // Current status of mount (vfsquery flags)
-	char            ns_mountopts[512];      // Significant mount options
-	uint32_t        ns_waittime;            // Time waiting for reply (sec)
-	uint32_t        ns_threadcount;         // Number of threads blocked on network calls
-	uint64_t        ns_threadids[0];        // Thread IDs of those blocked threads
-};
-
-/* vfsquery flags */
-#define VQ_NOTRESP      0x0001  /* server down */
-#define VQ_NEEDAUTH     0x0002  /* server bad auth */
-#define VQ_LOWDISK      0x0004  /* we're low on space */
-#define VQ_MOUNT        0x0008  /* new filesystem arrived */
-#define VQ_UNMOUNT      0x0010  /* filesystem has left */
-#define VQ_DEAD         0x0020  /* filesystem is dead, needs force unmount */
-#define VQ_ASSIST       0x0040  /* filesystem needs assistance from external program */
-#define VQ_NOTRESPLOCK  0x0080  /* server lockd down */
-#define VQ_UPDATE       0x0100  /* filesystem information has changed */
-#define VQ_VERYLOWDISK  0x0200  /* file system has *very* little disk space left */
-#define VQ_SYNCEVENT    0x0400  /* a sync just happened (not set by kernel starting Mac OS X 10.9) */
-#define VQ_SERVEREVENT  0x0800  /* server issued notification/warning */
-#define VQ_QUOTA        0x1000  /* a user quota has been hit */
-#define VQ_NEARLOWDISK          0x2000  /* Above lowdisk and below desired disk space */
-#define VQ_DESIRED_DISK         0x4000  /* the desired disk space */
-#define VQ_FREE_SPACE_CHANGE    0x8000  /* free disk space has significantly changed */
-#define VQ_FLAG10000    0x10000  /* placeholder */
-
-
-
-
-/*
- * Generic file handle
- */
-#define NFS_MAX_FH_SIZE         NFSV4_MAX_FH_SIZE
-#define NFSV4_MAX_FH_SIZE       128
-#define NFSV3_MAX_FH_SIZE       64
-#define NFSV2_MAX_FH_SIZE       32
-struct fhandle {
-	unsigned int    fh_len;                         /* length of file handle */
-	unsigned char   fh_data[NFS_MAX_FH_SIZE];       /* file handle value */
-};
-typedef struct fhandle  fhandle_t;
-
-
-__BEGIN_DECLS
-int     fhopen(const struct fhandle *, int);
-int     fstatfs(int, struct statfs *) __DARWIN_INODE64(fstatfs);
-#if !__DARWIN_ONLY_64_BIT_INO_T
-int     fstatfs64(int, struct statfs64 *) __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_5, __MAC_10_6, __IPHONE_NA, __IPHONE_NA);
-#endif /* !__DARWIN_ONLY_64_BIT_INO_T */
-int     getfh(const char *, fhandle_t *);
-int     getfsstat(struct statfs *, int, int) __DARWIN_INODE64(getfsstat);
-#if !__DARWIN_ONLY_64_BIT_INO_T
-int     getfsstat64(struct statfs64 *, int, int) __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_5, __MAC_10_6, __IPHONE_NA, __IPHONE_NA);
-#endif /* !__DARWIN_ONLY_64_BIT_INO_T */
-int     getmntinfo(struct statfs **, int) __DARWIN_INODE64(getmntinfo);
-int     getmntinfo_r_np(struct statfs **, int) __DARWIN_INODE64(getmntinfo_r_np)
-__OSX_AVAILABLE(10.13) __IOS_AVAILABLE(11.0)
-__TVOS_AVAILABLE(11.0) __WATCHOS_AVAILABLE(4.0);
-#if !__DARWIN_ONLY_64_BIT_INO_T
-int     getmntinfo64(struct statfs64 **, int) __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_5, __MAC_10_6, __IPHONE_NA, __IPHONE_NA);
-#endif /* !__DARWIN_ONLY_64_BIT_INO_T */
-int     mount(const char *, const char *, int, void *);
-int     fmount(const char *, int, int, void *) __OSX_AVAILABLE(10.13) __IOS_AVAILABLE(11.0) __TVOS_AVAILABLE(11.0) __WATCHOS_AVAILABLE(4.0);
-int     statfs(const char *, struct statfs *) __DARWIN_INODE64(statfs);
-#if !__DARWIN_ONLY_64_BIT_INO_T
-int     statfs64(const char *, struct statfs64 *) __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_5, __MAC_10_6, __IPHONE_NA, __IPHONE_NA);
-#endif /* !__DARWIN_ONLY_64_BIT_INO_T */
-int     unmount(const char *, int);
-int     getvfsbyname(const char *, struct vfsconf *);
-__END_DECLS
-
-#endif /* !_SYS_MOUNT_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/sys/param.h b/lib/libc/include/x86_64-macos-gnu/sys/param.h
deleted file mode 100644
index 88330ebbe7..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/sys/param.h
+++ /dev/null
@@ -1,253 +0,0 @@
-/*
- * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-/* Copyright (c) 1995, 1997 Apple Computer, Inc. All Rights Reserved */
-/*-
- * Copyright (c) 1982, 1986, 1989, 1993
- *	The Regents of the University of California.  All rights reserved.
- * (c) UNIX System Laboratories, Inc.
- * All or some portions of this file are derived from material licensed
- * to the University of California by American Telephone and Telegraph
- * Co. or Unix System Laboratories, Inc. and are reproduced herein with
- * the permission of UNIX System Laboratories, Inc.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *	This product includes software developed by the University of
- *	California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *	@(#)param.h	8.3 (Berkeley) 4/4/95
- */
-
-#ifndef _SYS_PARAM_H_
-#define _SYS_PARAM_H_
-
-#define BSD     199506          /* System version (year & month). */
-#define BSD4_3  1
-#define BSD4_4  1
-
-#define NeXTBSD 1995064         /* NeXTBSD version (year, month, release) */
-#define NeXTBSD4_0 0            /* NeXTBSD 4.0 */
-
-#include <sys/_types.h>
-#include <sys/_types/_null.h>
-
-#ifndef LOCORE
-#include <sys/types.h>
-#endif
-
-/*
- * Machine-independent constants (some used in following include files).
- * Redefined constants are from POSIX 1003.1 limits file.
- *
- * MAXCOMLEN should be >= sizeof(ac_comm) (see <acct.h>)
- * MAXLOGNAME should be >= UT_NAMESIZE (see <utmp.h>)
- */
-#include <sys/syslimits.h>
-
-#define MAXCOMLEN       16              /* max command name remembered */
-#define MAXINTERP       64              /* max interpreter file name length */
-#define MAXLOGNAME      255             /* max login name length */
-#define MAXUPRC         CHILD_MAX       /* max simultaneous processes */
-#define NCARGS          ARG_MAX         /* max bytes for an exec function */
-#define NGROUPS         NGROUPS_MAX     /* max number groups */
-#define NOFILE          256             /* default max open files per process */
-#define NOGROUP         65535           /* marker for empty group set member */
-#define MAXHOSTNAMELEN  256             /* max hostname size */
-#define MAXDOMNAMELEN   256             /* maximum domain name length */
-
-/* Machine type dependent parameters. */
-#include <machine/param.h>
-
-/* More types and definitions used throughout the kernel. */
-#include <limits.h>
-
-/* Signals. */
-#include <sys/signal.h>
-
-/*
- * Priorities.  Note that with 32 run queues, differences less than 4 are
- * insignificant.
- */
-#define PSWP    0
-#define PVM     4
-#define PINOD   8
-#define PRIBIO  16
-#define PVFS    20
-#define PZERO   22              /* No longer magic, shouldn't be here.  XXX */
-#define PSOCK   24
-#define PWAIT   32
-#define PLOCK   36
-#define PPAUSE  40
-#define PUSER   50
-#define MAXPRI  127             /* Priorities range from 0 through MAXPRI. */
-
-#define PRIMASK 0x0ff
-#define PCATCH  0x100           /* OR'd with pri for tsleep to check signals */
-#define PTTYBLOCK 0x200         /* for tty SIGTTOU and SIGTTIN blocking */
-#define PDROP   0x400           /* OR'd with pri to stop re-aquistion of mutex upon wakeup */
-#define PSPIN   0x800           /* OR'd with pri to require mutex in spin mode upon wakeup */
-
-#define NBPW    sizeof(int)     /* number of bytes per word (integer) */
-
-#define CMASK   022             /* default file mask: S_IWGRP|S_IWOTH */
-#define NODEV   (dev_t)(-1)     /* non-existent device */
-
-/*
- * Clustering of hardware pages on machines with ridiculously small
- * page sizes is done here.  The paging subsystem deals with units of
- * CLSIZE pte's describing NBPG (from machine/param.h) pages each.
- */
-#define CLBYTES         (CLSIZE*NBPG)
-#define CLOFSET         (CLSIZE*NBPG-1) /* for clusters, like PGOFSET */
-#define claligned(x)    ((((int)(x))&CLOFSET)==0)
-#define CLOFF           CLOFSET
-#define CLSHIFT         (PGSHIFT+CLSIZELOG2)
-
-#if CLSIZE == 1
-#define clbase(i)       (i)
-#define clrnd(i)        (i)
-#else
-/* Give the base virtual address (first of CLSIZE). */
-#define clbase(i)       ((i) &~ (CLSIZE-1))
-/* Round a number of clicks up to a whole cluster. */
-#define clrnd(i)        (((i) + (CLSIZE-1)) &~ (CLSIZE-1))
-#endif
-
-#define CBLOCK  64              /* Clist block size, must be a power of 2. */
-#define CBQSIZE (CBLOCK/NBBY)   /* Quote bytes/cblock - can do better. */
-                                /* Data chars/clist. */
-#define CBSIZE  (CBLOCK - sizeof(struct cblock *) - CBQSIZE)
-#define CROUND  (CBLOCK - 1)    /* Clist rounding. */
-
-/*
- * File system parameters and macros.
- *
- * The file system is made out of blocks of at most MAXPHYS units, with
- * smaller units (fragments) only in the last direct block.  MAXBSIZE
- * primarily determines the size of buffers in the buffer pool.  It may be
- * made larger than MAXPHYS without any effect on existing file systems;
- * however making it smaller may make some file systems unmountable.
- * We set this to track the value of MAX_UPL_TRANSFER_BYTES from
- * osfmk/mach/memory_object_types.h to bound it at the maximum UPL size.
- */
-#define MAXBSIZE        (256 * 4096)
-#define MAXPHYSIO       MAXPHYS
-#define MAXFRAG         8
-
-#define MAXPHYSIO_WIRED (16 * 1024 * 1024)
-
-/*
- * MAXPATHLEN defines the longest permissable path length after expanding
- * symbolic links. It is used to allocate a temporary buffer from the buffer
- * pool in which to do the name expansion, hence should be a power of two,
- * and must be less than or equal to MAXBSIZE.  MAXSYMLINKS defines the
- * maximum number of symbolic links that may be expanded in a path name.
- * It should be set high enough to allow all legitimate uses, but halt
- * infinite loops reasonably quickly.
- */
-#define MAXPATHLEN      PATH_MAX
-#define MAXSYMLINKS     32
-
-/* Bit map related macros. */
-#define setbit(a, i)     (((char *)(a))[(i)/NBBY] |= 1<<((i)%NBBY))
-#define clrbit(a, i)     (((char *)(a))[(i)/NBBY] &= ~(1<<((i)%NBBY)))
-#define isset(a, i)      (((char *)(a))[(i)/NBBY] & (1<<((i)%NBBY)))
-#define isclr(a, i)      ((((char *)(a))[(i)/NBBY] & (1<<((i)%NBBY))) == 0)
-
-/* Macros for counting and rounding. */
-#ifndef howmany
-#define howmany(x, y)   ((((x) % (y)) == 0) ? ((x) / (y)) : (((x) / (y)) + 1))
-#endif
-#define roundup(x, y)   ((((x) % (y)) == 0) ? \
-	                (x) : ((x) + ((y) - ((x) % (y)))))
-#define powerof2(x)     ((((x)-1)&(x))==0)
-
-/* Macros for min/max. */
-#ifndef MIN
-#define MIN(a, b) (((a)<(b))?(a):(b))
-#endif /* MIN */
-#ifndef MAX
-#define MAX(a, b) (((a)>(b))?(a):(b))
-#endif  /* MAX */
-
-/*
- * Constants for setting the parameters of the kernel memory allocator.
- *
- * 2 ** MINBUCKET is the smallest unit of memory that will be
- * allocated. It must be at least large enough to hold a pointer.
- *
- * Units of memory less or equal to MAXALLOCSAVE will permanently
- * allocate physical memory; requests for these size pieces of
- * memory are quite fast. Allocations greater than MAXALLOCSAVE must
- * always allocate and free physical memory; requests for these
- * size allocations should be done infrequently as they will be slow.
- *
- * Constraints: CLBYTES <= MAXALLOCSAVE <= 2 ** (MINBUCKET + 14), and
- * MAXALLOCSIZE must be a power of two.
- */
-#define MINBUCKET       4               /* 4 => min allocation of 16 bytes */
-#define MAXALLOCSAVE    (2 * CLBYTES)
-
-/*
- * Scale factor for scaled integers used to count %cpu time and load avgs.
- *
- * The number of CPU `tick's that map to a unique `%age' can be expressed
- * by the formula (1 / (2 ^ (FSHIFT - 11))).  The maximum load average that
- * can be calculated (assuming 32 bits) can be closely approximated using
- * the formula (2 ^ (2 * (16 - FSHIFT))) for (FSHIFT < 15).
- *
- * For the scheduler to maintain a 1:1 mapping of CPU `tick' to `%age',
- * FSHIFT must be at least 11; this gives us a maximum load avg of ~1024.
- */
-#define FSHIFT  11              /* bits to right of fixed binary point */
-#define FSCALE  (1<<FSHIFT)
-
-#endif  /* _SYS_PARAM_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/sys/proc.h b/lib/libc/include/x86_64-macos-gnu/sys/proc.h
deleted file mode 100644
index 56d8b874d5..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/sys/proc.h
+++ /dev/null
@@ -1,223 +0,0 @@
-/*
- * Copyright (c) 2000-2018 Apple Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-/* Copyright (c) 1995, 1997 Apple Computer, Inc. All Rights Reserved */
-/*-
- * Copyright (c) 1986, 1989, 1991, 1993
- *	The Regents of the University of California.  All rights reserved.
- * (c) UNIX System Laboratories, Inc.
- * All or some portions of this file are derived from material licensed
- * to the University of California by American Telephone and Telegraph
- * Co. or Unix System Laboratories, Inc. and are reproduced herein with
- * the permission of UNIX System Laboratories, Inc.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *	This product includes software developed by the University of
- *	California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *	@(#)proc.h	8.15 (Berkeley) 5/19/95
- */
-
-#ifndef _SYS_PROC_H_
-#define _SYS_PROC_H_
-
-#include <sys/appleapiopts.h>
-#include <sys/cdefs.h>
-#include <sys/select.h>                 /* For struct selinfo. */
-#include <sys/queue.h>
-#include <sys/lock.h>
-#include <sys/param.h>
-#include <sys/event.h>
-#include <sys/time.h>
-#include <mach/boolean.h>
-
-
-
-struct session;
-struct pgrp;
-struct proc;
-
-/* Exported fields for kern sysctls */
-struct extern_proc {
-	union {
-		struct {
-			struct  proc *__p_forw; /* Doubly-linked run/sleep queue. */
-			struct  proc *__p_back;
-		} p_st1;
-		struct timeval __p_starttime;   /* process start time */
-	} p_un;
-#define p_forw p_un.p_st1.__p_forw
-#define p_back p_un.p_st1.__p_back
-#define p_starttime p_un.__p_starttime
-	struct  vmspace *p_vmspace;     /* Address space. */
-	struct  sigacts *p_sigacts;     /* Signal actions, state (PROC ONLY). */
-	int     p_flag;                 /* P_* flags. */
-	char    p_stat;                 /* S* process status. */
-	pid_t   p_pid;                  /* Process identifier. */
-	pid_t   p_oppid;         /* Save parent pid during ptrace. XXX */
-	int     p_dupfd;         /* Sideways return value from fdopen. XXX */
-	/* Mach related  */
-	caddr_t user_stack;     /* where user stack was allocated */
-	void    *exit_thread;   /* XXX Which thread is exiting? */
-	int             p_debugger;             /* allow to debug */
-	boolean_t       sigwait;        /* indication to suspend */
-	/* scheduling */
-	u_int   p_estcpu;        /* Time averaged value of p_cpticks. */
-	int     p_cpticks;       /* Ticks of cpu time. */
-	fixpt_t p_pctcpu;        /* %cpu for this process during p_swtime */
-	void    *p_wchan;        /* Sleep address. */
-	char    *p_wmesg;        /* Reason for sleep. */
-	u_int   p_swtime;        /* Time swapped in or out. */
-	u_int   p_slptime;       /* Time since last blocked. */
-	struct  itimerval p_realtimer;  /* Alarm timer. */
-	struct  timeval p_rtime;        /* Real time. */
-	u_quad_t p_uticks;              /* Statclock hits in user mode. */
-	u_quad_t p_sticks;              /* Statclock hits in system mode. */
-	u_quad_t p_iticks;              /* Statclock hits processing intr. */
-	int     p_traceflag;            /* Kernel trace points. */
-	struct  vnode *p_tracep;        /* Trace to vnode. */
-	int     p_siglist;              /* DEPRECATED. */
-	struct  vnode *p_textvp;        /* Vnode of executable. */
-	int     p_holdcnt;              /* If non-zero, don't swap. */
-	sigset_t p_sigmask;     /* DEPRECATED. */
-	sigset_t p_sigignore;   /* Signals being ignored. */
-	sigset_t p_sigcatch;    /* Signals being caught by user. */
-	u_char  p_priority;     /* Process priority. */
-	u_char  p_usrpri;       /* User-priority based on p_cpu and p_nice. */
-	char    p_nice;         /* Process "nice" value. */
-	char    p_comm[MAXCOMLEN + 1];
-	struct  pgrp *p_pgrp;   /* Pointer to process group. */
-	struct  user *p_addr;   /* Kernel virtual addr of u-area (PROC ONLY). */
-	u_short p_xstat;        /* Exit status for wait; also stop signal. */
-	u_short p_acflag;       /* Accounting flags. */
-	struct  rusage *p_ru;   /* Exit information. XXX */
-};
-
-
-/* Status values. */
-#define SIDL    1               /* Process being created by fork. */
-#define SRUN    2               /* Currently runnable. */
-#define SSLEEP  3               /* Sleeping on an address. */
-#define SSTOP   4               /* Process debugging or suspension. */
-#define SZOMB   5               /* Awaiting collection by parent. */
-
-/* These flags are kept in extern_proc.p_flag. */
-#define P_ADVLOCK       0x00000001      /* Process may hold POSIX adv. lock */
-#define P_CONTROLT      0x00000002      /* Has a controlling terminal */
-#define P_LP64          0x00000004      /* Process is LP64 */
-#define P_NOCLDSTOP     0x00000008      /* No SIGCHLD when children stop */
-
-#define P_PPWAIT        0x00000010      /* Parent waiting for chld exec/exit */
-#define P_PROFIL        0x00000020      /* Has started profiling */
-#define P_SELECT        0x00000040      /* Selecting; wakeup/waiting danger */
-#define P_CONTINUED     0x00000080      /* Process was stopped and continued */
-
-#define P_SUGID         0x00000100      /* Has set privileges since last exec */
-#define P_SYSTEM        0x00000200      /* Sys proc: no sigs, stats or swap */
-#define P_TIMEOUT       0x00000400      /* Timing out during sleep */
-#define P_TRACED        0x00000800      /* Debugged process being traced */
-
-#define P_DISABLE_ASLR  0x00001000      /* Disable address space layout randomization */
-#define P_WEXIT         0x00002000      /* Working on exiting */
-#define P_EXEC          0x00004000      /* Process called exec. */
-
-/* Should be moved to machine-dependent areas. */
-#define P_OWEUPC        0x00008000      /* Owe process an addupc() call at next ast. */
-
-#define P_AFFINITY      0x00010000      /* xxx */
-#define P_TRANSLATED    0x00020000      /* xxx */
-#define P_CLASSIC       P_TRANSLATED    /* xxx */
-
-#define P_DELAYIDLESLEEP 0x00040000     /* Process is marked to delay idle sleep on disk IO */
-#define P_CHECKOPENEVT  0x00080000      /* check if a vnode has the OPENEVT flag set on open */
-
-#define P_DEPENDENCY_CAPABLE    0x00100000      /* process is ok to call vfs_markdependency() */
-#define P_REBOOT        0x00200000      /* Process called reboot() */
-#define P_RESV6         0x00400000      /* used to be P_TBE */
-#define P_RESV7         0x00800000      /* (P_SIGEXC)signal exceptions */
-
-#define P_THCWD         0x01000000      /* process has thread cwd  */
-#define P_RESV9         0x02000000      /* (P_VFORK)process has vfork children */
-#define P_ADOPTPERSONA  0x04000000      /* process adopted a persona (used to be P_NOATTACH) */
-#define P_RESV11        0x08000000      /* (P_INVFORK) proc in vfork */
-
-#define P_NOSHLIB       0x10000000      /* no shared libs are in use for proc */
-                                        /* flag set on exec */
-#define P_FORCEQUOTA    0x20000000      /* Force quota for root */
-#define P_NOCLDWAIT     0x40000000      /* No zombies when chil procs exit */
-#define P_NOREMOTEHANG  0x80000000      /* Don't hang on remote FS ops */
-
-#define P_INMEM         0               /* Obsolete: retained for compilation */
-#define P_NOSWAP        0               /* Obsolete: retained for compilation */
-#define P_PHYSIO        0               /* Obsolete: retained for compilation */
-#define P_FSTRACE       0               /* Obsolete: retained for compilation */
-#define P_SSTEP         0               /* Obsolete: retained for compilation */
-
-#define P_DIRTY_TRACK                           0x00000001      /* track dirty state */
-#define P_DIRTY_ALLOW_IDLE_EXIT                 0x00000002      /* process can be idle-exited when clean */
-#define P_DIRTY_DEFER                           0x00000004      /* defer initial opt-in to idle-exit */
-#define P_DIRTY                                 0x00000008      /* process is dirty */
-#define P_DIRTY_SHUTDOWN                        0x00000010      /* process is dirty during shutdown */
-#define P_DIRTY_TERMINATED                      0x00000020      /* process has been marked for termination */
-#define P_DIRTY_BUSY                            0x00000040      /* serialization flag */
-#define P_DIRTY_MARKED                          0x00000080      /* marked dirty previously */
-#define P_DIRTY_AGING_IN_PROGRESS               0x00000100      /* aging in one of the 'aging bands' */
-#define P_DIRTY_LAUNCH_IN_PROGRESS              0x00000200      /* launch is in progress */
-#define P_DIRTY_DEFER_ALWAYS                    0x00000400      /* defer going to idle-exit after every dirty->clean transition.
-	                                                         * For legacy jetsam policy only. This is the default with the other policies.*/
-
-#define P_DIRTY_IS_DIRTY                        (P_DIRTY | P_DIRTY_SHUTDOWN)
-#define P_DIRTY_IDLE_EXIT_ENABLED               (P_DIRTY_TRACK|P_DIRTY_ALLOW_IDLE_EXIT)
-
-
-
-
-#endif  /* !_SYS_PROC_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/sys/proc_info.h b/lib/libc/include/x86_64-macos-gnu/sys/proc_info.h
deleted file mode 100644
index b6809a463b..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/sys/proc_info.h
+++ /dev/null
@@ -1,799 +0,0 @@
-/*
- * Copyright (c) 2005-2020 Apple Computer, Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-
-#ifndef _SYS_PROC_INFO_H
-#define _SYS_PROC_INFO_H
-
-#include <sys/cdefs.h>
-#include <sys/param.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <sys/mount.h>
-#include <sys/socket.h>
-#include <sys/un.h>
-#include <sys/kern_control.h>
-#include <sys/event.h>
-#include <net/if.h>
-#include <net/route.h>
-#include <netinet/in.h>
-#include <netinet/tcp.h>
-#include <mach/machine.h>
-#include <uuid/uuid.h>
-
-
-__BEGIN_DECLS
-
-
-#define PROC_ALL_PIDS           1
-#define PROC_PGRP_ONLY          2
-#define PROC_TTY_ONLY           3
-#define PROC_UID_ONLY           4
-#define PROC_RUID_ONLY          5
-#define PROC_PPID_ONLY          6
-#define PROC_KDBG_ONLY          7
-
-struct proc_bsdinfo {
-	uint32_t                pbi_flags;              /* 64bit; emulated etc */
-	uint32_t                pbi_status;
-	uint32_t                pbi_xstatus;
-	uint32_t                pbi_pid;
-	uint32_t                pbi_ppid;
-	uid_t                   pbi_uid;
-	gid_t                   pbi_gid;
-	uid_t                   pbi_ruid;
-	gid_t                   pbi_rgid;
-	uid_t                   pbi_svuid;
-	gid_t                   pbi_svgid;
-	uint32_t                rfu_1;                  /* reserved */
-	char                    pbi_comm[MAXCOMLEN];
-	char                    pbi_name[2 * MAXCOMLEN];  /* empty if no name is registered */
-	uint32_t                pbi_nfiles;
-	uint32_t                pbi_pgid;
-	uint32_t                pbi_pjobc;
-	uint32_t                e_tdev;                 /* controlling tty dev */
-	uint32_t                e_tpgid;                /* tty process group id */
-	int32_t                 pbi_nice;
-	uint64_t                pbi_start_tvsec;
-	uint64_t                pbi_start_tvusec;
-};
-
-
-struct proc_bsdshortinfo {
-	uint32_t                pbsi_pid;               /* process id */
-	uint32_t                pbsi_ppid;              /* process parent id */
-	uint32_t                pbsi_pgid;              /* process perp id */
-	uint32_t                pbsi_status;            /* p_stat value, SZOMB, SRUN, etc */
-	char                    pbsi_comm[MAXCOMLEN];   /* upto 16 characters of process name */
-	uint32_t                pbsi_flags;              /* 64bit; emulated etc */
-	uid_t                   pbsi_uid;               /* current uid on process */
-	gid_t                   pbsi_gid;               /* current gid on process */
-	uid_t                   pbsi_ruid;              /* current ruid on process */
-	gid_t                   pbsi_rgid;              /* current tgid on process */
-	uid_t                   pbsi_svuid;             /* current svuid on process */
-	gid_t                   pbsi_svgid;             /* current svgid on process */
-	uint32_t                pbsi_rfu;               /* reserved for future use*/
-};
-
-
-
-
-/* pbi_flags values */
-#define PROC_FLAG_SYSTEM        1       /*  System process */
-#define PROC_FLAG_TRACED        2       /* process currently being traced, possibly by gdb */
-#define PROC_FLAG_INEXIT        4       /* process is working its way in exit() */
-#define PROC_FLAG_PPWAIT        8
-#define PROC_FLAG_LP64          0x10    /* 64bit process */
-#define PROC_FLAG_SLEADER       0x20    /* The process is the session leader */
-#define PROC_FLAG_CTTY          0x40    /* process has a control tty */
-#define PROC_FLAG_CONTROLT      0x80    /* Has a controlling terminal */
-#define PROC_FLAG_THCWD         0x100   /* process has a thread with cwd */
-/* process control bits for resource starvation */
-#define PROC_FLAG_PC_THROTTLE   0x200   /* In resource starvation situations, this process is to be throttled */
-#define PROC_FLAG_PC_SUSP       0x400   /* In resource starvation situations, this process is to be suspended */
-#define PROC_FLAG_PC_KILL       0x600   /* In resource starvation situations, this process is to be terminated */
-#define PROC_FLAG_PC_MASK       0x600
-/* process action bits for resource starvation */
-#define PROC_FLAG_PA_THROTTLE   0x800   /* The process is currently throttled due to resource starvation */
-#define PROC_FLAG_PA_SUSP       0x1000  /* The process is currently suspended due to resource starvation */
-#define PROC_FLAG_PSUGID        0x2000   /* process has set privileges since last exec */
-#define PROC_FLAG_EXEC          0x4000   /* process has called exec  */
-
-
-struct proc_taskinfo {
-	uint64_t                pti_virtual_size;       /* virtual memory size (bytes) */
-	uint64_t                pti_resident_size;      /* resident memory size (bytes) */
-	uint64_t                pti_total_user;         /* total time */
-	uint64_t                pti_total_system;
-	uint64_t                pti_threads_user;       /* existing threads only */
-	uint64_t                pti_threads_system;
-	int32_t                 pti_policy;             /* default policy for new threads */
-	int32_t                 pti_faults;             /* number of page faults */
-	int32_t                 pti_pageins;            /* number of actual pageins */
-	int32_t                 pti_cow_faults;         /* number of copy-on-write faults */
-	int32_t                 pti_messages_sent;      /* number of messages sent */
-	int32_t                 pti_messages_received;  /* number of messages received */
-	int32_t                 pti_syscalls_mach;      /* number of mach system calls */
-	int32_t                 pti_syscalls_unix;      /* number of unix system calls */
-	int32_t                 pti_csw;                /* number of context switches */
-	int32_t                 pti_threadnum;          /* number of threads in the task */
-	int32_t                 pti_numrunning;         /* number of running threads */
-	int32_t                 pti_priority;           /* task priority*/
-};
-
-struct proc_taskallinfo {
-	struct proc_bsdinfo     pbsd;
-	struct proc_taskinfo    ptinfo;
-};
-
-#define MAXTHREADNAMESIZE 64
-
-struct proc_threadinfo {
-	uint64_t                pth_user_time;          /* user run time */
-	uint64_t                pth_system_time;        /* system run time */
-	int32_t                 pth_cpu_usage;          /* scaled cpu usage percentage */
-	int32_t                 pth_policy;             /* scheduling policy in effect */
-	int32_t                 pth_run_state;          /* run state (see below) */
-	int32_t                 pth_flags;              /* various flags (see below) */
-	int32_t                 pth_sleep_time;         /* number of seconds that thread */
-	int32_t                 pth_curpri;             /* cur priority*/
-	int32_t                 pth_priority;           /*  priority*/
-	int32_t                 pth_maxpriority;        /* max priority*/
-	char                    pth_name[MAXTHREADNAMESIZE];    /* thread name, if any */
-};
-
-struct proc_regioninfo {
-	uint32_t                pri_protection;
-	uint32_t                pri_max_protection;
-	uint32_t                pri_inheritance;
-	uint32_t                pri_flags;              /* shared, external pager, is submap */
-	uint64_t                pri_offset;
-	uint32_t                pri_behavior;
-	uint32_t                pri_user_wired_count;
-	uint32_t                pri_user_tag;
-	uint32_t                pri_pages_resident;
-	uint32_t                pri_pages_shared_now_private;
-	uint32_t                pri_pages_swapped_out;
-	uint32_t                pri_pages_dirtied;
-	uint32_t                pri_ref_count;
-	uint32_t                pri_shadow_depth;
-	uint32_t                pri_share_mode;
-	uint32_t                pri_private_pages_resident;
-	uint32_t                pri_shared_pages_resident;
-	uint32_t                pri_obj_id;
-	uint32_t                pri_depth;
-	uint64_t                pri_address;
-	uint64_t                pri_size;
-};
-
-#define PROC_REGION_SUBMAP      1
-#define PROC_REGION_SHARED      2
-
-#define SM_COW             1
-#define SM_PRIVATE         2
-#define SM_EMPTY           3
-#define SM_SHARED          4
-#define SM_TRUESHARED      5
-#define SM_PRIVATE_ALIASED 6
-#define SM_SHARED_ALIASED  7
-#define SM_LARGE_PAGE      8
-
-
-/*
- *	Thread run states (state field).
- */
-
-#define TH_STATE_RUNNING        1       /* thread is running normally */
-#define TH_STATE_STOPPED        2       /* thread is stopped */
-#define TH_STATE_WAITING        3       /* thread is waiting normally */
-#define TH_STATE_UNINTERRUPTIBLE 4      /* thread is in an uninterruptible
-	                                 *  wait */
-#define TH_STATE_HALTED         5       /* thread is halted at a
-	                                 *  clean point */
-
-/*
- *	Thread flags (flags field).
- */
-#define TH_FLAGS_SWAPPED        0x1     /* thread is swapped out */
-#define TH_FLAGS_IDLE           0x2     /* thread is an idle thread */
-
-
-struct proc_workqueueinfo {
-	uint32_t        pwq_nthreads;           /* total number of workqueue threads */
-	uint32_t        pwq_runthreads;         /* total number of running workqueue threads */
-	uint32_t        pwq_blockedthreads;     /* total number of blocked workqueue threads */
-	uint32_t        pwq_state;
-};
-
-/*
- *	workqueue state (pwq_state field)
- */
-#define WQ_EXCEEDED_CONSTRAINED_THREAD_LIMIT 0x1
-#define WQ_EXCEEDED_TOTAL_THREAD_LIMIT 0x2
-#define WQ_FLAGS_AVAILABLE 0x4
-
-struct proc_fileinfo {
-	uint32_t                fi_openflags;
-	uint32_t                fi_status;
-	off_t                   fi_offset;
-	int32_t                 fi_type;
-	uint32_t                fi_guardflags;
-};
-
-/* stats flags in proc_fileinfo */
-#define PROC_FP_SHARED  1       /* shared by more than one fd */
-#define PROC_FP_CLEXEC  2       /* close on exec */
-#define PROC_FP_GUARDED 4       /* guarded fd */
-#define PROC_FP_CLFORK  8       /* close on fork */
-
-#define PROC_FI_GUARD_CLOSE             (1u << 0)
-#define PROC_FI_GUARD_DUP               (1u << 1)
-#define PROC_FI_GUARD_SOCKET_IPC        (1u << 2)
-#define PROC_FI_GUARD_FILEPORT          (1u << 3)
-
-struct proc_exitreasonbasicinfo {
-	uint32_t                        beri_namespace;
-	uint64_t                        beri_code;
-	uint64_t                        beri_flags;
-	uint32_t                        beri_reason_buf_size;
-} __attribute__((packed));
-
-struct proc_exitreasoninfo {
-	uint32_t                        eri_namespace;
-	uint64_t                        eri_code;
-	uint64_t                        eri_flags;
-	uint32_t                        eri_reason_buf_size;
-	uint64_t                        eri_kcd_buf;
-} __attribute__((packed));
-
-/*
- * A copy of stat64 with static sized fields.
- */
-struct vinfo_stat {
-	uint32_t        vst_dev;        /* [XSI] ID of device containing file */
-	uint16_t        vst_mode;       /* [XSI] Mode of file (see below) */
-	uint16_t        vst_nlink;      /* [XSI] Number of hard links */
-	uint64_t        vst_ino;        /* [XSI] File serial number */
-	uid_t           vst_uid;        /* [XSI] User ID of the file */
-	gid_t           vst_gid;        /* [XSI] Group ID of the file */
-	int64_t         vst_atime;      /* [XSI] Time of last access */
-	int64_t         vst_atimensec;  /* nsec of last access */
-	int64_t         vst_mtime;      /* [XSI] Last data modification time */
-	int64_t         vst_mtimensec;  /* last data modification nsec */
-	int64_t         vst_ctime;      /* [XSI] Time of last status change */
-	int64_t         vst_ctimensec;  /* nsec of last status change */
-	int64_t         vst_birthtime;  /*  File creation time(birth)  */
-	int64_t         vst_birthtimensec;      /* nsec of File creation time */
-	off_t           vst_size;       /* [XSI] file size, in bytes */
-	int64_t         vst_blocks;     /* [XSI] blocks allocated for file */
-	int32_t         vst_blksize;    /* [XSI] optimal blocksize for I/O */
-	uint32_t        vst_flags;      /* user defined flags for file */
-	uint32_t        vst_gen;        /* file generation number */
-	uint32_t        vst_rdev;       /* [XSI] Device ID */
-	int64_t         vst_qspare[2];  /* RESERVED: DO NOT USE! */
-};
-
-struct vnode_info {
-	struct vinfo_stat       vi_stat;
-	int                     vi_type;
-	int                     vi_pad;
-	fsid_t                  vi_fsid;
-};
-
-struct vnode_info_path {
-	struct vnode_info       vip_vi;
-	char                    vip_path[MAXPATHLEN];   /* tail end of it  */
-};
-
-struct vnode_fdinfo {
-	struct proc_fileinfo    pfi;
-	struct vnode_info       pvi;
-};
-
-struct vnode_fdinfowithpath {
-	struct proc_fileinfo    pfi;
-	struct vnode_info_path  pvip;
-};
-
-struct proc_regionwithpathinfo {
-	struct proc_regioninfo  prp_prinfo;
-	struct vnode_info_path  prp_vip;
-};
-
-struct proc_regionpath {
-	uint64_t prpo_addr;
-	uint64_t prpo_regionlength;
-	char prpo_path[MAXPATHLEN];
-};
-
-struct proc_vnodepathinfo {
-	struct vnode_info_path  pvi_cdir;
-	struct vnode_info_path  pvi_rdir;
-};
-
-struct proc_threadwithpathinfo {
-	struct proc_threadinfo  pt;
-	struct vnode_info_path  pvip;
-};
-
-/*
- *  Socket
- */
-
-
-/*
- * IPv4 and IPv6 Sockets
- */
-
-#define INI_IPV4        0x1
-#define INI_IPV6        0x2
-
-struct in4in6_addr {
-	u_int32_t               i46a_pad32[3];
-	struct in_addr          i46a_addr4;
-};
-
-struct in_sockinfo {
-	int                                     insi_fport;             /* foreign port */
-	int                                     insi_lport;             /* local port */
-	uint64_t                                insi_gencnt;            /* generation count of this instance */
-	uint32_t                                insi_flags;             /* generic IP/datagram flags */
-	uint32_t                                insi_flow;
-
-	uint8_t                                 insi_vflag;             /* ini_IPV4 or ini_IPV6 */
-	uint8_t                                 insi_ip_ttl;            /* time to live proto */
-	uint32_t                                rfu_1;                  /* reserved */
-	/* protocol dependent part */
-	union {
-		struct in4in6_addr      ina_46;
-		struct in6_addr         ina_6;
-	}                                       insi_faddr;             /* foreign host table entry */
-	union {
-		struct in4in6_addr      ina_46;
-		struct in6_addr         ina_6;
-	}                                       insi_laddr;             /* local host table entry */
-	struct {
-		u_char                  in4_tos;                        /* type of service */
-	}                                       insi_v4;
-	struct {
-		uint8_t                 in6_hlim;
-		int                     in6_cksum;
-		u_short                 in6_ifindex;
-		short                   in6_hops;
-	}                                       insi_v6;
-};
-
-/*
- * TCP Sockets
- */
-
-#define TSI_T_REXMT             0       /* retransmit */
-#define TSI_T_PERSIST           1       /* retransmit persistence */
-#define TSI_T_KEEP              2       /* keep alive */
-#define TSI_T_2MSL              3       /* 2*msl quiet time timer */
-#define TSI_T_NTIMERS           4
-
-#define TSI_S_CLOSED            0       /* closed */
-#define TSI_S_LISTEN            1       /* listening for connection */
-#define TSI_S_SYN_SENT          2       /* active, have sent syn */
-#define TSI_S_SYN_RECEIVED      3       /* have send and received syn */
-#define TSI_S_ESTABLISHED       4       /* established */
-#define TSI_S__CLOSE_WAIT       5       /* rcvd fin, waiting for close */
-#define TSI_S_FIN_WAIT_1        6       /* have closed, sent fin */
-#define TSI_S_CLOSING           7       /* closed xchd FIN; await FIN ACK */
-#define TSI_S_LAST_ACK          8       /* had fin and close; await FIN ACK */
-#define TSI_S_FIN_WAIT_2        9       /* have closed, fin is acked */
-#define TSI_S_TIME_WAIT         10      /* in 2*msl quiet wait after close */
-#define TSI_S_RESERVED          11      /* pseudo state: reserved */
-
-struct tcp_sockinfo {
-	struct in_sockinfo              tcpsi_ini;
-	int                             tcpsi_state;
-	int                             tcpsi_timer[TSI_T_NTIMERS];
-	int                             tcpsi_mss;
-	uint32_t                        tcpsi_flags;
-	uint32_t                        rfu_1;          /* reserved */
-	uint64_t                        tcpsi_tp;       /* opaque handle of TCP protocol control block */
-};
-
-/*
- * Unix Domain Sockets
- */
-
-
-struct un_sockinfo {
-	uint64_t                                unsi_conn_so;   /* opaque handle of connected socket */
-	uint64_t                                unsi_conn_pcb;  /* opaque handle of connected protocol control block */
-	union {
-		struct sockaddr_un      ua_sun;
-		char                    ua_dummy[SOCK_MAXADDRLEN];
-	}                                       unsi_addr;      /* bound address */
-	union {
-		struct sockaddr_un      ua_sun;
-		char                    ua_dummy[SOCK_MAXADDRLEN];
-	}                                       unsi_caddr;     /* address of socket connected to */
-};
-
-/*
- * PF_NDRV Sockets
- */
-
-struct ndrv_info {
-	uint32_t        ndrvsi_if_family;
-	uint32_t        ndrvsi_if_unit;
-	char            ndrvsi_if_name[IF_NAMESIZE];
-};
-
-/*
- * Kernel Event Sockets
- */
-
-struct kern_event_info {
-	uint32_t        kesi_vendor_code_filter;
-	uint32_t        kesi_class_filter;
-	uint32_t        kesi_subclass_filter;
-};
-
-/*
- * Kernel Control Sockets
- */
-
-struct kern_ctl_info {
-	uint32_t        kcsi_id;
-	uint32_t        kcsi_reg_unit;
-	uint32_t        kcsi_flags;                     /* support flags */
-	uint32_t        kcsi_recvbufsize;               /* request more than the default buffer size */
-	uint32_t        kcsi_sendbufsize;               /* request more than the default buffer size */
-	uint32_t        kcsi_unit;
-	char            kcsi_name[MAX_KCTL_NAME];       /* unique nke identifier, provided by DTS */
-};
-
-/*
- * VSock Sockets
- */
-
-struct vsock_sockinfo {
-	uint32_t        local_cid;
-	uint32_t        local_port;
-	uint32_t        remote_cid;
-	uint32_t        remote_port;
-};
-
-/* soi_state */
-
-#define SOI_S_NOFDREF           0x0001  /* no file table ref any more */
-#define SOI_S_ISCONNECTED       0x0002  /* socket connected to a peer */
-#define SOI_S_ISCONNECTING      0x0004  /* in process of connecting to peer */
-#define SOI_S_ISDISCONNECTING   0x0008  /* in process of disconnecting */
-#define SOI_S_CANTSENDMORE      0x0010  /* can't send more data to peer */
-#define SOI_S_CANTRCVMORE       0x0020  /* can't receive more data from peer */
-#define SOI_S_RCVATMARK         0x0040  /* at mark on input */
-#define SOI_S_PRIV              0x0080  /* privileged for broadcast, raw... */
-#define SOI_S_NBIO              0x0100  /* non-blocking ops */
-#define SOI_S_ASYNC             0x0200  /* async i/o notify */
-#define SOI_S_INCOMP            0x0800  /* Unaccepted, incomplete connection */
-#define SOI_S_COMP              0x1000  /* unaccepted, complete connection */
-#define SOI_S_ISDISCONNECTED    0x2000  /* socket disconnected from peer */
-#define SOI_S_DRAINING          0x4000  /* close waiting for blocked system calls to drain */
-
-struct sockbuf_info {
-	uint32_t                sbi_cc;
-	uint32_t                sbi_hiwat;                      /* SO_RCVBUF, SO_SNDBUF */
-	uint32_t                sbi_mbcnt;
-	uint32_t                sbi_mbmax;
-	uint32_t                sbi_lowat;
-	short                   sbi_flags;
-	short                   sbi_timeo;
-};
-
-enum {
-	SOCKINFO_GENERIC        = 0,
-	SOCKINFO_IN             = 1,
-	SOCKINFO_TCP            = 2,
-	SOCKINFO_UN             = 3,
-	SOCKINFO_NDRV           = 4,
-	SOCKINFO_KERN_EVENT     = 5,
-	SOCKINFO_KERN_CTL       = 6,
-	SOCKINFO_VSOCK          = 7,
-};
-
-struct socket_info {
-	struct vinfo_stat                       soi_stat;
-	uint64_t                                soi_so;         /* opaque handle of socket */
-	uint64_t                                soi_pcb;        /* opaque handle of protocol control block */
-	int                                     soi_type;
-	int                                     soi_protocol;
-	int                                     soi_family;
-	short                                   soi_options;
-	short                                   soi_linger;
-	short                                   soi_state;
-	short                                   soi_qlen;
-	short                                   soi_incqlen;
-	short                                   soi_qlimit;
-	short                                   soi_timeo;
-	u_short                                 soi_error;
-	uint32_t                                soi_oobmark;
-	struct sockbuf_info                     soi_rcv;
-	struct sockbuf_info                     soi_snd;
-	int                                     soi_kind;
-	uint32_t                                rfu_1;          /* reserved */
-	union {
-		struct in_sockinfo      pri_in;                 /* SOCKINFO_IN */
-		struct tcp_sockinfo     pri_tcp;                /* SOCKINFO_TCP */
-		struct un_sockinfo      pri_un;                 /* SOCKINFO_UN */
-		struct ndrv_info        pri_ndrv;               /* SOCKINFO_NDRV */
-		struct kern_event_info  pri_kern_event;         /* SOCKINFO_KERN_EVENT */
-		struct kern_ctl_info    pri_kern_ctl;           /* SOCKINFO_KERN_CTL */
-		struct vsock_sockinfo   pri_vsock;              /* SOCKINFO_VSOCK */
-	}                                       soi_proto;
-};
-
-struct socket_fdinfo {
-	struct proc_fileinfo    pfi;
-	struct socket_info      psi;
-};
-
-
-
-struct psem_info {
-	struct vinfo_stat       psem_stat;
-	char                    psem_name[MAXPATHLEN];
-};
-
-struct psem_fdinfo {
-	struct proc_fileinfo    pfi;
-	struct psem_info        pseminfo;
-};
-
-
-
-struct pshm_info  {
-	struct vinfo_stat       pshm_stat;
-	uint64_t                pshm_mappaddr;
-	char                    pshm_name[MAXPATHLEN];
-};
-
-struct pshm_fdinfo {
-	struct proc_fileinfo    pfi;
-	struct pshm_info        pshminfo;
-};
-
-
-struct pipe_info {
-	struct vinfo_stat       pipe_stat;
-	uint64_t                pipe_handle;
-	uint64_t                pipe_peerhandle;
-	int                     pipe_status;
-	int                     rfu_1;  /* reserved */
-};
-
-struct pipe_fdinfo {
-	struct proc_fileinfo    pfi;
-	struct pipe_info        pipeinfo;
-};
-
-
-struct kqueue_info {
-	struct vinfo_stat       kq_stat;
-	uint32_t                kq_state;
-	uint32_t                rfu_1;  /* reserved */
-};
-
-struct kqueue_dyninfo {
-	struct kqueue_info kqdi_info;
-	uint64_t kqdi_servicer;
-	uint64_t kqdi_owner;
-	uint32_t kqdi_sync_waiters;
-	uint8_t  kqdi_sync_waiter_qos;
-	uint8_t  kqdi_async_qos;
-	uint16_t kqdi_request_state;
-	uint8_t  kqdi_events_qos;
-	uint8_t  kqdi_pri;
-	uint8_t  kqdi_pol;
-	uint8_t  kqdi_cpupercent;
-	uint8_t  _kqdi_reserved0[4];
-	uint64_t _kqdi_reserved1[4];
-};
-
-/* keep in sync with KQ_* in sys/eventvar.h */
-#define PROC_KQUEUE_SELECT      0x01
-#define PROC_KQUEUE_SLEEP       0x02
-#define PROC_KQUEUE_32          0x08
-#define PROC_KQUEUE_64          0x10
-#define PROC_KQUEUE_QOS         0x20
-
-
-struct kqueue_fdinfo {
-	struct proc_fileinfo    pfi;
-	struct kqueue_info      kqueueinfo;
-};
-
-struct appletalk_info {
-	struct vinfo_stat       atalk_stat;
-};
-
-struct appletalk_fdinfo {
-	struct proc_fileinfo    pfi;
-	struct appletalk_info   appletalkinfo;
-};
-
-typedef uint64_t proc_info_udata_t;
-
-/* defns of process file desc type */
-#define PROX_FDTYPE_ATALK       0
-#define PROX_FDTYPE_VNODE       1
-#define PROX_FDTYPE_SOCKET      2
-#define PROX_FDTYPE_PSHM        3
-#define PROX_FDTYPE_PSEM        4
-#define PROX_FDTYPE_KQUEUE      5
-#define PROX_FDTYPE_PIPE        6
-#define PROX_FDTYPE_FSEVENTS    7
-#define PROX_FDTYPE_NETPOLICY   9
-
-struct proc_fdinfo {
-	int32_t                 proc_fd;
-	uint32_t                proc_fdtype;
-};
-
-struct proc_fileportinfo {
-	uint32_t                proc_fileport;
-	uint32_t                proc_fdtype;
-};
-
-
-/* Flavors for proc_pidinfo() */
-#define PROC_PIDLISTFDS                 1
-#define PROC_PIDLISTFD_SIZE             (sizeof(struct proc_fdinfo))
-
-#define PROC_PIDTASKALLINFO             2
-#define PROC_PIDTASKALLINFO_SIZE        (sizeof(struct proc_taskallinfo))
-
-#define PROC_PIDTBSDINFO                3
-#define PROC_PIDTBSDINFO_SIZE           (sizeof(struct proc_bsdinfo))
-
-#define PROC_PIDTASKINFO                4
-#define PROC_PIDTASKINFO_SIZE           (sizeof(struct proc_taskinfo))
-
-#define PROC_PIDTHREADINFO              5
-#define PROC_PIDTHREADINFO_SIZE         (sizeof(struct proc_threadinfo))
-
-#define PROC_PIDLISTTHREADS             6
-#define PROC_PIDLISTTHREADS_SIZE        (2* sizeof(uint32_t))
-
-#define PROC_PIDREGIONINFO              7
-#define PROC_PIDREGIONINFO_SIZE         (sizeof(struct proc_regioninfo))
-
-#define PROC_PIDREGIONPATHINFO          8
-#define PROC_PIDREGIONPATHINFO_SIZE     (sizeof(struct proc_regionwithpathinfo))
-
-#define PROC_PIDVNODEPATHINFO           9
-#define PROC_PIDVNODEPATHINFO_SIZE      (sizeof(struct proc_vnodepathinfo))
-
-#define PROC_PIDTHREADPATHINFO          10
-#define PROC_PIDTHREADPATHINFO_SIZE     (sizeof(struct proc_threadwithpathinfo))
-
-#define PROC_PIDPATHINFO                11
-#define PROC_PIDPATHINFO_SIZE           (MAXPATHLEN)
-#define PROC_PIDPATHINFO_MAXSIZE        (4*MAXPATHLEN)
-
-#define PROC_PIDWORKQUEUEINFO           12
-#define PROC_PIDWORKQUEUEINFO_SIZE      (sizeof(struct proc_workqueueinfo))
-
-#define PROC_PIDT_SHORTBSDINFO          13
-#define PROC_PIDT_SHORTBSDINFO_SIZE     (sizeof(struct proc_bsdshortinfo))
-
-#define PROC_PIDLISTFILEPORTS           14
-#define PROC_PIDLISTFILEPORTS_SIZE      (sizeof(struct proc_fileportinfo))
-
-#define PROC_PIDTHREADID64INFO          15
-#define PROC_PIDTHREADID64INFO_SIZE     (sizeof(struct proc_threadinfo))
-
-#define PROC_PID_RUSAGE                 16
-#define PROC_PID_RUSAGE_SIZE            0
-
-/* Flavors for proc_pidfdinfo */
-
-#define PROC_PIDFDVNODEINFO             1
-#define PROC_PIDFDVNODEINFO_SIZE        (sizeof(struct vnode_fdinfo))
-
-#define PROC_PIDFDVNODEPATHINFO         2
-#define PROC_PIDFDVNODEPATHINFO_SIZE    (sizeof(struct vnode_fdinfowithpath))
-
-#define PROC_PIDFDSOCKETINFO            3
-#define PROC_PIDFDSOCKETINFO_SIZE       (sizeof(struct socket_fdinfo))
-
-#define PROC_PIDFDPSEMINFO              4
-#define PROC_PIDFDPSEMINFO_SIZE         (sizeof(struct psem_fdinfo))
-
-#define PROC_PIDFDPSHMINFO              5
-#define PROC_PIDFDPSHMINFO_SIZE         (sizeof(struct pshm_fdinfo))
-
-#define PROC_PIDFDPIPEINFO              6
-#define PROC_PIDFDPIPEINFO_SIZE         (sizeof(struct pipe_fdinfo))
-
-#define PROC_PIDFDKQUEUEINFO            7
-#define PROC_PIDFDKQUEUEINFO_SIZE       (sizeof(struct kqueue_fdinfo))
-
-#define PROC_PIDFDATALKINFO             8
-#define PROC_PIDFDATALKINFO_SIZE        (sizeof(struct appletalk_fdinfo))
-
-
-
-/* Flavors for proc_pidfileportinfo */
-
-#define PROC_PIDFILEPORTVNODEPATHINFO   2       /* out: vnode_fdinfowithpath */
-#define PROC_PIDFILEPORTVNODEPATHINFO_SIZE      \
-	                                PROC_PIDFDVNODEPATHINFO_SIZE
-
-#define PROC_PIDFILEPORTSOCKETINFO      3       /* out: socket_fdinfo */
-#define PROC_PIDFILEPORTSOCKETINFO_SIZE PROC_PIDFDSOCKETINFO_SIZE
-
-#define PROC_PIDFILEPORTPSHMINFO        5       /* out: pshm_fdinfo */
-#define PROC_PIDFILEPORTPSHMINFO_SIZE   PROC_PIDFDPSHMINFO_SIZE
-
-#define PROC_PIDFILEPORTPIPEINFO        6       /* out: pipe_fdinfo */
-#define PROC_PIDFILEPORTPIPEINFO_SIZE   PROC_PIDFDPIPEINFO_SIZE
-
-/* used for proc_setcontrol */
-#define PROC_SELFSET_PCONTROL           1
-
-#define PROC_SELFSET_THREADNAME         2
-#define PROC_SELFSET_THREADNAME_SIZE    (MAXTHREADNAMESIZE -1)
-
-#define PROC_SELFSET_VMRSRCOWNER        3
-
-#define PROC_SELFSET_DELAYIDLESLEEP     4
-
-/* used for proc_dirtycontrol */
-#define PROC_DIRTYCONTROL_TRACK         1
-#define PROC_DIRTYCONTROL_SET           2
-#define PROC_DIRTYCONTROL_GET           3
-#define PROC_DIRTYCONTROL_CLEAR         4
-
-/* proc_track_dirty() flags */
-#define PROC_DIRTY_TRACK                0x1
-#define PROC_DIRTY_ALLOW_IDLE_EXIT      0x2
-#define PROC_DIRTY_DEFER                0x4
-#define PROC_DIRTY_LAUNCH_IN_PROGRESS   0x8
-#define PROC_DIRTY_DEFER_ALWAYS         0x10
-
-/* proc_get_dirty() flags */
-#define PROC_DIRTY_TRACKED              0x1
-#define PROC_DIRTY_ALLOWS_IDLE_EXIT     0x2
-#define PROC_DIRTY_IS_DIRTY             0x4
-#define PROC_DIRTY_LAUNCH_IS_IN_PROGRESS   0x8
-
-/* Flavors for proc_udata_info */
-#define PROC_UDATA_INFO_GET             1
-#define PROC_UDATA_INFO_SET             2
-
-
-
-
-__END_DECLS
-
-#endif /*_SYS_PROC_INFO_H */
diff --git a/lib/libc/include/x86_64-macos-gnu/sys/resource.h b/lib/libc/include/x86_64-macos-gnu/sys/resource.h
deleted file mode 100644
index b6bf678d37..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/sys/resource.h
+++ /dev/null
@@ -1,458 +0,0 @@
-/*
- * Copyright (c) 2000-2018 Apple Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-/* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */
-/*
- * Copyright (c) 1982, 1986, 1993
- *	The Regents of the University of California.  All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *	This product includes software developed by the University of
- *	California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *	@(#)resource.h	8.2 (Berkeley) 1/4/94
- */
-
-#ifndef _SYS_RESOURCE_H_
-#define _SYS_RESOURCE_H_
-
-#include <sys/appleapiopts.h>
-#include <sys/cdefs.h>
-#include <sys/_types.h>
-
-#if __DARWIN_C_LEVEL >= __DARWIN_C_FULL
-#include <stdint.h>
-#endif /* __DARWIN_C_LEVEL >= __DARWIN_C_FULL */
-
-#include <Availability.h>
-
-/* [XSI] The timeval structure shall be defined as described in
- * <sys/time.h>
- */
-#include <sys/_types/_timeval.h>
-
-/* The id_t type shall be defined as described in <sys/types.h> */
-#include <sys/_types/_id_t.h>
-
-
-/*
- * Resource limit type (low 63 bits, excluding the sign bit)
- */
-typedef __uint64_t      rlim_t;
-
-
-/*****
- * PRIORITY
- */
-
-/*
- * Possible values of the first parameter to getpriority()/setpriority(),
- * used to indicate the type of the second parameter.
- */
-#define PRIO_PROCESS    0               /* Second argument is a PID */
-#define PRIO_PGRP       1               /* Second argument is a GID */
-#define PRIO_USER       2               /* Second argument is a UID */
-
-#if __DARWIN_C_LEVEL >= __DARWIN_C_FULL
-#define PRIO_DARWIN_THREAD      3               /* Second argument is always 0 (current thread) */
-#define PRIO_DARWIN_PROCESS     4               /* Second argument is a PID */
-
-
-/*
- * Range limitations for the value of the third parameter to setpriority().
- */
-#define PRIO_MIN        -20
-#define PRIO_MAX        20
-
-/*
- * use PRIO_DARWIN_BG to set the current thread into "background" state
- * which lowers CPU, disk IO, and networking priorites until thread terminates
- * or "background" state is revoked
- */
-#define PRIO_DARWIN_BG 0x1000
-
-/*
- * use PRIO_DARWIN_NONUI to restrict a process's ability to make calls to
- * the GPU. (deprecated)
- */
-#define PRIO_DARWIN_NONUI 0x1001
-
-#endif  /* __DARWIN_C_LEVEL >= __DARWIN_C_FULL */
-
-
-
-/*****
- * RESOURCE USAGE
- */
-
-/*
- * Possible values of the first parameter to getrusage(), used to indicate
- * the scope of the information to be returned.
- */
-#define RUSAGE_SELF     0               /* Current process information */
-#define RUSAGE_CHILDREN -1              /* Current process' children */
-
-/*
- * A structure representing an accounting of resource utilization.  The
- * address of an instance of this structure is the second parameter to
- * getrusage().
- *
- * Note: All values other than ru_utime and ru_stime are implementaiton
- *       defined and subject to change in a future release.  Their use
- *       is discouraged for standards compliant programs.
- */
-struct  rusage {
-	struct timeval ru_utime;        /* user time used (PL) */
-	struct timeval ru_stime;        /* system time used (PL) */
-#if __DARWIN_C_LEVEL < __DARWIN_C_FULL
-	long    ru_opaque[14];          /* implementation defined */
-#else
-	/*
-	 * Informational aliases for source compatibility with programs
-	 * that need more information than that provided by standards,
-	 * and which do not mind being OS-dependent.
-	 */
-	long    ru_maxrss;              /* max resident set size (PL) */
-#define ru_first        ru_ixrss        /* internal: ruadd() range start */
-	long    ru_ixrss;               /* integral shared memory size (NU) */
-	long    ru_idrss;               /* integral unshared data (NU)  */
-	long    ru_isrss;               /* integral unshared stack (NU) */
-	long    ru_minflt;              /* page reclaims (NU) */
-	long    ru_majflt;              /* page faults (NU) */
-	long    ru_nswap;               /* swaps (NU) */
-	long    ru_inblock;             /* block input operations (atomic) */
-	long    ru_oublock;             /* block output operations (atomic) */
-	long    ru_msgsnd;              /* messages sent (atomic) */
-	long    ru_msgrcv;              /* messages received (atomic) */
-	long    ru_nsignals;            /* signals received (atomic) */
-	long    ru_nvcsw;               /* voluntary context switches (atomic) */
-	long    ru_nivcsw;              /* involuntary " */
-#define ru_last         ru_nivcsw       /* internal: ruadd() range end */
-#endif  /* __DARWIN_C_LEVEL >= __DARWIN_C_FULL */
-};
-
-#if __DARWIN_C_LEVEL >= __DARWIN_C_FULL
-/*
- * Flavors for proc_pid_rusage().
- */
-#define RUSAGE_INFO_V0  0
-#define RUSAGE_INFO_V1  1
-#define RUSAGE_INFO_V2  2
-#define RUSAGE_INFO_V3  3
-#define RUSAGE_INFO_V4  4
-#define RUSAGE_INFO_CURRENT     RUSAGE_INFO_V4
-
-typedef void *rusage_info_t;
-
-struct rusage_info_v0 {
-	uint8_t  ri_uuid[16];
-	uint64_t ri_user_time;
-	uint64_t ri_system_time;
-	uint64_t ri_pkg_idle_wkups;
-	uint64_t ri_interrupt_wkups;
-	uint64_t ri_pageins;
-	uint64_t ri_wired_size;
-	uint64_t ri_resident_size;
-	uint64_t ri_phys_footprint;
-	uint64_t ri_proc_start_abstime;
-	uint64_t ri_proc_exit_abstime;
-};
-
-struct rusage_info_v1 {
-	uint8_t  ri_uuid[16];
-	uint64_t ri_user_time;
-	uint64_t ri_system_time;
-	uint64_t ri_pkg_idle_wkups;
-	uint64_t ri_interrupt_wkups;
-	uint64_t ri_pageins;
-	uint64_t ri_wired_size;
-	uint64_t ri_resident_size;
-	uint64_t ri_phys_footprint;
-	uint64_t ri_proc_start_abstime;
-	uint64_t ri_proc_exit_abstime;
-	uint64_t ri_child_user_time;
-	uint64_t ri_child_system_time;
-	uint64_t ri_child_pkg_idle_wkups;
-	uint64_t ri_child_interrupt_wkups;
-	uint64_t ri_child_pageins;
-	uint64_t ri_child_elapsed_abstime;
-};
-
-struct rusage_info_v2 {
-	uint8_t  ri_uuid[16];
-	uint64_t ri_user_time;
-	uint64_t ri_system_time;
-	uint64_t ri_pkg_idle_wkups;
-	uint64_t ri_interrupt_wkups;
-	uint64_t ri_pageins;
-	uint64_t ri_wired_size;
-	uint64_t ri_resident_size;
-	uint64_t ri_phys_footprint;
-	uint64_t ri_proc_start_abstime;
-	uint64_t ri_proc_exit_abstime;
-	uint64_t ri_child_user_time;
-	uint64_t ri_child_system_time;
-	uint64_t ri_child_pkg_idle_wkups;
-	uint64_t ri_child_interrupt_wkups;
-	uint64_t ri_child_pageins;
-	uint64_t ri_child_elapsed_abstime;
-	uint64_t ri_diskio_bytesread;
-	uint64_t ri_diskio_byteswritten;
-};
-
-struct rusage_info_v3 {
-	uint8_t  ri_uuid[16];
-	uint64_t ri_user_time;
-	uint64_t ri_system_time;
-	uint64_t ri_pkg_idle_wkups;
-	uint64_t ri_interrupt_wkups;
-	uint64_t ri_pageins;
-	uint64_t ri_wired_size;
-	uint64_t ri_resident_size;
-	uint64_t ri_phys_footprint;
-	uint64_t ri_proc_start_abstime;
-	uint64_t ri_proc_exit_abstime;
-	uint64_t ri_child_user_time;
-	uint64_t ri_child_system_time;
-	uint64_t ri_child_pkg_idle_wkups;
-	uint64_t ri_child_interrupt_wkups;
-	uint64_t ri_child_pageins;
-	uint64_t ri_child_elapsed_abstime;
-	uint64_t ri_diskio_bytesread;
-	uint64_t ri_diskio_byteswritten;
-	uint64_t ri_cpu_time_qos_default;
-	uint64_t ri_cpu_time_qos_maintenance;
-	uint64_t ri_cpu_time_qos_background;
-	uint64_t ri_cpu_time_qos_utility;
-	uint64_t ri_cpu_time_qos_legacy;
-	uint64_t ri_cpu_time_qos_user_initiated;
-	uint64_t ri_cpu_time_qos_user_interactive;
-	uint64_t ri_billed_system_time;
-	uint64_t ri_serviced_system_time;
-};
-
-struct rusage_info_v4 {
-	uint8_t  ri_uuid[16];
-	uint64_t ri_user_time;
-	uint64_t ri_system_time;
-	uint64_t ri_pkg_idle_wkups;
-	uint64_t ri_interrupt_wkups;
-	uint64_t ri_pageins;
-	uint64_t ri_wired_size;
-	uint64_t ri_resident_size;
-	uint64_t ri_phys_footprint;
-	uint64_t ri_proc_start_abstime;
-	uint64_t ri_proc_exit_abstime;
-	uint64_t ri_child_user_time;
-	uint64_t ri_child_system_time;
-	uint64_t ri_child_pkg_idle_wkups;
-	uint64_t ri_child_interrupt_wkups;
-	uint64_t ri_child_pageins;
-	uint64_t ri_child_elapsed_abstime;
-	uint64_t ri_diskio_bytesread;
-	uint64_t ri_diskio_byteswritten;
-	uint64_t ri_cpu_time_qos_default;
-	uint64_t ri_cpu_time_qos_maintenance;
-	uint64_t ri_cpu_time_qos_background;
-	uint64_t ri_cpu_time_qos_utility;
-	uint64_t ri_cpu_time_qos_legacy;
-	uint64_t ri_cpu_time_qos_user_initiated;
-	uint64_t ri_cpu_time_qos_user_interactive;
-	uint64_t ri_billed_system_time;
-	uint64_t ri_serviced_system_time;
-	uint64_t ri_logical_writes;
-	uint64_t ri_lifetime_max_phys_footprint;
-	uint64_t ri_instructions;
-	uint64_t ri_cycles;
-	uint64_t ri_billed_energy;
-	uint64_t ri_serviced_energy;
-	uint64_t ri_interval_max_phys_footprint;
-	uint64_t ri_runnable_time;
-};
-
-typedef struct rusage_info_v4 rusage_info_current;
-
-#endif /* __DARWIN_C_LEVEL >= __DARWIN_C_FULL */
-
-
-
-/*****
- * RESOURCE LIMITS
- */
-
-/*
- * Symbolic constants for resource limits; since all limits are representable
- * as a type rlim_t, we are permitted to define RLIM_SAVED_* in terms of
- * RLIM_INFINITY.
- */
-#define RLIM_INFINITY   (((__uint64_t)1 << 63) - 1)     /* no limit */
-#define RLIM_SAVED_MAX  RLIM_INFINITY   /* Unrepresentable hard limit */
-#define RLIM_SAVED_CUR  RLIM_INFINITY   /* Unrepresentable soft limit */
-
-/*
- * Possible values of the first parameter to getrlimit()/setrlimit(), to
- * indicate for which resource the operation is being performed.
- */
-#define RLIMIT_CPU      0               /* cpu time per process */
-#define RLIMIT_FSIZE    1               /* file size */
-#define RLIMIT_DATA     2               /* data segment size */
-#define RLIMIT_STACK    3               /* stack size */
-#define RLIMIT_CORE     4               /* core file size */
-#define RLIMIT_AS       5               /* address space (resident set size) */
-#if __DARWIN_C_LEVEL >= __DARWIN_C_FULL
-#define RLIMIT_RSS      RLIMIT_AS       /* source compatibility alias */
-#define RLIMIT_MEMLOCK  6               /* locked-in-memory address space */
-#define RLIMIT_NPROC    7               /* number of processes */
-#endif  /* __DARWIN_C_LEVEL >= __DARWIN_C_FULL */
-#define RLIMIT_NOFILE   8               /* number of open files */
-#if __DARWIN_C_LEVEL >= __DARWIN_C_FULL
-#define RLIM_NLIMITS    9               /* total number of resource limits */
-#endif  /* __DARWIN_C_LEVEL >= __DARWIN_C_FULL */
-#define _RLIMIT_POSIX_FLAG      0x1000  /* Set bit for strict POSIX */
-
-/*
- * A structure representing a resource limit.  The address of an instance
- * of this structure is the second parameter to getrlimit()/setrlimit().
- */
-struct rlimit {
-	rlim_t  rlim_cur;               /* current (soft) limit */
-	rlim_t  rlim_max;               /* maximum value for rlim_cur */
-};
-
-#if __DARWIN_C_LEVEL >= __DARWIN_C_FULL
-/*
- * proc_rlimit_control()
- *
- * Resource limit flavors
- */
-#define RLIMIT_WAKEUPS_MONITOR          0x1 /* Configure the wakeups monitor. */
-#define RLIMIT_CPU_USAGE_MONITOR        0x2 /* Configure the CPU usage monitor. */
-#define RLIMIT_THREAD_CPULIMITS         0x3 /* Configure a blocking, per-thread, CPU limits. */
-#define RLIMIT_FOOTPRINT_INTERVAL       0x4 /* Configure memory footprint interval tracking */
-
-/*
- * Flags for wakeups monitor control.
- */
-#define WAKEMON_ENABLE                  0x01
-#define WAKEMON_DISABLE                 0x02
-#define WAKEMON_GET_PARAMS              0x04
-#define WAKEMON_SET_DEFAULTS            0x08
-#define WAKEMON_MAKE_FATAL              0x10 /* Configure the task so that violations are fatal. */
-
-/*
- * Flags for CPU usage monitor control.
- */
-#define CPUMON_MAKE_FATAL               0x1000
-
-/*
- * Flags for memory footprint interval tracking.
- */
-#define FOOTPRINT_INTERVAL_RESET        0x1 /* Reset the footprint interval counter to zero */
-
-struct proc_rlimit_control_wakeupmon {
-	uint32_t wm_flags;
-	int32_t wm_rate;
-};
-
-
-
-/* I/O type */
-#define IOPOL_TYPE_DISK 0
-#define IOPOL_TYPE_VFS_ATIME_UPDATES 2
-#define IOPOL_TYPE_VFS_MATERIALIZE_DATALESS_FILES 3
-#define IOPOL_TYPE_VFS_STATFS_NO_DATA_VOLUME 4
-
-/* scope */
-#define IOPOL_SCOPE_PROCESS   0
-#define IOPOL_SCOPE_THREAD    1
-#define IOPOL_SCOPE_DARWIN_BG 2
-
-/* I/O Priority */
-#define IOPOL_DEFAULT           0
-#define IOPOL_IMPORTANT         1
-#define IOPOL_PASSIVE           2
-#define IOPOL_THROTTLE          3
-#define IOPOL_UTILITY           4
-#define IOPOL_STANDARD          5
-
-/* compatibility with older names */
-#define IOPOL_APPLICATION       IOPOL_STANDARD
-#define IOPOL_NORMAL            IOPOL_IMPORTANT
-
-
-#define IOPOL_ATIME_UPDATES_DEFAULT     0
-#define IOPOL_ATIME_UPDATES_OFF         1
-
-#define IOPOL_MATERIALIZE_DATALESS_FILES_DEFAULT 0
-#define IOPOL_MATERIALIZE_DATALESS_FILES_OFF     1
-#define IOPOL_MATERIALIZE_DATALESS_FILES_ON      2
-
-#define IOPOL_VFS_STATFS_NO_DATA_VOLUME_DEFAULT 0
-#define IOPOL_VFS_STATFS_FORCE_NO_DATA_VOLUME   1
-
-#endif /* __DARWIN_C_LEVEL >= __DARWIN_C_FULL */
-
-
-__BEGIN_DECLS
-int     getpriority(int, id_t);
-#if __DARWIN_C_LEVEL >= __DARWIN_C_FULL
-int     getiopolicy_np(int, int) __OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_2_0);
-#endif /* __DARWIN_C_LEVEL >= __DARWIN_C_FULL */
-int     getrlimit(int, struct rlimit *) __DARWIN_ALIAS(getrlimit);
-int     getrusage(int, struct rusage *);
-int     setpriority(int, id_t, int);
-#if __DARWIN_C_LEVEL >= __DARWIN_C_FULL
-int     setiopolicy_np(int, int, int) __OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_2_0);
-#endif /* __DARWIN_C_LEVEL >= __DARWIN_C_FULL */
-int     setrlimit(int, const struct rlimit *) __DARWIN_ALIAS(setrlimit);
-__END_DECLS
-
-#endif  /* !_SYS_RESOURCE_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/sys/shm.h b/lib/libc/include/x86_64-macos-gnu/sys/shm.h
deleted file mode 100644
index 0e5070a03b..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/sys/shm.h
+++ /dev/null
@@ -1,186 +0,0 @@
-/*
- * Copyright (c) 2000-2002 Apple Computer, Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-/*	$NetBSD: shm.h,v 1.15 1994/06/29 06:45:17 cgd Exp $	*/
-
-/*
- * Copyright (c) 1994 Adam Glass
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *      This product includes software developed by Adam Glass.
- * 4. The name of the author may not be used to endorse or promote products
- *    derived from this software without specific prior written permission
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
- * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
- * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
- * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
- * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-/*
- * As defined+described in "X/Open System Interfaces and Headers"
- *                         Issue 4, p. XXX
- */
-
-#ifndef _SYS_SHM_H_
-#define _SYS_SHM_H_
-
-#include <sys/cdefs.h>
-#include <sys/_types.h>
-
-/*
- * [XSI]	All of the symbols from <sys/ipc.h> SHALL be defined
- *		when this header is included
- */
-#include <sys/ipc.h>
-
-/*
- * [XSI] The pid_t, time_t, key_t, and size_t types shall be defined as
- * described in <sys/types.h>.
- *
- * NOTE:	The definition of the key_t type is implicit from the
- *		inclusion of <sys/ipc.h>
- */
-#include <sys/_types/_pid_t.h>
-#include <sys/_types/_time_t.h>
-#include <sys/_types/_size_t.h>
-
-/*
- * [XSI] The unsigned integer type used for the number of current attaches
- * that MUST be able to store values at least as large as a type unsigned
- * short.
- */
-typedef unsigned short  shmatt_t;
-
-
-/*
- * Possible flag values which may be OR'ed into the third argument to
- * shmat()
- */
-#define SHM_RDONLY      010000  /* [XSI] Attach read-only (else read-write) */
-#define SHM_RND         020000  /* [XSI] Round attach address to SHMLBA */
-
-/*
- * This value is symbolic, and generally not expected to be sed by user
- * programs directly, although such ise is permitted by the standard.  Its
- * value in our implementation is equal to the number of bytes per page.
- *
- * NOTE:	We DO NOT obtain this value from the appropriate system
- *		headers at this time, to avoid the resulting namespace
- *		pollution, which is why we discourages its use.
- */
-#define SHMLBA      4096        /* [XSI] Segment low boundary address multiple*/
-
-/* "official" access mode definitions; somewhat braindead since you have
- *  to specify (SHM_* >> 3) for group and (SHM_* >> 6) for world permissions */
-#define SHM_R       (IPC_R)
-#define SHM_W       (IPC_W)
-
-#pragma pack(4)
-
-/*
- * Technically, we should force all code references to the new structure
- * definition, not in just the standards conformance case, and leave the
- * legacy interface there for binary compatibility only.  Currently, we
- * are only forcing this for programs requesting standards conformance.
- */
-#if __DARWIN_UNIX03 || defined(KERNEL)
-/*
- * Structure used internally.
- *
- * This structure is exposed because standards dictate that it is used as
- * the third argment to shmctl().
- *
- * NOTE:	The field shm_internal is not meaningful in user space,
- *		and must not be used there.
- */
-#if (defined(_POSIX_C_SOURCE) && !defined(_DARWIN_C_SOURCE))
-struct shmid_ds
-#else
-#define shmid_ds        __shmid_ds_new
-struct __shmid_ds_new
-#endif
-{
-	struct __ipc_perm_new shm_perm; /* [XSI] Operation permission value */
-	size_t          shm_segsz;      /* [XSI] Size of segment in bytes */
-	pid_t           shm_lpid;       /* [XSI] PID of last shared memory op */
-	pid_t           shm_cpid;       /* [XSI] PID of creator */
-	shmatt_t        shm_nattch;     /* [XSI] Number of current attaches */
-	time_t          shm_atime;      /* [XSI] Time of last shmat() */
-	time_t          shm_dtime;      /* [XSI] Time of last shmdt() */
-	time_t          shm_ctime;      /* [XSI] Time of last shmctl() change */
-	void            *shm_internal;  /* reserved for kernel use */
-};
-#else   /* !__DARWIN_UNIX03 */
-#define shmid_ds        __shmid_ds_old
-#endif  /* !__DARWIN_UNIX03 */
-
-#if !__DARWIN_UNIX03
-struct __shmid_ds_old {
-	struct __ipc_perm_old shm_perm; /* [XSI] Operation permission value */
-	size_t          shm_segsz;      /* [XSI] Size of segment in bytes */
-	pid_t           shm_lpid;       /* [XSI] PID of last shared memory op */
-	pid_t           shm_cpid;       /* [XSI] PID of creator */
-	shmatt_t        shm_nattch;     /* [XSI] Number of current attaches */
-	time_t          shm_atime;      /* [XSI] Time of last shmat() */
-	time_t          shm_dtime;      /* [XSI] Time of last shmdt() */
-	time_t          shm_ctime;      /* [XSI] Time of last shmctl() change */
-	void            *shm_internal;  /* reserved for kernel use */
-};
-#endif  /* !__DARWIN_UNIX03 */
-
-#pragma pack()
-
-
-__BEGIN_DECLS
-#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-int     shmsys(int, ...);
-#endif /* (!_POSIX_C_SOURCE || _DARWIN_C_SOURCE) */
-void    *shmat(int, const void *, int);
-int     shmctl(int, int, struct shmid_ds *) __DARWIN_ALIAS(shmctl);
-int     shmdt(const void *);
-int     shmget(key_t, size_t, int);
-__END_DECLS
-
-
-#endif /* !_SYS_SHM_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/sys/socket.h b/lib/libc/include/x86_64-macos-gnu/sys/socket.h
deleted file mode 100644
index c8a0d27615..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/sys/socket.h
+++ /dev/null
@@ -1,732 +0,0 @@
-/*
- * Copyright (c) 2000-2019 Apple Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-/* Copyright (c) 1998, 1999 Apple Computer, Inc. All Rights Reserved */
-/* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */
-/*
- * Copyright (c) 1982, 1985, 1986, 1988, 1993, 1994
- *	The Regents of the University of California.  All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *	This product includes software developed by the University of
- *	California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *	@(#)socket.h	8.4 (Berkeley) 2/21/94
- * $FreeBSD: src/sys/sys/socket.h,v 1.39.2.7 2001/07/03 11:02:01 ume Exp $
- */
-/*
- * NOTICE: This file was modified by SPARTA, Inc. in 2005 to introduce
- * support for mandatory and extensible security protections.  This notice
- * is included in support of clause 2.2 (b) of the Apple Public License,
- * Version 2.0.
- */
-
-#ifndef _SYS_SOCKET_H_
-#define _SYS_SOCKET_H_
-
-#include <sys/types.h>
-#include <sys/cdefs.h>
-#include <machine/_param.h>
-#include <net/net_kev.h>
-
-
-#include <Availability.h>
-
-/*
- * Definitions related to sockets: types, address families, options.
- */
-
-/*
- * Data types.
- */
-
-#include <sys/_types/_gid_t.h>
-#include <sys/_types/_off_t.h>
-#include <sys/_types/_pid_t.h>
-#include <sys/_types/_sa_family_t.h>
-#include <sys/_types/_socklen_t.h>
-
-/* XXX Not explicitly defined by POSIX, but function return types are */
-#include <sys/_types/_size_t.h>
-
-/* XXX Not explicitly defined by POSIX, but function return types are */
-#include <sys/_types/_ssize_t.h>
-
-/*
- * [XSI] The iovec structure shall be defined as described in <sys/uio.h>.
- */
-#include <sys/_types/_iovec_t.h>
-
-/*
- * Types
- */
-#define SOCK_STREAM     1               /* stream socket */
-#define SOCK_DGRAM      2               /* datagram socket */
-#define SOCK_RAW        3               /* raw-protocol interface */
-#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-#define SOCK_RDM        4               /* reliably-delivered message */
-#endif  /* (!_POSIX_C_SOURCE || _DARWIN_C_SOURCE) */
-#define SOCK_SEQPACKET  5               /* sequenced packet stream */
-
-/*
- * Option flags per-socket.
- */
-#define SO_DEBUG        0x0001          /* turn on debugging info recording */
-#define SO_ACCEPTCONN   0x0002          /* socket has had listen() */
-#define SO_REUSEADDR    0x0004          /* allow local address reuse */
-#define SO_KEEPALIVE    0x0008          /* keep connections alive */
-#define SO_DONTROUTE    0x0010          /* just use interface addresses */
-#define SO_BROADCAST    0x0020          /* permit sending of broadcast msgs */
-#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-#define SO_USELOOPBACK  0x0040          /* bypass hardware when possible */
-#define SO_LINGER       0x0080          /* linger on close if data present (in ticks) */
-#else
-#define SO_LINGER       0x1080          /* linger on close if data present (in seconds) */
-#endif  /* (!_POSIX_C_SOURCE || _DARWIN_C_SOURCE) */
-#define SO_OOBINLINE    0x0100          /* leave received OOB data in line */
-#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-#define SO_REUSEPORT    0x0200          /* allow local address & port reuse */
-#define SO_TIMESTAMP    0x0400          /* timestamp received dgram traffic */
-#define SO_TIMESTAMP_MONOTONIC  0x0800  /* Monotonically increasing timestamp on rcvd dgram */
-#ifndef __APPLE__
-#define SO_ACCEPTFILTER 0x1000          /* there is an accept filter */
-#else
-#define SO_DONTTRUNC    0x2000          /* APPLE: Retain unread data */
-                                        /*  (ATOMIC proto) */
-#define SO_WANTMORE     0x4000          /* APPLE: Give hint when more data ready */
-#define SO_WANTOOBFLAG  0x8000          /* APPLE: Want OOB in MSG_FLAG on receive */
-
-
-#endif  /* (!__APPLE__) */
-#endif  /* (!_POSIX_C_SOURCE || _DARWIN_C_SOURCE) */
-
-/*
- * Additional options, not kept in so_options.
- */
-#define SO_SNDBUF       0x1001          /* send buffer size */
-#define SO_RCVBUF       0x1002          /* receive buffer size */
-#define SO_SNDLOWAT     0x1003          /* send low-water mark */
-#define SO_RCVLOWAT     0x1004          /* receive low-water mark */
-#define SO_SNDTIMEO     0x1005          /* send timeout */
-#define SO_RCVTIMEO     0x1006          /* receive timeout */
-#define SO_ERROR        0x1007          /* get error status and clear */
-#define SO_TYPE         0x1008          /* get socket type */
-#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-#define SO_LABEL        0x1010          /* socket's MAC label */
-#define SO_PEERLABEL    0x1011          /* socket's peer MAC label */
-#ifdef __APPLE__
-#define SO_NREAD        0x1020          /* APPLE: get 1st-packet byte count */
-#define SO_NKE          0x1021          /* APPLE: Install socket-level NKE */
-#define SO_NOSIGPIPE    0x1022          /* APPLE: No SIGPIPE on EPIPE */
-#define SO_NOADDRERR    0x1023          /* APPLE: Returns EADDRNOTAVAIL when src is not available anymore */
-#define SO_NWRITE       0x1024          /* APPLE: Get number of bytes currently in send socket buffer */
-#define SO_REUSESHAREUID        0x1025          /* APPLE: Allow reuse of port/socket by different userids */
-#ifdef __APPLE_API_PRIVATE
-#define SO_NOTIFYCONFLICT       0x1026  /* APPLE: send notification if there is a bind on a port which is already in use */
-#define SO_UPCALLCLOSEWAIT      0x1027  /* APPLE: block on close until an upcall returns */
-#endif
-#define SO_LINGER_SEC   0x1080          /* linger on close if data present (in seconds) */
-#define SO_RANDOMPORT   0x1082  /* APPLE: request local port randomization */
-#define SO_NP_EXTENSIONS        0x1083  /* To turn off some POSIX behavior */
-#endif
-
-#define SO_NUMRCVPKT            0x1112  /* number of datagrams in receive socket buffer */
-#define SO_NET_SERVICE_TYPE     0x1116  /* Network service type */
-
-
-#define SO_NETSVC_MARKING_LEVEL 0x1119  /* Get QoS marking in effect for socket */
-
-/*
- * Network Service Type for option SO_NET_SERVICE_TYPE
- *
- * The vast majority of sockets should use Best Effort that is the default
- * Network Service Type. Other Network Service Types have to be used only if
- * the traffic actually matches the description of the Network Service Type.
- *
- * Network Service Types do not represent priorities but rather describe
- * different categories of delay, jitter and loss parameters.
- * Those parameters may influence protocols from layer 4 protocols like TCP
- * to layer 2 protocols like Wi-Fi. The Network Service Type can determine
- * how the traffic is queued and scheduled by the host networking stack and
- * by other entities on the network like switches and routers. For example
- * for Wi-Fi, the Network Service Type can select the marking of the
- * layer 2 packet with the appropriate WMM Access Category.
- *
- * There is no point in attempting to game the system and use
- * a Network Service Type that does not correspond to the actual
- * traffic characteristic but one that seems to have a higher precedence.
- * The reason is that for service classes that have lower tolerance
- * for delay and jitter, the queues size is lower than for service
- * classes that are more tolerant to delay and jitter.
- *
- * For example using a voice service type for bulk data transfer will lead
- * to disastrous results as soon as congestion happens because the voice
- * queue overflows and packets get dropped. This is not only bad for the bulk
- * data transfer but it is also bad for VoIP apps that legitimately are using
- * the voice  service type.
- *
- * The characteristics of the Network Service Types are based on the service
- * classes defined in RFC 4594 "Configuration Guidelines for DiffServ Service
- * Classes"
- *
- * When system detects the outgoing interface belongs to a DiffServ domain
- * that follows the recommendation of the IETF draft "Guidelines for DiffServ to
- * IEEE 802.11 Mapping", the packet will marked at layer 3 with a DSCP value
- * that corresponds to Network Service Type.
- *
- * NET_SERVICE_TYPE_BE
- *	"Best Effort", unclassified/standard.  This is the default service
- *	class and cover the majority of the traffic.
- *
- * NET_SERVICE_TYPE_BK
- *	"Background", high delay tolerant, loss tolerant. elastic flow,
- *	variable size & long-lived. E.g: non-interactive network bulk transfer
- *	like synching or backup.
- *
- * NET_SERVICE_TYPE_RD
- *	"Responsive Data", a notch higher than "Best Effort", medium delay
- *	tolerant, elastic & inelastic flow, bursty, long-lived. E.g. email,
- *	instant messaging, for which there is a sense of interactivity and
- *	urgency (user waiting for output).
- *
- * NET_SERVICE_TYPE_OAM
- *	"Operations, Administration, and Management", medium delay tolerant,
- *	low-medium loss tolerant, elastic & inelastic flows, variable size.
- *	E.g. VPN tunnels.
- *
- * NET_SERVICE_TYPE_AV
- *	"Multimedia Audio/Video Streaming", medium delay tolerant, low-medium
- *	loss tolerant, elastic flow, constant packet interval, variable rate
- *	and size. E.g. video and audio playback with buffering.
- *
- * NET_SERVICE_TYPE_RV
- *	"Responsive Multimedia Audio/Video", low delay tolerant, low-medium
- *	loss tolerant, elastic flow, variable packet interval, rate and size.
- *	E.g. screen sharing.
- *
- * NET_SERVICE_TYPE_VI
- *	"Interactive Video", low delay tolerant, low-medium loss tolerant,
- *	elastic flow, constant packet interval, variable rate & size. E.g.
- *	video telephony.
- *
- * NET_SERVICE_TYPE_SIG
- *	"Signaling", low delay tolerant, low loss tolerant, inelastic flow,
- *	jitter tolerant, rate is bursty but short, variable size. E.g. SIP.
- *
- * NET_SERVICE_TYPE_VO
- *	"Interactive Voice", very low delay tolerant, very low loss tolerant,
- *	inelastic flow, constant packet rate, somewhat fixed size.
- *	E.g. VoIP.
- */
-
-#define NET_SERVICE_TYPE_BE     0 /* Best effort */
-#define NET_SERVICE_TYPE_BK     1 /* Background system initiated */
-#define NET_SERVICE_TYPE_SIG    2 /* Signaling */
-#define NET_SERVICE_TYPE_VI     3 /* Interactive Video */
-#define NET_SERVICE_TYPE_VO     4 /* Interactive Voice */
-#define NET_SERVICE_TYPE_RV     5 /* Responsive Multimedia Audio/Video */
-#define NET_SERVICE_TYPE_AV     6 /* Multimedia Audio/Video Streaming */
-#define NET_SERVICE_TYPE_OAM    7 /* Operations, Administration, and Management */
-#define NET_SERVICE_TYPE_RD     8 /* Responsive Data */
-
-
-/* These are supported values for SO_NETSVC_MARKING_LEVEL */
-#define NETSVC_MRKNG_UNKNOWN            0       /* The outgoing network interface is not known */
-#define NETSVC_MRKNG_LVL_L2             1       /* Default marking at layer 2 (for example Wi-Fi WMM) */
-#define NETSVC_MRKNG_LVL_L3L2_ALL       2       /* Layer 3 DSCP marking and layer 2 marking for all Network Service Types */
-#define NETSVC_MRKNG_LVL_L3L2_BK        3       /* The system policy limits layer 3 DSCP marking and layer 2 marking
-	                                         * to background Network Service Types */
-
-
-typedef __uint32_t sae_associd_t;
-#define SAE_ASSOCID_ANY 0
-#define SAE_ASSOCID_ALL ((sae_associd_t)(-1ULL))
-
-typedef __uint32_t sae_connid_t;
-#define SAE_CONNID_ANY  0
-#define SAE_CONNID_ALL  ((sae_connid_t)(-1ULL))
-
-/* connectx() flag parameters */
-#define CONNECT_RESUME_ON_READ_WRITE    0x1 /* resume connect() on read/write */
-#define CONNECT_DATA_IDEMPOTENT         0x2 /* data is idempotent */
-#define CONNECT_DATA_AUTHENTICATED      0x4 /* data includes security that replaces the TFO-cookie */
-
-/* sockaddr endpoints */
-typedef struct sa_endpoints {
-	unsigned int            sae_srcif;      /* optional source interface */
-	const struct sockaddr   *sae_srcaddr;   /* optional source address */
-	socklen_t               sae_srcaddrlen; /* size of source address */
-	const struct sockaddr   *sae_dstaddr;   /* destination address */
-	socklen_t               sae_dstaddrlen; /* size of destination address */
-} sa_endpoints_t;
-#endif  /* (!_POSIX_C_SOURCE || _DARWIN_C_SOURCE) */
-
-/*
- * Structure used for manipulating linger option.
- */
-struct  linger {
-	int     l_onoff;                /* option on/off */
-	int     l_linger;               /* linger time */
-};
-
-#ifndef __APPLE__
-struct  accept_filter_arg {
-	char    af_name[16];
-	char    af_arg[256 - 16];
-};
-#endif
-
-#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-#ifdef __APPLE__
-
-/*
- * Structure to control non-portable Sockets extension to POSIX
- */
-struct so_np_extensions {
-	u_int32_t       npx_flags;
-	u_int32_t       npx_mask;
-};
-
-#define SONPX_SETOPTSHUT        0x000000001     /* flag for allowing setsockopt after shutdown */
-
-
-
-#endif
-#endif
-
-/*
- * Level number for (get/set)sockopt() to apply to socket itself.
- */
-#define SOL_SOCKET      0xffff          /* options for socket level */
-
-
-/*
- * Address families.
- */
-#define AF_UNSPEC       0               /* unspecified */
-#define AF_UNIX         1               /* local to host (pipes) */
-#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-#define AF_LOCAL        AF_UNIX         /* backward compatibility */
-#endif  /* (!_POSIX_C_SOURCE || _DARWIN_C_SOURCE) */
-#define AF_INET         2               /* internetwork: UDP, TCP, etc. */
-#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-#define AF_IMPLINK      3               /* arpanet imp addresses */
-#define AF_PUP          4               /* pup protocols: e.g. BSP */
-#define AF_CHAOS        5               /* mit CHAOS protocols */
-#define AF_NS           6               /* XEROX NS protocols */
-#define AF_ISO          7               /* ISO protocols */
-#define AF_OSI          AF_ISO
-#define AF_ECMA         8               /* European computer manufacturers */
-#define AF_DATAKIT      9               /* datakit protocols */
-#define AF_CCITT        10              /* CCITT protocols, X.25 etc */
-#define AF_SNA          11              /* IBM SNA */
-#define AF_DECnet       12              /* DECnet */
-#define AF_DLI          13              /* DEC Direct data link interface */
-#define AF_LAT          14              /* LAT */
-#define AF_HYLINK       15              /* NSC Hyperchannel */
-#define AF_APPLETALK    16              /* Apple Talk */
-#define AF_ROUTE        17              /* Internal Routing Protocol */
-#define AF_LINK         18              /* Link layer interface */
-#define pseudo_AF_XTP   19              /* eXpress Transfer Protocol (no AF) */
-#define AF_COIP         20              /* connection-oriented IP, aka ST II */
-#define AF_CNT          21              /* Computer Network Technology */
-#define pseudo_AF_RTIP  22              /* Help Identify RTIP packets */
-#define AF_IPX          23              /* Novell Internet Protocol */
-#define AF_SIP          24              /* Simple Internet Protocol */
-#define pseudo_AF_PIP   25              /* Help Identify PIP packets */
-#define AF_NDRV         27              /* Network Driver 'raw' access */
-#define AF_ISDN         28              /* Integrated Services Digital Network */
-#define AF_E164         AF_ISDN         /* CCITT E.164 recommendation */
-#define pseudo_AF_KEY   29              /* Internal key-management function */
-#endif  /* (!_POSIX_C_SOURCE || _DARWIN_C_SOURCE) */
-#define AF_INET6        30              /* IPv6 */
-#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-#define AF_NATM         31              /* native ATM access */
-#define AF_SYSTEM       32              /* Kernel event messages */
-#define AF_NETBIOS      33              /* NetBIOS */
-#define AF_PPP          34              /* PPP communication protocol */
-#define pseudo_AF_HDRCMPLT 35           /* Used by BPF to not rewrite headers
-	                                 *  in interface output routine */
-#define AF_RESERVED_36  36              /* Reserved for internal usage */
-#define AF_IEEE80211    37              /* IEEE 802.11 protocol */
-#define AF_UTUN         38
-#define AF_MAX          40
-#endif  /* (!_POSIX_C_SOURCE || _DARWIN_C_SOURCE) */
-
-/*
- * [XSI] Structure used by kernel to store most addresses.
- */
-struct sockaddr {
-	__uint8_t       sa_len;         /* total length */
-	sa_family_t     sa_family;      /* [XSI] address family */
-	char            sa_data[14];    /* [XSI] addr value (actually larger) */
-};
-
-#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-#define SOCK_MAXADDRLEN 255             /* longest possible addresses */
-
-/*
- * Structure used by kernel to pass protocol
- * information in raw sockets.
- */
-struct sockproto {
-	__uint16_t      sp_family;              /* address family */
-	__uint16_t      sp_protocol;            /* protocol */
-};
-#endif  /* (!_POSIX_C_SOURCE || _DARWIN_C_SOURCE) */
-
-/*
- * RFC 2553: protocol-independent placeholder for socket addresses
- */
-#define _SS_MAXSIZE     128
-#define _SS_ALIGNSIZE   (sizeof(__int64_t))
-#define _SS_PAD1SIZE    \
-	        (_SS_ALIGNSIZE - sizeof(__uint8_t) - sizeof(sa_family_t))
-#define _SS_PAD2SIZE    \
-	        (_SS_MAXSIZE - sizeof(__uint8_t) - sizeof(sa_family_t) - \
-	                        _SS_PAD1SIZE - _SS_ALIGNSIZE)
-
-/*
- * [XSI] sockaddr_storage
- */
-struct sockaddr_storage {
-	__uint8_t       ss_len;         /* address length */
-	sa_family_t     ss_family;      /* [XSI] address family */
-	char                    __ss_pad1[_SS_PAD1SIZE];
-	__int64_t       __ss_align;     /* force structure storage alignment */
-	char                    __ss_pad2[_SS_PAD2SIZE];
-};
-
-/*
- * Protocol families, same as address families for now.
- */
-#define PF_UNSPEC       AF_UNSPEC
-#define PF_LOCAL        AF_LOCAL
-#define PF_UNIX         PF_LOCAL        /* backward compatibility */
-#define PF_INET         AF_INET
-#define PF_IMPLINK      AF_IMPLINK
-#define PF_PUP          AF_PUP
-#define PF_CHAOS        AF_CHAOS
-#define PF_NS           AF_NS
-#define PF_ISO          AF_ISO
-#define PF_OSI          AF_ISO
-#define PF_ECMA         AF_ECMA
-#define PF_DATAKIT      AF_DATAKIT
-#define PF_CCITT        AF_CCITT
-#define PF_SNA          AF_SNA
-#define PF_DECnet       AF_DECnet
-#define PF_DLI          AF_DLI
-#define PF_LAT          AF_LAT
-#define PF_HYLINK       AF_HYLINK
-#define PF_APPLETALK    AF_APPLETALK
-#define PF_ROUTE        AF_ROUTE
-#define PF_LINK         AF_LINK
-#define PF_XTP          pseudo_AF_XTP   /* really just proto family, no AF */
-#define PF_COIP         AF_COIP
-#define PF_CNT          AF_CNT
-#define PF_SIP          AF_SIP
-#define PF_IPX          AF_IPX          /* same format as AF_NS */
-#define PF_RTIP         pseudo_AF_RTIP  /* same format as AF_INET */
-#define PF_PIP          pseudo_AF_PIP
-#define PF_NDRV         AF_NDRV
-#define PF_ISDN         AF_ISDN
-#define PF_KEY          pseudo_AF_KEY
-#define PF_INET6        AF_INET6
-#define PF_NATM         AF_NATM
-#define PF_SYSTEM       AF_SYSTEM
-#define PF_NETBIOS      AF_NETBIOS
-#define PF_PPP          AF_PPP
-#define PF_RESERVED_36  AF_RESERVED_36
-#define PF_UTUN         AF_UTUN
-#define PF_MAX          AF_MAX
-
-/*
- * These do not have socket-layer support:
- */
-#define PF_VLAN         ((uint32_t)0x766c616e)  /* 'vlan' */
-#define PF_BOND         ((uint32_t)0x626f6e64)  /* 'bond' */
-
-/*
- * Definitions for network related sysctl, CTL_NET.
- *
- * Second level is protocol family.
- * Third level is protocol number.
- *
- * Further levels are defined by the individual families below.
- */
-#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-#define NET_MAXID       AF_MAX
-#endif /* (_POSIX_C_SOURCE && !_DARWIN_C_SOURCE) */
-
-
-#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-/*
- * PF_ROUTE - Routing table
- *
- * Three additional levels are defined:
- *	Fourth: address family, 0 is wildcard
- *	Fifth: type of info, defined below
- *	Sixth: flag(s) to mask with for NET_RT_FLAGS
- */
-#define NET_RT_DUMP             1       /* dump; may limit to a.f. */
-#define NET_RT_FLAGS            2       /* by flags, e.g. RESOLVING */
-#define NET_RT_IFLIST           3       /* survey interface list */
-#define NET_RT_STAT             4       /* routing statistics */
-#define NET_RT_TRASH            5       /* routes not in table but not freed */
-#define NET_RT_IFLIST2          6       /* interface list with addresses */
-#define NET_RT_DUMP2            7       /* dump; may limit to a.f. */
-/*
- * Allows read access non-local host's MAC address
- * if the process has neighbor cache entitlement.
- */
-#define NET_RT_FLAGS_PRIV       10
-#define NET_RT_MAXID            11
-#endif /* (_POSIX_C_SOURCE && !_DARWIN_C_SOURCE) */
-
-
-
-
-/*
- * Maximum queue length specifiable by listen.
- */
-#define SOMAXCONN       128
-
-/*
- * [XSI] Message header for recvmsg and sendmsg calls.
- * Used value-result for recvmsg, value only for sendmsg.
- */
-struct msghdr {
-	void            *msg_name;      /* [XSI] optional address */
-	socklen_t       msg_namelen;    /* [XSI] size of address */
-	struct          iovec *msg_iov; /* [XSI] scatter/gather array */
-	int             msg_iovlen;     /* [XSI] # elements in msg_iov */
-	void            *msg_control;   /* [XSI] ancillary data, see below */
-	socklen_t       msg_controllen; /* [XSI] ancillary data buffer len */
-	int             msg_flags;      /* [XSI] flags on received message */
-};
-
-
-
-#define MSG_OOB         0x1             /* process out-of-band data */
-#define MSG_PEEK        0x2             /* peek at incoming message */
-#define MSG_DONTROUTE   0x4             /* send without using routing tables */
-#define MSG_EOR         0x8             /* data completes record */
-#define MSG_TRUNC       0x10            /* data discarded before delivery */
-#define MSG_CTRUNC      0x20            /* control data lost before delivery */
-#define MSG_WAITALL     0x40            /* wait for full request or error */
-#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-#define MSG_DONTWAIT    0x80            /* this message should be nonblocking */
-#define MSG_EOF         0x100           /* data completes connection */
-#ifdef __APPLE__
-#ifdef __APPLE_API_OBSOLETE
-#define MSG_WAITSTREAM  0x200           /* wait up to full request.. may return partial */
-#endif
-#define MSG_FLUSH       0x400           /* Start of 'hold' seq; dump so_temp, deprecated */
-#define MSG_HOLD        0x800           /* Hold frag in so_temp, deprecated */
-#define MSG_SEND        0x1000          /* Send the packet in so_temp, deprecated */
-#define MSG_HAVEMORE    0x2000          /* Data ready to be read */
-#define MSG_RCVMORE     0x4000          /* Data remains in current pkt */
-#endif
-#define MSG_NEEDSA      0x10000         /* Fail receive if socket address cannot be allocated */
-#endif  /* (!_POSIX_C_SOURCE || _DARWIN_C_SOURCE) */
-
-/*
- * Header for ancillary data objects in msg_control buffer.
- * Used for additional information with/about a datagram
- * not expressible by flags.  The format is a sequence
- * of message elements headed by cmsghdr structures.
- */
-struct cmsghdr {
-	socklen_t       cmsg_len;       /* [XSI] data byte count, including hdr */
-	int             cmsg_level;     /* [XSI] originating protocol */
-	int             cmsg_type;      /* [XSI] protocol-specific type */
-/* followed by	unsigned char  cmsg_data[]; */
-};
-
-#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-#ifndef __APPLE__
-/*
- * While we may have more groups than this, the cmsgcred struct must
- * be able to fit in an mbuf, and NGROUPS_MAX is too large to allow
- * this.
- */
-#define CMGROUP_MAX 16
-
-/*
- * Credentials structure, used to verify the identity of a peer
- * process that has sent us a message. This is allocated by the
- * peer process but filled in by the kernel. This prevents the
- * peer from lying about its identity. (Note that cmcred_groups[0]
- * is the effective GID.)
- */
-struct cmsgcred {
-	pid_t   cmcred_pid;             /* PID of sending process */
-	uid_t   cmcred_uid;             /* real UID of sending process */
-	uid_t   cmcred_euid;            /* effective UID of sending process */
-	gid_t   cmcred_gid;             /* real GID of sending process */
-	short   cmcred_ngroups;         /* number or groups */
-	gid_t   cmcred_groups[CMGROUP_MAX];     /* groups */
-};
-#endif
-#endif  /* (!_POSIX_C_SOURCE || _DARWIN_C_SOURCE) */
-
-/* given pointer to struct cmsghdr, return pointer to data */
-#define CMSG_DATA(cmsg)         ((unsigned char *)(cmsg) + \
-	__DARWIN_ALIGN32(sizeof(struct cmsghdr)))
-
-/*
- * RFC 2292 requires to check msg_controllen, in case that the kernel returns
- * an empty list for some reasons.
- */
-#define CMSG_FIRSTHDR(mhdr) \
-	((mhdr)->msg_controllen >= sizeof(struct cmsghdr) ? \
-	    (struct cmsghdr *)(mhdr)->msg_control : \
-	    (struct cmsghdr *)0L)
-
-
-/*
- * Given pointer to struct cmsghdr, return pointer to next cmsghdr
- * RFC 2292 says that CMSG_NXTHDR(mhdr, NULL) is equivalent to CMSG_FIRSTHDR(mhdr)
- */
-#define CMSG_NXTHDR(mhdr, cmsg)                                         \
-	((char *)(cmsg) == (char *)0L ? CMSG_FIRSTHDR(mhdr) :           \
-	    ((((unsigned char *)(cmsg) +                                \
-	    __DARWIN_ALIGN32((__uint32_t)(cmsg)->cmsg_len) +            \
-	    __DARWIN_ALIGN32(sizeof(struct cmsghdr))) >                 \
-	    ((unsigned char *)(mhdr)->msg_control +                     \
-	    (mhdr)->msg_controllen)) ?                                  \
-	        (struct cmsghdr *)0L /* NULL */ :                       \
-	        (struct cmsghdr *)(void *)((unsigned char *)(cmsg) +    \
-	            __DARWIN_ALIGN32((__uint32_t)(cmsg)->cmsg_len))))
-
-#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-/* RFC 2292 additions */
-#define CMSG_SPACE(l)           (__DARWIN_ALIGN32(sizeof(struct cmsghdr)) + __DARWIN_ALIGN32(l))
-#define CMSG_LEN(l)             (__DARWIN_ALIGN32(sizeof(struct cmsghdr)) + (l))
-
-#endif  /* (!_POSIX_C_SOURCE || _DARWIN_C_SOURCE) */
-
-/* "Socket"-level control message types: */
-#define SCM_RIGHTS                      0x01    /* access rights (array of int) */
-#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-#define SCM_TIMESTAMP                   0x02    /* timestamp (struct timeval) */
-#define SCM_CREDS                       0x03    /* process creds (struct cmsgcred) */
-#define SCM_TIMESTAMP_MONOTONIC         0x04    /* timestamp (uint64_t) */
-
-
-#endif  /* (!_POSIX_C_SOURCE || _DARWIN_C_SOURCE) */
-
-/*
- * howto arguments for shutdown(2), specified by Posix.1g.
- */
-#define SHUT_RD         0               /* shut down the reading side */
-#define SHUT_WR         1               /* shut down the writing side */
-#define SHUT_RDWR       2               /* shut down both sides */
-
-#if !defined(_POSIX_C_SOURCE)
-/*
- * sendfile(2) header/trailer struct
- */
-struct sf_hdtr {
-	struct iovec *headers;  /* pointer to an array of header struct iovec's */
-	int hdr_cnt;            /* number of header iovec's */
-	struct iovec *trailers; /* pointer to an array of trailer struct iovec's */
-	int trl_cnt;            /* number of trailer iovec's */
-};
-
-
-#endif  /* !_POSIX_C_SOURCE */
-
-
-__BEGIN_DECLS
-
-int     accept(int, struct sockaddr * __restrict, socklen_t * __restrict)
-__DARWIN_ALIAS_C(accept);
-int     bind(int, const struct sockaddr *, socklen_t) __DARWIN_ALIAS(bind);
-int     connect(int, const struct sockaddr *, socklen_t) __DARWIN_ALIAS_C(connect);
-int     getpeername(int, struct sockaddr * __restrict, socklen_t * __restrict)
-__DARWIN_ALIAS(getpeername);
-int     getsockname(int, struct sockaddr * __restrict, socklen_t * __restrict)
-__DARWIN_ALIAS(getsockname);
-int     getsockopt(int, int, int, void * __restrict, socklen_t * __restrict);
-int     listen(int, int) __DARWIN_ALIAS(listen);
-ssize_t recv(int, void *, size_t, int) __DARWIN_ALIAS_C(recv);
-ssize_t recvfrom(int, void *, size_t, int, struct sockaddr * __restrict,
-    socklen_t * __restrict) __DARWIN_ALIAS_C(recvfrom);
-ssize_t recvmsg(int, struct msghdr *, int) __DARWIN_ALIAS_C(recvmsg);
-ssize_t send(int, const void *, size_t, int) __DARWIN_ALIAS_C(send);
-ssize_t sendmsg(int, const struct msghdr *, int) __DARWIN_ALIAS_C(sendmsg);
-ssize_t sendto(int, const void *, size_t,
-    int, const struct sockaddr *, socklen_t) __DARWIN_ALIAS_C(sendto);
-int     setsockopt(int, int, int, const void *, socklen_t);
-int     shutdown(int, int);
-int     sockatmark(int) __OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_2_0);
-int     socket(int, int, int);
-int     socketpair(int, int, int, int *) __DARWIN_ALIAS(socketpair);
-
-#if !defined(_POSIX_C_SOURCE)
-int     sendfile(int, int, off_t, off_t *, struct sf_hdtr *, int);
-#endif  /* !_POSIX_C_SOURCE */
-
-#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-void    pfctlinput(int, struct sockaddr *);
-
-__API_AVAILABLE(macosx(10.11), ios(9.0), tvos(9.0), watchos(2.0))
-int connectx(int, const sa_endpoints_t *, sae_associd_t, unsigned int,
-    const struct iovec *, unsigned int, size_t *, sae_connid_t *);
-
-__API_AVAILABLE(macosx(10.11), ios(9.0), tvos(9.0), watchos(2.0))
-int disconnectx(int, sae_associd_t, sae_connid_t);
-#endif  /* (!_POSIX_C_SOURCE || _DARWIN_C_SOURCE) */
-__END_DECLS
-
-
-#endif /* !_SYS_SOCKET_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/sys/sockio.h b/lib/libc/include/x86_64-macos-gnu/sys/sockio.h
deleted file mode 100644
index c18d55b522..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/sys/sockio.h
+++ /dev/null
@@ -1,180 +0,0 @@
-/*
- * Copyright (c) 2000-2019 Apple Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-/* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */
-/*-
- * Copyright (c) 1982, 1986, 1990, 1993, 1994
- *	The Regents of the University of California.  All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *	This product includes software developed by the University of
- *	California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *	@(#)sockio.h	8.1 (Berkeley) 3/28/94
- */
-
-#ifndef _SYS_SOCKIO_H_
-#define _SYS_SOCKIO_H_
-
-#include <sys/appleapiopts.h>
-
-#include <sys/ioccom.h>
-
-/* Socket ioctl's. */
-#define SIOCSHIWAT       _IOW('s',  0, int)             /* set high watermark */
-#define SIOCGHIWAT       _IOR('s',  1, int)             /* get high watermark */
-#define SIOCSLOWAT       _IOW('s',  2, int)             /* set low watermark */
-#define SIOCGLOWAT       _IOR('s',  3, int)             /* get low watermark */
-#define SIOCATMARK       _IOR('s',  7, int)             /* at oob mark? */
-#define SIOCSPGRP        _IOW('s',  8, int)             /* set process group */
-#define SIOCGPGRP        _IOR('s',  9, int)             /* get process group */
-
-/*
- * OSIOCGIF* ioctls are deprecated; they are kept for binary compatibility.
- */
-#define SIOCSIFADDR     _IOW('i', 12, struct ifreq)     /* set ifnet address */
-#define SIOCSIFDSTADDR   _IOW('i', 14, struct ifreq)    /* set p-p address */
-#define SIOCSIFFLAGS     _IOW('i', 16, struct ifreq)    /* set ifnet flags */
-#define SIOCGIFFLAGS    _IOWR('i', 17, struct ifreq)    /* get ifnet flags */
-#define SIOCSIFBRDADDR   _IOW('i', 19, struct ifreq)    /* set broadcast addr */
-#define SIOCSIFNETMASK   _IOW('i', 22, struct ifreq)    /* set net addr mask */
-#define SIOCGIFMETRIC   _IOWR('i', 23, struct ifreq)    /* get IF metric */
-#define SIOCSIFMETRIC   _IOW('i', 24, struct ifreq)     /* set IF metric */
-#define SIOCDIFADDR     _IOW('i', 25, struct ifreq)     /* delete IF addr */
-#define SIOCAIFADDR     _IOW('i', 26, struct ifaliasreq)/* add/chg IF alias */
-
-#define SIOCGIFADDR     _IOWR('i', 33, struct ifreq)    /* get ifnet address */
-#define SIOCGIFDSTADDR  _IOWR('i', 34, struct ifreq)    /* get p-p address */
-#define SIOCGIFBRDADDR  _IOWR('i', 35, struct ifreq)    /* get broadcast addr */
-#define SIOCGIFCONF     _IOWR('i', 36, struct ifconf)   /* get ifnet list */
-#define SIOCGIFNETMASK  _IOWR('i', 37, struct ifreq)    /* get net addr mask */
-#define SIOCAUTOADDR    _IOWR('i', 38, struct ifreq)    /* autoconf address */
-#define SIOCAUTONETMASK _IOW('i', 39, struct ifreq)     /* autoconf netmask */
-#define SIOCARPIPLL             _IOWR('i', 40, struct ifreq)    /* arp for IPv4LL address */
-
-#define SIOCADDMULTI     _IOW('i', 49, struct ifreq)    /* add m'cast addr */
-#define SIOCDELMULTI     _IOW('i', 50, struct ifreq)    /* del m'cast addr */
-#define SIOCGIFMTU      _IOWR('i', 51, struct ifreq)    /* get IF mtu */
-#define SIOCSIFMTU       _IOW('i', 52, struct ifreq)    /* set IF mtu */
-#define SIOCGIFPHYS     _IOWR('i', 53, struct ifreq)    /* get IF wire */
-#define SIOCSIFPHYS      _IOW('i', 54, struct ifreq)    /* set IF wire */
-#define SIOCSIFMEDIA    _IOWR('i', 55, struct ifreq)    /* set net media */
-
-/*
- * The command SIOCGIFMEDIA does not allow a process to access the extended
- * media subtype and extended subtype values are returned as IFM_OTHER.
- */
-#define SIOCGIFMEDIA    _IOWR('i', 56, struct ifmediareq) /* get compatible net media  */
-
-#define SIOCSIFGENERIC   _IOW('i', 57, struct ifreq)    /* generic IF set op */
-#define SIOCGIFGENERIC  _IOWR('i', 58, struct ifreq)    /* generic IF get op */
-#define SIOCRSLVMULTI   _IOWR('i', 59, struct rslvmulti_req)
-
-#define SIOCSIFLLADDR   _IOW('i', 60, struct ifreq)     /* set link level addr */
-#define SIOCGIFSTATUS   _IOWR('i', 61, struct ifstat)   /* get IF status */
-#define SIOCSIFPHYADDR   _IOW('i', 62, struct ifaliasreq) /* set gif addres */
-#define SIOCGIFPSRCADDR _IOWR('i', 63, struct ifreq)    /* get gif psrc addr */
-#define SIOCGIFPDSTADDR _IOWR('i', 64, struct ifreq)    /* get gif pdst addr */
-#define SIOCDIFPHYADDR   _IOW('i', 65, struct ifreq)    /* delete gif addrs */
-
-#define SIOCGIFDEVMTU   _IOWR('i', 68, struct ifreq)    /* get if ifdevmtu */
-#define SIOCSIFALTMTU    _IOW('i', 69, struct ifreq)    /* set if alternate mtu */
-#define SIOCGIFALTMTU   _IOWR('i', 72, struct ifreq)    /* get if alternate mtu */
-#define SIOCSIFBOND      _IOW('i', 70, struct ifreq)    /* set bond if config */
-#define SIOCGIFBOND     _IOWR('i', 71, struct ifreq)    /* get bond if config */
-
-/*
- * The command SIOCGIFXMEDIA is meant to be used by processes only to be able
- * to access the extended media subtypes with the extended IFM_TMASK.
- *
- * An ifnet must not implement SIOCGIFXMEDIA as it gets the extended
- * media subtypes by simply compiling with <net/if_media.h>
- */
-#define SIOCGIFXMEDIA   _IOWR('i', 72, struct ifmediareq) /* get net extended media */
-
-
-#define SIOCSIFCAP       _IOW('i', 90, struct ifreq)    /* set IF features */
-#define SIOCGIFCAP      _IOWR('i', 91, struct ifreq)    /* get IF features */
-
-#define SIOCIFCREATE    _IOWR('i', 120, struct ifreq)   /* create clone if */
-#define SIOCIFDESTROY    _IOW('i', 121, struct ifreq)   /* destroy clone if */
-#define SIOCIFCREATE2   _IOWR('i', 122, struct ifreq)   /* create clone if with data */
-
-#define SIOCSDRVSPEC    _IOW('i', 123, struct ifdrv)    /* set driver-specific
-	                                                 *         parameters */
-#define SIOCGDRVSPEC    _IOWR('i', 123, struct ifdrv)   /* get driver-specific
-	                                                 *         parameters */
-#define SIOCSIFVLAN      _IOW('i', 126, struct ifreq)   /* set VLAN config */
-#define SIOCGIFVLAN     _IOWR('i', 127, struct ifreq)   /* get VLAN config */
-#define SIOCSETVLAN     SIOCSIFVLAN
-#define SIOCGETVLAN     SIOCGIFVLAN
-
-#define SIOCIFGCLONERS  _IOWR('i', 129, struct if_clonereq) /* get cloners */
-
-#define SIOCGIFASYNCMAP _IOWR('i', 124, struct ifreq)   /* get ppp asyncmap */
-#define SIOCSIFASYNCMAP _IOW('i', 125, struct ifreq)    /* set ppp asyncmap */
-
-
-
-#define SIOCGIFMAC      _IOWR('i', 130, struct ifreq)   /* get IF MAC label */
-#define SIOCSIFMAC      _IOW('i', 131, struct ifreq)    /* set IF MAC label */
-#define SIOCSIFKPI      _IOW('i', 134, struct ifreq) /* set interface kext param - root only */
-#define SIOCGIFKPI      _IOWR('i', 135, struct ifreq) /* get interface kext param */
-
-#define SIOCGIFWAKEFLAGS _IOWR('i', 136, struct ifreq) /* get interface wake property flags */
-
-#define SIOCGIFFUNCTIONALTYPE   _IOWR('i', 173, struct ifreq) /* get interface functional type */
-
-#define SIOCSIF6LOWPAN  _IOW('i', 196, struct ifreq)    /* set 6LOWPAN config */
-#define SIOCGIF6LOWPAN  _IOWR('i', 197, struct ifreq)   /* get 6LOWPAN config */
-
-
-#endif /* !_SYS_SOCKIO_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/sys/spawn.h b/lib/libc/include/x86_64-macos-gnu/sys/spawn.h
deleted file mode 100644
index 483f017b69..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/sys/spawn.h
+++ /dev/null
@@ -1,77 +0,0 @@
-/*
- * Copyright (c) 2006 Apple Computer, Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-
-/*
- * [SPN] Support for _POSIX_SPAWN
- *
- * This header contains information that is shared between the user space
- * and kernel versions of the posix_spawn() code.  Shared elements are all
- * manifest constants, at the current time.
- */
-
-#ifndef _SYS_SPAWN_H_
-#define _SYS_SPAWN_H_
-
-/*
- * Possible bit values which may be OR'ed together and provided as the second
- * parameter to posix_spawnattr_setflags() or implicit returned in the value of
- * the second parameter to posix_spawnattr_getflags().
- */
-#define POSIX_SPAWN_RESETIDS            0x0001  /* [SPN] R[UG]ID not E[UG]ID */
-#define POSIX_SPAWN_SETPGROUP           0x0002  /* [SPN] set non-parent PGID */
-#define POSIX_SPAWN_SETSIGDEF           0x0004  /* [SPN] reset sigset default */
-#define POSIX_SPAWN_SETSIGMASK          0x0008  /* [SPN] set signal mask */
-
-#if 0   /* _POSIX_PRIORITY_SCHEDULING [PS] : not supported */
-#define POSIX_SPAWN_SETSCHEDPARAM       0x0010
-#define POSIX_SPAWN_SETSCHEDULER        0x0020
-#endif  /* 0 */
-
-#if     !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-/*
- * Darwin-specific flags
- */
-#define POSIX_SPAWN_SETEXEC             0x0040
-#define POSIX_SPAWN_START_SUSPENDED     0x0080
-#define POSIX_SPAWN_SETSID              0x0400
-#define POSIX_SPAWN_CLOEXEC_DEFAULT     0x4000
-
-/*
- * Possible values to be set for the process control actions on resource starvation.
- * POSIX_SPAWN_PCONTROL_THROTTLE indicates that the process is to be throttled on starvation.
- * POSIX_SPAWN_PCONTROL_SUSPEND indicates that the process is to be suspended on starvation.
- * POSIX_SPAWN_PCONTROL_KILL indicates that the process is to be terminated  on starvation.
- */
-#define POSIX_SPAWN_PCONTROL_NONE       0x0000
-#define POSIX_SPAWN_PCONTROL_THROTTLE   0x0001
-#define POSIX_SPAWN_PCONTROL_SUSPEND    0x0002
-#define POSIX_SPAWN_PCONTROL_KILL       0x0003
-
-#endif /* (!_POSIX_C_SOURCE || _DARWIN_C_SOURCE) */
-
-#endif  /* _SYS_SPAWN_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/sys/stat.h b/lib/libc/include/x86_64-macos-gnu/sys/stat.h
deleted file mode 100644
index 7f2a490ee1..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/sys/stat.h
+++ /dev/null
@@ -1,430 +0,0 @@
-/*
- * Copyright (c) 2000-2014 Apple Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-/* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */
-/*-
- * Copyright (c) 1982, 1986, 1989, 1993
- *	The Regents of the University of California.  All rights reserved.
- * (c) UNIX System Laboratories, Inc.
- * All or some portions of this file are derived from material licensed
- * to the University of California by American Telephone and Telegraph
- * Co. or Unix System Laboratories, Inc. and are reproduced herein with
- * the permission of UNIX System Laboratories, Inc.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *	This product includes software developed by the University of
- *	California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *	@(#)stat.h	8.9 (Berkeley) 8/17/94
- */
-
-
-#ifndef _SYS_STAT_H_
-#define _SYS_STAT_H_
-
-#include <sys/_types.h>
-#include <sys/cdefs.h>
-#include <Availability.h>
-
-/* [XSI] The timespec structure may be defined as described in <time.h> */
-#include <sys/_types/_timespec.h>
-
-/*
- * [XSI] The blkcnt_t, blksize_t, dev_t, ino_t, mode_t, nlink_t, uid_t,
- * gid_t, off_t, and time_t types shall be defined as described in
- * <sys/types.h>.
- */
-#include <sys/_types/_blkcnt_t.h>
-#include <sys/_types/_blksize_t.h>
-#include <sys/_types/_dev_t.h>                  /* device number */
-#include <sys/_types/_ino_t.h>
-
-#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-#include <sys/_types/_ino64_t.h>
-#endif /* !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE) */
-
-#include <sys/_types/_mode_t.h>
-#include <sys/_types/_nlink_t.h>
-#include <sys/_types/_uid_t.h>
-#include <sys/_types/_gid_t.h>
-#include <sys/_types/_off_t.h>
-#include <sys/_types/_time_t.h>
-
-#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-/*
- * XXX So deprecated, it would make your head spin
- *
- * The old stat structure.  In fact, this is not used by the kernel at all,
- * and should not be used by user space, and should be removed from this
- * header file entirely (along with the unused cvtstat() prototype in
- * vnode_internal.h).
- */
-struct ostat {
-	__uint16_t      st_dev;         /* inode's device */
-	ino_t           st_ino;         /* inode's number */
-	mode_t          st_mode;        /* inode protection mode */
-	nlink_t         st_nlink;       /* number of hard links */
-	__uint16_t      st_uid;         /* user ID of the file's owner */
-	__uint16_t      st_gid;         /* group ID of the file's group */
-	__uint16_t      st_rdev;        /* device type */
-	__int32_t       st_size;        /* file size, in bytes */
-	struct  timespec st_atimespec;  /* time of last access */
-	struct  timespec st_mtimespec;  /* time of last data modification */
-	struct  timespec st_ctimespec;  /* time of last file status change */
-	__int32_t       st_blksize;     /* optimal blocksize for I/O */
-	__int32_t       st_blocks;      /* blocks allocated for file */
-	__uint32_t      st_flags;       /* user defined flags for file */
-	__uint32_t      st_gen;         /* file generation number */
-};
-
-#define __DARWIN_STRUCT_STAT64_TIMES \
-	struct timespec st_atimespec;           /* time of last access */ \
-	struct timespec st_mtimespec;           /* time of last data modification */ \
-	struct timespec st_ctimespec;           /* time of last status change */ \
-	struct timespec st_birthtimespec;       /* time of file creation(birth) */
-
-#else /* (_POSIX_C_SOURCE && !_DARWIN_C_SOURCE) */
-
-#define __DARWIN_STRUCT_STAT64_TIMES \
-	time_t		st_atime;               /* [XSI] Time of last access */ \
-	long		st_atimensec;           /* nsec of last access */ \
-	time_t		st_mtime;               /* [XSI] Last data modification time */ \
-	long		st_mtimensec;           /* last data modification nsec */ \
-	time_t		st_ctime;               /* [XSI] Time of last status change */ \
-	long		st_ctimensec;           /* nsec of last status change */ \
-	time_t		st_birthtime;           /*  File creation time(birth)  */ \
-	long		st_birthtimensec;       /* nsec of File creation time */
-
-#endif /* (!_POSIX_C_SOURCE || _DARWIN_C_SOURCE) */
-
-/*
- * This structure is used as the second parameter to the fstat64(),
- * lstat64(), and stat64() functions, and for struct stat when
- * __DARWIN_64_BIT_INO_T is set. __DARWIN_STRUCT_STAT64 is defined
- * above, depending on whether we use struct timespec or the direct
- * components.
- *
- * This is simillar to stat except for 64bit inode number
- * number instead of 32bit ino_t and the addition of create(birth) time.
- */
-#define __DARWIN_STRUCT_STAT64 { \
-	dev_t		st_dev;                 /* [XSI] ID of device containing file */ \
-	mode_t		st_mode;                /* [XSI] Mode of file (see below) */ \
-	nlink_t		st_nlink;               /* [XSI] Number of hard links */ \
-	__darwin_ino64_t st_ino;                /* [XSI] File serial number */ \
-	uid_t		st_uid;                 /* [XSI] User ID of the file */ \
-	gid_t		st_gid;                 /* [XSI] Group ID of the file */ \
-	dev_t		st_rdev;                /* [XSI] Device ID */ \
-	__DARWIN_STRUCT_STAT64_TIMES \
-	off_t		st_size;                /* [XSI] file size, in bytes */ \
-	blkcnt_t	st_blocks;              /* [XSI] blocks allocated for file */ \
-	blksize_t	st_blksize;             /* [XSI] optimal blocksize for I/O */ \
-	__uint32_t	st_flags;               /* user defined flags for file */ \
-	__uint32_t	st_gen;                 /* file generation number */ \
-	__int32_t	st_lspare;              /* RESERVED: DO NOT USE! */ \
-	__int64_t	st_qspare[2];           /* RESERVED: DO NOT USE! */ \
-}
-
-/*
- * [XSI] This structure is used as the second parameter to the fstat(),
- * lstat(), and stat() functions.
- */
-#if __DARWIN_64_BIT_INO_T
-
-struct stat __DARWIN_STRUCT_STAT64;
-
-#else /* !__DARWIN_64_BIT_INO_T */
-
-struct stat {
-	dev_t           st_dev;         /* [XSI] ID of device containing file */
-	ino_t           st_ino;         /* [XSI] File serial number */
-	mode_t          st_mode;        /* [XSI] Mode of file (see below) */
-	nlink_t         st_nlink;       /* [XSI] Number of hard links */
-	uid_t           st_uid;         /* [XSI] User ID of the file */
-	gid_t           st_gid;         /* [XSI] Group ID of the file */
-	dev_t           st_rdev;        /* [XSI] Device ID */
-#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-	struct  timespec st_atimespec;  /* time of last access */
-	struct  timespec st_mtimespec;  /* time of last data modification */
-	struct  timespec st_ctimespec;  /* time of last status change */
-#else
-	time_t          st_atime;       /* [XSI] Time of last access */
-	long            st_atimensec;   /* nsec of last access */
-	time_t          st_mtime;       /* [XSI] Last data modification time */
-	long            st_mtimensec;   /* last data modification nsec */
-	time_t          st_ctime;       /* [XSI] Time of last status change */
-	long            st_ctimensec;   /* nsec of last status change */
-#endif
-	off_t           st_size;        /* [XSI] file size, in bytes */
-	blkcnt_t        st_blocks;      /* [XSI] blocks allocated for file */
-	blksize_t       st_blksize;     /* [XSI] optimal blocksize for I/O */
-	__uint32_t      st_flags;       /* user defined flags for file */
-	__uint32_t      st_gen;         /* file generation number */
-	__int32_t       st_lspare;      /* RESERVED: DO NOT USE! */
-	__int64_t       st_qspare[2];   /* RESERVED: DO NOT USE! */
-};
-
-#endif /* __DARWIN_64_BIT_INO_T */
-
-#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-
-#if !__DARWIN_ONLY_64_BIT_INO_T
-
-struct stat64 __DARWIN_STRUCT_STAT64;
-
-#endif /* !__DARWIN_ONLY_64_BIT_INO_T */
-
-#endif /* (!_POSIX_C_SOURCE || _DARWIN_C_SOURCE) */
-
-
-
-
-#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-#define st_atime st_atimespec.tv_sec
-#define st_mtime st_mtimespec.tv_sec
-#define st_ctime st_ctimespec.tv_sec
-#define st_birthtime st_birthtimespec.tv_sec
-#endif /* (!_POSIX_C_SOURCE || _DARWIN_C_SOURCE) */
-
-/*
- * [XSI] The following are symbolic names for the values of type mode_t.  They
- * are bitmap values.
- */
-#include <sys/_types/_s_ifmt.h>
-
-/*
- * [XSI] The following macros shall be provided to test whether a file is
- * of the specified type.  The value m supplied to the macros is the value
- * of st_mode from a stat structure.  The macro shall evaluate to a non-zero
- * value if the test is true; 0 if the test is false.
- */
-#define S_ISBLK(m)      (((m) & S_IFMT) == S_IFBLK)     /* block special */
-#define S_ISCHR(m)      (((m) & S_IFMT) == S_IFCHR)     /* char special */
-#define S_ISDIR(m)      (((m) & S_IFMT) == S_IFDIR)     /* directory */
-#define S_ISFIFO(m)     (((m) & S_IFMT) == S_IFIFO)     /* fifo or socket */
-#define S_ISREG(m)      (((m) & S_IFMT) == S_IFREG)     /* regular file */
-#define S_ISLNK(m)      (((m) & S_IFMT) == S_IFLNK)     /* symbolic link */
-#define S_ISSOCK(m)     (((m) & S_IFMT) == S_IFSOCK)    /* socket */
-#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-#define S_ISWHT(m)      (((m) & S_IFMT) == S_IFWHT)     /* OBSOLETE: whiteout */
-#endif
-
-/*
- * [XSI] The implementation may implement message queues, semaphores, or
- * shared memory objects as distinct file types.  The following macros
- * shall be provided to test whether a file is of the specified type.
- * The value of the buf argument supplied to the macros is a pointer to
- * a stat structure.  The macro shall evaluate to a non-zero value if
- * the specified object is implemented as a distinct file type and the
- * specified file type is contained in the stat structure referenced by
- * buf.  Otherwise, the macro shall evaluate to zero.
- *
- * NOTE:	The current implementation does not do this, although
- *		this may change in future revisions, and co currently only
- *		provides these macros to ensure source compatability with
- *		implementations which do.
- */
-#define S_TYPEISMQ(buf)         (0)     /* Test for a message queue */
-#define S_TYPEISSEM(buf)        (0)     /* Test for a semaphore */
-#define S_TYPEISSHM(buf)        (0)     /* Test for a shared memory object */
-
-/*
- * [TYM] The implementation may implement typed memory objects as distinct
- * file types, and the following macro shall test whether a file is of the
- * specified type.  The value of the buf argument supplied to the macros is
- * a pointer to a stat structure.  The macro shall evaluate to a non-zero
- * value if the specified object is implemented as a distinct file type and
- * the specified file type is contained in the stat structure referenced by
- * buf.  Otherwise, the macro shall evaluate to zero.
- *
- * NOTE:	The current implementation does not do this, although
- *		this may change in future revisions, and co currently only
- *		provides this macro to ensure source compatability with
- *		implementations which do.
- */
-#define S_TYPEISTMO(buf)        (0)     /* Test for a typed memory object */
-
-
-#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-#define ACCESSPERMS     (S_IRWXU|S_IRWXG|S_IRWXO)       /* 0777 */
-                                                        /* 7777 */
-#define ALLPERMS        (S_ISUID|S_ISGID|S_ISTXT|S_IRWXU|S_IRWXG|S_IRWXO)
-/* 0666 */
-#define DEFFILEMODE     (S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH)
-
-#define S_BLKSIZE       512             /* block size used in the stat struct */
-
-/*
- * Definitions of flags stored in file flags word.
- *
- * Super-user and owner changeable flags.
- */
-#define UF_SETTABLE     0x0000ffff      /* mask of owner changeable flags */
-#define UF_NODUMP       0x00000001      /* do not dump file */
-#define UF_IMMUTABLE    0x00000002      /* file may not be changed */
-#define UF_APPEND       0x00000004      /* writes to file may only append */
-#define UF_OPAQUE       0x00000008      /* directory is opaque wrt. union */
-/*
- * The following bit is reserved for FreeBSD.  It is not implemented
- * in Mac OS X.
- */
-/* #define UF_NOUNLINK	0x00000010 */	/* file may not be removed or renamed */
-#define UF_COMPRESSED   0x00000020      /* file is compressed (some file-systems) */
-
-/* UF_TRACKED is used for dealing with document IDs.  We no longer issue
- *  notifications for deletes or renames for files which have UF_TRACKED set. */
-#define UF_TRACKED              0x00000040
-
-#define UF_DATAVAULT    0x00000080      /* entitlement required for reading */
-                                        /* and writing */
-
-/* Bits 0x0100 through 0x4000 are currently undefined. */
-#define UF_HIDDEN       0x00008000      /* hint that this item should not be */
-                                        /* displayed in a GUI */
-/*
- * Super-user changeable flags.
- */
-#define SF_SUPPORTED    0x009f0000      /* mask of superuser supported flags */
-#define SF_SETTABLE     0x3fff0000      /* mask of superuser changeable flags */
-#define SF_SYNTHETIC    0xc0000000      /* mask of system read-only synthetic flags */
-#define SF_ARCHIVED     0x00010000      /* file is archived */
-#define SF_IMMUTABLE    0x00020000      /* file may not be changed */
-#define SF_APPEND       0x00040000      /* writes to file may only append */
-#define SF_RESTRICTED   0x00080000      /* entitlement required for writing */
-#define SF_NOUNLINK     0x00100000      /* Item may not be removed, renamed or mounted on */
-
-/*
- * The following two bits are reserved for FreeBSD.  They are not
- * implemented in Mac OS X.
- */
-/* #define SF_SNAPSHOT	0x00200000 */	/* snapshot inode */
-/* NOTE: There is no SF_HIDDEN bit. */
-
-#define SF_FIRMLINK     0x00800000      /* file is a firmlink */
-
-/*
- * Synthetic flags.
- *
- * These are read-only.  We keep them out of SF_SUPPORTED so that
- * attempts to set them will fail.
- */
-#define SF_DATALESS     0x40000000     /* file is dataless object */
-
-
-#endif
-
-/*
- * Extended flags ("EF") returned by ATTR_CMNEXT_EXT_FLAGS from getattrlist/getattrlistbulk
- */
-#define EF_MAY_SHARE_BLOCKS     0x00000001      /* file may share blocks with another file */
-#define EF_NO_XATTRS            0x00000002      /* file has no xattrs at all */
-#define EF_IS_SYNC_ROOT         0x00000004      /* file is a sync root for iCloud */
-#define EF_IS_PURGEABLE         0x00000008      /* file is purgeable */
-#define EF_IS_SPARSE            0x00000010      /* file has at least one sparse region */
-
-
-
-
-__BEGIN_DECLS
-/* [XSI] */
-int     chmod(const char *, mode_t) __DARWIN_ALIAS(chmod);
-int     fchmod(int, mode_t) __DARWIN_ALIAS(fchmod);
-int     fstat(int, struct stat *) __DARWIN_INODE64(fstat);
-int     lstat(const char *, struct stat *) __DARWIN_INODE64(lstat);
-int     mkdir(const char *, mode_t);
-int     mkfifo(const char *, mode_t);
-int     stat(const char *, struct stat *) __DARWIN_INODE64(stat);
-int     mknod(const char *, mode_t, dev_t);
-mode_t  umask(mode_t);
-
-#if __DARWIN_C_LEVEL >= 200809L
-int     fchmodat(int, const char *, mode_t, int) __OSX_AVAILABLE_STARTING(__MAC_10_10, __IPHONE_8_0);
-int     fstatat(int, const char *, struct stat *, int) __DARWIN_INODE64(fstatat) __OSX_AVAILABLE_STARTING(__MAC_10_10, __IPHONE_8_0);
-int     mkdirat(int, const char *, mode_t) __OSX_AVAILABLE_STARTING(__MAC_10_10, __IPHONE_8_0);
-
-#define UTIME_NOW       -1
-#define UTIME_OMIT      -2
-
-int     futimens(int __fd, const struct timespec __times[2]) __API_AVAILABLE(macosx(10.13), ios(11.0), tvos(11.0), watchos(4.0));
-int     utimensat(int __fd, const char *__path, const struct timespec __times[2],
-    int __flag) __API_AVAILABLE(macosx(10.13), ios(11.0), tvos(11.0), watchos(4.0));
-#endif
-
-#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-
-#include <sys/_types/_filesec_t.h>
-
-int     chflags(const char *, __uint32_t);
-int     chmodx_np(const char *, filesec_t);
-int     fchflags(int, __uint32_t);
-int     fchmodx_np(int, filesec_t);
-int     fstatx_np(int, struct stat *, filesec_t) __DARWIN_INODE64(fstatx_np);
-int     lchflags(const char *, __uint32_t) __OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_2_0);
-int     lchmod(const char *, mode_t) __OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_2_0);
-int     lstatx_np(const char *, struct stat *, filesec_t) __DARWIN_INODE64(lstatx_np);
-int     mkdirx_np(const char *, filesec_t);
-int     mkfifox_np(const char *, filesec_t);
-int     statx_np(const char *, struct stat *, filesec_t) __DARWIN_INODE64(statx_np);
-int     umaskx_np(filesec_t) __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_6, __IPHONE_NA, __IPHONE_NA);
-
-#if !__DARWIN_ONLY_64_BIT_INO_T
-/* The following deprecated routines are simillar to stat and friends except provide struct stat64 instead of struct stat  */
-int     fstatx64_np(int, struct stat64 *, filesec_t) __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_5, __MAC_10_6, __IPHONE_NA, __IPHONE_NA);
-int     lstatx64_np(const char *, struct stat64 *, filesec_t) __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_5, __MAC_10_6, __IPHONE_NA, __IPHONE_NA);
-int     statx64_np(const char *, struct stat64 *, filesec_t) __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_5, __MAC_10_6, __IPHONE_NA, __IPHONE_NA);
-int     fstat64(int, struct stat64 *) __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_5, __MAC_10_6, __IPHONE_NA, __IPHONE_NA);
-int     lstat64(const char *, struct stat64 *) __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_5, __MAC_10_6, __IPHONE_NA, __IPHONE_NA);
-int     stat64(const char *, struct stat64 *) __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_5, __MAC_10_6, __IPHONE_NA, __IPHONE_NA);
-#endif /* !__DARWIN_ONLY_64_BIT_INO_T */
-#endif /* (!_POSIX_C_SOURCE || _DARWIN_C_SOURCE) */
-
-__END_DECLS
-#endif /* !_SYS_STAT_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/sys/sysctl.h b/lib/libc/include/x86_64-macos-gnu/sys/sysctl.h
deleted file mode 100644
index 9e3d84e04c..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/sys/sysctl.h
+++ /dev/null
@@ -1,775 +0,0 @@
-/*
- * Copyright (c) 2000-2019 Apple Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-/* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */
-/*
- * Copyright (c) 1989, 1993
- *	The Regents of the University of California.  All rights reserved.
- *
- * This code is derived from software contributed to Berkeley by
- * Mike Karels at Berkeley Software Design, Inc.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *	This product includes software developed by the University of
- *	California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *	@(#)sysctl.h	8.1 (Berkeley) 6/2/93
- */
-/*
- * NOTICE: This file was modified by SPARTA, Inc. in 2005 to introduce
- * support for mandatory and extensible security protections.  This notice
- * is included in support of clause 2.2 (b) of the Apple Public License,
- * Version 2.0.
- */
-
-#ifndef _SYS_SYSCTL_H_
-#define _SYS_SYSCTL_H_
-
-/*
- * These are for the eproc structure defined below.
- */
-#include <sys/cdefs.h>
-
-#include <sys/appleapiopts.h>
-#include <sys/time.h>
-#include <sys/ucred.h>
-#include <sys/proc.h>
-#include <sys/vm.h>
-
-
-/*
- * Definitions for sysctl call.  The sysctl call uses a hierarchical name
- * for objects that can be examined or modified.  The name is expressed as
- * a sequence of integers.  Like a file path name, the meaning of each
- * component depends on its place in the hierarchy.  The top-level and kern
- * identifiers are defined here, and other identifiers are defined in the
- * respective subsystem header files.
- */
-
-#define CTL_MAXNAME     12      /* largest number of components supported */
-
-/*
- * Each subsystem defined by sysctl defines a list of variables
- * for that subsystem. Each name is either a node with further
- * levels defined below it, or it is a leaf of some particular
- * type given below. Each sysctl level defines a set of name/type
- * pairs to be used by sysctl(1) in manipulating the subsystem.
- *
- * When declaring new sysctl names, use the CTLFLAG_LOCKED flag in the
- * type to indicate that all necessary locking will be handled
- * within the sysctl.
- *
- * Any sysctl defined without CTLFLAG_LOCKED is considered legacy
- * and will be protected by a global mutex.
- *
- * Note:	This is not optimal, so it is best to handle locking
- *		yourself, if you are able to do so.  A simple design
- *		pattern for use to avoid in a single function known
- *		to potentially be in the paging path ot doing a DMA
- *		to physical memory in a user space process is:
- *
- *			lock
- *			perform operation vs. local buffer
- *			unlock
- *			SYSCTL_OUT(rey, local buffer, length)
- *
- *		...this assumes you are not using a deep call graph
- *		or are unable to pass a local buffer address as a
- *		parameter into your deep call graph.
- *
- *		Note that very large user buffers can fail the wire
- *		if to do so would require more physical pages than
- *		are available (the caller will get an ENOMEM error,
- *		see sysctl_mem_hold() for details).
- */
-struct ctlname {
-	char    *ctl_name;      /* subsystem name */
-	int     ctl_type;       /* type of name */
-};
-
-#define CTLTYPE         0xf     /* Mask for the type */
-#define CTLTYPE_NODE    1       /* name is a node */
-#define CTLTYPE_INT     2       /* name describes an integer */
-#define CTLTYPE_STRING  3       /* name describes a string */
-#define CTLTYPE_QUAD    4       /* name describes a 64-bit number */
-#define CTLTYPE_OPAQUE  5       /* name describes a structure */
-#define CTLTYPE_STRUCT  CTLTYPE_OPAQUE  /* name describes a structure */
-
-#define CTLFLAG_RD      0x80000000      /* Allow reads of variable */
-#define CTLFLAG_WR      0x40000000      /* Allow writes to the variable */
-#define CTLFLAG_RW      (CTLFLAG_RD|CTLFLAG_WR)
-#define CTLFLAG_NOLOCK  0x20000000      /* XXX Don't Lock */
-#define CTLFLAG_ANYBODY 0x10000000      /* All users can set this var */
-#define CTLFLAG_SECURE  0x08000000      /* Permit set only if securelevel<=0 */
-#define CTLFLAG_MASKED  0x04000000      /* deprecated variable, do not display */
-#define CTLFLAG_NOAUTO  0x02000000      /* do not auto-register */
-#define CTLFLAG_KERN    0x01000000      /* valid inside the kernel */
-#define CTLFLAG_LOCKED  0x00800000      /* node will handle locking itself */
-#define CTLFLAG_OID2    0x00400000      /* struct sysctl_oid has version info */
-
-/*
- * USE THIS instead of a hardwired number from the categories below
- * to get dynamically assigned sysctl entries using the linker-set
- * technology. This is the way nearly all new sysctl variables should
- * be implemented.
- *
- * e.g. SYSCTL_INT(_parent, OID_AUTO, name, CTLFLAG_RW, &variable, 0, "");
- *
- * Note that linker set technology will automatically register all nodes
- * declared like this on kernel initialization, UNLESS they are defined
- * in I/O-Kit. In this case, you have to call sysctl_register_oid()
- * manually - just like in a KEXT.
- */
-#define OID_AUTO        (-1)
-#define OID_AUTO_START 100 /* conventional */
-
-
-#define SYSCTL_DEF_ENABLED
-
-#ifdef SYSCTL_DEF_ENABLED
-/*
- * Top-level identifiers
- */
-#define CTL_UNSPEC      0               /* unused */
-#define CTL_KERN        1               /* "high kernel": proc, limits */
-#define CTL_VM          2               /* virtual memory */
-#define CTL_VFS         3               /* file system, mount type is next */
-#define CTL_NET         4               /* network, see socket.h */
-#define CTL_DEBUG       5               /* debugging parameters */
-#define CTL_HW          6               /* generic cpu/io */
-#define CTL_MACHDEP     7               /* machine dependent */
-#define CTL_USER        8               /* user-level */
-#define CTL_MAXID       9               /* number of valid top-level ids */
-
-#define CTL_NAMES { \
-	{ 0, 0 }, \
-	{ "kern", CTLTYPE_NODE }, \
-	{ "vm", CTLTYPE_NODE }, \
-	{ "vfs", CTLTYPE_NODE }, \
-	{ "net", CTLTYPE_NODE }, \
-	{ "debug", CTLTYPE_NODE }, \
-	{ "hw", CTLTYPE_NODE }, \
-	{ "machdep", CTLTYPE_NODE }, \
-	{ "user", CTLTYPE_NODE }, \
-}
-
-/*
- * CTL_KERN identifiers
- */
-#define KERN_OSTYPE              1      /* string: system version */
-#define KERN_OSRELEASE           2      /* string: system release */
-#define KERN_OSREV               3      /* int: system revision */
-#define KERN_VERSION             4      /* string: compile time info */
-#define KERN_MAXVNODES           5      /* int: max vnodes */
-#define KERN_MAXPROC             6      /* int: max processes */
-#define KERN_MAXFILES            7      /* int: max open files */
-#define KERN_ARGMAX              8      /* int: max arguments to exec */
-#define KERN_SECURELVL           9      /* int: system security level */
-#define KERN_HOSTNAME           10      /* string: hostname */
-#define KERN_HOSTID             11      /* int: host identifier */
-#define KERN_CLOCKRATE          12      /* struct: struct clockrate */
-#define KERN_VNODE              13      /* struct: vnode structures */
-#define KERN_PROC               14      /* struct: process entries */
-#define KERN_FILE               15      /* struct: file entries */
-#define KERN_PROF               16      /* node: kernel profiling info */
-#define KERN_POSIX1             17      /* int: POSIX.1 version */
-#define KERN_NGROUPS            18      /* int: # of supplemental group ids */
-#define KERN_JOB_CONTROL        19      /* int: is job control available */
-#define KERN_SAVED_IDS          20      /* int: saved set-user/group-ID */
-#define KERN_BOOTTIME           21      /* struct: time kernel was booted */
-#define KERN_NISDOMAINNAME      22      /* string: YP domain name */
-#define KERN_DOMAINNAME         KERN_NISDOMAINNAME
-#define KERN_MAXPARTITIONS      23      /* int: number of partitions/disk */
-#define KERN_KDEBUG                     24      /* int: kernel trace points */
-#define KERN_UPDATEINTERVAL     25      /* int: update process sleep time */
-#define KERN_OSRELDATE          26      /* int: OS release date */
-#define KERN_NTP_PLL            27      /* node: NTP PLL control */
-#define KERN_BOOTFILE           28      /* string: name of booted kernel */
-#define KERN_MAXFILESPERPROC    29      /* int: max open files per proc */
-#define KERN_MAXPROCPERUID      30      /* int: max processes per uid */
-#define KERN_DUMPDEV            31      /* dev_t: device to dump on */
-#define KERN_IPC                32      /* node: anything related to IPC */
-#define KERN_DUMMY              33      /* unused */
-#define KERN_PS_STRINGS 34      /* int: address of PS_STRINGS */
-#define KERN_USRSTACK32 35      /* int: address of USRSTACK */
-#define KERN_LOGSIGEXIT 36      /* int: do we log sigexit procs? */
-#define KERN_SYMFILE            37      /* string: kernel symbol filename */
-#define KERN_PROCARGS           38
-/* 39 was KERN_PCSAMPLES... now obsolete */
-#define KERN_NETBOOT            40      /* int: are we netbooted? 1=yes,0=no */
-/* 41 was KERN_PANICINFO : panic UI information (deprecated) */
-#define KERN_SYSV               42      /* node: System V IPC information */
-#define KERN_AFFINITY           43      /* xxx */
-#define KERN_TRANSLATE          44      /* xxx */
-#define KERN_CLASSIC            KERN_TRANSLATE  /* XXX backwards compat */
-#define KERN_EXEC               45      /* xxx */
-#define KERN_CLASSICHANDLER     KERN_EXEC /* XXX backwards compatibility */
-#define KERN_AIOMAX             46      /* int: max aio requests */
-#define KERN_AIOPROCMAX         47      /* int: max aio requests per process */
-#define KERN_AIOTHREADS         48      /* int: max aio worker threads */
-#ifdef __APPLE_API_UNSTABLE
-#define KERN_PROCARGS2          49
-#endif /* __APPLE_API_UNSTABLE */
-#define KERN_COREFILE           50      /* string: corefile format string */
-#define KERN_COREDUMP           51      /* int: whether to coredump at all */
-#define KERN_SUGID_COREDUMP     52      /* int: whether to dump SUGID cores */
-#define KERN_PROCDELAYTERM      53      /* int: set/reset current proc for delayed termination during shutdown */
-#define KERN_SHREG_PRIVATIZABLE 54      /* int: can shared regions be privatized ? */
-/* 55 was KERN_PROC_LOW_PRI_IO... now deprecated */
-#define KERN_LOW_PRI_WINDOW     56      /* int: set/reset throttle window - milliseconds */
-#define KERN_LOW_PRI_DELAY      57      /* int: set/reset throttle delay - milliseconds */
-#define KERN_POSIX              58      /* node: posix tunables */
-#define KERN_USRSTACK64         59      /* LP64 user stack query */
-#define KERN_NX_PROTECTION      60      /* int: whether no-execute protection is enabled */
-#define KERN_TFP                61      /* Task for pid settings */
-#define KERN_PROCNAME           62      /* setup process program  name(2*MAXCOMLEN) */
-#define KERN_THALTSTACK         63      /* for compat with older x86 and does nothing */
-#define KERN_SPECULATIVE_READS  64      /* int: whether speculative reads are disabled */
-#define KERN_OSVERSION          65      /* for build number i.e. 9A127 */
-#define KERN_SAFEBOOT           66      /* are we booted safe? */
-/*	67 was KERN_LCTX (login context) */
-#define KERN_RAGEVNODE          68
-#define KERN_TTY                69      /* node: tty settings */
-#define KERN_CHECKOPENEVT       70      /* spi: check the VOPENEVT flag on vnodes at open time */
-#define KERN_THREADNAME         71      /* set/get thread name */
-#define KERN_MAXID              72      /* number of valid kern ids */
-/*
- * Don't add any more sysctls like this.  Instead, use the SYSCTL_*() macros
- * and OID_AUTO. This will have the added benefit of not having to recompile
- * sysctl(8) to pick up your changes.
- */
-
-
-#if defined(__LP64__)
-#define KERN_USRSTACK KERN_USRSTACK64
-#else
-#define KERN_USRSTACK KERN_USRSTACK32
-#endif
-
-
-/* KERN_RAGEVNODE types */
-#define KERN_RAGE_PROC          1
-#define KERN_RAGE_THREAD        2
-#define KERN_UNRAGE_PROC        3
-#define KERN_UNRAGE_THREAD      4
-
-/* KERN_OPENEVT types */
-#define KERN_OPENEVT_PROC     1
-#define KERN_UNOPENEVT_PROC   2
-
-/* KERN_TFP types */
-#define KERN_TFP_POLICY                 1
-
-/* KERN_TFP_POLICY values . All policies allow task port for self */
-#define KERN_TFP_POLICY_DENY            0       /* Deny Mode: None allowed except privileged */
-#define KERN_TFP_POLICY_DEFAULT         2       /* Default  Mode: related ones allowed and upcall authentication */
-
-/* KERN_KDEBUG types */
-#define KERN_KDEFLAGS         1
-#define KERN_KDDFLAGS         2
-#define KERN_KDENABLE         3
-#define KERN_KDSETBUF         4
-#define KERN_KDGETBUF         5
-#define KERN_KDSETUP          6
-#define KERN_KDREMOVE         7
-#define KERN_KDSETREG         8
-#define KERN_KDGETREG         9
-#define KERN_KDREADTR         10
-#define KERN_KDPIDTR          11
-#define KERN_KDTHRMAP         12
-/* Don't use 13 as it is overloaded with KERN_VNODE */
-#define KERN_KDPIDEX          14
-#define KERN_KDSETRTCDEC      15 /* obsolete */
-#define KERN_KDGETENTROPY     16 /* obsolete */
-#define KERN_KDWRITETR        17
-#define KERN_KDWRITEMAP       18
-#define KERN_KDTEST           19
-/* 20 unused */
-#define KERN_KDREADCURTHRMAP  21
-#define KERN_KDSET_TYPEFILTER 22
-#define KERN_KDBUFWAIT        23
-#define KERN_KDCPUMAP         24
-/* 25 - 26 unused */
-#define KERN_KDWRITEMAP_V3    27
-#define KERN_KDWRITETR_V3     28
-
-#define CTL_KERN_NAMES { \
-	{ 0, 0 }, \
-	{ "ostype", CTLTYPE_STRING }, \
-	{ "osrelease", CTLTYPE_STRING }, \
-	{ "osrevision", CTLTYPE_INT }, \
-	{ "version", CTLTYPE_STRING }, \
-	{ "maxvnodes", CTLTYPE_INT }, \
-	{ "maxproc", CTLTYPE_INT }, \
-	{ "maxfiles", CTLTYPE_INT }, \
-	{ "argmax", CTLTYPE_INT }, \
-	{ "securelevel", CTLTYPE_INT }, \
-	{ "hostname", CTLTYPE_STRING }, \
-	{ "hostid", CTLTYPE_INT }, \
-	{ "clockrate", CTLTYPE_STRUCT }, \
-	{ "vnode", CTLTYPE_STRUCT }, \
-	{ "proc", CTLTYPE_STRUCT }, \
-	{ "file", CTLTYPE_STRUCT }, \
-	{ "profiling", CTLTYPE_NODE }, \
-	{ "posix1version", CTLTYPE_INT }, \
-	{ "ngroups", CTLTYPE_INT }, \
-	{ "job_control", CTLTYPE_INT }, \
-	{ "saved_ids", CTLTYPE_INT }, \
-	{ "boottime", CTLTYPE_STRUCT }, \
-	{ "nisdomainname", CTLTYPE_STRING }, \
-	{ "maxpartitions", CTLTYPE_INT }, \
-	{ "kdebug", CTLTYPE_INT }, \
-	{ "update", CTLTYPE_INT }, \
-	{ "osreldate", CTLTYPE_INT }, \
-	{ "ntp_pll", CTLTYPE_NODE }, \
-	{ "bootfile", CTLTYPE_STRING }, \
-	{ "maxfilesperproc", CTLTYPE_INT }, \
-	{ "maxprocperuid", CTLTYPE_INT }, \
-	{ "dumpdev", CTLTYPE_STRUCT }, /* we lie; don't print as int */ \
-	{ "ipc", CTLTYPE_NODE }, \
-	{ "dummy", CTLTYPE_INT }, \
-	{ "dummy", CTLTYPE_INT }, \
-	{ "usrstack", CTLTYPE_INT }, \
-	{ "logsigexit", CTLTYPE_INT }, \
-	{ "symfile",CTLTYPE_STRING },\
-	{ "procargs",CTLTYPE_STRUCT },\
-	{ "dummy", CTLTYPE_INT },               /* deprecated pcsamples */ \
-	{ "netboot", CTLTYPE_INT }, \
-	{ "dummy", CTLTYPE_INT },               /* deprecated: panicinfo */ \
-	{ "sysv", CTLTYPE_NODE }, \
-	{ "dummy", CTLTYPE_INT }, \
-	{ "dummy", CTLTYPE_INT }, \
-	{ "exec", CTLTYPE_NODE }, \
-	{ "aiomax", CTLTYPE_INT }, \
-	{ "aioprocmax", CTLTYPE_INT }, \
-	{ "aiothreads", CTLTYPE_INT }, \
-	{ "procargs2",CTLTYPE_STRUCT }, \
-	{ "corefile",CTLTYPE_STRING }, \
-	{ "coredump", CTLTYPE_INT }, \
-	{ "sugid_coredump", CTLTYPE_INT }, \
-	{ "delayterm", CTLTYPE_INT }, \
-	{ "shreg_private", CTLTYPE_INT }, \
-	{ "proc_low_pri_io", CTLTYPE_INT }, \
-	{ "low_pri_window", CTLTYPE_INT }, \
-	{ "low_pri_delay", CTLTYPE_INT }, \
-	{ "posix", CTLTYPE_NODE }, \
-	{ "usrstack64", CTLTYPE_QUAD }, \
-	{ "nx", CTLTYPE_INT }, \
-	{ "tfp", CTLTYPE_NODE }, \
-	{ "procname", CTLTYPE_STRING }, \
-	{ "threadsigaltstack", CTLTYPE_INT }, \
-	{ "speculative_reads_disabled", CTLTYPE_INT }, \
-	{ "osversion", CTLTYPE_STRING }, \
-	{ "safeboot", CTLTYPE_INT }, \
-	{ "dummy", CTLTYPE_INT },               /* deprecated: lctx */ \
-	{ "rage_vnode", CTLTYPE_INT }, \
-	{ "tty", CTLTYPE_NODE },        \
-	{ "check_openevt", CTLTYPE_INT }, \
-	{ "thread_name", CTLTYPE_STRING } \
-}
-
-/*
- * CTL_VFS identifiers
- */
-#define CTL_VFS_NAMES { \
-	{ "vfsconf", CTLTYPE_STRUCT } \
-}
-
-/*
- * KERN_PROC subtypes
- */
-#define KERN_PROC_ALL           0       /* everything */
-#define KERN_PROC_PID           1       /* by process id */
-#define KERN_PROC_PGRP          2       /* by process group id */
-#define KERN_PROC_SESSION       3       /* by session of pid */
-#define KERN_PROC_TTY           4       /* by controlling tty */
-#define KERN_PROC_UID           5       /* by effective uid */
-#define KERN_PROC_RUID          6       /* by real uid */
-#define KERN_PROC_LCID          7       /* by login context id */
-
-/*
- * KERN_VFSNSPACE subtypes
- */
-#define KERN_VFSNSPACE_HANDLE_PROC              1
-#define KERN_VFSNSPACE_UNHANDLE_PROC    2
-
-/*
- * KERN_PROC subtype ops return arrays of augmented proc structures:
- */
-
-struct _pcred {
-	char    pc_lock[72];            /* opaque content */
-	struct  ucred *pc_ucred;        /* Current credentials. */
-	uid_t   p_ruid;                 /* Real user id. */
-	uid_t   p_svuid;                /* Saved effective user id. */
-	gid_t   p_rgid;                 /* Real group id. */
-	gid_t   p_svgid;                /* Saved effective group id. */
-	int     p_refcnt;               /* Number of references. */
-};
-
-struct _ucred {
-	int32_t cr_ref;                 /* reference count */
-	uid_t   cr_uid;                 /* effective user id */
-	short   cr_ngroups;             /* number of groups */
-	gid_t   cr_groups[NGROUPS];     /* groups */
-};
-
-struct kinfo_proc {
-	struct  extern_proc kp_proc;                    /* proc structure */
-	struct  eproc {
-		struct  proc *e_paddr;          /* address of proc */
-		struct  session *e_sess;        /* session pointer */
-		struct  _pcred e_pcred;         /* process credentials */
-		struct  _ucred e_ucred;         /* current credentials */
-		struct   vmspace e_vm;          /* address space */
-		pid_t   e_ppid;                 /* parent process id */
-		pid_t   e_pgid;                 /* process group id */
-		short   e_jobc;                 /* job control counter */
-		dev_t   e_tdev;                 /* controlling tty dev */
-		pid_t   e_tpgid;                /* tty process group id */
-		struct  session *e_tsess;       /* tty session pointer */
-#define WMESGLEN        7
-		char    e_wmesg[WMESGLEN + 1];    /* wchan message */
-		segsz_t e_xsize;                /* text size */
-		short   e_xrssize;              /* text rss */
-		short   e_xccount;              /* text references */
-		short   e_xswrss;
-		int32_t e_flag;
-#define EPROC_CTTY      0x01    /* controlling tty vnode active */
-#define EPROC_SLEADER   0x02    /* session leader */
-#define COMAPT_MAXLOGNAME       12
-		char    e_login[COMAPT_MAXLOGNAME];     /* short setlogin() name */
-		int32_t e_spare[4];
-	} kp_eproc;
-};
-
-
-
-/*
- * KERN_IPC identifiers
- */
-#define KIPC_MAXSOCKBUF         1       /* int: max size of a socket buffer */
-#define KIPC_SOCKBUF_WASTE      2       /* int: wastage factor in sockbuf */
-#define KIPC_SOMAXCONN          3       /* int: max length of connection q */
-#define KIPC_MAX_LINKHDR        4       /* int: max length of link header */
-#define KIPC_MAX_PROTOHDR       5       /* int: max length of network header */
-#define KIPC_MAX_HDR            6       /* int: max total length of headers */
-#define KIPC_MAX_DATALEN        7       /* int: max length of data? */
-#define KIPC_MBSTAT             8       /* struct: mbuf usage statistics */
-#define KIPC_NMBCLUSTERS        9       /* int: maximum mbuf clusters */
-#define KIPC_SOQLIMITCOMPAT     10      /* int: socket queue limit */
-
-/*
- * CTL_VM identifiers
- */
-#define VM_METER        1               /* struct vmmeter */
-#define VM_LOADAVG      2               /* struct loadavg */
-/*
- * Note: "3" was skipped sometime ago and should probably remain unused
- * to avoid any new entry from being accepted by older kernels...
- */
-#define VM_MACHFACTOR   4               /* struct loadavg with mach factor*/
-#define VM_SWAPUSAGE    5               /* total swap usage */
-#define VM_MAXID        6               /* number of valid vm ids */
-
-#define CTL_VM_NAMES { \
-	{ 0, 0 }, \
-	{ "vmmeter", CTLTYPE_STRUCT }, \
-	{ "loadavg", CTLTYPE_STRUCT }, \
-	{ 0, 0 }, /* placeholder for "3" (see comment above) */ \
-	{ "dummy", CTLTYPE_INT }, \
-	{ "swapusage", CTLTYPE_STRUCT } \
-}
-
-struct xsw_usage {
-	u_int64_t       xsu_total;
-	u_int64_t       xsu_avail;
-	u_int64_t       xsu_used;
-	u_int32_t       xsu_pagesize;
-	boolean_t       xsu_encrypted;
-};
-
-#ifdef __APPLE_API_PRIVATE
-/* Load average structure.  Use of fixpt_t assume <sys/types.h> in scope. */
-/* XXX perhaps we should protect fixpt_t, and define it here (or discard it) */
-struct loadavg {
-	fixpt_t ldavg[3];
-	long    fscale;
-};
-extern struct loadavg averunnable;
-#define LSCALE  1000            /* scaling for "fixed point" arithmetic */
-
-#endif /* __APPLE_API_PRIVATE */
-
-
-/*
- * CTL_HW identifiers
- */
-#define HW_MACHINE       1              /* string: machine class */
-#define HW_MODEL         2              /* string: specific machine model */
-#define HW_NCPU          3              /* int: number of cpus */
-#define HW_BYTEORDER     4              /* int: machine byte order */
-#define HW_PHYSMEM       5              /* int: total memory */
-#define HW_USERMEM       6              /* int: non-kernel memory */
-#define HW_PAGESIZE      7              /* int: software page size */
-#define HW_DISKNAMES     8              /* strings: disk drive names */
-#define HW_DISKSTATS     9              /* struct: diskstats[] */
-#define HW_EPOCH        10              /* int: 0 for Legacy, else NewWorld */
-#define HW_FLOATINGPT   11              /* int: has HW floating point? */
-#define HW_MACHINE_ARCH 12              /* string: machine architecture */
-#define HW_VECTORUNIT   13              /* int: has HW vector unit? */
-#define HW_BUS_FREQ     14              /* int: Bus Frequency */
-#define HW_CPU_FREQ     15              /* int: CPU Frequency */
-#define HW_CACHELINE    16              /* int: Cache Line Size in Bytes */
-#define HW_L1ICACHESIZE 17              /* int: L1 I Cache Size in Bytes */
-#define HW_L1DCACHESIZE 18              /* int: L1 D Cache Size in Bytes */
-#define HW_L2SETTINGS   19              /* int: L2 Cache Settings */
-#define HW_L2CACHESIZE  20              /* int: L2 Cache Size in Bytes */
-#define HW_L3SETTINGS   21              /* int: L3 Cache Settings */
-#define HW_L3CACHESIZE  22              /* int: L3 Cache Size in Bytes */
-#define HW_TB_FREQ      23              /* int: Bus Frequency */
-#define HW_MEMSIZE      24              /* uint64_t: physical ram size */
-#define HW_AVAILCPU     25              /* int: number of available CPUs */
-#define HW_MAXID        26              /* number of valid hw ids */
-
-#define CTL_HW_NAMES { \
-	{ 0, 0 }, \
-	{ "machine", CTLTYPE_STRING }, \
-	{ "model", CTLTYPE_STRING }, \
-	{ "ncpu", CTLTYPE_INT }, \
-	{ "byteorder", CTLTYPE_INT }, \
-	{ "physmem", CTLTYPE_INT }, \
-	{ "usermem", CTLTYPE_INT }, \
-	{ "pagesize", CTLTYPE_INT }, \
-	{ "disknames", CTLTYPE_STRUCT }, \
-	{ "diskstats", CTLTYPE_STRUCT }, \
-	{ "epoch", CTLTYPE_INT }, \
-	{ "floatingpoint", CTLTYPE_INT }, \
-	{ "machinearch", CTLTYPE_STRING }, \
-	{ "vectorunit", CTLTYPE_INT }, \
-	{ "busfrequency", CTLTYPE_INT }, \
-	{ "cpufrequency", CTLTYPE_INT }, \
-	{ "cachelinesize", CTLTYPE_INT }, \
-	{ "l1icachesize", CTLTYPE_INT }, \
-	{ "l1dcachesize", CTLTYPE_INT }, \
-	{ "l2settings", CTLTYPE_INT }, \
-	{ "l2cachesize", CTLTYPE_INT }, \
-	{ "l3settings", CTLTYPE_INT }, \
-	{ "l3cachesize", CTLTYPE_INT }, \
-	{ "tbfrequency", CTLTYPE_INT }, \
-	{ "memsize", CTLTYPE_QUAD }, \
-	{ "availcpu", CTLTYPE_INT } \
-}
-
-/*
- * XXX This information should be moved to the man page.
- *
- * These are the support HW selectors for sysctlbyname.  Parameters that are byte counts or frequencies are 64 bit numbers.
- * All other parameters are 32 bit numbers.
- *
- *   hw.memsize                - The number of bytes of physical memory in the system.
- *
- *   hw.ncpu                   - The maximum number of processors that could be available this boot.
- *                               Use this value for sizing of static per processor arrays; i.e. processor load statistics.
- *
- *   hw.activecpu              - The number of processors currently available for executing threads.
- *                               Use this number to determine the number threads to create in SMP aware applications.
- *                               This number can change when power management modes are changed.
- *
- *   hw.physicalcpu            - The number of physical processors available in the current power management mode.
- *   hw.physicalcpu_max        - The maximum number of physical processors that could be available this boot
- *
- *   hw.logicalcpu             - The number of logical processors available in the current power management mode.
- *   hw.logicalcpu_max         - The maximum number of logical processors that could be available this boot
- *
- *   hw.tbfrequency            - This gives the time base frequency used by the OS and is the basis of all timing services.
- *                               In general is is better to use mach's or higher level timing services, but this value
- *                               is needed to convert the PPC Time Base registers to real time.
- *
- *   hw.cpufrequency           - These values provide the current, min and max cpu frequency.  The min and max are for
- *   hw.cpufrequency_max       - all power management modes.  The current frequency is the max frequency in the current mode.
- *   hw.cpufrequency_min       - All frequencies are in Hz.
- *
- *   hw.busfrequency           - These values provide the current, min and max bus frequency.  The min and max are for
- *   hw.busfrequency_max       - all power management modes.  The current frequency is the max frequency in the current mode.
- *   hw.busfrequency_min       - All frequencies are in Hz.
- *
- *   hw.cputype                - These values provide the mach-o cpu type and subtype.  A complete list is in <mach/machine.h>
- *   hw.cpusubtype             - These values should be used to determine what processor family the running cpu is from so that
- *                               the best binary can be chosen, or the best dynamic code generated.  They should not be used
- *                               to determine if a given processor feature is available.
- *   hw.cputhreadtype          - This value will be present if the processor supports threads.  Like hw.cpusubtype this selector
- *                               should not be used to infer features, and only used to name the processors thread architecture.
- *                               The values are defined in <mach/machine.h>
- *
- *   hw.byteorder              - Gives the byte order of the processor.  4321 for big endian, 1234 for little.
- *
- *   hw.pagesize               - Gives the size in bytes of the pages used by the processor and VM system.
- *
- *   hw.cachelinesize          - Gives the size in bytes of the processor's cache lines.
- *                               This value should be use to control the strides of loops that use cache control instructions
- *                               like dcbz, dcbt or dcbst.
- *
- *   hw.l1dcachesize           - These values provide the size in bytes of the L1, L2 and L3 caches.  If a cache is not present
- *   hw.l1icachesize           - then the selector will return and error.
- *   hw.l2cachesize            -
- *   hw.l3cachesize            -
- *
- *   hw.packages               - Gives the number of processor packages.
- *
- * These are the selectors for optional processor features for specific processors.  Selectors that return errors are not support
- * on the system.  Supported features will return 1 if they are recommended or 0 if they are supported but are not expected to help .
- * performance.  Future versions of these selectors may return larger values as necessary so it is best to test for non zero.
- *
- * For PowerPC:
- *
- *   hw.optional.floatingpoint - Floating Point Instructions
- *   hw.optional.altivec       - AltiVec Instructions
- *   hw.optional.graphicsops   - Graphics Operations
- *   hw.optional.64bitops      - 64-bit Instructions
- *   hw.optional.fsqrt         - HW Floating Point Square Root Instruction
- *   hw.optional.stfiwx        - Store Floating Point as Integer Word Indexed Instructions
- *   hw.optional.dcba          - Data Cache Block Allocate Instruction
- *   hw.optional.datastreams   - Data Streams Instructions
- *   hw.optional.dcbtstreams   - Data Cache Block Touch Steams Instruction Form
- *
- * For x86 Architecture:
- *
- *   hw.optional.floatingpoint     - Floating Point Instructions
- *   hw.optional.mmx               - Original MMX vector instructions
- *   hw.optional.sse               - Streaming SIMD Extensions
- *   hw.optional.sse2              - Streaming SIMD Extensions 2
- *   hw.optional.sse3              - Streaming SIMD Extensions 3
- *   hw.optional.supplementalsse3  - Supplemental Streaming SIMD Extensions 3
- *   hw.optional.x86_64            - 64-bit support
- */
-
-
-/*
- * CTL_USER definitions
- */
-#define USER_CS_PATH             1      /* string: _CS_PATH */
-#define USER_BC_BASE_MAX         2      /* int: BC_BASE_MAX */
-#define USER_BC_DIM_MAX          3      /* int: BC_DIM_MAX */
-#define USER_BC_SCALE_MAX        4      /* int: BC_SCALE_MAX */
-#define USER_BC_STRING_MAX       5      /* int: BC_STRING_MAX */
-#define USER_COLL_WEIGHTS_MAX    6      /* int: COLL_WEIGHTS_MAX */
-#define USER_EXPR_NEST_MAX       7      /* int: EXPR_NEST_MAX */
-#define USER_LINE_MAX            8      /* int: LINE_MAX */
-#define USER_RE_DUP_MAX          9      /* int: RE_DUP_MAX */
-#define USER_POSIX2_VERSION     10      /* int: POSIX2_VERSION */
-#define USER_POSIX2_C_BIND      11      /* int: POSIX2_C_BIND */
-#define USER_POSIX2_C_DEV       12      /* int: POSIX2_C_DEV */
-#define USER_POSIX2_CHAR_TERM   13      /* int: POSIX2_CHAR_TERM */
-#define USER_POSIX2_FORT_DEV    14      /* int: POSIX2_FORT_DEV */
-#define USER_POSIX2_FORT_RUN    15      /* int: POSIX2_FORT_RUN */
-#define USER_POSIX2_LOCALEDEF   16      /* int: POSIX2_LOCALEDEF */
-#define USER_POSIX2_SW_DEV      17      /* int: POSIX2_SW_DEV */
-#define USER_POSIX2_UPE         18      /* int: POSIX2_UPE */
-#define USER_STREAM_MAX         19      /* int: POSIX2_STREAM_MAX */
-#define USER_TZNAME_MAX         20      /* int: POSIX2_TZNAME_MAX */
-#define USER_MAXID              21      /* number of valid user ids */
-
-#define CTL_USER_NAMES { \
-	{ 0, 0 }, \
-	{ "cs_path", CTLTYPE_STRING }, \
-	{ "bc_base_max", CTLTYPE_INT }, \
-	{ "bc_dim_max", CTLTYPE_INT }, \
-	{ "bc_scale_max", CTLTYPE_INT }, \
-	{ "bc_string_max", CTLTYPE_INT }, \
-	{ "coll_weights_max", CTLTYPE_INT }, \
-	{ "expr_nest_max", CTLTYPE_INT }, \
-	{ "line_max", CTLTYPE_INT }, \
-	{ "re_dup_max", CTLTYPE_INT }, \
-	{ "posix2_version", CTLTYPE_INT }, \
-	{ "posix2_c_bind", CTLTYPE_INT }, \
-	{ "posix2_c_dev", CTLTYPE_INT }, \
-	{ "posix2_char_term", CTLTYPE_INT }, \
-	{ "posix2_fort_dev", CTLTYPE_INT }, \
-	{ "posix2_fort_run", CTLTYPE_INT }, \
-	{ "posix2_localedef", CTLTYPE_INT }, \
-	{ "posix2_sw_dev", CTLTYPE_INT }, \
-	{ "posix2_upe", CTLTYPE_INT }, \
-	{ "stream_max", CTLTYPE_INT }, \
-	{ "tzname_max", CTLTYPE_INT } \
-}
-
-
-
-/*
- * CTL_DEBUG definitions
- *
- * Second level identifier specifies which debug variable.
- * Third level identifier specifies which stucture component.
- */
-#define CTL_DEBUG_NAME          0       /* string: variable name */
-#define CTL_DEBUG_VALUE         1       /* int: variable value */
-#define CTL_DEBUG_MAXID         20
-
-
-#if (CTL_MAXID != 9) || (KERN_MAXID != 72) || (VM_MAXID != 6) || (HW_MAXID != 26) || (USER_MAXID != 21) || (CTL_DEBUG_MAXID != 20)
-#error Use the SYSCTL_*() macros and OID_AUTO instead!
-#endif
-
-
-
-__BEGIN_DECLS
-int     sysctl(int *, u_int, void *, size_t *, void *, size_t);
-int     sysctlbyname(const char *, void *, size_t *, void *, size_t);
-int     sysctlnametomib(const char *, int *, size_t *);
-__END_DECLS
-
-
-
-#endif /* SYSCTL_DEF_ENABLED */
-
-
-#endif  /* !_SYS_SYSCTL_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/sys/syslimits.h b/lib/libc/include/x86_64-macos-gnu/sys/syslimits.h
deleted file mode 100644
index ff60b66ff5..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/sys/syslimits.h
+++ /dev/null
@@ -1,117 +0,0 @@
-/*
- * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-/*	$NetBSD: syslimits.h,v 1.15 1997/06/25 00:48:09 lukem Exp $	*/
-
-/*
- * Copyright (c) 1988, 1993
- *	The Regents of the University of California.  All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *	This product includes software developed by the University of
- *	California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *	@(#)syslimits.h	8.1 (Berkeley) 6/2/93
- */
-
-#ifndef _SYS_SYSLIMITS_H_
-#define _SYS_SYSLIMITS_H_
-
-#include <sys/cdefs.h>
-
-#if !defined(_ANSI_SOURCE)
-/*
- * Note: CHILD_MAX *must* be less than hard_maxproc, which is set at
- * compile time; you *cannot* set it higher than the hard limit!!
- */
-#define ARG_MAX            (256 * 1024) /* max bytes for an exec function */
-#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-#define CHILD_MAX                  266  /* max simultaneous processes */
-#define GID_MAX            2147483647U  /* max value for a gid_t (2^31-2) */
-#endif /* (_POSIX_C_SOURCE && !_DARWIN_C_SOURCE) */
-#define LINK_MAX                32767   /* max file link count */
-#define MAX_CANON                1024   /* max bytes in term canon input line */
-#define MAX_INPUT                1024   /* max bytes in terminal input */
-#define NAME_MAX                  255   /* max bytes in a file name */
-#define NGROUPS_MAX                16   /* max supplemental group id's */
-#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-#define UID_MAX            2147483647U  /* max value for a uid_t (2^31-2) */
-
-#define OPEN_MAX                10240   /* max open files per process - todo, make a config option? */
-
-#endif /* (_POSIX_C_SOURCE && !_DARWIN_C_SOURCE) */
-#define PATH_MAX                 1024   /* max bytes in pathname */
-#define PIPE_BUF                  512   /* max bytes for atomic pipe writes */
-
-#define BC_BASE_MAX                99   /* max ibase/obase values in bc(1) */
-#define BC_DIM_MAX               2048   /* max array elements in bc(1) */
-#define BC_SCALE_MAX               99   /* max scale value in bc(1) */
-#define BC_STRING_MAX            1000   /* max const string length in bc(1) */
-#define CHARCLASS_NAME_MAX         14   /* max character class name size */
-#define COLL_WEIGHTS_MAX            2   /* max weights for order keyword */
-#define EQUIV_CLASS_MAX             2
-#define EXPR_NEST_MAX              32   /* max expressions nested in expr(1) */
-#define LINE_MAX                 2048   /* max bytes in an input line */
-#define RE_DUP_MAX                255   /* max RE's in interval notation */
-
-#if __DARWIN_UNIX03
-#define NZERO                      20   /* default priority [XSI] */
-                                        /* = ((PRIO_MAX - PRIO_MIN) / 2) + 1 */
-                                        /* range: 0 - 39 [(2 * NZERO) - 1] */
-                                        /* 0 is not actually used */
-#else /* !__DARWIN_UNIX03 */
-#define NZERO                       0   /* default priority */
-                                        /* range: -20 - 20 */
-                                        /* (PRIO_MIN - PRIO_MAX) */
-#endif /* __DARWIN_UNIX03 */
-#endif /* !_ANSI_SOURCE */
-
-#endif /* !_SYS_SYSLIMITS_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/sys/ucontext.h b/lib/libc/include/x86_64-macos-gnu/sys/ucontext.h
deleted file mode 100644
index 5b55545a47..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/sys/ucontext.h
+++ /dev/null
@@ -1,41 +0,0 @@
-/*
- * Copyright (c) 2002-2006 Apple Computer, Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-
-#ifndef _SYS_UCONTEXT_H_
-#define _SYS_UCONTEXT_H_
-
-#include <sys/cdefs.h>
-#include <sys/_types.h>
-
-#include <machine/_mcontext.h>
-#include <sys/_types/_ucontext.h>
-
-#include <sys/_types/_sigset_t.h>
-
-
-#endif /* _SYS_UCONTEXT_H_ */
diff --git a/lib/libc/include/x86_64-macos-gnu/sys/uio.h b/lib/libc/include/x86_64-macos-gnu/sys/uio.h
deleted file mode 100644
index a5b1bad7cf..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/sys/uio.h
+++ /dev/null
@@ -1,100 +0,0 @@
-/*
- * Copyright (c) 2000-2008 Apple Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-/* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */
-/*
- * Copyright (c) 1982, 1986, 1993, 1994
- *	The Regents of the University of California.  All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *	This product includes software developed by the University of
- *	California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *	@(#)uio.h	8.5 (Berkeley) 2/22/94
- */
-
-#ifndef _SYS_UIO_H_
-#define _SYS_UIO_H_
-
-#include <sys/cdefs.h>
-#include <sys/_types.h>
-
-/*
- * [XSI] The ssize_t and size_t types shall be defined as described
- * in <sys/types.h>.
- */
-#include <sys/_types/_size_t.h>
-#include <sys/_types/_ssize_t.h>
-
-/*
- * [XSI] Structure whose address is passed as the second parameter to the
- * readv() and writev() functions.
- */
-#include <sys/_types/_iovec_t.h>
-
-
-#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-/*
- * IO direction for uio_t.
- *	UIO_READ - data moves into iovec(s) associated with uio_t
- *	UIO_WRITE - data moves out of iovec(s) associated with uio_t
- */
-enum uio_rw { UIO_READ, UIO_WRITE };
-#endif
-
-
-
-__BEGIN_DECLS
-ssize_t readv(int, const struct iovec *, int) __DARWIN_ALIAS_C(readv);
-ssize_t writev(int, const struct iovec *, int) __DARWIN_ALIAS_C(writev);
-__END_DECLS
-
-#endif /* !_SYS_UIO_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/sys/un.h b/lib/libc/include/x86_64-macos-gnu/sys/un.h
deleted file mode 100644
index a27ead5406..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/sys/un.h
+++ /dev/null
@@ -1,105 +0,0 @@
-/*
- * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-/*
- * Copyright (c) 1982, 1986, 1993
- *	The Regents of the University of California.  All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *	This product includes software developed by the University of
- *	California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *	@(#)un.h	8.3 (Berkeley) 2/19/95
- */
-
-#ifndef _SYS_UN_H_
-#define _SYS_UN_H_
-
-#include <sys/appleapiopts.h>
-#include <sys/cdefs.h>
-#include <sys/_types.h>
-
-/* [XSI] The sa_family_t type shall be defined as described in <sys/socket.h> */
-#include <sys/_types/_sa_family_t.h>
-
-/*
- * [XSI] Definitions for UNIX IPC domain.
- */
-struct  sockaddr_un {
-	unsigned char   sun_len;        /* sockaddr len including null */
-	sa_family_t     sun_family;     /* [XSI] AF_UNIX */
-	char            sun_path[104];  /* [XSI] path name (gag) */
-};
-
-#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-
-/* Level number of get/setsockopt for local domain sockets */
-#define SOL_LOCAL               0
-
-/* Socket options. */
-#define LOCAL_PEERCRED          0x001           /* retrieve peer credentials */
-#define LOCAL_PEERPID           0x002           /* retrieve peer pid */
-#define LOCAL_PEEREPID          0x003           /* retrieve eff. peer pid */
-#define LOCAL_PEERUUID          0x004           /* retrieve peer UUID */
-#define LOCAL_PEEREUUID         0x005           /* retrieve eff. peer UUID */
-
-#endif  /* (!_POSIX_C_SOURCE || _DARWIN_C_SOURCE) */
-
-
-
-#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-/* actual length of an initialized sockaddr_un */
-#define SUN_LEN(su) \
-	(sizeof(*(su)) - sizeof((su)->sun_path) + strlen((su)->sun_path))
-#endif  /* (!_POSIX_C_SOURCE || _DARWIN_C_SOURCE) */
-
-
-#endif /* !_SYS_UN_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/time.h b/lib/libc/include/x86_64-macos-gnu/time.h
deleted file mode 100644
index b2edfb95cd..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/time.h
+++ /dev/null
@@ -1,208 +0,0 @@
-/*
- * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
- *
- * @APPLE_LICENSE_HEADER_START@
- * 
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this
- * file.
- * 
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- * 
- * @APPLE_LICENSE_HEADER_END@
- */
-/*
- * Copyright (c) 1989, 1993
- *	The Regents of the University of California.  All rights reserved.
- * (c) UNIX System Laboratories, Inc.
- * All or some portions of this file are derived from material licensed
- * to the University of California by American Telephone and Telegraph
- * Co. or Unix System Laboratories, Inc. and are reproduced herein with
- * the permission of UNIX System Laboratories, Inc.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *	This product includes software developed by the University of
- *	California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *	@(#)time.h	8.3 (Berkeley) 1/21/94
- */
-
-#ifndef _TIME_H_
-#define	_TIME_H_
-
-#include <_types.h>
-#include <sys/cdefs.h>
-#include <Availability.h>
-#include <sys/_types/_clock_t.h>
-#include <sys/_types/_null.h>
-#include <sys/_types/_size_t.h>
-#include <sys/_types/_time_t.h>
-#include <sys/_types/_timespec.h>
-
-struct tm {
-	int	tm_sec;		/* seconds after the minute [0-60] */
-	int	tm_min;		/* minutes after the hour [0-59] */
-	int	tm_hour;	/* hours since midnight [0-23] */
-	int	tm_mday;	/* day of the month [1-31] */
-	int	tm_mon;		/* months since January [0-11] */
-	int	tm_year;	/* years since 1900 */
-	int	tm_wday;	/* days since Sunday [0-6] */
-	int	tm_yday;	/* days since January 1 [0-365] */
-	int	tm_isdst;	/* Daylight Savings Time flag */
-	long	tm_gmtoff;	/* offset from UTC in seconds */
-	char	*tm_zone;	/* timezone abbreviation */
-};
-
-#if __DARWIN_UNIX03
-#define CLOCKS_PER_SEC  1000000	/* [XSI] */
-#else /* !__DARWIN_UNIX03 */
-#include <machine/_limits.h>	/* Include file containing CLK_TCK. */
-
-#define CLOCKS_PER_SEC  (__DARWIN_CLK_TCK)
-#endif /* __DARWIN_UNIX03 */
-
-#ifndef _ANSI_SOURCE
-extern char *tzname[];
-#endif
-
-extern int getdate_err;
-#if __DARWIN_UNIX03
-extern long timezone __DARWIN_ALIAS(timezone);
-#endif /* __DARWIN_UNIX03 */
-extern int daylight;
-
-__BEGIN_DECLS
-char *asctime(const struct tm *);
-clock_t clock(void) __DARWIN_ALIAS(clock);
-char *ctime(const time_t *);
-double difftime(time_t, time_t);
-struct tm *getdate(const char *);
-struct tm *gmtime(const time_t *);
-struct tm *localtime(const time_t *);
-time_t mktime(struct tm *) __DARWIN_ALIAS(mktime);
-size_t strftime(char * __restrict, size_t, const char * __restrict, const struct tm * __restrict) __DARWIN_ALIAS(strftime);
-char *strptime(const char * __restrict, const char * __restrict, struct tm * __restrict) __DARWIN_ALIAS(strptime);
-time_t time(time_t *);
-
-#ifndef _ANSI_SOURCE
-void tzset(void);
-#endif /* not ANSI */
-
-/* [TSF] Thread safe functions */
-char *asctime_r(const struct tm * __restrict, char * __restrict);
-char *ctime_r(const time_t *, char *);
-struct tm *gmtime_r(const time_t * __restrict, struct tm * __restrict);
-struct tm *localtime_r(const time_t * __restrict, struct tm * __restrict);
-
-#if !defined(_ANSI_SOURCE) && (!defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE))
-time_t posix2time(time_t);
-#if !__DARWIN_UNIX03
-char *timezone(int, int);
-#endif /* !__DARWIN_UNIX03 */
-void tzsetwall(void);
-time_t time2posix(time_t);
-time_t timelocal(struct tm * const);
-time_t timegm(struct tm * const);
-#endif /* neither ANSI nor POSIX */
-
-#if !defined(_ANSI_SOURCE)
-int nanosleep(const struct timespec *__rqtp, struct timespec *__rmtp) __DARWIN_ALIAS_C(nanosleep);
-#endif
-
-#if !defined(_DARWIN_FEATURE_CLOCK_GETTIME) || _DARWIN_FEATURE_CLOCK_GETTIME != 0
-#if __DARWIN_C_LEVEL >= 199309L
-#if __has_feature(enumerator_attributes)
-#define __CLOCK_AVAILABILITY __OSX_AVAILABLE(10.12) __IOS_AVAILABLE(10.0) __TVOS_AVAILABLE(10.0) __WATCHOS_AVAILABLE(3.0)
-#else
-#define __CLOCK_AVAILABILITY
-#endif
-
-typedef enum {
-_CLOCK_REALTIME __CLOCK_AVAILABILITY = 0,
-#define CLOCK_REALTIME _CLOCK_REALTIME
-_CLOCK_MONOTONIC __CLOCK_AVAILABILITY = 6,
-#define CLOCK_MONOTONIC _CLOCK_MONOTONIC
-#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-_CLOCK_MONOTONIC_RAW __CLOCK_AVAILABILITY = 4,
-#define CLOCK_MONOTONIC_RAW _CLOCK_MONOTONIC_RAW
-_CLOCK_MONOTONIC_RAW_APPROX __CLOCK_AVAILABILITY = 5,
-#define CLOCK_MONOTONIC_RAW_APPROX _CLOCK_MONOTONIC_RAW_APPROX
-_CLOCK_UPTIME_RAW __CLOCK_AVAILABILITY = 8,
-#define CLOCK_UPTIME_RAW _CLOCK_UPTIME_RAW
-_CLOCK_UPTIME_RAW_APPROX __CLOCK_AVAILABILITY = 9,
-#define CLOCK_UPTIME_RAW_APPROX _CLOCK_UPTIME_RAW_APPROX
-#endif
-_CLOCK_PROCESS_CPUTIME_ID __CLOCK_AVAILABILITY = 12,
-#define CLOCK_PROCESS_CPUTIME_ID _CLOCK_PROCESS_CPUTIME_ID
-_CLOCK_THREAD_CPUTIME_ID __CLOCK_AVAILABILITY = 16
-#define CLOCK_THREAD_CPUTIME_ID _CLOCK_THREAD_CPUTIME_ID
-} clockid_t;
-
-__CLOCK_AVAILABILITY
-int clock_getres(clockid_t __clock_id, struct timespec *__res);
-
-__CLOCK_AVAILABILITY
-int clock_gettime(clockid_t __clock_id, struct timespec *__tp);
-
-#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-__CLOCK_AVAILABILITY
-__uint64_t clock_gettime_nsec_np(clockid_t __clock_id);
-#endif
-
-__OSX_AVAILABLE(10.12) __IOS_PROHIBITED
-__TVOS_PROHIBITED __WATCHOS_PROHIBITED
-int clock_settime(clockid_t __clock_id, const struct timespec *__tp);
-
-#undef __CLOCK_AVAILABILITY
-#endif /* __DARWIN_C_LEVEL */
-#endif /* _DARWIN_FEATURE_CLOCK_GETTIME */
-
-#if (__DARWIN_C_LEVEL >= __DARWIN_C_FULL) && \
-        ((defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L) || \
-        (defined(__cplusplus) && __cplusplus >= 201703L))
-/* ISO/IEC 9899:201x 7.27.2.5 The timespec_get function */
-#define TIME_UTC	1	/* time elapsed since epoch */
-__API_AVAILABLE(macosx(10.15), ios(13.0), tvos(13.0), watchos(6.0))
-int timespec_get(struct timespec *ts, int base);
-#endif
-
-__END_DECLS
-
-#ifdef _USE_EXTENDED_LOCALES_
-#include <xlocale/_time.h>
-#endif /* _USE_EXTENDED_LOCALES_ */
-
-#endif /* !_TIME_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/ucontext.h b/lib/libc/include/x86_64-macos-gnu/ucontext.h
deleted file mode 100644
index 27b4111035..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/ucontext.h
+++ /dev/null
@@ -1,54 +0,0 @@
-/*
- * Copyright (c) 2002, 2008, 2009 Apple Inc. All rights reserved.
- *
- * @APPLE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this
- * file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_LICENSE_HEADER_END@
- */
-
-/*
- * These routines are DEPRECATED and should not be used.
- */
-#ifndef _UCONTEXT_H_
-#define _UCONTEXT_H_
-
-#include <sys/cdefs.h>
-
-#ifdef _XOPEN_SOURCE
-#include <sys/ucontext.h>
-#include <Availability.h>
-
-__BEGIN_DECLS
-__API_DEPRECATED("No longer supported", macos(10.5, 10.6))
-int  getcontext(ucontext_t *);
-
-__API_DEPRECATED("No longer supported", macos(10.5, 10.6))
-void makecontext(ucontext_t *, void (*)(), int, ...);
-
-__API_DEPRECATED("No longer supported", macos(10.5, 10.6))
-int  setcontext(const ucontext_t *);
-
-__API_DEPRECATED("No longer supported", macos(10.5, 10.6))
-int  swapcontext(ucontext_t * __restrict, const ucontext_t * __restrict);
-
-__END_DECLS
-#else /* !_XOPEN_SOURCE */
-#error The deprecated ucontext routines require _XOPEN_SOURCE to be defined
-#endif /* _XOPEN_SOURCE */
-
-#endif /* _UCONTEXT_H_ */
diff --git a/lib/libc/include/x86_64-macos-gnu/xlocale/_inttypes.h b/lib/libc/include/x86_64-macos-gnu/xlocale/_inttypes.h
deleted file mode 100644
index 4da8f90c6d..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/xlocale/_inttypes.h
+++ /dev/null
@@ -1,47 +0,0 @@
-/*
- * Copyright (c) 2005 Apple Computer, Inc. All rights reserved.
- *
- * @APPLE_LICENSE_HEADER_START@
- * 
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this
- * file.
- * 
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- * 
- * @APPLE_LICENSE_HEADER_END@
- */
-
-#ifndef _XLOCALE__INTTYPES_H_
-#define _XLOCALE__INTTYPES_H_
-
-#include <sys/cdefs.h>
-#include <stdint.h>
-#include <_xlocale.h>
-
-__BEGIN_DECLS
-intmax_t  strtoimax_l(const char * __restrict nptr, char ** __restrict endptr,
-		int base, locale_t);
-uintmax_t strtoumax_l(const char * __restrict nptr, char ** __restrict endptr,
-		int base, locale_t);
-intmax_t  wcstoimax_l(const wchar_t * __restrict nptr,
-		wchar_t ** __restrict endptr, int base, locale_t);
-uintmax_t wcstoumax_l(const wchar_t * __restrict nptr,
-		wchar_t ** __restrict endptr, int base, locale_t);
-
-/* Poison the following routines if -fshort-wchar is set */
-#if !defined(__cplusplus) && defined(__WCHAR_MAX__) && __WCHAR_MAX__ <= 0xffffU
-#pragma GCC poison wcstoimax_l wcstoumax_l
-#endif
-__END_DECLS
-
-#endif /* _XLOCALE__INTTYPES_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/xlocale/_wchar.h b/lib/libc/include/x86_64-macos-gnu/xlocale/_wchar.h
deleted file mode 100644
index b4af0f816e..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/xlocale/_wchar.h
+++ /dev/null
@@ -1,145 +0,0 @@
-/*
- * Copyright (c) 2005 Apple Computer, Inc. All rights reserved.
- *
- * @APPLE_LICENSE_HEADER_START@
- * 
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this
- * file.
- * 
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- * 
- * @APPLE_LICENSE_HEADER_END@
- */
-
-#ifndef _XLOCALE__WCHAR_H_
-#define _XLOCALE__WCHAR_H_
-
-#include <_stdio.h>
-#include <_xlocale.h>
-#include <sys/_types/_mbstate_t.h>
-
-/* Initially added in Issue 4 */
-__BEGIN_DECLS
-wint_t	btowc_l(int, locale_t);
-wint_t	fgetwc_l(FILE *, locale_t);
-wchar_t	*fgetws_l(wchar_t * __restrict, int, FILE * __restrict, locale_t);
-wint_t	fputwc_l(wchar_t, FILE *, locale_t);
-int	fputws_l(const wchar_t * __restrict, FILE * __restrict, locale_t);
-int	fwprintf_l(FILE * __restrict, locale_t, const wchar_t * __restrict, ...);
-int	fwscanf_l(FILE * __restrict, locale_t, const wchar_t * __restrict, ...);
-wint_t	getwc_l(FILE *, locale_t);
-wint_t	getwchar_l(locale_t);
-size_t	mbrlen_l(const char * __restrict, size_t, mbstate_t * __restrict,
-	    locale_t);
-size_t	mbrtowc_l(wchar_t * __restrict, const char * __restrict, size_t,
-	    mbstate_t * __restrict, locale_t);
-int	mbsinit_l(const mbstate_t *, locale_t);
-size_t	mbsrtowcs_l(wchar_t * __restrict, const char ** __restrict, size_t,
-	    mbstate_t * __restrict, locale_t);
-wint_t	putwc_l(wchar_t, FILE *, locale_t);
-wint_t	putwchar_l(wchar_t, locale_t);
-int	swprintf_l(wchar_t * __restrict, size_t n, locale_t,
-		const wchar_t * __restrict, ...);
-int	swscanf_l(const wchar_t * __restrict, locale_t,
-		const wchar_t * __restrict, ...);
-wint_t	ungetwc_l(wint_t, FILE *, locale_t);
-int	vfwprintf_l(FILE * __restrict, locale_t, const wchar_t * __restrict,
-		__darwin_va_list);
-int	vswprintf_l(wchar_t * __restrict, size_t n, locale_t,
-		const wchar_t * __restrict, __darwin_va_list);
-int	vwprintf_l(locale_t, const wchar_t * __restrict, __darwin_va_list);
-size_t	wcrtomb_l(char * __restrict, wchar_t, mbstate_t * __restrict,
-	    locale_t);
-int	wcscoll_l(const wchar_t *, const wchar_t *, locale_t);
-size_t	wcsftime_l(wchar_t * __restrict, size_t, const wchar_t * __restrict,
-		const struct tm * __restrict, locale_t)
-		__DARWIN_ALIAS(wcsftime_l);
-size_t	wcsrtombs_l(char * __restrict, const wchar_t ** __restrict, size_t,
-	    mbstate_t * __restrict, locale_t);
-double	wcstod_l(const wchar_t * __restrict, wchar_t ** __restrict, locale_t);
-long	wcstol_l(const wchar_t * __restrict, wchar_t ** __restrict, int,
-	    locale_t);
-unsigned long
-	wcstoul_l(const wchar_t * __restrict, wchar_t ** __restrict, int,
-	    locale_t);
-int	wcswidth_l(const wchar_t *, size_t, locale_t);
-size_t	wcsxfrm_l(wchar_t * __restrict, const wchar_t * __restrict, size_t,
-	    locale_t);
-int	wctob_l(wint_t, locale_t);
-int	wcwidth_l(wchar_t, locale_t);
-int	wprintf_l(locale_t, const wchar_t * __restrict, ...);
-int	wscanf_l(locale_t, const wchar_t * __restrict, ...);
-__END_DECLS
- 
- 
- 
-/* Additional functionality provided by:
- * POSIX.1-2001
- */
-
-#if __DARWIN_C_LEVEL >= 200112L
-__BEGIN_DECLS
-int	vfwscanf_l(FILE * __restrict, locale_t, const wchar_t * __restrict,
-		__darwin_va_list);
-int	vswscanf_l(const wchar_t * __restrict, locale_t,
-		const wchar_t * __restrict, __darwin_va_list);
-int	vwscanf_l(locale_t, const wchar_t * __restrict, __darwin_va_list);
-float	wcstof_l(const wchar_t * __restrict, wchar_t ** __restrict, locale_t);
-long double
-	wcstold_l(const wchar_t * __restrict, wchar_t ** __restrict, locale_t);
-#if !__DARWIN_NO_LONG_LONG
-long long
-	wcstoll_l(const wchar_t * __restrict, wchar_t ** __restrict, int,
-	    locale_t);
-unsigned long long
-	wcstoull_l(const wchar_t * __restrict, wchar_t ** __restrict, int,
-	    locale_t);
-#endif /* !__DARWIN_NO_LONG_LONG */
-__END_DECLS
-#endif /* __DARWIN_C_LEVEL >= 200112L */
-
-
-
-/* Additional functionality provided by:
- * POSIX.1-2008
- */
-
-#if __DARWIN_C_LEVEL >= 200809L
-__BEGIN_DECLS
-size_t	mbsnrtowcs_l(wchar_t * __restrict, const char ** __restrict, size_t,
-	    size_t, mbstate_t * __restrict, locale_t);
-int     wcscasecmp_l(const wchar_t *, const wchar_t *, locale_t) __OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_4_3);
-int     wcsncasecmp_l(const wchar_t *, const wchar_t *, size_t n, locale_t) __OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_4_3);
-size_t	wcsnrtombs_l(char * __restrict, const wchar_t ** __restrict, size_t,
-	    size_t, mbstate_t * __restrict, locale_t);
-__END_DECLS
-#endif /* __DARWIN_C_LEVEL >= 200809L */
-
-
-
-/* Darwin extensions */
-
-#if __DARWIN_C_LEVEL >= __DARWIN_C_FULL
-__BEGIN_DECLS
-wchar_t	*fgetwln_l(FILE * __restrict, size_t *, locale_t) __OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_4_3);
-__END_DECLS
-#endif /* __DARWIN_C_LEVEL >= __DARWIN_C_FULL */
-
-
-
-/* Poison the following routines if -fshort-wchar is set */
-#if !defined(__cplusplus) && defined(__WCHAR_MAX__) && __WCHAR_MAX__ <= 0xffffU
-#pragma GCC poison fgetwln_l fgetws_l fputwc_l fputws_l fwprintf_l fwscanf_l mbrtowc_l mbsnrtowcs_l mbsrtowcs_l putwc_l putwchar_l swprintf_l swscanf_l vfwprintf_l vfwscanf_l vswprintf_l vswscanf_l vwprintf_l vwscanf_l wcrtomb_l wcscoll_l wcsftime_l wcsftime_l wcsnrtombs_l wcsrtombs_l wcstod_l wcstof_l wcstol_l wcstold_l wcstoll_l wcstoul_l wcstoull_l wcswidth_l wcsxfrm_l wcwidth_l wprintf_l wscanf_l
-#endif
-
-#endif /* _XLOCALE__WCHAR_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/xpc/availability.h b/lib/libc/include/x86_64-macos-gnu/xpc/availability.h
deleted file mode 100644
index d4efcec685..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/xpc/availability.h
+++ /dev/null
@@ -1,120 +0,0 @@
-#ifndef __XPC_AVAILABILITY_H__
-#define __XPC_AVAILABILITY_H__
-
-#include <Availability.h>
-
-// Certain parts of the project use all the project's headers but have to build
-// against newer OSX SDKs than ebuild uses -- liblaunch_host being the example.
-// So we need to define these.
-#ifndef __MAC_10_15
-#define __MAC_10_15 101500
-#define __AVAILABILITY_INTERNAL__MAC_10_15 \
-__attribute__((availability(macosx, introduced=10.15)))
-#endif // __MAC_10_15
-
-#ifndef __MAC_10_14
-#define __MAC_10_14 101400
-#define __AVAILABILITY_INTERNAL__MAC_10_14 \
-__attribute__((availability(macosx, introduced=10.14)))
-#endif // __MAC_10_14
-
-#ifndef __MAC_10_13
-#define __MAC_10_13 101300
-#define __AVAILABILITY_INTERNAL__MAC_10_13 \
-	__attribute__((availability(macosx, introduced=10.13)))
-#endif // __MAC_10_13
-
-#ifndef __MAC_10_12
-#define __MAC_10_12 101200
-#define __AVAILABILITY_INTERNAL__MAC_10_12 \
-	__attribute__((availability(macosx, introduced=10.12)))
-#endif // __MAC_10_12
-
-#ifndef __MAC_10_11
-#define __MAC_10_11 101100
-#define __AVAILABILITY_INTERNAL__MAC_10_11 \
-	__attribute__((availability(macosx, introduced=10.11)))
-#endif // __MAC_10_11
-
-#ifndef __AVAILABILITY_INTERNAL__MAC_10_2_DEP__MAC_10_11
-#define __AVAILABILITY_INTERNAL__MAC_10_2_DEP__MAC_10_11
-#endif // __AVAILABILITY_INTERNAL__MAC_10_2_DEP__MAC_10_11
-
-#ifndef __AVAILABILITY_INTERNAL__MAC_10_3_DEP__MAC_10_11
-#define __AVAILABILITY_INTERNAL__MAC_10_3_DEP__MAC_10_11
-#endif // __AVAILABILITY_INTERNAL__MAC_10_3_DEP__MAC_10_11
-
-#ifndef __AVAILABILITY_INTERNAL__MAC_10_4_DEP__MAC_10_11
-#define __AVAILABILITY_INTERNAL__MAC_10_4_DEP__MAC_10_11
-#endif // __AVAILABILITY_INTERNAL__MAC_10_4_DEP__MAC_10_11
-
-#ifndef __AVAILABILITY_INTERNAL__MAC_10_5_DEP__MAC_10_11
-#define __AVAILABILITY_INTERNAL__MAC_10_5_DEP__MAC_10_11
-#endif // __AVAILABILITY_INTERNAL__MAC_10_5_DEP__MAC_10_11
-
-#ifndef __AVAILABILITY_INTERNAL__MAC_10_6_DEP__MAC_10_11
-#define __AVAILABILITY_INTERNAL__MAC_10_6_DEP__MAC_10_11
-#endif // __AVAILABILITY_INTERNAL__MAC_10_6_DEP__MAC_10_11
-
-#ifndef __AVAILABILITY_INTERNAL__MAC_10_7_DEP__MAC_10_11
-#define __AVAILABILITY_INTERNAL__MAC_10_7_DEP__MAC_10_11
-#endif // __AVAILABILITY_INTERNAL__MAC_10_7_DEP__MAC_10_11
-
-#ifndef __AVAILABILITY_INTERNAL__MAC_10_8_DEP__MAC_10_11
-#define __AVAILABILITY_INTERNAL__MAC_10_8_DEP__MAC_10_11
-#endif // __AVAILABILITY_INTERNAL__MAC_10_8_DEP__MAC_10_11
-
-#ifndef __AVAILABILITY_INTERNAL__MAC_10_9_DEP__MAC_10_11
-#define __AVAILABILITY_INTERNAL__MAC_10_9_DEP__MAC_10_11
-#endif // __AVAILABILITY_INTERNAL__MAC_10_9_DEP__MAC_10_11
-
-#ifndef __AVAILABILITY_INTERNAL__MAC_10_10_DEP__MAC_10_11
-#define __AVAILABILITY_INTERNAL__MAC_10_10_DEP__MAC_10_11
-#endif // __AVAILABILITY_INTERNAL__MAC_10_10_DEP__MAC_10_11
-
-#ifndef __AVAILABILITY_INTERNAL__MAC_10_11_DEP__MAC_10_11
-#define __AVAILABILITY_INTERNAL__MAC_10_11_DEP__MAC_10_11
-#endif // __AVAILABILITY_INTERNAL__MAC_10_11_DEP__MAC_10_11
-
-#ifndef __AVAILABILITY_INTERNAL__MAC_10_6_DEP__MAC_10_13
-#define __AVAILABILITY_INTERNAL__MAC_10_6_DEP__MAC_10_13
-#endif // __AVAILABILITY_INTERNAL__MAC_10_6_DEP__MAC_10_13
-
-#if __has_include(<simulator_host.h>)
-#include <simulator_host.h>
-#else // __has_include(<simulator_host.h>)
-#ifndef IPHONE_SIMULATOR_HOST_MIN_VERSION_REQUIRED
-#define IPHONE_SIMULATOR_HOST_MIN_VERSION_REQUIRED 999999
-#endif // IPHONE_SIMULATOR_HOST_MIN_VERSION_REQUIRED
-#endif // __has_include(<simulator_host.h>)
-
-#ifndef __WATCHOS_UNAVAILABLE
-#define __WATCHOS_UNAVAILABLE
-#endif
-
-#ifndef __TVOS_UNAVAILABLE
-#define __TVOS_UNAVAILABLE
-#endif
-
-// simulator host-side bits build against SDKs not having __*_AVAILABLE() yet
-#ifndef __OSX_AVAILABLE
-#define __OSX_AVAILABLE(...)
-#endif
-
-#ifndef __IOS_AVAILABLE
-#define __IOS_AVAILABLE(...)
-#endif
-
-#ifndef __TVOS_AVAILABLE
-#define __TVOS_AVAILABLE(...)
-#endif
-
-#ifndef __WATCHOS_AVAILABLE
-#define __WATCHOS_AVAILABLE(...)
-#endif
-
-#ifndef __API_AVAILABLE
-#define __API_AVAILABLE(...)
-#endif
-
-#endif // __XPC_AVAILABILITY_H__
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/xpc/base.h b/lib/libc/include/x86_64-macos-gnu/xpc/base.h
deleted file mode 100644
index 8fce33a1d4..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/xpc/base.h
+++ /dev/null
@@ -1,211 +0,0 @@
-// Copyright (c) 2009-2011 Apple Inc. All rights reserved.
-
-#ifndef __XPC_BASE_H__
-#define __XPC_BASE_H__
-
-#include <sys/cdefs.h>
-
-__BEGIN_DECLS
-
-#if !defined(__has_include)
-#define __has_include(x) 0
-#endif // !defined(__has_include)
-
-#if !defined(__has_attribute)
-#define __has_attribute(x) 0
-#endif // !defined(__has_attribute)
-
-#if !defined(__has_feature)
-#define __has_feature(x) 0
-#endif // !defined(__has_feature)
-
-#if !defined(__has_extension)
-#define __has_extension(x) 0
-#endif // !defined(__has_extension)
-
-#if __has_include(<xpc/availability.h>)
-#include <xpc/availability.h>
-#else // __has_include(<xpc/availability.h>)
-#include <Availability.h>
-#endif // __has_include(<xpc/availability.h>)
-
-#ifndef __XPC_INDIRECT__
-#error "Please #include <xpc/xpc.h> instead of this file directly."
-#endif // __XPC_INDIRECT__ 
-
-#pragma mark Attribute Shims
-#ifdef __GNUC__
-#define XPC_CONSTRUCTOR __attribute__((constructor))
-#define XPC_NORETURN __attribute__((__noreturn__))
-#define XPC_NOTHROW __attribute__((__nothrow__))
-#define XPC_NONNULL1 __attribute__((__nonnull__(1)))
-#define XPC_NONNULL2 __attribute__((__nonnull__(2)))
-#define XPC_NONNULL3 __attribute__((__nonnull__(3)))
-#define XPC_NONNULL4 __attribute__((__nonnull__(4)))
-#define XPC_NONNULL5 __attribute__((__nonnull__(5)))
-#define XPC_NONNULL6 __attribute__((__nonnull__(6)))
-#define XPC_NONNULL7 __attribute__((__nonnull__(7)))
-#define XPC_NONNULL8 __attribute__((__nonnull__(8)))
-#define XPC_NONNULL9 __attribute__((__nonnull__(9)))
-#define XPC_NONNULL10 __attribute__((__nonnull__(10)))
-#define XPC_NONNULL11 __attribute__((__nonnull__(11)))
-#define XPC_NONNULL_ALL __attribute__((__nonnull__))
-#define XPC_SENTINEL __attribute__((__sentinel__))
-#define XPC_PURE __attribute__((__pure__))
-#define XPC_WARN_RESULT __attribute__((__warn_unused_result__))
-#define XPC_MALLOC __attribute__((__malloc__))
-#define XPC_UNUSED __attribute__((__unused__))
-#define XPC_USED __attribute__((__used__))
-#define XPC_PACKED __attribute__((__packed__))
-#define XPC_PRINTF(m, n) __attribute__((format(printf, m, n)))
-#define XPC_INLINE static __inline__ __attribute__((__always_inline__))
-#define XPC_NOINLINE __attribute__((noinline))
-#define XPC_NOIMPL __attribute__((unavailable))
-
-#if __has_attribute(noescape)
-#define XPC_NOESCAPE __attribute__((__noescape__))
-#else
-#define XPC_NOESCAPE
-#endif
-
-#if __has_extension(attribute_unavailable_with_message)
-#define XPC_UNAVAILABLE(m) __attribute__((unavailable(m)))
-#else // __has_extension(attribute_unavailable_with_message)
-#define XPC_UNAVAILABLE(m) XPC_NOIMPL
-#endif // __has_extension(attribute_unavailable_with_message)
-
-#define XPC_EXPORT extern __attribute__((visibility("default")))
-#define XPC_NOEXPORT __attribute__((visibility("hidden")))
-#define XPC_WEAKIMPORT extern __attribute__((weak_import))
-#define XPC_DEBUGGER_EXCL XPC_NOEXPORT XPC_USED
-#define XPC_TRANSPARENT_UNION __attribute__((transparent_union))
-#if __clang__
-#define XPC_DEPRECATED(m) __attribute__((deprecated(m)))
-#else // __clang__
-#define XPC_DEPRECATED(m) __attribute__((deprecated))
-#endif // __clang 
-
-#if defined(__XPC_TEST__) && __XPC_TEST__
-#define XPC_TESTSTATIC
-#define XPC_TESTEXTERN extern
-#else // defined(__XPC_TEST__) && __XPC_TEST__
-#define XPC_TESTSTATIC static
-#endif // defined(__XPC_TEST__) && __XPC_TEST__
-
-#if __has_feature(objc_arc)
-#define XPC_GIVES_REFERENCE __strong
-#define XPC_UNRETAINED __unsafe_unretained
-#define XPC_BRIDGE(xo) ((__bridge void *)(xo))
-#define XPC_BRIDGEREF_BEGIN(xo) ((__bridge_retained void *)(xo))
-#define XPC_BRIDGEREF_BEGIN_WITH_REF(xo) ((__bridge void *)(xo))
-#define XPC_BRIDGEREF_MIDDLE(xo) ((__bridge id)(xo))
-#define XPC_BRIDGEREF_END(xo) ((__bridge_transfer id)(xo))
-#else // __has_feature(objc_arc)
-#define XPC_GIVES_REFERENCE
-#define XPC_UNRETAINED
-#define XPC_BRIDGE(xo) (xo)
-#define XPC_BRIDGEREF_BEGIN(xo) (xo)
-#define XPC_BRIDGEREF_BEGIN_WITH_REF(xo) (xo)
-#define XPC_BRIDGEREF_MIDDLE(xo) (xo)
-#define XPC_BRIDGEREF_END(xo) (xo)
-#endif // __has_feature(objc_arc)
-
-#define _xpc_unreachable() __builtin_unreachable()
-#else // __GNUC__ 
-/*! @parseOnly */
-#define XPC_CONSTRUCTOR
-/*! @parseOnly */
-#define XPC_NORETURN
-/*! @parseOnly */
-#define XPC_NOTHROW
-/*! @parseOnly */
-#define XPC_NONNULL1
-/*! @parseOnly */
-#define XPC_NONNULL2
-/*! @parseOnly */
-#define XPC_NONNULL3
-/*! @parseOnly */
-#define XPC_NONNULL4
-/*! @parseOnly */
-#define XPC_NONNULL5
-/*! @parseOnly */
-#define XPC_NONNULL6
-/*! @parseOnly */
-#define XPC_NONNULL7
-/*! @parseOnly */
-#define XPC_NONNULL8
-/*! @parseOnly */
-#define XPC_NONNULL9
-/*! @parseOnly */
-#define XPC_NONNULL10
-/*! @parseOnly */
-#define XPC_NONNULL11
-/*! @parseOnly */
-#define XPC_NONNULL(n)
-/*! @parseOnly */
-#define XPC_NONNULL_ALL
-/*! @parseOnly */
-#define XPC_SENTINEL
-/*! @parseOnly */
-#define XPC_PURE
-/*! @parseOnly */
-#define XPC_WARN_RESULT
-/*! @parseOnly */
-#define XPC_MALLOC
-/*! @parseOnly */
-#define XPC_UNUSED
-/*! @parseOnly */
-#define XPC_PACKED
-/*! @parseOnly */
-#define XPC_PRINTF(m, n)
-/*! @parseOnly */
-#define XPC_INLINE static inline
-/*! @parseOnly */
-#define XPC_NOINLINE
-/*! @parseOnly */
-#define XPC_NOIMPL
-/*! @parseOnly */
-#define XPC_EXPORT extern
-/*! @parseOnly */
-#define XPC_WEAKIMPORT
-/*! @parseOnly */
-#define XPC_DEPRECATED
-/*! @parseOnly */
-#define XPC_UNAVAILABLE(m)
-/*! @parseOnly */
-#define XPC_NOESCAPE
-#endif // __GNUC__
-
-#if __has_feature(assume_nonnull)
-#define XPC_ASSUME_NONNULL_BEGIN _Pragma("clang assume_nonnull begin")
-#define XPC_ASSUME_NONNULL_END   _Pragma("clang assume_nonnull end")
-#else
-#define XPC_ASSUME_NONNULL_BEGIN
-#define XPC_ASSUME_NONNULL_END
-#endif
-
-#if __has_feature(nullability_on_arrays)
-#define XPC_NONNULL_ARRAY _Nonnull
-#else
-#define XPC_NONNULL_ARRAY
-#endif
-
-#ifdef OS_CLOSED_OPTIONS
-#define XPC_FLAGS_ENUM(_name, _type, ...) \
-		OS_CLOSED_OPTIONS(_name, _type, __VA_ARGS__)
-#else // OS_CLOSED_ENUM
-#define XPC_FLAGS_ENUM(_name, _type, ...) \
-		OS_ENUM(_name, _type, __VA_ARGS__)
-#endif // OS_CLOSED_ENUM
-
-#ifdef OS_CLOSED_ENUM
-#define XPC_ENUM(_name, _type, ...) \
-		OS_CLOSED_ENUM(_name, _type, __VA_ARGS__)
-#else // OS_CLOSED_ENUM
-#define XPC_ENUM(_name, _type, ...) \
-		OS_ENUM(_name, _type, __VA_ARGS__)
-#endif // OS_CLOSED_ENUM
-
-__END_DECLS
-
-#endif // __XPC_BASE_H__
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/xpc/connection.h b/lib/libc/include/x86_64-macos-gnu/xpc/connection.h
deleted file mode 100644
index 7a6ac1a2f9..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/xpc/connection.h
+++ /dev/null
@@ -1,747 +0,0 @@
-#ifndef __XPC_CONNECTION_H__
-#define __XPC_CONNECTION_H__
-
-#ifndef __XPC_INDIRECT__
-#error "Please #include <xpc/xpc.h> instead of this file directly."
-// For HeaderDoc.
-#include <xpc/base.h>
-#endif // __XPC_INDIRECT__
-
-#ifndef __BLOCKS__
-#error "XPC connections require Blocks support."
-#endif // __BLOCKS__
-
-XPC_ASSUME_NONNULL_BEGIN
-__BEGIN_DECLS
-
-/*!
- * @constant XPC_ERROR_CONNECTION_INTERRUPTED
- * Will be delivered to the connection's event handler if the remote service
- * exited. The connection is still live even in this case, and resending a
- * message will cause the service to be launched on-demand. This error serves
- * as a client's indication that it should resynchronize any state that it had
- * given the service.
- *
- * Any messages in the queue to be sent will be unwound and canceled when this
- * error occurs. In the case where a message waiting to be sent has a reply
- * handler, that handler will be invoked with this error. In the context of the
- * reply handler, this error indicates that a reply to the message will never
- * arrive.
- *
- * Messages that do not have reply handlers associated with them will be
- * silently disposed of. This error will only be given to peer connections.
- */
-#define XPC_ERROR_CONNECTION_INTERRUPTED \
-	XPC_GLOBAL_OBJECT(_xpc_error_connection_interrupted)
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT
-const struct _xpc_dictionary_s _xpc_error_connection_interrupted;
-
-/*!
- * @constant XPC_ERROR_CONNECTION_INVALID
- * Will be delivered to the connection's event handler if the named service
- * provided to xpc_connection_create() could not be found in the XPC service
- * namespace. The connection is useless and should be disposed of.
- *
- * Any messages in the queue to be sent will be unwound and canceled when this
- * error occurs, similarly to the behavior when XPC_ERROR_CONNECTION_INTERRUPTED
- * occurs. The only difference is that the XPC_ERROR_CONNECTION_INVALID will be
- * given to outstanding reply handlers and the connection's event handler.
- *
- * This error may be given to any type of connection.
- */
-#define XPC_ERROR_CONNECTION_INVALID \
-	XPC_GLOBAL_OBJECT(_xpc_error_connection_invalid)
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT
-const struct _xpc_dictionary_s _xpc_error_connection_invalid;
-
-/*!
- * @constant XPC_ERROR_TERMINATION_IMMINENT
- * On macOS, this error will be delivered to a peer connection's event handler
- * when the XPC runtime has determined that the program should exit and that
- * all outstanding transactions must be wound down, and no new transactions can
- * be opened.
- *
- * After this error has been delivered to the event handler, no more messages
- * will be received by the connection. The runtime will still attempt to deliver
- * outgoing messages, but this error should be treated as an indication that
- * the program will exit very soon, and any outstanding business over the
- * connection should be wrapped up as quickly as possible and the connection
- * canceled shortly thereafter.
- *
- * This error will only be delivered to peer connections received through a
- * listener or the xpc_main() event handler.
- */
-#define XPC_ERROR_TERMINATION_IMMINENT \
-	XPC_GLOBAL_OBJECT(_xpc_error_termination_imminent)
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT
-const struct _xpc_dictionary_s _xpc_error_termination_imminent;
-
-/*!
- * @constant XPC_CONNECTION_MACH_SERVICE_LISTENER
- * Passed to xpc_connection_create_mach_service(). This flag indicates that the
- * caller is the listener for the named service. This flag may only be passed
- * for services which are advertised in the process' launchd.plist(5). You may
- * not use this flag to dynamically add services to the Mach bootstrap
- * namespace.
- */
-#define XPC_CONNECTION_MACH_SERVICE_LISTENER (1 << 0)
-
-/*!
- * @constant XPC_CONNECTION_MACH_SERVICE_PRIVILEGED
- * Passed to xpc_connection_create_mach_service(). This flag indicates that the
- * job advertising the service name in its launchd.plist(5) should be in the
- * privileged Mach bootstrap. This is typically accomplished by placing your
- * launchd.plist(5) in /Library/LaunchDaemons. If specified alongside the
- * XPC_CONNECTION_MACH_SERVICE_LISTENER flag, this flag is a no-op.
- */
-#define XPC_CONNECTION_MACH_SERVICE_PRIVILEGED (1 << 1)
-
-/*!
- * @typedef xpc_finalizer_f
- * A function that is invoked when a connection is being torn down and its
- * context needs to be freed. The sole argument is the value that was given to
- * {@link xpc_connection_set_context} or NULL if no context has been set. It is
- * not safe to reference the connection from within this function.
- *
- * @param value
- * The context object that is to be disposed of.
- */
-typedef void (*xpc_finalizer_t)(void * _Nullable value);
-
-/*!
- * @function xpc_connection_create
- * Creates a new connection object.
- *
- * @param name
- * If non-NULL, the name of the service with which to connect. The returned
- * connection will be a peer.
- *
- * If NULL, an anonymous listener connection will be created. You can embed the
- * ability to create new peer connections in an endpoint, which can be inserted
- * into a message and sent to another process .
- *
- * @param targetq
- * The GCD queue to which the event handler block will be submitted. This
- * parameter may be NULL, in which case the connection's target queue will be
- * libdispatch's default target queue, defined as DISPATCH_TARGET_QUEUE_DEFAULT.
- * The target queue may be changed later with a call to
- * xpc_connection_set_target_queue().
- *
- * @result
- * A new connection object. The caller is responsible for disposing of the
- * returned object with {@link xpc_release} when it is no longer needed.
- *
- * @discussion
- * This method will succeed even if the named service does not exist. This is
- * because the XPC namespace is not queried for the service name until the
- * connection has been activated. See {@link xpc_connection_activate()}.
- *
- * XPC connections, like dispatch sources, are returned in an inactive state, so
- * you must call {@link xpc_connection_activate()} in order to begin receiving
- * events from the connection. Also like dispatch sources, connections must be
- * activated and not suspended in order to be safely released. It is
- * a programming error to release an inactive or suspended connection.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_MALLOC XPC_RETURNS_RETAINED XPC_WARN_RESULT
-xpc_connection_t
-xpc_connection_create(const char * _Nullable name,
-	dispatch_queue_t _Nullable targetq);
-
-/*!
- * @function xpc_connection_create_mach_service
- * Creates a new connection object representing a Mach service.
- *
- * @param name
- * The name of the remote service with which to connect. The service name must
- * exist in a Mach bootstrap that is accessible to the process and be advertised
- * in a launchd.plist.
- *
- * @param targetq
- * The GCD queue to which the event handler block will be submitted. This
- * parameter may be NULL, in which case the connection's target queue will be
- * libdispatch's default target queue, defined as DISPATCH_TARGET_QUEUE_DEFAULT.
- * The target queue may be changed later with a call to
- * xpc_connection_set_target_queue().
- *
- * @param flags
- * Additional attributes with which to create the connection.
- *
- * @result
- * A new connection object.
- *
- * @discussion
- * If the XPC_CONNECTION_MACH_SERVICE_LISTENER flag is given to this method,
- * then the connection returned will be a listener connection. Otherwise, a peer
- * connection will be returned. See the documentation for
- * {@link xpc_connection_set_event_handler()} for the semantics of listener
- * connections versus peer connections.
- *
- * This method will succeed even if the named service does not exist. This is
- * because the Mach namespace is not queried for the service name until the
- * connection has been activated. See {@link xpc_connection_activate()}.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_MALLOC XPC_RETURNS_RETAINED XPC_WARN_RESULT XPC_NONNULL1
-xpc_connection_t
-xpc_connection_create_mach_service(const char *name,
-	dispatch_queue_t _Nullable targetq, uint64_t flags);
-
-/*!
- * @function xpc_connection_create_from_endpoint
- * Creates a new connection from the given endpoint.
- *
- * @param endpoint
- * The endpoint from which to create the new connection.
- *
- * @result
- * A new peer connection to the listener represented by the given endpoint.
- *
- * The same responsibilities of setting an event handler and activating the
- * connection after calling xpc_connection_create() apply to the connection
- * returned by this API. Since the connection yielded by this API is not
- * associated with a name (and therefore is not rediscoverable), this connection
- * will receive XPC_ERROR_CONNECTION_INVALID if the listening side crashes,
- * exits or cancels the listener connection.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_MALLOC XPC_RETURNS_RETAINED XPC_WARN_RESULT XPC_NONNULL_ALL
-xpc_connection_t
-xpc_connection_create_from_endpoint(xpc_endpoint_t endpoint);
-
-/*!
- * @function xpc_connection_set_target_queue
- * Sets the target queue of the given connection.
- *
- * @param connection
- * The connection object which is to be manipulated.
- *
- * @param targetq
- * The GCD queue to which the event handler block will be submitted. This
- * parameter may be NULL, in which case the connection's target queue will be
- * libdispatch's default target queue, defined as DISPATCH_TARGET_QUEUE_DEFAULT.
- *
- * @discussion
- * Setting the target queue is asynchronous and non-preemptive and therefore
- * this method will not interrupt the execution of an already-running event
- * handler block. Setting the target queue may be likened to issuing a barrier
- * to the connection which does the actual work of changing the target queue.
- *
- * The XPC runtime guarantees this non-preemptiveness even for concurrent target
- * queues. If the target queue is a concurrent queue, then XPC still guarantees
- * that there will never be more than one invocation of the connection's event
- * handler block executing concurrently. If you wish to process events
- * concurrently, you can dispatch_async(3) to a concurrent queue from within
- * the event handler.
- *
- * IMPORTANT: When called from within the event handler block,
- * dispatch_get_current_queue(3) is NOT guaranteed to return a pointer to the
- * queue set with this method.
- *
- * Despite this seeming inconsistency, the XPC runtime guarantees that, when the
- * target queue is a serial queue, the event handler block will execute
- * synchonously with respect to other blocks submitted to that same queue. When
- * the target queue is a concurrent queue, the event handler block may run
- * concurrently with other blocks submitted to that queue, but it will never run
- * concurrently with other invocations of itself for the same connection, as
- * discussed previously.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_NONNULL1
-void
-xpc_connection_set_target_queue(xpc_connection_t connection,
-	dispatch_queue_t _Nullable targetq);
-
-/*!
- * @function xpc_connection_set_event_handler
- * Sets the event handler block for the connection.
- *
- * @param connection
- * The connection object which is to be manipulated.
- *
- * @param handler
- * The event handler block.
- *
- * @discussion
- * Setting the event handler is asynchronous and non-preemptive, and therefore
- * this method will not interrupt the execution of an already-running event
- * handler block. If the event handler is executing at the time of this call, it
- * will finish, and then the connection's event handler will be changed before
- * the next invocation of the event handler. The XPC runtime guarantees this
- * non-preemptiveness even for concurrent target queues.
- *
- * Connection event handlers are non-reentrant, so it is safe to call
- * xpc_connection_set_event_handler() from within the event handler block.
- *
- * The event handler's execution should be treated as a barrier to all
- * connection activity. When it is executing, the connection will not attempt to
- * send or receive messages, including reply messages. Thus, it is not safe to
- * call xpc_connection_send_message_with_reply_sync() on the connection from
- * within the event handler.
- *
- * You do not hold a reference on the object received as the event handler's
- * only argument. Regardless of the type of object received, it is safe to call
- * xpc_retain() on the object to obtain a reference to it.
- *
- * A connection may receive different events depending upon whether it is a
- * listener or not. Any connection may receive an error in its event handler.
- * But while normal connections may receive messages in addition to errors,
- * listener connections will receive connections and and not messages.
- *
- * Connections received by listeners are equivalent to those returned by
- * xpc_connection_create() with a non-NULL name argument and a NULL targetq
- * argument with the exception that you do not hold a reference on them.
- * You must set an event handler and activate the connection. If you do not wish
- * to accept the connection, you may simply call xpc_connection_cancel() on it
- * and return. The runtime will dispose of it for you.
- *
- * If there is an error in the connection, this handler will be invoked with the
- * error dictionary as its argument. This dictionary will be one of the well-
- * known XPC_ERROR_* dictionaries.
- *
- * Regardless of the type of event, ownership of the event object is NOT
- * implicitly transferred. Thus, the object will be released and deallocated at
- * some point in the future after the event handler returns. If you wish the
- * event's lifetime to persist, you must retain it with xpc_retain().
- *
- * Connections received through the event handler will be released and
- * deallocated after the connection has gone invalid and delivered that event to
- * its event handler.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_NONNULL_ALL
-void
-xpc_connection_set_event_handler(xpc_connection_t connection,
-	xpc_handler_t handler);
-
-/*!
- * @function xpc_connection_activate
- * Activates the connection. Connections start in an inactive state, so you must
- * call xpc_connection_activate() on a connection before it will send or receive
- * any messages.
- *
- * @param connection
- * The connection object which is to be manipulated.
- *
- * @discussion
- * Calling xpc_connection_activate() on an active connection has no effect.
- * Releasing the last reference on an inactive connection that was created with
- * an xpc_connection_create*() call is undefined.
- *
- * For backward compatibility reasons, xpc_connection_resume() on an inactive
- * and not otherwise suspended xpc connection has the same effect as calling
- * xpc_connection_activate(). For new code, using xpc_connection_activate()
- * is preferred.
- */
-__OSX_AVAILABLE(10.12) __IOS_AVAILABLE(10.0)
-__TVOS_AVAILABLE(10.0) __WATCHOS_AVAILABLE(3.0)
-XPC_EXPORT XPC_NONNULL_ALL
-void
-xpc_connection_activate(xpc_connection_t connection);
-
-/*!
- * @function xpc_connection_suspend
- * Suspends the connection so that the event handler block will not fire and
- * that the connection will not attempt to send any messages it has in its
- * queue. All calls to xpc_connection_suspend() must be balanced with calls to
- * xpc_connection_resume() before releasing the last reference to the
- * connection.
- *
- * @param connection
- * The connection object which is to be manipulated.
- *
- * @discussion
- * Suspension is asynchronous and non-preemptive, and therefore this method will
- * not interrupt the execution of an already-running event handler block. If
- * the event handler is executing at the time of this call, it will finish, and
- * then the connection will be suspended before the next scheduled invocation
- * of the event handler. The XPC runtime guarantees this non-preemptiveness even
- * for concurrent target queues.
- *
- * Connection event handlers are non-reentrant, so it is safe to call
- * xpc_connection_suspend() from within the event handler block.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_NONNULL_ALL
-void
-xpc_connection_suspend(xpc_connection_t connection);
-
-/*!
- * @function xpc_connection_resume
- * Resumes the connection.
- *
- * @param connection
- * The connection object which is to be manipulated.
- *
- * @discussion
- * In order for a connection to become live, every call to
- * xpc_connection_suspend() must be balanced with a call to
- * xpc_connection_resume().
- *
- * For backward compatibility reasons, xpc_connection_resume() on an inactive
- * and not otherwise suspended xpc connection has the same effect as calling
- * xpc_connection_activate(). For new code, using xpc_connection_activate()
- * is preferred.
- *
- * Calling xpc_connection_resume() more times than xpc_connection_suspend()
- * has been called is otherwise considered an error.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_NONNULL_ALL
-void
-xpc_connection_resume(xpc_connection_t connection);
-
-/*!
- * @function xpc_connection_send_message
- * Sends a message over the connection to the destination service.
- *
- * @param connection
- * The connection over which the message shall be sent.
- *
- * @param message
- * The message to send. This must be a dictionary object. This dictionary is
- * logically copied by the connection, so it is safe to modify the dictionary
- * after this call.
- *
- * @discussion
- * Messages are delivered in FIFO order. This API is safe to call from multiple
- * GCD queues. There is no indication that a message was delivered successfully.
- * This is because even once the message has been successfully enqueued on the
- * remote end, there are no guarantees about when the runtime will dequeue the
- * message and invoke the other connection's event handler block.
- *
- * If this API is used to send a message that is in reply to another message,
- * there is no guarantee of ordering between the invocations of the connection's
- * event handler and the reply handler for that message, even if they are
- * targeted to the same queue.
- *
- * After extensive study, we have found that clients who are interested in
- * the state of the message on the server end are typically holding open
- * transactions related to that message. And the only reliable way to track the
- * lifetime of that transaction is at the protocol layer. So the server should
- * send a reply message, which upon receiving, will cause the client to close
- * its transaction.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_NONNULL_ALL
-void
-xpc_connection_send_message(xpc_connection_t connection, xpc_object_t message);
-
-/*!
- * @function xpc_connection_send_barrier
- * Issues a barrier against the connection's message-send activity.
- *
- * @param connection
- * The connection against which the barrier is to be issued.
- *
- * @param barrier
- * The barrier block to issue. This barrier prevents concurrent message-send
- * activity on the connection. No messages will be sent while the barrier block
- * is executing.
- *
- * @discussion
- * XPC guarantees that, even if the connection's target queue is a concurrent
- * queue, there are no other messages being sent concurrently while the barrier
- * block is executing. XPC does not guarantee that the receipt of messages
- * (either through the connection's event handler or through reply handlers)
- * will be suspended while the barrier is executing.
- *
- * A barrier is issued relative to the message-send queue. Thus, if you call
- * xpc_connection_send_message() five times and then call
- * xpc_connection_send_barrier(), the barrier will be invoked after the fifth
- * message has been sent and its memory disposed of. You may safely cancel a
- * connection from within a barrier block.
- *
- * If a barrier is issued after sending a message which expects a reply, the
- * behavior is the same as described above. The receipt of a reply message will
- * not influence when the barrier runs.
- *
- * A barrier block can be useful for throttling resource consumption on the
- * connected side of a connection. For example, if your connection sends many
- * large messages, you can use a barrier to limit the number of messages that
- * are inflight at any given time. This can be particularly useful for messages
- * that contain kernel resources (like file descriptors) which have a system-
- * wide limit.
- *
- * If a barrier is issued on a canceled connection, it will be invoked
- * immediately. If a connection has been canceled and still has outstanding
- * barriers, those barriers will be invoked as part of the connection's
- * unwinding process.
- *
- * It is important to note that a barrier block's execution order is not
- * guaranteed with respect to other blocks that have been scheduled on the
- * target queue of the connection. Or said differently,
- * xpc_connection_send_barrier(3) is not equivalent to dispatch_async(3).
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_NONNULL_ALL
-void
-xpc_connection_send_barrier(xpc_connection_t connection,
-	dispatch_block_t barrier);
-
-/*!
- * @function xpc_connection_send_message_with_reply
- * Sends a message over the connection to the destination service and associates
- * a handler to be invoked when the remote service sends a reply message.
- *
- * @param connection
- * The connection over which the message shall be sent.
- *
- * @param message
- * The message to send. This must be a dictionary object.
- *
- * @param replyq
- * The GCD queue to which the reply handler will be submitted. This may be a
- * concurrent queue.
- *
- * @param handler
- * The handler block to invoke when a reply to the message is received from
- * the connection. If the remote service exits prematurely before the reply was
- * received, the XPC_ERROR_CONNECTION_INTERRUPTED error will be returned.
- * If the connection went invalid before the message could be sent, the
- * XPC_ERROR_CONNECTION_INVALID error will be returned.
- *
- * @discussion
- * If the given GCD queue is a concurrent queue, XPC cannot guarantee that there
- * will not be multiple reply handlers being invoked concurrently. XPC does not
- * guarantee any ordering for the invocation of reply handers. So if multiple
- * messages are waiting for replies and the connection goes invalid, there is no
- * guarantee that the reply handlers will be invoked in FIFO order. Similarly,
- * XPC does not guarantee that reply handlers will not run concurrently with
- * the connection's event handler in the case that the reply queue and the
- * connection's target queue are the same concurrent queue.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_NONNULL1 XPC_NONNULL2 XPC_NONNULL4
-void
-xpc_connection_send_message_with_reply(xpc_connection_t connection,
-	xpc_object_t message, dispatch_queue_t _Nullable replyq,
-	xpc_handler_t handler);
-
-/*!
- * @function xpc_connection_send_message_with_reply_sync
- * Sends a message over the connection and blocks the caller until a reply is
- * received.
- *
- * @param connection
- * The connection over which the message shall be sent.
- *
- * @param message
- * The message to send. This must be a dictionary object.
- *
- * @result
- * The message that the remote service sent in reply to the original message.
- * If the remote service exits prematurely before the reply was received, the
- * XPC_ERROR_CONNECTION_INTERRUPTED error will be returned. If the connection
- * went invalid before the message could be sent, the
- * XPC_ERROR_CONNECTION_INVALID error will be returned.
- *
- * You are responsible for releasing the returned object.
- *
- * @discussion
- * This API is primarily for transitional purposes. Its implementation is
- * conceptually equivalent to calling xpc_connection_send_message_with_reply()
- * and then immediately blocking the calling thread on a semaphore and
- * signaling the semaphore from the reply block.
- *
- * Be judicious about your use of this API. It can block indefinitely, so if you
- * are using it to implement an API that can be called from the main thread, you
- * may wish to consider allowing the API to take a queue and callback block so
- * that results may be delivered asynchronously if possible.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_NONNULL_ALL XPC_WARN_RESULT XPC_RETURNS_RETAINED
-xpc_object_t
-xpc_connection_send_message_with_reply_sync(xpc_connection_t connection,
-	xpc_object_t message);
-
-/*!
- * @function xpc_connection_cancel
- * Cancels the connection and ensures that its event handler will not fire
- * again. After this call, any messages that have not yet been sent will be
- * discarded, and the connection will be unwound. If there are messages that are
- * awaiting replies, they will have their reply handlers invoked with the
- * XPC_ERROR_CONNECTION_INVALID error.
- *
- * @param connection
- * The connection object which is to be manipulated.
- *
- * @discussion
- * Cancellation is asynchronous and non-preemptive and therefore this method
- * will not interrupt the execution of an already-running event handler block.
- * If the event handler is executing at the time of this call, it will finish,
- * and then the connection will be canceled, causing a final invocation of the
- * event handler to be scheduled with the XPC_ERROR_CONNECTION_INVALID error.
- * After that invocation, there will be no further invocations of the event
- * handler.
- *
- * The XPC runtime guarantees this non-preemptiveness even for concurrent target
- * queues.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_NONNULL_ALL
-void
-xpc_connection_cancel(xpc_connection_t connection);
-
-/*!
- * @function xpc_connection_get_name
- * Returns the name of the service with which the connections was created.
- *
- * @param connection
- * The connection object which is to be examined.
- *
- * @result
- * The name of the remote service. If you obtained the connection through an
- * invocation of another connection's event handler, NULL is returned.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_NONNULL_ALL XPC_WARN_RESULT
-const char * _Nullable
-xpc_connection_get_name(xpc_connection_t connection);
-
-/*!
- * @function xpc_connection_get_euid
- * Returns the EUID of the remote peer.
- *
- * @param connection
- * The connection object which is to be examined.
- *
- * @result
- * The EUID of the remote peer at the time the connection was made.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_NONNULL_ALL XPC_WARN_RESULT
-uid_t
-xpc_connection_get_euid(xpc_connection_t connection);
-
-/*!
- * @function xpc_connection_get_egid
- * Returns the EGID of the remote peer.
- *
- * @param connection
- * The connection object which is to be examined.
- *
- * @result
- * The EGID of the remote peer at the time the connection was made.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_NONNULL_ALL XPC_WARN_RESULT
-gid_t
-xpc_connection_get_egid(xpc_connection_t connection);
-
-/*!
- * @function xpc_connection_get_pid
- * Returns the PID of the remote peer.
- *
- * @param connection
- * The connection object which is to be examined.
- *
- * @result
- * The PID of the remote peer.
- *
- * @discussion
- * A given PID is not guaranteed to be unique across an entire boot cycle.
- * Great care should be taken when dealing with this information, as it can go
- * stale after the connection is established. OS X recycles PIDs, and therefore
- * another process could spawn and claim the PID before a message is actually
- * received from the connection.
- *
- * XPC will deliver an error to your event handler if the remote process goes
- * away, but there are no guarantees as to the timing of this notification's
- * delivery either at the kernel layer or at the XPC layer.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_NONNULL_ALL XPC_WARN_RESULT
-pid_t
-xpc_connection_get_pid(xpc_connection_t connection);
-
-/*!
- * @function xpc_connection_get_asid
- * Returns the audit session identifier of the remote peer.
- *
- * @param connection
- * The connection object which is to be examined.
- *
- * @result
- * The audit session ID of the remote peer at the time the connection was made.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_NONNULL_ALL XPC_WARN_RESULT
-au_asid_t
-xpc_connection_get_asid(xpc_connection_t connection);
-
-/*!
- * @function xpc_connection_set_context
- * Sets context on an connection.
- *
- * @param connection
- * The connection which is to be manipulated.
- *
- * @param context
- * The context to associate with the connection.
- *
- * @discussion
- * If you must manage the memory of the context object, you must set a finalizer
- * to dispose of it. If this method is called on a connection which already has
- * context associated with it, the finalizer will NOT be invoked. The finalizer
- * is only invoked when the connection is being deallocated.
- *
- * It is recommended that, instead of changing the actual context pointer
- * associated with the object, you instead change the state of the context
- * object itself.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_NONNULL1
-void
-xpc_connection_set_context(xpc_connection_t connection,
-	void * _Nullable context);
-
-/*!
- * @function xpc_connection_get_context
- * Returns the context associated with the connection.
- *
- * @param connection
- * The connection which is to be examined.
- *
- * @result
- * The context associated with the connection. NULL if there has been no context
- * associated with the object.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_NONNULL_ALL XPC_WARN_RESULT
-void * _Nullable
-xpc_connection_get_context(xpc_connection_t connection);
-
-/*!
- * @function xpc_connection_set_finalizer_f
- * Sets the finalizer for the given connection.
- *
- * @param connection
- * The connection on which to set the finalizer.
- *
- * @param finalizer
- * The function that will be invoked when the connection's retain count has
- * dropped to zero and is being torn down.
- *
- * @discussion
- * This method disposes of the context value associated with a connection, as
- * set by {@link xpc_connection_set_context}.
- *
- * For many uses of context objects, this API allows for a convenient shorthand
- * for freeing them. For example, for a context object allocated with malloc(3):
- *
- * xpc_connection_set_finalizer_f(object, free);
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_NONNULL1
-void
-xpc_connection_set_finalizer_f(xpc_connection_t connection,
-	xpc_finalizer_t _Nullable finalizer);
-
-__END_DECLS
-XPC_ASSUME_NONNULL_END
-
-#endif // __XPC_CONNECTION_H__
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos-gnu/xpc/xpc.h b/lib/libc/include/x86_64-macos-gnu/xpc/xpc.h
deleted file mode 100644
index cb6cbb3997..0000000000
--- a/lib/libc/include/x86_64-macos-gnu/xpc/xpc.h
+++ /dev/null
@@ -1,2663 +0,0 @@
-// Copyright (c) 2009-2011 Apple Inc. All rights reserved. 
-
-#ifndef __XPC_H__
-#define __XPC_H__
-
-#include <os/object.h>
-#include <dispatch/dispatch.h>
-
-#include <sys/mman.h>
-#include <uuid/uuid.h>
-#include <bsm/audit.h>
-#include <stdarg.h>
-#include <stdbool.h>
-#include <stdint.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-#include <unistd.h>
-#include <fcntl.h>
-
-#ifndef __XPC_INDIRECT__
-#define __XPC_INDIRECT__
-#endif // __XPC_INDIRECT__
-
-#include <xpc/base.h>
-
-#if __has_include(<xpc/xpc_transaction_deprecate.h>)
-#include <xpc/xpc_transaction_deprecate.h>
-#else // __has_include(<xpc/transaction_deprecate.h>)
-#define XPC_TRANSACTION_DEPRECATED
-#endif // __has_include(<xpc/transaction_deprecate.h>)
-
-XPC_ASSUME_NONNULL_BEGIN
-__BEGIN_DECLS
-
-#ifndef __OSX_AVAILABLE_STARTING
-#define __OSX_AVAILABLE_STARTING(x, y)
-#endif // __OSX_AVAILABLE_STARTING
-
-#define XPC_API_VERSION 20121012
-
-/*!
- * @typedef xpc_type_t
- * A type that describes XPC object types.
- */
-typedef const struct _xpc_type_s * xpc_type_t;
-#ifndef XPC_TYPE
-#define XPC_TYPE(type) const struct _xpc_type_s type
-#endif // XPC_TYPE
-
-/*!
- * @typedef xpc_object_t
- * A type that can describe all XPC objects. Dictionaries, arrays, strings, etc.
- * are all described by this type.
- *
- * XPC objects are created with a retain count of 1, and therefore it is the
- * caller's responsibility to call xpc_release() on them when they are no longer
- * needed.
- */
-
-#if OS_OBJECT_USE_OBJC
-/* By default, XPC objects are declared as Objective-C types when building with
- * an Objective-C compiler. This allows them to participate in ARC, in RR
- * management by the Blocks runtime and in leaks checking by the static
- * analyzer, and enables them to be added to Cocoa collections.
- *
- * See <os/object.h> for details.
- */
-OS_OBJECT_DECL(xpc_object);
-#ifndef XPC_DECL
-#define XPC_DECL(name) typedef xpc_object_t name##_t
-#endif // XPC_DECL
-
-#define XPC_GLOBAL_OBJECT(object) ((OS_OBJECT_BRIDGE xpc_object_t)&(object))
-#define XPC_RETURNS_RETAINED OS_OBJECT_RETURNS_RETAINED
-XPC_INLINE XPC_NONNULL_ALL
-void
-_xpc_object_validate(xpc_object_t object) {
-	void *isa = *(void * volatile *)(OS_OBJECT_BRIDGE void *)object;
-	(void)isa;
-}
-#else // OS_OBJECT_USE_OBJC
-typedef void * xpc_object_t;
-#define XPC_DECL(name) typedef struct _##name##_s * name##_t
-#define XPC_GLOBAL_OBJECT(object) (&(object))
-#define XPC_RETURNS_RETAINED
-#endif // OS_OBJECT_USE_OBJC 
-
-/*!
- * @typedef xpc_handler_t
- * The type of block that is accepted by the XPC connection APIs.
- *
- * @param object
- * An XPC object that is to be handled. If there was an error, this object will
- * be equal to one of the well-known XPC_ERROR_* dictionaries and can be
- * compared with the equality operator.
- *
- * @discussion
- * You are not responsible for releasing the event object.
- */
-#if __BLOCKS__
-typedef void (^xpc_handler_t)(xpc_object_t object);
-#endif // __BLOCKS__ 
-
-/*!
- * @define XPC_TYPE_CONNECTION
- * A type representing a connection to a named service. This connection is
- * bidirectional and can be used to both send and receive messages. A
- * connection carries the credentials of the remote service provider.
- */
-#define XPC_TYPE_CONNECTION (&_xpc_type_connection)
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT
-XPC_TYPE(_xpc_type_connection);
-XPC_DECL(xpc_connection);
-
-/*!
- * @typedef xpc_connection_handler_t
- * The type of the function that will be invoked for a bundled XPC service when
- * there is a new connection on the service.
- *
- * @param connection
- * A new connection that is equivalent to one received by a listener connection.
- * See the documentation for {@link xpc_connection_set_event_handler} for the
- * semantics associated with the received connection.
- */
-typedef void (*xpc_connection_handler_t)(xpc_connection_t connection);
-
-/*!
- * @define XPC_TYPE_ENDPOINT
- * A type representing a connection in serialized form. Unlike a connection, an
- * endpoint is an inert object that does not have any runtime activity
- * associated with it. Thus, it is safe to pass an endpoint in a message. Upon
- * receiving an endpoint, the recipient can use
- * xpc_connection_create_from_endpoint() to create as many distinct connections
- * as desired. 
- */
-#define XPC_TYPE_ENDPOINT (&_xpc_type_endpoint)
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT
-XPC_TYPE(_xpc_type_endpoint);
-XPC_DECL(xpc_endpoint);
-
-/*!
- * @define XPC_TYPE_NULL
- * A type representing a null object. This type is useful for disambiguating
- * an unset key in a dictionary and one which has been reserved but set empty.
- * Also, this type is a way to represent a "null" value in dictionaries, which
- * do not accept NULL.
- */
-#define XPC_TYPE_NULL (&_xpc_type_null)
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT
-XPC_TYPE(_xpc_type_null);
-
-/*!
- * @define XPC_TYPE_BOOL
- * A type representing a Boolean value.
- */
-#define XPC_TYPE_BOOL (&_xpc_type_bool)
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT
-XPC_TYPE(_xpc_type_bool);
-
-/*!
- * @define XPC_BOOL_TRUE
- * A constant representing a Boolean value of true. You may compare a Boolean
- * object against this constant to determine its value.
- */
-#define XPC_BOOL_TRUE XPC_GLOBAL_OBJECT(_xpc_bool_true)
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT
-const struct _xpc_bool_s _xpc_bool_true;
-
-/*!
- * @define XPC_BOOL_FALSE
- * A constant representing a Boolean value of false. You may compare a Boolean
- * object against this constant to determine its value.
- */
-#define XPC_BOOL_FALSE XPC_GLOBAL_OBJECT(_xpc_bool_false)
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT
-const struct _xpc_bool_s _xpc_bool_false;
-
-/*!
- * @define XPC_TYPE_INT64
- * A type representing a signed, 64-bit integer value.
- */
-#define XPC_TYPE_INT64 (&_xpc_type_int64)
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT
-XPC_TYPE(_xpc_type_int64);
-
-/*!
- * @define XPC_TYPE_UINT64
- * A type representing an unsigned, 64-bit integer value.
- */
-#define XPC_TYPE_UINT64 (&_xpc_type_uint64)
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT
-XPC_TYPE(_xpc_type_uint64);
-
-/*!
- * @define XPC_TYPE_DOUBLE
- * A type representing an IEEE-compliant, double-precision floating point value.
- */
-#define XPC_TYPE_DOUBLE (&_xpc_type_double)
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT
-XPC_TYPE(_xpc_type_double);
-
-/*!
- * @define XPC_TYPE_DATE
-* A type representing a date interval. The interval is with respect to the
- * Unix epoch. XPC dates are in Unix time and are thus unaware of local time
- * or leap seconds.
- */
-#define XPC_TYPE_DATE (&_xpc_type_date)
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT
-XPC_TYPE(_xpc_type_date);
-
-/*!
- * @define XPC_TYPE_DATA
- * A type representing a an arbitrary buffer of bytes.
- */
-#define XPC_TYPE_DATA (&_xpc_type_data)
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT
-XPC_TYPE(_xpc_type_data);
-
-/*!
- * @define XPC_TYPE_STRING
- * A type representing a NUL-terminated C-string.
- */
-#define XPC_TYPE_STRING (&_xpc_type_string)
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT
-XPC_TYPE(_xpc_type_string);
-
-/*!
- * @define XPC_TYPE_UUID
- * A type representing a Universally Unique Identifier as defined by uuid(3). 
- */
-#define XPC_TYPE_UUID (&_xpc_type_uuid)
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT
-XPC_TYPE(_xpc_type_uuid);
-
-/*!
- * @define XPC_TYPE_FD
- * A type representing a POSIX file descriptor.
- */
-#define XPC_TYPE_FD (&_xpc_type_fd)
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT
-XPC_TYPE(_xpc_type_fd);
-
-/*!
- * @define XPC_TYPE_SHMEM
- * A type representing a region of shared memory.
- */
-#define XPC_TYPE_SHMEM (&_xpc_type_shmem)
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT
-XPC_TYPE(_xpc_type_shmem);
-
-/*!
- * @define XPC_TYPE_ARRAY
- * A type representing an array of XPC objects. This array must be contiguous,
- * i.e. it cannot contain NULL values. If you wish to indicate that a slot
- * is empty, you can insert a null object. The array will grow as needed to
- * accommodate more objects.
- */
-#define XPC_TYPE_ARRAY (&_xpc_type_array)
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT
-XPC_TYPE(_xpc_type_array);
-
-/*!
- * @define XPC_TYPE_DICTIONARY
- * A type representing a dictionary of XPC objects, keyed off of C-strings.
- * You may insert NULL values into this collection. The dictionary will grow
- * as needed to accommodate more key/value pairs.
- */
-#define XPC_TYPE_DICTIONARY (&_xpc_type_dictionary)
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT
-XPC_TYPE(_xpc_type_dictionary);
-
-/*!
- * @define XPC_TYPE_ERROR
- * A type representing an error object. Errors in XPC are dictionaries, but
- * xpc_get_type() will return this type when given an error object. You
- * cannot create an error object directly; XPC will only give them to handlers.
- * These error objects have pointer values that are constant across the lifetime
- * of your process and can be safely compared.
- *
- * These constants are enumerated in the header for the connection object. Error
- * dictionaries may reserve keys so that they can be queried to obtain more
- * detailed information about the error. Currently, the only reserved key is
- * XPC_ERROR_KEY_DESCRIPTION.
- */
-#define XPC_TYPE_ERROR (&_xpc_type_error)
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT
-XPC_TYPE(_xpc_type_error);
-
-/*!
- * @define XPC_ERROR_KEY_DESCRIPTION
- * In an error dictionary, querying for this key will return a string object
- * that describes the error in a human-readable way.
- */
-#define XPC_ERROR_KEY_DESCRIPTION _xpc_error_key_description
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT
-const char * const _xpc_error_key_description;
-
-/*!
- * @define XPC_EVENT_KEY_NAME
- * In an event dictionary, this querying for this key will return a string
- * object that describes the event.
- */
-#define XPC_EVENT_KEY_NAME _xpc_event_key_name
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT
-const char * const _xpc_event_key_name;
-
-XPC_ASSUME_NONNULL_END
-#if !defined(__XPC_BUILDING_XPC__) || !__XPC_BUILDING_XPC__
-#include <xpc/endpoint.h>
-#include <xpc/debug.h>
-#if __BLOCKS__
-#include <xpc/connection.h>
-#include <xpc/activity.h>
-#endif // __BLOCKS__
-#undef __XPC_INDIRECT__
-#include <launch.h>
-#endif // !defined(__XPC_BUILDING_XPC__) || !__XPC_BUILDING_XPC__
-XPC_ASSUME_NONNULL_BEGIN
-
-#pragma mark XPC Object Protocol
-/*!
- * @function xpc_retain
- *
- * @abstract
- * Increments the reference count of an object.
- *
- * @param object
- * The object which is to be manipulated.
- *
- * @result
- * The object which was given.
- *
- * @discussion
- * Calls to xpc_retain() must be balanced with calls to xpc_release()
- * to avoid leaking memory.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_NONNULL1
-xpc_object_t
-xpc_retain(xpc_object_t object);
-#if OS_OBJECT_USE_OBJC_RETAIN_RELEASE
-#undef xpc_retain
-#define xpc_retain(object) ({ xpc_object_t _o = (object); \
-		_xpc_object_validate(_o); [_o retain]; })
-#endif // OS_OBJECT_USE_OBJC_RETAIN_RELEASE
-
-/*!
- * @function xpc_release
- *
- * @abstract
- * Decrements the reference count of an object.
- *
- * @param object
- * The object which is to be manipulated.
- *
- * @discussion
- * The caller must take care to balance retains and releases. When creating or
- * retaining XPC objects, the creator obtains a reference on the object. Thus,
- * it is the caller's responsibility to call xpc_release() on those objects when
- * they are no longer needed.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_NONNULL1
-void
-xpc_release(xpc_object_t object);
-#if OS_OBJECT_USE_OBJC_RETAIN_RELEASE
-#undef xpc_release
-#define xpc_release(object) ({ xpc_object_t _o = (object); \
-		_xpc_object_validate(_o); [_o release]; })
-#endif // OS_OBJECT_USE_OBJC_RETAIN_RELEASE
-
-/*!
- * @function xpc_get_type
- *
- * @abstract
- * Returns the type of an object.
- *
- * @param object
- * The object to examine.
- *
- * @result
- * An opaque pointer describing the type of the object. This pointer is suitable
- * direct comparison to exported type constants with the equality operator.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_NONNULL_ALL XPC_WARN_RESULT
-xpc_type_t
-xpc_get_type(xpc_object_t object);
-
-/*!
- * @function xpc_type_get_name
- *
- * @abstract
- * Returns a string describing an XPC object type.
- *
- * @param type
- * The type to describe.
- *
- * @result
- * A string describing the type of an object, like "string" or "int64".
- * This string should not be freed or modified.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_15, __IPHONE_13_0)
-XPC_EXPORT XPC_NONNULL1
-const char *
-xpc_type_get_name(xpc_type_t type);
-
-/*!
- * @function xpc_copy
- *
- * @abstract
- * Creates a copy of the object.
- *
- * @param object
- * The object to copy.
- *
- * @result
- * The new object. NULL if the object type does not support copying or if
- * sufficient memory for the copy could not be allocated. Service objects do
- * not support copying.
- *
- * @discussion
- * When called on an array or dictionary, xpc_copy() will perform a deep copy.
- *
- * The object returned is not necessarily guaranteed to be a new object, and
- * whether it is will depend on the implementation of the object being copied.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_NONNULL_ALL XPC_WARN_RESULT XPC_RETURNS_RETAINED
-xpc_object_t _Nullable
-xpc_copy(xpc_object_t object);
-
-/*!
- * @function xpc_equal
- *
- * @abstract
- * Compares two objects for equality.
- *
- * @param object1
- * The first object to compare.
- *
- * @param object2
- * The second object to compare.
- *
- * @result
- * Returns true if the objects are equal, otherwise false. Two objects must be
- * of the same type in order to be equal.
- *
- * For two arrays to be equal, they must contain the same values at the 
- * same indexes. For two dictionaries to be equal, they must contain the same
- * values for the same keys.
- *
- * Two objects being equal implies that their hashes (as returned by xpc_hash())
- * are also equal.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_NONNULL1 XPC_NONNULL2 XPC_WARN_RESULT
-bool
-xpc_equal(xpc_object_t object1, xpc_object_t object2);
-
-/*!
- * @function xpc_hash
- *
- * @abstract
- * Calculates a hash value for the given object.
- *
- * @param object
- * The object for which to calculate a hash value. This value may be modded
- * with a table size for insertion into a dictionary-like data structure.
- *
- * @result
- * The calculated hash value.
- *
- * @discussion
- * Note that the computed hash values for any particular type and value of an 
- * object can change from across releases and platforms and should not be
- * assumed to be constant across all time and space or stored persistently.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_NONNULL1 XPC_WARN_RESULT
-size_t
-xpc_hash(xpc_object_t object);
-
-/*!
- * @function xpc_copy_description
- *
- * @abstract
- * Copies a debug string describing the object.
- *
- * @param object
- * The object which is to be examined.
- *
- * @result
- * A string describing object which contains information useful for debugging.
- * This string should be disposed of with free(3) when done.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_MALLOC XPC_WARN_RESULT XPC_NONNULL1
-char *
-xpc_copy_description(xpc_object_t object);
-
-#pragma mark XPC Object Types
-#pragma mark Null
-/*!
- * @function xpc_null_create
- *
- * @abstract
- * Creates an XPC object representing the null object.
- *
- * @result
- * A new null object.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_RETURNS_RETAINED XPC_WARN_RESULT
-xpc_object_t
-xpc_null_create(void);
-
-#pragma mark Boolean
-/*!
- * @function xpc_bool_create
- *
- * @abstract
- * Creates an XPC Boolean object.
- *
- * @param value
- * The Boolean primitive value which is to be boxed.
- *
- * @result
- * A new Boolean object. 
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_RETURNS_RETAINED XPC_WARN_RESULT
-xpc_object_t
-xpc_bool_create(bool value);
-
-/*!
- * @function xpc_bool_get_value
- *
- * @abstract
- * Returns the underlying Boolean value from the object.
- *
- * @param xbool
- * The Boolean object which is to be examined.
- *
- * @result
- * The underlying Boolean value or false if the given object was not an XPC
- * Boolean object.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT
-bool
-xpc_bool_get_value(xpc_object_t xbool);
-
-#pragma mark Signed Integer
-/*!
- * @function xpc_int64_create
- *
- * @abstract
- * Creates an XPC signed integer object.
- *
- * @param value
- * The signed integer value which is to be boxed.
- *
- * @result
- * A new signed integer object.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_MALLOC XPC_RETURNS_RETAINED XPC_WARN_RESULT
-xpc_object_t
-xpc_int64_create(int64_t value);
-
-/*!
- * @function xpc_int64_get_value
- *
- * @abstract
- * Returns the underlying signed 64-bit integer value from an object.
- *
- * @param xint
- * The signed integer object which is to be examined.
- *
- * @result
- * The underlying signed 64-bit value or 0 if the given object was not an XPC
- * integer object.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_WARN_RESULT XPC_NONNULL1
-int64_t
-xpc_int64_get_value(xpc_object_t xint);
-
-#pragma mark Unsigned Integer
-/*!
- * @function xpc_uint64_create
- *
- * @abstract
- * Creates an XPC unsigned integer object.
- *
- * @param value
- * The unsigned integer value which is to be boxed.
- *
- * @result
- * A new unsigned integer object.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_MALLOC XPC_RETURNS_RETAINED XPC_WARN_RESULT
-xpc_object_t
-xpc_uint64_create(uint64_t value);
-
-/*!
- * @function xpc_uint64_get_value
- *
- * @abstract
- * Returns the underlying unsigned 64-bit integer value from an object.
- *
- * @param xuint
- * The unsigned integer object which is to be examined.
- *
- * @result
- * The underlying unsigned integer value or 0 if the given object was not an XPC
- * unsigned integer object.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_WARN_RESULT XPC_NONNULL1
-uint64_t
-xpc_uint64_get_value(xpc_object_t xuint);
-
-#pragma mark Double
-/*!
- * @function xpc_double_create
- *
- * @abstract
- * Creates an XPC double object.
- *
- * @param value
- * The floating point quantity which is to be boxed.
- *
- * @result
- * A new floating point object.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_MALLOC XPC_RETURNS_RETAINED XPC_WARN_RESULT
-xpc_object_t
-xpc_double_create(double value);
-
-/*!
- * @function xpc_double_get_value
- *
- * @abstract
- * Returns the underlying double-precision floating point value from an object.
- *
- * @param xdouble
- * The floating point object which is to be examined.
- *
- * @result
- * The underlying floating point value or NAN if the given object was not an XPC
- * floating point object.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_WARN_RESULT XPC_NONNULL1
-double
-xpc_double_get_value(xpc_object_t xdouble);
-
-#pragma mark Date
-/*!
- * @function xpc_date_create
- *
- * @abstract
- * Creates an XPC date object.
- *
- * @param interval
- * The date interval which is to be boxed. Negative values indicate the number
- * of nanoseconds before the epoch. Positive values indicate the number of
- * nanoseconds after the epoch.
- *
- * @result
- * A new date object.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_MALLOC XPC_RETURNS_RETAINED XPC_WARN_RESULT
-xpc_object_t
-xpc_date_create(int64_t interval);
-
-/*!
- * @function xpc_date_create_from_current
- *
- * @abstract
- * Creates an XPC date object representing the current date.
- *
- * @result
- * A new date object representing the current date.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_MALLOC XPC_RETURNS_RETAINED XPC_WARN_RESULT
-xpc_object_t
-xpc_date_create_from_current(void);
-
-/*!
- * @function xpc_date_get_value
- *
- * @abstract
- * Returns the underlying date interval from an object.
- *
- * @param xdate
- * The date object which is to be examined.
- *
- * @result
- * The underlying date interval or 0 if the given object was not an XPC date
- * object.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_WARN_RESULT XPC_NONNULL1
-int64_t
-xpc_date_get_value(xpc_object_t xdate);
-
-#pragma mark Data
-/*!
- * @function xpc_data_create
- *
- * @abstract
- * Creates an XPC object representing buffer of bytes.
- *
- * @param bytes
- * The buffer of bytes which is to be boxed. You may create an empty data object
- * by passing NULL for this parameter and 0 for the length. Passing NULL with
- * any other length will result in undefined behavior.
- *
- * @param length
- * The number of bytes which are to be boxed.
- *
- * @result
- * A new data object. 
- *
- * @discussion
- * This method will copy the buffer given into internal storage. After calling
- * this method, it is safe to dispose of the given buffer.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_MALLOC XPC_RETURNS_RETAINED XPC_WARN_RESULT
-xpc_object_t
-xpc_data_create(const void * _Nullable bytes, size_t length);
-
-/*!
- * @function xpc_data_create_with_dispatch_data
- *
- * @abstract
- * Creates an XPC object representing buffer of bytes described by the given GCD
- * data object.
- *
- * @param ddata
- * The GCD data object containing the bytes which are to be boxed. This object
- * is retained by the data object.
- *
- * @result
- * A new data object. 
- *
- * @discussion
- * The object returned by this method will refer to the buffer returned by
- * dispatch_data_create_map(). The point where XPC will make the call to
- * dispatch_data_create_map() is undefined.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_MALLOC XPC_RETURNS_RETAINED XPC_WARN_RESULT XPC_NONNULL1
-xpc_object_t
-xpc_data_create_with_dispatch_data(dispatch_data_t ddata);
-
-/*!
- * @function xpc_data_get_length
- *
- * @abstract
- * Returns the length of the data encapsulated by an XPC data object.
- *
- * @param xdata
- * The data object which is to be examined.
- *
- * @result
- * The length of the underlying boxed data or 0 if the given object was not an
- * XPC data object.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_WARN_RESULT XPC_NONNULL1
-size_t
-xpc_data_get_length(xpc_object_t xdata);
-
-/*!
- * @function xpc_data_get_bytes_ptr
- *
- * @abstract
- * Returns a pointer to the internal storage of a data object.
- *
- * @param xdata
- * The data object which is to be examined.
- *
- * @result
- * A pointer to the underlying boxed data or NULL if the given object was not an
- * XPC data object.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_WARN_RESULT XPC_NONNULL1
-const void * _Nullable
-xpc_data_get_bytes_ptr(xpc_object_t xdata);
-
-/*!
- * @function xpc_data_get_bytes
- *
- * @abstract
- * Copies the bytes stored in an data objects into the specified buffer.
- *
- * @param xdata
- * The data object which is to be examined.
- *
- * @param buffer
- * The buffer in which to copy the data object's bytes.
- *
- * @param off
- * The offset at which to begin the copy. If this offset is greater than the 
- * length of the data element, nothing is copied. Pass 0 to start the copy
- * at the beginning of the buffer.
- *
- * @param length
- * The length of the destination buffer.
- *
- * @result
- * The number of bytes that were copied into the buffer or 0 if the given object
- * was not an XPC data object.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_WARN_RESULT XPC_NONNULL1 XPC_NONNULL2
-size_t
-xpc_data_get_bytes(xpc_object_t xdata, 
-	void *buffer, size_t off, size_t length);
-
-#pragma mark String
-/*!
- * @function xpc_string_create
- *
- * @abstract
- * Creates an XPC object representing a NUL-terminated C-string.
- *
- * @param string
- * The C-string which is to be boxed.
- *
- * @result
- * A new string object. 
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_MALLOC XPC_RETURNS_RETAINED XPC_WARN_RESULT XPC_NONNULL1
-xpc_object_t
-xpc_string_create(const char *string);
-
-/*!
- * @function xpc_string_create_with_format
- *
- * @abstract
- * Creates an XPC object representing a C-string that is generated from the
- * given format string and arguments.
- *
- * @param fmt
- * The printf(3)-style format string from which to construct the final C-string
- * to be boxed.
- *
- * @param ...
- * The arguments which correspond to those specified in the format string.
- *
- * @result
- * A new string object. 
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_MALLOC XPC_RETURNS_RETAINED XPC_WARN_RESULT XPC_NONNULL1
-XPC_PRINTF(1, 2)
-xpc_object_t
-xpc_string_create_with_format(const char *fmt, ...);
-
-/*!
- * @function xpc_string_create_with_format_and_arguments
- *
- * @abstract
- * Creates an XPC object representing a C-string that is generated from the
- * given format string and argument list pointer.
- *
- * @param fmt
- * The printf(3)-style format string from which to construct the final C-string
- * to be boxed.
- *
- * @param ap
- * A pointer to the arguments which correspond to those specified in the format
- * string.
- *
- * @result
- * A new string object. 
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_MALLOC XPC_RETURNS_RETAINED XPC_WARN_RESULT XPC_NONNULL1
-XPC_PRINTF(1, 0)
-xpc_object_t
-xpc_string_create_with_format_and_arguments(const char *fmt, va_list ap);
-
-/*!
- * @function xpc_string_get_length
- *
- * @abstract
- * Returns the length of the underlying string.
- *
- * @param xstring
- * The string object which is to be examined.
- *
- * @result
- * The length of the underlying string, not including the NUL-terminator, or 0 
- * if the given object was not an XPC string object.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_WARN_RESULT XPC_NONNULL_ALL
-size_t
-xpc_string_get_length(xpc_object_t xstring);
-
-/*!
- * @function xpc_string_get_string_ptr
- *
- * @abstract
- * Returns a pointer to the internal storage of a string object.
- *
- * @param xstring
- * The string object which is to be examined.
- *
- * @result
- * A pointer to the string object's internal storage or NULL if the given object
- * was not an XPC string object.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_WARN_RESULT XPC_NONNULL1
-const char * _Nullable
-xpc_string_get_string_ptr(xpc_object_t xstring);
-
-#pragma mark UUID
-/*!
- * @function xpc_uuid_create
- *
- * @abstract
- * Creates an XPC object representing a universally-unique identifier (UUID) as
- * described by uuid(3).
- *
- * @param uuid
- * The UUID which is to be boxed.
- *
- * @result
- * A new UUID object. 
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_MALLOC XPC_RETURNS_RETAINED XPC_WARN_RESULT XPC_NONNULL1
-xpc_object_t
-xpc_uuid_create(const uuid_t XPC_NONNULL_ARRAY uuid);
-
-/*!
- * @function xpc_uuid_get_bytes
- *
- * @abstract
- * Returns a pointer to the the boxed UUID bytes in an XPC UUID object.
- *
- * @param xuuid
- * The UUID object which is to be examined.
- * 
- * @result
- * The underlying <code>uuid_t</code> bytes or NULL if the given object was not
- * an XPC UUID object. The returned pointer may be safely passed to the uuid(3)
- * APIs.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_NONNULL1
-const uint8_t * _Nullable
-xpc_uuid_get_bytes(xpc_object_t xuuid);
-
-#pragma mark File Descriptors
-/*!
- * @function xpc_fd_create
- *
- * @abstract
- * Creates an XPC object representing a POSIX file descriptor.
- *
- * @param fd
- * The file descriptor which is to be boxed.
- *
- * @result
- * A new file descriptor object. NULL if sufficient memory could not be
- * allocated or if the given file descriptor was not valid.
- *
- * @discussion
- * This method performs the equivalent of a dup(2) on the descriptor, and thus
- * it is safe to call close(2) on the descriptor after boxing it with a file
- * descriptor object.
- *
- * IMPORTANT: Pointer equality is the ONLY valid test for equality between two
- * file descriptor objects. There is no reliable way to determine whether two
- * file descriptors refer to the same inode with the same capabilities, so two
- * file descriptor objects created from the same underlying file descriptor
- * number will not compare equally with xpc_equal(). This is also true of a
- * file descriptor object created using xpc_copy() and the original.
- *
- * This also implies that two collections containing file descriptor objects
- * cannot be equal unless the exact same object was inserted into both.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_MALLOC XPC_RETURNS_RETAINED XPC_WARN_RESULT
-xpc_object_t _Nullable
-xpc_fd_create(int fd);
-
-/*!
- * @function xpc_fd_dup
- *
- * @abstract
- * Returns a file descriptor that is equivalent to the one boxed by the file
- * file descriptor object.
- *
- * @param xfd
- * The file descriptor object which is to be examined.
- *
- * @result
- * A file descriptor that is equivalent to the one originally given to
- * xpc_fd_create(). If the descriptor could not be created or if the given 
- * object was not an XPC file descriptor, -1 is returned.
- *
- * @discussion
- * Multiple invocations of xpc_fd_dup() will not return the same file descriptor
- * number, but they will return descriptors that are equivalent, as though they
- * had been created by dup(2).
- *
- * The caller is responsible for calling close(2) on the returned descriptor.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_WARN_RESULT XPC_NONNULL1
-int
-xpc_fd_dup(xpc_object_t xfd);
-
-#pragma mark Shared Memory
-/*!
- * @function xpc_shmem_create
- *
- * @abstract
- * Creates an XPC object representing the given shared memory region.
- *
- * @param region
- * A pointer to a region of shared memory, created through a call to mmap(2)
- * with the MAP_SHARED flag, which is to be boxed.
- *
- * @param length
- * The length of the region.
- *
- * @result
- * A new shared memory object.
- *
- * @discussion
- * Only memory regions whose exact characteristics are known to the caller
- * should be boxed using this API. Memory returned from malloc(3) may not be
- * safely shared on either OS X or iOS because the underlying virtual memory
- * objects for malloc(3)ed allocations are owned by the malloc(3) subsystem and
- * not the caller of malloc(3).
- *
- * If you wish to share a memory region that you receive from another subsystem,
- * part of the interface contract with that other subsystem must include how to
- * create the region of memory, or sharing it may be unsafe.
- *
- * Certain operations may internally fragment a region of memory in a way that
- * would truncate the range detected by the shared memory object. vm_copy(), for
- * example, may split the region into multiple parts to avoid copying certain
- * page ranges. For this reason, it is recommended that you delay all VM
- * operations until the shared memory object has been created so that the VM
- * system knows that the entire range is intended for sharing.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_MALLOC XPC_RETURNS_RETAINED XPC_WARN_RESULT XPC_NONNULL1
-xpc_object_t
-xpc_shmem_create(void *region, size_t length);
-
-/*!
- * @function xpc_shmem_map
- *
- * @abstract
- * Maps the region boxed by the XPC shared memory object into the caller's
- * address space.
- *
- * @param xshmem
- * The shared memory object to be examined.
- *
- * @param region
- * On return, this will point to the region at which the shared memory was
- * mapped.
- *
- * @result
- * The length of the region that was mapped. If the mapping failed or if the
- * given object was not an XPC shared memory object, 0 is returned. The length 
- * of the mapped region will always be an integral page size, even if the
- * creator of the region specified a non-integral page size.
- *
- * @discussion
- * The resulting region must be disposed of with munmap(2).
- *
- * It is the responsibility of the caller to manage protections on the new
- * region accordingly. 
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_WARN_RESULT XPC_NONNULL_ALL
-size_t
-xpc_shmem_map(xpc_object_t xshmem, void * _Nullable * _Nonnull region);
-
-#pragma mark Array
-/*!
- * @typedef xpc_array_applier_t
- * A block to be invoked for every value in the array.
- *
- * @param index
- * The current index in the iteration.
- *
- * @param value
- * The current value in the iteration.
- *
- * @result
- * A Boolean indicating whether iteration should continue.
- */
-#ifdef __BLOCKS__
-typedef bool (^xpc_array_applier_t)(size_t index, xpc_object_t _Nonnull value);
-#endif // __BLOCKS__ 
-
-/*!
- * @function xpc_array_create
- *
- * @abstract
- * Creates an XPC object representing an array of XPC objects.
- *
- * @discussion
- * This array must be contiguous and cannot contain any NULL values. If you
- * wish to insert the equivalent of a NULL value, you may use the result of
- * {@link xpc_null_create}.
- *
- * @param objects
- * An array of XPC objects which is to be boxed. The order of this array is
- * preserved in the object. If this array contains a NULL value, the behavior
- * is undefined. This parameter may be NULL only if the count is 0.
- *
- * @param count
- * The number of objects in the given array. If the number passed is less than
- * the actual number of values in the array, only the specified number of items
- * are inserted into the resulting array. If the number passed is more than
- * the the actual number of values, the behavior is undefined.
- *
- * @result
- * A new array object. 
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_MALLOC XPC_RETURNS_RETAINED XPC_WARN_RESULT
-xpc_object_t
-xpc_array_create(const xpc_object_t _Nonnull * _Nullable objects, size_t count);
-
-/*!
- * @function xpc_array_set_value
- *
- * @abstract
- * Inserts the specified object into the array at the specified index.
- *
- * @param xarray
- * The array object which is to be manipulated.
- *
- * @param index
- * The index at which to insert the value. This value must lie within the index
- * space of the array (0 to N-1 inclusive, where N is the count of the array).
- * If the index is outside that range, the behavior is undefined.
- * 
- * @param value
- * The object to insert. This value is retained by the array and cannot be
- * NULL. If there is already a value at the specified index, it is released,
- * and the new value is inserted in its place.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_NONNULL1 XPC_NONNULL3
-void
-xpc_array_set_value(xpc_object_t xarray, size_t index, xpc_object_t value);
-
-/*!
- * @function xpc_array_append_value
- *
- * @abstract
- * Appends an object to an XPC array.
- *
- * @param xarray
- * The array object which is to be manipulated.
- *
- * @param value
- * The object to append. This object is retained by the array.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_NONNULL1 XPC_NONNULL2
-void
-xpc_array_append_value(xpc_object_t xarray, xpc_object_t value);
-
-/*!
- * @function xpc_array_get_count
- *
- * @abstract
- * Returns the count of values currently in the array.
- *
- * @param xarray
- * The array object which is to be examined.
- *
- * @result
- * The count of values in the array or 0 if the given object was not an XPC 
- * array.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_WARN_RESULT XPC_NONNULL1
-size_t
-xpc_array_get_count(xpc_object_t xarray);
-
-/*!
- * @function xpc_array_get_value
- *
- * @abstract
- * Returns the value at the specified index in the array.
- *
- * @param xarray
- * The array object which is to be examined.
- *
- * @param index
- * The index of the value to obtain. This value must lie within the range of
- * indexes as specified in xpc_array_set_value().
- * 
- * @result
- * The object at the specified index within the array or NULL if the given
- * object was not an XPC array.
- *
- * @discussion
- * This method does not grant the caller a reference to the underlying object,
- * and thus the caller is not responsible for releasing the object.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_NONNULL_ALL
-xpc_object_t
-xpc_array_get_value(xpc_object_t xarray, size_t index);
-
-/*!
- * @function xpc_array_apply
- *
- * @abstract
- * Invokes the given block for every value in the array.
- *
- * @param xarray
- * The array object which is to be examined.
- *
- * @param applier
- * The block which this function applies to every element in the array.
- * 
- * @result
- * A Boolean indicating whether iteration of the array completed successfully.
- * Iteration will only fail if the applier block returns false.
- *
- * @discussion
- * You should not modify an array's contents during iteration. The array indexes
- * are iterated in order.
- */
-#ifdef __BLOCKS__
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_NONNULL_ALL
-bool
-xpc_array_apply(xpc_object_t xarray, XPC_NOESCAPE xpc_array_applier_t applier);
-#endif // __BLOCKS__ 
-
-#pragma mark Array Primitive Setters
-/*!
- * @define XPC_ARRAY_APPEND
- * A constant that may be passed as the destination index to the class of
- * primitive XPC array setters indicating that the given primitive should be
- * appended to the array.
- */
-#define XPC_ARRAY_APPEND ((size_t)(-1))
-
-/*!
- * @function xpc_array_set_bool
- *
- * @abstract
- * Inserts a <code>bool</code> (primitive) value into an array.
- *
- * @param xarray
- * The array object which is to be manipulated.
- *
- * @param index
- * The index at which to insert the value. This value must lie within the index
- * space of the array (0 to N-1 inclusive, where N is the count of the array) or
- * be XPC_ARRAY_APPEND. If the index is outside that range, the behavior is
- * undefined.
- *
- * @param value
- * The <code>bool</code> value to insert. After calling this method, the XPC
- * object corresponding to the primitive value inserted may be safely retrieved
- * with {@link xpc_array_get_value()}.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_NONNULL1
-void
-xpc_array_set_bool(xpc_object_t xarray, size_t index, bool value);
-
-/*!
- * @function xpc_array_set_int64
- *
- * @abstract
- * Inserts an <code>int64_t</code> (primitive) value into an array.
- *
- * @param xarray
- * The array object which is to be manipulated.
- *
- * @param index
- * The index at which to insert the value. This value must lie within the index
- * space of the array (0 to N-1 inclusive, where N is the count of the array) or
- * be XPC_ARRAY_APPEND. If the index is outside that range, the behavior is
- * undefined.
- *
- * @param value
- * The <code>int64_t</code> value to insert. After calling this method, the XPC
- * object corresponding to the primitive value inserted may be safely retrieved
- * with {@link xpc_array_get_value()}.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_NONNULL1
-void
-xpc_array_set_int64(xpc_object_t xarray, size_t index, int64_t value);
-
-/*!
- * @function xpc_array_set_uint64
- *
- * @abstract
- * Inserts a <code>uint64_t</code> (primitive) value into an array.
- *
- * @param xarray
- * The array object which is to be manipulated.
- *
- * @param index
- * The index at which to insert the value. This value must lie within the index
- * space of the array (0 to N-1 inclusive, where N is the count of the array) or
- * be XPC_ARRAY_APPEND. If the index is outside that range, the behavior is
- * undefined.
- *
- * @param value
- * The <code>uint64_t</code> value to insert. After calling this method, the XPC
- * object corresponding to the primitive value inserted may be safely retrieved
- * with {@link xpc_array_get_value()}.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_NONNULL1
-void
-xpc_array_set_uint64(xpc_object_t xarray, size_t index, uint64_t value);
-
-/*!
- * @function xpc_array_set_double
- *
- * @abstract
- * Inserts a <code>double</code> (primitive) value into an array.
- *
- * @param xarray
- * The array object which is to be manipulated.
- *
- * @param index
- * The index at which to insert the value. This value must lie within the index
- * space of the array (0 to N-1 inclusive, where N is the count of the array) or
- * be XPC_ARRAY_APPEND. If the index is outside that range, the behavior is
- * undefined.
- *
- * @param value
- * The <code>double</code> value to insert. After calling this method, the XPC
- * object corresponding to the primitive value inserted may be safely retrieved
- * with {@link xpc_array_get_value()}.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_NONNULL1
-void
-xpc_array_set_double(xpc_object_t xarray, size_t index, double value);
-
-/*!
- * @function xpc_array_set_date
- *
- * @abstract
- * Inserts a date value into an array.
- *
- * @param xarray
- * The array object which is to be manipulated.
- *
- * @param index
- * The index at which to insert the value. This value must lie within the index
- * space of the array (0 to N-1 inclusive, where N is the count of the array) or
- * be XPC_ARRAY_APPEND. If the index is outside that range, the behavior is
- * undefined.
- *
- * @param value
- * The date value to insert, represented as an <code>int64_t</code>. After 
- * calling this method, the XPC object corresponding to the primitive value 
- * inserted may be safely retrieved with {@link xpc_array_get_value()}.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_NONNULL1
-void
-xpc_array_set_date(xpc_object_t xarray, size_t index, int64_t value);
-
-/*!
- * @function xpc_array_set_data
- *
- * @abstract
- * Inserts a raw data value into an array.
- *
- * @param xarray
- * The array object which is to be manipulated.
- *
- * @param index
- * The index at which to insert the value. This value must lie within the index
- * space of the array (0 to N-1 inclusive, where N is the count of the array) or
- * be XPC_ARRAY_APPEND. If the index is outside that range, the behavior is
- * undefined.
- *
- * @param bytes
- * The raw data to insert. After calling this method, the XPC object
- * corresponding to the primitive value inserted may be safely retrieved with
- * {@link xpc_array_get_value()}.
- *
- * @param length
- * The length of the data.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_NONNULL1 XPC_NONNULL3
-void
-xpc_array_set_data(xpc_object_t xarray, size_t index, const void *bytes,
-	size_t length);
-
-/*!
- * @function xpc_array_set_string
- *
- * @abstract
- * Inserts a C string into an array.
- *
- * @param xarray
- * The array object which is to be manipulated.
- *
- * @param index
- * The index at which to insert the value. This value must lie within the index
- * space of the array (0 to N-1 inclusive, where N is the count of the array) or
- * be XPC_ARRAY_APPEND. If the index is outside that range, the behavior is
- * undefined.
- *
- * @param string
- * The C string to insert. After calling this method, the XPC object
- * corresponding to the primitive value inserted may be safely retrieved with
- * {@link xpc_array_get_value()}.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_NONNULL1 XPC_NONNULL3
-void
-xpc_array_set_string(xpc_object_t xarray, size_t index, const char *string);
-
-/*!
- * @function xpc_array_set_uuid
- *
- * @abstract
- * Inserts a <code>uuid_t</code> (primitive) value into an array.
- *
- * @param xarray
- * The array object which is to be manipulated.
- *
- * @param index
- * The index at which to insert the value. This value must lie within the index
- * space of the array (0 to N-1 inclusive, where N is the count of the array) or
- * be XPC_ARRAY_APPEND. If the index is outside that range, the behavior is
- * undefined.
- *
- * @param uuid
- * The UUID primitive to insert. After calling this method, the XPC object
- * corresponding to the primitive value inserted may be safely retrieved with
- * {@link xpc_array_get_value()}.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_NONNULL1 XPC_NONNULL3
-void
-xpc_array_set_uuid(xpc_object_t xarray, size_t index,
-	const uuid_t XPC_NONNULL_ARRAY uuid);
-
-/*!
- * @function xpc_array_set_fd
- *
- * @abstract
- * Inserts a file descriptor into an array.
- *
- * @param xarray
- * The array object which is to be manipulated.
- *
- * @param index
- * The index at which to insert the value. This value must lie within the index
- * space of the array (0 to N-1 inclusive, where N is the count of the array) or
- * be XPC_ARRAY_APPEND. If the index is outside that range, the behavior is
- * undefined.
- *
- * @param fd
- * The file descriptor to insert. After calling this method, the XPC object
- * corresponding to the primitive value inserted may be safely retrieved with
- * {@link xpc_array_get_value()}.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_NONNULL1
-void
-xpc_array_set_fd(xpc_object_t xarray, size_t index, int fd);
-
-/*!
- * @function xpc_array_set_connection
- *
- * @abstract
- * Inserts a connection into an array.
- *
- * @param xarray
- * The array object which is to be manipulated.
- *
- * @param index
- * The index at which to insert the value. This value must lie within the index
- * space of the array (0 to N-1 inclusive, where N is the count of the array) or
- * be XPC_ARRAY_APPEND. If the index is outside that range, the behavior is
- * undefined.
- *
- * @param connection
- * The connection to insert. After calling this method, the XPC object
- * corresponding to the primitive value inserted may be safely retrieved with
- * {@link xpc_array_get_value()}. The connection is NOT retained by the array.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_NONNULL1 XPC_NONNULL3
-void
-xpc_array_set_connection(xpc_object_t xarray, size_t index,
-	xpc_connection_t connection);
-
-#pragma mark Array Primitive Getters
-/*!
- * @function xpc_array_get_bool
- *
- * @abstract
- * Gets a <code>bool</code> primitive value from an array directly.
- *
- * @param xarray
- * The array which is to be examined.
- *
- * @param index
- * The index of the value to obtain. This value must lie within the index space
- * of the array (0 to N-1 inclusive, where N is the count of the array). If the
- * index is outside that range, the behavior is undefined.
- *
- * @result
- * The underlying <code>bool</code> value at the specified index. false if the
- * value at the specified index is not a Boolean value.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_WARN_RESULT XPC_NONNULL1
-bool
-xpc_array_get_bool(xpc_object_t xarray, size_t index);
-
-/*!
- * @function xpc_array_get_int64
- *
- * @abstract
- * Gets an <code>int64_t</code> primitive value from an array directly.
- *
- * @param xarray
- * The array which is to be examined.
- *
- * @param index
- * The index of the value to obtain. This value must lie within the index space
- * of the array (0 to N-1 inclusive, where N is the count of the array). If the
- * index is outside that range, the behavior is undefined.
- *
- * @result
- * The underlying <code>int64_t</code> value at the specified index. 0 if the
- * value at the specified index is not a signed integer value. 
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_WARN_RESULT XPC_NONNULL1
-int64_t
-xpc_array_get_int64(xpc_object_t xarray, size_t index);
-
-/*!
- * @function xpc_array_get_uint64
- *
- * @abstract
- * Gets a <code>uint64_t</code> primitive value from an array directly.
- *
- * @param xarray
- * The array which is to be examined.
- *
- * @param index
- * The index of the value to obtain. This value must lie within the index space
- * of the array (0 to N-1 inclusive, where N is the count of the array). If the
- * index is outside that range, the behavior is undefined.
- *
- * @result
- * The underlying <code>uint64_t</code> value at the specified index. 0 if the
- * value at the specified index is not an unsigned integer value.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_WARN_RESULT XPC_NONNULL1
-uint64_t
-xpc_array_get_uint64(xpc_object_t xarray, size_t index);
-
-/*!
- * @function xpc_array_get_double
- *
- * @abstract
- * Gets a <code>double</code> primitive value from an array directly.
- *
- * @param xarray
- * The array which is to be examined.
- *
- * @param index
- * The index of the value to obtain. This value must lie within the index space
- * of the array (0 to N-1 inclusive, where N is the count of the array). If the
- * index is outside that range, the behavior is undefined.
- *
- * @result
- * The underlying <code>double</code> value at the specified index. NAN if the
- * value at the specified index is not a floating point value.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_WARN_RESULT XPC_NONNULL1
-double
-xpc_array_get_double(xpc_object_t xarray, size_t index);
-
-/*!
- * @function xpc_array_get_date
- *
- * @abstract
- * Gets a date interval from an array directly.
- *
- * @param xarray
- * The array which is to be examined.
- *
- * @param index
- * The index of the value to obtain. This value must lie within the index space
- * of the array (0 to N-1 inclusive, where N is the count of the array). If the
- * index is outside that range, the behavior is undefined.
- *
- * @result
- * The underlying date interval at the specified index. 0 if the value at the
- * specified index is not a date value.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_WARN_RESULT XPC_NONNULL1
-int64_t
-xpc_array_get_date(xpc_object_t xarray, size_t index);
-
-/*!
- * @function xpc_array_get_data
- *
- * @abstract
- * Gets a pointer to the raw bytes of a data object from an array directly.
- *
- * @param xarray
- * The array which is to be examined.
- *
- * @param index
- * The index of the value to obtain. This value must lie within the index space
- * of the array (0 to N-1 inclusive, where N is the count of the array). If the
- * index is outside that range, the behavior is undefined.
- *
- * @param length
- * Upon return output, will contain the length of the data corresponding to the
- * specified key.
- *
- * @result
- * The underlying bytes at the specified index. NULL if the value at the
- * specified index is not a data value.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_WARN_RESULT XPC_NONNULL1
-const void * _Nullable
-xpc_array_get_data(xpc_object_t xarray, size_t index,
-	size_t * _Nullable length);
-
-/*!
- * @function xpc_array_get_string
- *
- * @abstract
- * Gets a C string value from an array directly.
- *
- * @param xarray
- * The array which is to be examined.
- *
- * @param index
- * The index of the value to obtain. This value must lie within the index space
- * of the array (0 to N-1 inclusive, where N is the count of the array). If the
- * index is outside that range, the behavior is undefined.
- *
- * @result
- * The underlying C string at the specified index. NULL if the value at the
- * specified index is not a C string value.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_WARN_RESULT XPC_NONNULL1
-const char * _Nullable
-xpc_array_get_string(xpc_object_t xarray, size_t index);
-
-/*!
- * @function xpc_array_get_uuid
- *
- * @abstract
- * Gets a <code>uuid_t</code> value from an array directly.
- *
- * @param xarray
- * The array which is to be examined.
- *
- * @param index
- * The index of the value to obtain. This value must lie within the index space
- * of the array (0 to N-1 inclusive, where N is the count of the array). If the
- * index is outside that range, the behavior is undefined.
- *
- * @result
- * The underlying <code>uuid_t</code> value at the specified index. The null
- * UUID if the value at the specified index is not a UUID value. The returned
- * pointer may be safely passed to the uuid(3) APIs.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_WARN_RESULT XPC_NONNULL1
-const uint8_t * _Nullable
-xpc_array_get_uuid(xpc_object_t xarray, size_t index);
-
-/*!
- * @function xpc_array_dup_fd
- *
- * @abstract
- * Gets a file descriptor from an array directly.
- *
- * @param xarray
- * The array which is to be examined.
- *
- * @param index
- * The index of the value to obtain. This value must lie within the index space
- * of the array (0 to N-1 inclusive, where N is the count of the array). If the
- * index is outside that range, the behavior is undefined.
- *
- * @result
- * A new file descriptor created from the value at the specified index. You are
- * responsible for close(2)ing this descriptor. -1 if the value at the specified
- * index is not a file descriptor value.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_WARN_RESULT XPC_NONNULL1
-int
-xpc_array_dup_fd(xpc_object_t xarray, size_t index);
-
-/*!
- * @function xpc_array_create_connection
- *
- * @abstract
- * Creates a connection object from an array directly.
- *
- * @param xarray
- * The array which is to be examined.
- *
- * @param index
- * The index of the value to obtain. This value must lie within the index space
- * of the array (0 to N-1 inclusive, where N is the count of the array). If the
- * index is outside that range, the behavior is undefined.
- *
- * @result
- * A new connection created from the value at the specified index. You are
- * responsible for calling xpc_release() on the returned connection. NULL if the
- * value at the specified index is not an endpoint containing a connection. Each
- * call to this method for the same index in the same array will yield a
- * different connection. See {@link xpc_connection_create_from_endpoint()} for
- * discussion as to the responsibilities when dealing with the returned
- * connection.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_MALLOC XPC_RETURNS_RETAINED XPC_WARN_RESULT XPC_NONNULL1
-xpc_connection_t _Nullable
-xpc_array_create_connection(xpc_object_t xarray, size_t index);
-
-/*!
- * @function xpc_array_get_dictionary
- *
- * @abstract
- * Returns the dictionary at the specified index in the array.
- *
- * @param xarray
- * The array object which is to be examined.
- *
- * @param index
- * The index of the value to obtain. This value must lie within the range of
- * indexes as specified in xpc_array_set_value().
- * 
- * @result
- * The object at the specified index within the array or NULL if the given
- * object was not an XPC array or if the the value at the specified index was
- * not a dictionary.
- *
- * @discussion
- * This method does not grant the caller a reference to the underlying object,
- * and thus the caller is not responsible for releasing the object.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_11, __IPHONE_9_0)
-XPC_EXPORT XPC_WARN_RESULT XPC_NONNULL_ALL
-xpc_object_t _Nullable
-xpc_array_get_dictionary(xpc_object_t xarray, size_t index);
-
-/*!
- * @function xpc_array_get_array
- *
- * @abstract
- * Returns the array at the specified index in the array.
- *
- * @param xarray
- * The array object which is to be examined.
- *
- * @param index
- * The index of the value to obtain. This value must lie within the range of
- * indexes as specified in xpc_array_set_value().
- * 
- * @result
- * The object at the specified index within the array or NULL if the given
- * object was not an XPC array or if the the value at the specified index was
- * not an array.
- *
- * @discussion
- * This method does not grant the caller a reference to the underlying object,
- * and thus the caller is not responsible for releasing the object.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_11, __IPHONE_9_0)
-XPC_EXPORT XPC_WARN_RESULT XPC_NONNULL_ALL
-xpc_object_t _Nullable
-xpc_array_get_array(xpc_object_t xarray, size_t index);
-
-#pragma mark Dictionary
-/*!
- * @typedef xpc_dictionary_applier_t
- * A block to be invoked for every key/value pair in the dictionary.
- *
- * @param key
- * The current key in the iteration.
- *
- * @param value
- * The current value in the iteration.
- *
- * @result
- * A Boolean indicating whether iteration should continue.
- */
-#ifdef __BLOCKS__
-typedef bool (^xpc_dictionary_applier_t)(const char * _Nonnull key,
-		xpc_object_t _Nonnull value);
-#endif // __BLOCKS__ 
-
-/*!
- * @function xpc_dictionary_create
- *
- * @abstract
- * Creates an XPC object representing a dictionary of XPC objects keyed to
- * C-strings.
- *
- * @param keys
- * An array of C-strings that are to be the keys for the values to be inserted.
- * Each element of this array is copied into the dictionary's internal storage.
- * Elements of this array may NOT be NULL.
- *
- * @param values
- * A C-array that is parallel to the array of keys, consisting of objects that
- * are to be inserted. Each element in this array is retained. Elements in this
- * array may be NULL.
- *
- * @param count
- * The number of key/value pairs in the given arrays. If the count is less than
- * the actual count of values, only that many key/value pairs will be inserted
- * into the dictionary.
- *
- * If the count is more than the the actual count of key/value pairs, the
- * behavior is undefined. If one array is NULL and the other is not, the 
- * behavior is undefined. If both arrays are NULL and the count is non-0, the
- * behavior is undefined.
- *
- * @result
- * The new dictionary object.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_MALLOC XPC_RETURNS_RETAINED XPC_WARN_RESULT
-xpc_object_t
-xpc_dictionary_create(const char * _Nonnull const * _Nullable keys,
-	const xpc_object_t _Nullable * _Nullable values, size_t count);
-
-/*!
- * @function xpc_dictionary_create_reply
- * 
- * @abstract
- * Creates a dictionary that is in reply to the given dictionary.
- *
- * @param original
- * The original dictionary that is to be replied to.
- *
- * @result
- * The new dictionary object. NULL if the object was not a dictionary with a
- * reply context.
- *
- * @discussion
- * After completing successfully on a dictionary, this method may not be called
- * again on that same dictionary. Attempts to do so will return NULL.
- *
- * When this dictionary is sent across the reply connection, the remote end's
- * reply handler is invoked.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_MALLOC XPC_RETURNS_RETAINED XPC_WARN_RESULT XPC_NONNULL_ALL
-xpc_object_t _Nullable
-xpc_dictionary_create_reply(xpc_object_t original);
-
-/*!
- * @function xpc_dictionary_set_value
- *
- * @abstract
- * Sets the value for the specified key to the specified object.
- *
- * @param xdict
- * The dictionary object which is to be manipulated.
- *
- * @param key
- * The key for which the value shall be set.
- *
- * @param value
- * The object to insert. The object is retained by the dictionary. If there
- * already exists a value for the specified key, the old value is released
- * and overwritten by the new value. This parameter may be NULL, in which case
- * the value corresponding to the specified key is deleted if present.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_NONNULL1 XPC_NONNULL2
-void
-xpc_dictionary_set_value(xpc_object_t xdict, const char *key,
-	xpc_object_t _Nullable value);
-
-/*!
- * @function xpc_dictionary_get_value
- *
- * @abstract
- * Returns the value for the specified key.
- *
- * @param xdict
- * The dictionary object which is to be examined.
- *
- * @param key
- * The key whose value is to be obtained.
- * 
- * @result
- * The object for the specified key within the dictionary. NULL if there is no
- * value associated with the specified key or if the given object was not an
- * XPC dictionary.
- *
- * @discussion
- * This method does not grant the caller a reference to the underlying object,
- * and thus the caller is not responsible for releasing the object.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_WARN_RESULT XPC_NONNULL1 XPC_NONNULL2
-xpc_object_t _Nullable
-xpc_dictionary_get_value(xpc_object_t xdict, const char *key);
-
-/*!
- * @function xpc_dictionary_get_count
- *
- * @abstract
- * Returns the number of values stored in the dictionary.
- *
- * @param xdict
- * The dictionary object which is to be examined.
- *
- * @result
- * The number of values stored in the dictionary or 0 if the given object was 
- * not an XPC dictionary. Calling xpc_dictionary_set_value() with a non-NULL
- * value will increment the count. Calling xpc_dictionary_set_value() with a 
- * NULL value will decrement the count.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_WARN_RESULT XPC_NONNULL1
-size_t
-xpc_dictionary_get_count(xpc_object_t xdict);
-
-/*!
- * @function xpc_dictionary_apply
- *
- * @abstract
- * Invokes the given block for every key/value pair in the dictionary.
- *
- * @param xdict
- * The dictionary object which is to be examined.
- *
- * @param applier
- * The block which this function applies to every key/value pair in the 
- * dictionary.
- * 
- * @result
- * A Boolean indicating whether iteration of the dictionary completed
- * successfully. Iteration will only fail if the applier block returns false.
- *
- * @discussion
- * You should not modify a dictionary's contents during iteration. There is no
- * guaranteed order of iteration over dictionaries.
- */
-#ifdef __BLOCKS__
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_NONNULL_ALL
-bool
-xpc_dictionary_apply(xpc_object_t xdict,
-		XPC_NOESCAPE xpc_dictionary_applier_t applier);
-#endif // __BLOCKS__ 
-
-/*!
- * @function xpc_dictionary_get_remote_connection
- *
- * @abstract
- * Returns the connection from which the dictionary was received.
- *
- * @param xdict
- * The dictionary object which is to be examined.
- *
- * @result
- * If the dictionary was received by a connection event handler or a dictionary
- * created through xpc_dictionary_create_reply(), a connection object over which
- * a reply message can be sent is returned. For any other dictionary, NULL is
- * returned.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_WARN_RESULT XPC_NONNULL_ALL
-xpc_connection_t _Nullable
-xpc_dictionary_get_remote_connection(xpc_object_t xdict);
-
-#pragma mark Dictionary Primitive Setters
-/*!
- * @function xpc_dictionary_set_bool
- *
- * @abstract
- * Inserts a <code>bool</code> (primitive) value into a dictionary.
- *
- * @param xdict
- * The dictionary which is to be manipulated.
- *
- * @param key
- * The key for which the primitive value shall be set.
- *
- * @param value
- * The <code>bool</code> value to insert. After calling this method, the XPC
- * object corresponding to the primitive value inserted may be safely retrieved
- * with {@link xpc_dictionary_get_value()}.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_NONNULL1 XPC_NONNULL2
-void
-xpc_dictionary_set_bool(xpc_object_t xdict, const char *key, bool value);
-
-/*!
- * @function xpc_dictionary_set_int64
- *
- * @abstract
- * Inserts an <code>int64_t</code> (primitive) value into a dictionary.
- *
- * @param xdict
- * The dictionary which is to be manipulated.
- *
- * @param key
- * The key for which the primitive value shall be set.
- *
- * @param value
- * The <code>int64_t</code> value to insert. After calling this method, the XPC
- * object corresponding to the primitive value inserted may be safely retrieved
- * with {@link xpc_dictionary_get_value()}.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_NONNULL1 XPC_NONNULL2
-void
-xpc_dictionary_set_int64(xpc_object_t xdict, const char *key, int64_t value);
-
-/*!
- * @function xpc_dictionary_set_uint64
- *
- * @abstract
- * Inserts a <code>uint64_t</code> (primitive) value into a dictionary.
- *
- * @param xdict
- * The dictionary which is to be manipulated.
- *
- * @param key
- * The key for which the primitive value shall be set.
- *
- * @param value
- * The <code>uint64_t</code> value to insert. After calling this method, the XPC
- * object corresponding to the primitive value inserted may be safely retrieved
- * with {@link xpc_dictionary_get_value()}.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_NONNULL1 XPC_NONNULL2
-void
-xpc_dictionary_set_uint64(xpc_object_t xdict, const char *key, uint64_t value);
-
-/*!
- * @function xpc_dictionary_set_double
- *
- * @abstract
- * Inserts a <code>double</code> (primitive) value into a dictionary.
- *
- * @param xdict
- * The dictionary which is to be manipulated.
- *
- * @param key
- * The key for which the primitive value shall be set.
- *
- * @param value
- * The <code>double</code> value to insert. After calling this method, the XPC
- * object corresponding to the primitive value inserted may be safely retrieved
- * with {@link xpc_dictionary_get_value()}.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_NONNULL1 XPC_NONNULL2
-void
-xpc_dictionary_set_double(xpc_object_t xdict, const char *key, double value);
-
-/*!
- * @function xpc_dictionary_set_date
- *
- * @abstract
- * Inserts a date (primitive) value into a dictionary.
- *
- * @param xdict
- * The dictionary which is to be manipulated.
- *
- * @param key
- * The key for which the primitive value shall be set.
- *
- * @param value
- * The date value to insert. After calling this method, the XPC object
- * corresponding to the primitive value inserted may be safely retrieved with
- * {@link xpc_dictionary_get_value()}.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_NONNULL1 XPC_NONNULL2
-void
-xpc_dictionary_set_date(xpc_object_t xdict, const char *key, int64_t value);
-
-/*!
- * @function xpc_dictionary_set_data
- *
- * @abstract
- * Inserts a raw data value into a dictionary.
- *
- * @param xdict
- * The dictionary which is to be manipulated.
- *
- * @param key
- * The key for which the primitive value shall be set.
- *
- * @param bytes
- * The bytes to insert. After calling this method, the XPC object corresponding
- * to the primitive value inserted may be safely retrieved with
- * {@link xpc_dictionary_get_value()}.
- *
- * @param length
- * The length of the data.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_NONNULL1 XPC_NONNULL2 XPC_NONNULL3
-void
-xpc_dictionary_set_data(xpc_object_t xdict, const char *key, const void *bytes,
-	size_t length);
-
-/*!
- * @function xpc_dictionary_set_string
- *
- * @abstract
- * Inserts a C string value into a dictionary.
- *
- * @param xdict
- * The dictionary which is to be manipulated.
- *
- * @param key
- * The key for which the primitive value shall be set.
- *
- * @param string
- * The C string to insert. After calling this method, the XPC object 
- * corresponding to the primitive value inserted may be safely retrieved with
- * {@link xpc_dictionary_get_value()}.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_NONNULL1 XPC_NONNULL2 XPC_NONNULL3
-void
-xpc_dictionary_set_string(xpc_object_t xdict, const char *key,
-	const char *string);
-
-/*!
- * @function xpc_dictionary_set_uuid
- *
- * @abstract
- * Inserts a uuid (primitive) value into an array.
- *
- * @param xdict
- * The dictionary which is to be manipulated.
- *
- * @param key
- * The key for which the primitive value shall be set.
- *
- * @param uuid
- * The <code>uuid_t</code> value to insert. After calling this method, the XPC
- * object corresponding to the primitive value inserted may be safely retrieved
- * with {@link xpc_dictionary_get_value()}.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_NONNULL1 XPC_NONNULL2 XPC_NONNULL3
-void
-xpc_dictionary_set_uuid(xpc_object_t xdict, const char *key,
-	const uuid_t XPC_NONNULL_ARRAY uuid);
-
-/*!
- * @function xpc_dictionary_set_fd
- *
- * @abstract
- * Inserts a file descriptor into a dictionary.
- *
- * @param xdict
- * The dictionary which is to be manipulated.
- *
- * @param key
- * The key for which the primitive value shall be set.
- *
- * @param fd
- * The file descriptor to insert. After calling this method, the XPC object
- * corresponding to the primitive value inserted may be safely retrieved
- * with {@link xpc_dictionary_get_value()}.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_NONNULL1 XPC_NONNULL2
-void
-xpc_dictionary_set_fd(xpc_object_t xdict, const char *key, int fd);
-
-/*!
- * @function xpc_dictionary_set_connection
- *
- * @abstract
- * Inserts a connection into a dictionary.
- *
- * @param xdict
- * The dictionary which is to be manipulated.
- *
- * @param key
- * The key for which the primitive value shall be set.
- *
- * @param connection
- * The connection to insert. After calling this method, the XPC object
- * corresponding to the primitive value inserted may be safely retrieved
- * with {@link xpc_dictionary_get_value()}. The connection is NOT retained by
- * the dictionary.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_NONNULL1 XPC_NONNULL2 XPC_NONNULL3
-void
-xpc_dictionary_set_connection(xpc_object_t xdict, const char *key,
-	xpc_connection_t connection);
-
-#pragma mark Dictionary Primitive Getters
-/*!
- * @function xpc_dictionary_get_bool
- *
- * @abstract
- * Gets a <code>bool</code> primitive value from a dictionary directly.
- *
- * @param xdict
- * The dictionary object which is to be examined.
- *
- * @param key
- * The key whose value is to be obtained.
- *
- * @result
- * The underlying <code>bool</code> value for the specified key. false if the
- * the value for the specified key is not a Boolean value or if there is no
- * value for the specified key.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_WARN_RESULT XPC_NONNULL_ALL
-bool
-xpc_dictionary_get_bool(xpc_object_t xdict, const char *key);
-
-/*!
- * @function xpc_dictionary_get_int64
- *
- * @abstract
- * Gets an <code>int64</code> primitive value from a dictionary directly.
- *
- * @param xdict
- * The dictionary object which is to be examined.
- *
- * @param key
- * The key whose value is to be obtained.
- *
- * @result
- * The underlying <code>int64_t</code> value for the specified key. 0 if the
- * value for the specified key is not a signed integer value or if there is no
- * value for the specified key.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_WARN_RESULT XPC_NONNULL_ALL
-int64_t
-xpc_dictionary_get_int64(xpc_object_t xdict, const char *key);
-
-/*!
- * @function xpc_dictionary_get_uint64
- *
- * @abstract
- * Gets a <code>uint64</code> primitive value from a dictionary directly.
- *
- * @param xdict
- * The dictionary object which is to be examined.
- *
- * @param key
- * The key whose value is to be obtained.
- *
- * @result
- * The underlying <code>uint64_t</code> value for the specified key. 0 if the
- * value for the specified key is not an unsigned integer value or if there is
- * no value for the specified key.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_WARN_RESULT XPC_NONNULL_ALL
-uint64_t
-xpc_dictionary_get_uint64(xpc_object_t xdict, const char *key);
-
-/*!
- * @function xpc_dictionary_get_double
- *
- * @abstract
- * Gets a <code>double</code> primitive value from a dictionary directly.
- *
- * @param xdict
- * The dictionary object which is to be examined.
- *
- * @param key
- * The key whose value is to be obtained.
- *
- * @result
- * The underlying <code>double</code> value for the specified key. NAN if the
- * value for the specified key is not a floating point value or if there is no
- * value for the specified key.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_WARN_RESULT XPC_NONNULL_ALL
-double
-xpc_dictionary_get_double(xpc_object_t xdict, const char *key);
-
-/*!
- * @function xpc_dictionary_get_date
- *
- * @abstract
- * Gets a date value from a dictionary directly.
- *
- * @param xdict
- * The dictionary object which is to be examined.
- *
- * @param key
- * The key whose value is to be obtained.
- *
- * @result
- * The underlying date interval for the specified key. 0 if the value for the
- * specified key is not a date value or if there is no value for the specified
- * key.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_WARN_RESULT XPC_NONNULL_ALL
-int64_t
-xpc_dictionary_get_date(xpc_object_t xdict, const char *key);
-
-/*!
- * @function xpc_dictionary_get_data
- *
- * @abstract
- * Gets a raw data value from a dictionary directly.
- *
- * @param xdict
- * The dictionary object which is to be examined.
- *
- * @param key
- * The key whose value is to be obtained.
- *
- * @param length
- * For the data type, the third parameter, upon output, will contain the length
- * of the data corresponding to the specified key. May be NULL.
- *
- * @result
- * The underlying raw data for the specified key. NULL if the value for the
- * specified key is not a data value or if there is no value for the specified
- * key.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_WARN_RESULT XPC_NONNULL1
-const void * _Nullable
-xpc_dictionary_get_data(xpc_object_t xdict, const char *key,
-	size_t * _Nullable length);
-
-/*!
- * @function xpc_dictionary_get_string
- *
- * @abstract
- * Gets a C string value from a dictionary directly.
- *
- * @param xdict
- * The dictionary object which is to be examined.
- *
- * @param key
- * The key whose value is to be obtained.
- *
- * @result
- * The underlying C string for the specified key. NULL if the value for the
- * specified key is not a C string value or if there is no value for the
- * specified key.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_WARN_RESULT XPC_NONNULL_ALL
-const char * _Nullable
-xpc_dictionary_get_string(xpc_object_t xdict, const char *key);
-
-/*!
- * @function xpc_dictionary_get_uuid
- *
- * @abstract
- * Gets a uuid value from a dictionary directly.
- *
- * @param xdict
- * The dictionary object which is to be examined.
- *
- * @param key
- * The key whose value is to be obtained.
- *
- * @result
- * The underlying <code>uuid_t</code> value for the specified key. NULL is the
- * value at the specified index is not a UUID value. The returned pointer may be
- * safely passed to the uuid(3) APIs.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_WARN_RESULT XPC_NONNULL1 XPC_NONNULL2
-const uint8_t * _Nullable
-xpc_dictionary_get_uuid(xpc_object_t xdict, const char *key);
-
-/*!
- * @function xpc_dictionary_dup_fd
- *
- * @abstract
- * Creates a file descriptor from a dictionary directly.
- *
- * @param xdict
- * The dictionary object which is to be examined.
- *
- * @param key
- * The key whose value is to be obtained.
- *
- * @result
- * A new file descriptor created from the value for the specified key. You are
- * responsible for close(2)ing this descriptor. -1 if the value for the
- * specified key is not a file descriptor value or if there is no value for the
- * specified key.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_WARN_RESULT XPC_NONNULL_ALL
-int
-xpc_dictionary_dup_fd(xpc_object_t xdict, const char *key);
-
-/*!
- * @function xpc_dictionary_create_connection
- *
- * @abstract
- * Creates a connection from a dictionary directly.
- *
- * @param xdict
- * The dictionary object which is to be examined.
- *
- * @param key
- * The key whose value is to be obtained.
- *
- * @result
- * A new connection created from the value for the specified key. You are
- * responsible for calling xpc_release() on the returned connection. NULL if the
- * value for the specified key is not an endpoint containing a connection or if
- * there is no value for the specified key. Each call to this method for the
- * same key in the same dictionary will yield a different connection. See
- * {@link xpc_connection_create_from_endpoint()} for discussion as to the
- * responsibilities when dealing with the returned connection.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_MALLOC XPC_RETURNS_RETAINED XPC_WARN_RESULT XPC_NONNULL_ALL
-xpc_connection_t _Nullable
-xpc_dictionary_create_connection(xpc_object_t xdict, const char *key);
-
-/*!
- * @function xpc_dictionary_get_dictionary
- *
- * @abstract
- * Returns the dictionary value for the specified key.
- *
- * @param xdict
- * The dictionary object which is to be examined.
- *
- * @param key
- * The key whose value is to be obtained.
- * 
- * @result
- * The object for the specified key within the dictionary. NULL if there is no
- * value associated with the specified key, if the given object was not an
- * XPC dictionary, or if the object for the specified key is not a dictionary.
- *
- * @discussion
- * This method does not grant the caller a reference to the underlying object,
- * and thus the caller is not responsible for releasing the object.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_11, __IPHONE_9_0)
-XPC_EXPORT XPC_WARN_RESULT XPC_NONNULL_ALL
-xpc_object_t _Nullable
-xpc_dictionary_get_dictionary(xpc_object_t xdict, const char *key);
-
-/*!
- * @function xpc_dictionary_get_array
- *
- * @abstract
- * Returns the array value for the specified key.
- *
- * @param xdict
- * The dictionary object which is to be examined.
- *
- * @param key
- * The key whose value is to be obtained.
- * 
- * @result
- * The object for the specified key within the dictionary. NULL if there is no
- * value associated with the specified key, if the given object was not an
- * XPC dictionary, or if the object for the specified key is not an array.
- *
- * @discussion
- * This method does not grant the caller a reference to the underlying object,
- * and thus the caller is not responsible for releasing the object.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_11, __IPHONE_9_0)
-XPC_EXPORT XPC_WARN_RESULT XPC_NONNULL_ALL
-xpc_object_t _Nullable
-xpc_dictionary_get_array(xpc_object_t xdict, const char *key);
-
-#pragma mark Runtime
-/*!
- * @function xpc_main
- * The springboard into the XPCService runtime. This function will set up your
- * service bundle's listener connection and manage it automatically. After this
- * initial setup, this function will, by default, call dispatch_main(). You may
- * override this behavior by setting the RunLoopType key in your XPC service
- * bundle's Info.plist under the XPCService dictionary.
- *
- * @param handler
- * The handler with which to accept new connections.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_NORETURN XPC_NONNULL1
-void
-xpc_main(xpc_connection_handler_t handler);
-
-#pragma mark Transactions
-/*!
- * @function xpc_transaction_begin
- * Informs the XPC runtime that a transaction has begun and that the service
- * should not exit due to inactivity.
- * 
- * @discussion
- * A service with no outstanding transactions may automatically exit due to
- * inactivity as determined by the system.
- *
- * This function may be used to manually manage transactions in cases where
- * their automatic management (as described below) does not meet the needs of an
- * XPC service. This function also updates the transaction count used for sudden
- * termination, i.e. vproc_transaction_begin(), and these two interfaces may be
- * used in combination.
- *
- * The XPC runtime will automatically begin a transaction on behalf of a service
- * when a new message is received. If no reply message is expected, the
- * transaction is automatically ended when the connection event handler returns.
- * If a reply message is created, the transaction will end when the reply
- * message is sent or released. An XPC service may use xpc_transaction_begin()
- * and xpc_transaction_end() to inform the XPC runtime about activity that
- * occurs outside of this common pattern.
- *
- * On macOS, when the XPC runtime has determined that the service should exit,
- * the event handlers for all active peer connections will receive
- * {@link XPC_ERROR_TERMINATION_IMMINENT} as an indication that they should
- * unwind their existing transactions. After this error is delivered to a
- * connection's event handler, no more messages will be delivered to the
- * connection.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_TRANSACTION_DEPRECATED
-XPC_EXPORT
-void
-xpc_transaction_begin(void);
-
-/*!
- * @function xpc_transaction_end
- * Informs the XPC runtime that a transaction has ended.
- * 
- * @discussion
- * As described in {@link xpc_transaction_begin()}, this API may be used
- * interchangeably with vproc_transaction_end().
- *
- * See the discussion for {@link xpc_transaction_begin()} for details regarding
- * the XPC runtime's idle-exit policy.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_TRANSACTION_DEPRECATED
-XPC_EXPORT
-void
-xpc_transaction_end(void);
-
-#pragma mark XPC Event Stream
-/*!
- * @function xpc_set_event_stream_handler
- * Sets the event handler to invoke when streamed events are received.
- *
- * @param stream
- * The name of the event stream for which this handler will be invoked.
- *
- * @param targetq
- * The GCD queue to which the event handler block will be submitted. This
- * parameter may be NULL, in which case the connection's target queue will be
- * libdispatch's default target queue, defined as DISPATCH_TARGET_QUEUE_DEFAULT.
- * 
- * @param handler
- * The event handler block. The event which this block receives as its first
- * parameter will always be a dictionary which contains the XPC_EVENT_KEY_NAME
- * key. The value for this key will be a string whose value is the name assigned
- * to the XPC event specified in the launchd.plist. Future keys may be added to
- * this dictionary.
- *
- * @discussion
- * Multiple calls to this function for the same event stream will result in
- * undefined behavior.
- */
-#if __BLOCKS__
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
-XPC_EXPORT XPC_NONNULL1 XPC_NONNULL3
-void
-xpc_set_event_stream_handler(const char *stream,
-	dispatch_queue_t _Nullable targetq, xpc_handler_t handler);
-#endif // __BLOCKS__ 
-
-__END_DECLS
-XPC_ASSUME_NONNULL_END
-
-#endif // __XPC_H__
\ No newline at end of file

From d4468affb751668e156230c32b29c84684825b4f Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Wed, 4 Aug 2021 21:11:31 -0700
Subject: [PATCH 76/96] stage2 generics improvements: anytype and param type
 exprs

AstGen result locations now have a `coerced_ty` tag which is the same as
`ty` except it assumes that Sema will do a coercion, so it does not
redundantly add an `as` instruction into the ZIR code. This results in
cleaner ZIR and about a 14% reduction of ZIR bytes.

param and param_comptime ZIR instructions now have a block body for
their type expressions. This allows Sema to skip evaluation of the
block in the case that the parameter is comptime-provided. It also
allows a new mechanism to function: when evaluating type expressions of
generic functions, if it would depend on another parameter, it returns
`error.GenericPoison` which bubbles up and then is caught by the
param/param_comptime instruction and then handled.

This allows parameters to be evaluated independently so that the type
info for functions which have comptime or anytype parameters will still
have types populated for parameters that do not depend on values of
previous parameters (because evaluation of their param blocks will return
successfully instead of `error.GenericPoison`).

It also makes iteration over the block that contains function parameters
slightly more efficient since it now only contains the param
instructions.

Finally, it fixes the case where a generic function type expression contains
a function prototype. Formerly, this situation would cause shared state
to clobber each other; now it is in a proper tree structure so that
can't happen. This fix also required adding a field to Sema
`comptime_args_fn_inst` to make sure that the `comptime_args` field
passed into Sema is applied to the correct `func` instruction.

Source location for `node_offset_asm_ret_ty` is fixed; it was pointing at
the asm output name rather than the return type as intended.

Generic function instantiation is fixed, notably with respect to
parameter type expressions that depend on previous parameters, and with
respect to types which must be always comptime-known. This involves
passing all the comptime arguments at a callsite of a generic function,
and allowing the generic function semantic analysis to coerce the values
to the proper types (since it has access to the evaluated parameter type
expressions) and then decide based on the type whether the parameter is
runtime known or not. In the case of explicitly marked `comptime`
parameters, there is a check at the semantic analysis of the `call`
instruction.

Semantic analysis of `call` instructions does type coercion on the
arguments, which is needed both for generic functions and to make up for
using `coerced_ty` result locations (mentioned above).

Tasks left in this branch:
 * Implement the memoization table.
 * Add test coverage.
 * Improve error reporting and source locations for compile errors.
---
 BRANCH_TODO          |   4 -
 src/AstGen.zig       |  71 ++++---
 src/Compilation.zig  |   2 +-
 src/Module.zig       |  52 +++++-
 src/Sema.zig         | 430 +++++++++++++++++++++++++++----------------
 src/Zir.zig          |  32 +++-
 src/codegen/llvm.zig |   4 +
 src/type.zig         | 116 ++++++++++++
 src/value.zig        |  55 ++----
 test/cases.zig       |   2 +-
 10 files changed, 520 insertions(+), 248 deletions(-)
 delete mode 100644 BRANCH_TODO

diff --git a/BRANCH_TODO b/BRANCH_TODO
deleted file mode 100644
index e8606332d7..0000000000
--- a/BRANCH_TODO
+++ /dev/null
@@ -1,4 +0,0 @@
-* memoize the instantiation in a table
-* expressions that depend on comptime stuff need a poison value to use for
-  types when generating the generic function type
-* comptime anytype
diff --git a/src/AstGen.zig b/src/AstGen.zig
index 7534afe961..493e0a75f4 100644
--- a/src/AstGen.zig
+++ b/src/AstGen.zig
@@ -195,6 +195,9 @@ pub const ResultLoc = union(enum) {
     none_or_ref,
     /// The expression will be coerced into this type, but it will be evaluated as an rvalue.
     ty: Zir.Inst.Ref,
+    /// Same as `ty` but it is guaranteed that Sema will additionall perform the coercion,
+    /// so no `as` instruction needs to be emitted.
+    coerced_ty: Zir.Inst.Ref,
     /// The expression must store its result into this typed pointer. The result instruction
     /// from the expression must be ignored.
     ptr: Zir.Inst.Ref,
@@ -225,7 +228,7 @@ pub const ResultLoc = union(enum) {
     fn strategy(rl: ResultLoc, block_scope: *GenZir) Strategy {
         switch (rl) {
             // In this branch there will not be any store_to_block_ptr instructions.
-            .discard, .none, .none_or_ref, .ty, .ref => return .{
+            .discard, .none, .none_or_ref, .ty, .coerced_ty, .ref => return .{
                 .tag = .break_operand,
                 .elide_store_to_block_ptr_instructions = false,
             },
@@ -260,13 +263,14 @@ pub const ResultLoc = union(enum) {
 pub const align_rl: ResultLoc = .{ .ty = .u16_type };
 pub const bool_rl: ResultLoc = .{ .ty = .bool_type };
 pub const type_rl: ResultLoc = .{ .ty = .type_type };
+pub const coerced_type_rl: ResultLoc = .{ .coerced_ty = .type_type };
 
 fn typeExpr(gz: *GenZir, scope: *Scope, type_node: ast.Node.Index) InnerError!Zir.Inst.Ref {
     const prev_force_comptime = gz.force_comptime;
     gz.force_comptime = true;
     defer gz.force_comptime = prev_force_comptime;
 
-    return expr(gz, scope, .{ .ty = .type_type }, type_node);
+    return expr(gz, scope, coerced_type_rl, type_node);
 }
 
 /// Same as `expr` but fails with a compile error if the result type is `noreturn`.
@@ -1079,16 +1083,19 @@ fn fnProtoExpr(
                     .param_anytype;
                 _ = try gz.addStrTok(tag, param_name, name_token);
             } else {
+                const gpa = astgen.gpa;
                 const param_type_node = param.type_expr;
                 assert(param_type_node != 0);
-                const param_type = try expr(gz, scope, type_rl, param_type_node);
+                var param_gz = gz.makeSubBlock(scope);
+                defer param_gz.instructions.deinit(gpa);
+                const param_type = try expr(&param_gz, scope, coerced_type_rl, param_type_node);
+                const param_inst_expected = @intCast(u32, astgen.instructions.len + 1);
+                _ = try param_gz.addBreak(.break_inline, param_inst_expected, param_type);
                 const main_tokens = tree.nodes.items(.main_token);
                 const name_token = param.name_token orelse main_tokens[param_type_node];
                 const tag: Zir.Inst.Tag = if (is_comptime) .param_comptime else .param;
-                _ = try gz.addPlTok(tag, name_token, Zir.Inst.Param{
-                    .name = param_name,
-                    .ty = param_type,
-                });
+                const param_inst = try gz.addParam(tag, name_token, param_name, param_gz.instructions.items);
+                assert(param_inst_expected == param_inst);
             }
         }
         break :is_var_args false;
@@ -1219,7 +1226,7 @@ fn arrayInitExpr(
                 return arrayInitExprRlNone(gz, scope, node, array_init.ast.elements, .array_init_anon);
             }
         },
-        .ty => |ty_inst| {
+        .ty, .coerced_ty => |ty_inst| {
             if (types.array != .none) {
                 const result = try arrayInitExprRlTy(gz, scope, node, array_init.ast.elements, types.elem, .array_init);
                 return rvalue(gz, rl, result, node);
@@ -1388,7 +1395,7 @@ fn structInitExpr(
                 return structInitExprRlNone(gz, scope, node, struct_init, .struct_init_anon);
             }
         },
-        .ty => |ty_inst| {
+        .ty, .coerced_ty => |ty_inst| {
             if (struct_init.ast.type_expr == 0) {
                 return structInitExprRlTy(gz, scope, node, struct_init, ty_inst, .struct_init);
             }
@@ -2617,7 +2624,7 @@ fn assignOp(
     const lhs_ptr = try lvalExpr(gz, scope, node_datas[infix_node].lhs);
     const lhs = try gz.addUnNode(.load, lhs_ptr, infix_node);
     const lhs_type = try gz.addUnNode(.typeof, lhs, infix_node);
-    const rhs = try expr(gz, scope, .{ .ty = lhs_type }, node_datas[infix_node].rhs);
+    const rhs = try expr(gz, scope, .{ .coerced_ty = lhs_type }, node_datas[infix_node].rhs);
 
     const result = try gz.addPlNode(op_inst_tag, infix_node, Zir.Inst.Bin{
         .lhs = lhs,
@@ -2953,14 +2960,18 @@ fn fnDecl(
             } else param: {
                 const param_type_node = param.type_expr;
                 assert(param_type_node != 0);
-                const param_type = try expr(&decl_gz, params_scope, type_rl, param_type_node);
+                var param_gz = decl_gz.makeSubBlock(scope);
+                defer param_gz.instructions.deinit(gpa);
+                const param_type = try expr(&param_gz, params_scope, coerced_type_rl, param_type_node);
+                const param_inst_expected = @intCast(u32, astgen.instructions.len + 1);
+                _ = try param_gz.addBreak(.break_inline, param_inst_expected, param_type);
+
                 const main_tokens = tree.nodes.items(.main_token);
                 const name_token = param.name_token orelse main_tokens[param_type_node];
                 const tag: Zir.Inst.Tag = if (is_comptime) .param_comptime else .param;
-                break :param try decl_gz.addPlTok(tag, name_token, Zir.Inst.Param{
-                    .name = param_name,
-                    .ty = param_type,
-                });
+                const param_inst = try decl_gz.addParam(tag, name_token, param_name, param_gz.instructions.items);
+                assert(param_inst_expected == param_inst);
+                break :param indexToRef(param_inst);
             };
 
             if (param_name == 0) continue;
@@ -6758,7 +6769,7 @@ fn as(
 ) InnerError!Zir.Inst.Ref {
     const dest_type = try typeExpr(gz, scope, lhs);
     switch (rl) {
-        .none, .none_or_ref, .discard, .ref, .ty => {
+        .none, .none_or_ref, .discard, .ref, .ty, .coerced_ty => {
             const result = try reachableExpr(gz, scope, .{ .ty = dest_type }, rhs, node);
             return rvalue(gz, rl, result, node);
         },
@@ -6781,7 +6792,7 @@ fn unionInit(
     const union_type = try typeExpr(gz, scope, params[0]);
     const field_name = try comptimeExpr(gz, scope, .{ .ty = .const_slice_u8_type }, params[1]);
     switch (rl) {
-        .none, .none_or_ref, .discard, .ref, .ty, .inferred_ptr => {
+        .none, .none_or_ref, .discard, .ref, .ty, .coerced_ty, .inferred_ptr => {
             _ = try gz.addPlNode(.field_type_ref, params[1], Zir.Inst.FieldTypeRef{
                 .container_type = union_type,
                 .field_name = field_name,
@@ -6867,7 +6878,7 @@ fn bitCast(
     const astgen = gz.astgen;
     const dest_type = try typeExpr(gz, scope, lhs);
     switch (rl) {
-        .none, .none_or_ref, .discard, .ty => {
+        .none, .none_or_ref, .discard, .ty, .coerced_ty => {
             const operand = try expr(gz, scope, .none, rhs);
             const result = try gz.addPlNode(.bitcast, node, Zir.Inst.Bin{
                 .lhs = dest_type,
@@ -7677,7 +7688,7 @@ fn callExpr(
                 .param_index = @intCast(u32, i),
             } },
         });
-        args[i] = try expr(gz, scope, .{ .ty = param_type }, param_node);
+        args[i] = try expr(gz, scope, .{ .coerced_ty = param_type }, param_node);
     }
 
     const modifier: std.builtin.CallOptions.Modifier = blk: {
@@ -8370,7 +8381,7 @@ fn rvalue(
     src_node: ast.Node.Index,
 ) InnerError!Zir.Inst.Ref {
     switch (rl) {
-        .none, .none_or_ref => return result,
+        .none, .none_or_ref, .coerced_ty => return result,
         .discard => {
             // Emit a compile error for discarding error values.
             _ = try gz.addUnNode(.ensure_result_non_error, result, src_node);
@@ -9042,7 +9053,7 @@ const GenZir = struct {
         // we emit ZIR for the block break instructions to have the result values,
         // and then rvalue() on that to pass the value to the result location.
         switch (parent_rl) {
-            .ty => |ty_inst| {
+            .ty, .coerced_ty => |ty_inst| {
                 gz.rl_ty_inst = ty_inst;
                 gz.break_result_loc = parent_rl;
             },
@@ -9425,18 +9436,26 @@ const GenZir = struct {
         return indexToRef(new_index);
     }
 
-    fn addPlTok(
+    fn addParam(
         gz: *GenZir,
         tag: Zir.Inst.Tag,
         /// Absolute token index. This function does the conversion to Decl offset.
         abs_tok_index: ast.TokenIndex,
-        extra: anytype,
-    ) !Zir.Inst.Ref {
+        name: u32,
+        body: []const u32,
+    ) !Zir.Inst.Index {
         const gpa = gz.astgen.gpa;
         try gz.instructions.ensureUnusedCapacity(gpa, 1);
         try gz.astgen.instructions.ensureUnusedCapacity(gpa, 1);
+        try gz.astgen.extra.ensureUnusedCapacity(gpa, @typeInfo(Zir.Inst.Param).Struct.fields.len +
+            body.len);
+
+        const payload_index = gz.astgen.addExtraAssumeCapacity(Zir.Inst.Param{
+            .name = name,
+            .body_len = @intCast(u32, body.len),
+        });
+        gz.astgen.extra.appendSliceAssumeCapacity(body);
 
-        const payload_index = try gz.astgen.addExtra(extra);
         const new_index = @intCast(Zir.Inst.Index, gz.astgen.instructions.len);
         gz.astgen.instructions.appendAssumeCapacity(.{
             .tag = tag,
@@ -9446,7 +9465,7 @@ const GenZir = struct {
             } },
         });
         gz.instructions.appendAssumeCapacity(new_index);
-        return indexToRef(new_index);
+        return new_index;
     }
 
     fn addExtendedPayload(
diff --git a/src/Compilation.zig b/src/Compilation.zig
index f8f8cea328..adb4940243 100644
--- a/src/Compilation.zig
+++ b/src/Compilation.zig
@@ -2118,7 +2118,7 @@ pub fn performAllTheWork(self: *Compilation) error{ TimerUnsupported, OutOfMemor
                 if (builtin.mode == .Debug and self.verbose_air) {
                     std.debug.print("# Begin Function AIR: {s}:\n", .{decl.name});
                     @import("print_air.zig").dump(gpa, air, decl.namespace.file_scope.zir, liveness);
-                    std.debug.print("# End Function AIR: {s}:\n", .{decl.name});
+                    std.debug.print("# End Function AIR: {s}\n\n", .{decl.name});
                 }
 
                 self.bin_file.updateFunc(module, func, air, liveness) catch |err| switch (err) {
diff --git a/src/Module.zig b/src/Module.zig
index 184ea617b1..2c3e745c11 100644
--- a/src/Module.zig
+++ b/src/Module.zig
@@ -1173,6 +1173,8 @@ pub const Scope = struct {
         /// for the one that will be the same for all Block instances.
         src_decl: *Decl,
         instructions: ArrayListUnmanaged(Air.Inst.Index),
+        // `param` instructions are collected here to be used by the `func` instruction.
+        params: std.ArrayListUnmanaged(Param) = .{},
         label: ?*Label = null,
         inlining: ?*Inlining,
         /// If runtime_index is not 0 then one of these is guaranteed to be non null.
@@ -1187,6 +1189,12 @@ pub const Scope = struct {
         /// when null, it is determined by build mode, changed by @setRuntimeSafety
         want_safety: ?bool = null,
 
+        const Param = struct {
+            /// `noreturn` means `anytype`.
+            ty: Type,
+            is_comptime: bool,
+        };
+
         /// This `Block` maps a block ZIR instruction to the corresponding
         /// AIR instruction for break instruction analysis.
         pub const Label = struct {
@@ -1634,8 +1642,11 @@ pub const SrcLoc = struct {
                     .@"asm" => tree.asmFull(node),
                     else => unreachable,
                 };
+                const asm_output = full.outputs[0];
+                const node_datas = tree.nodes.items(.data);
+                const ret_ty_node = node_datas[asm_output].lhs;
                 const main_tokens = tree.nodes.items(.main_token);
-                const tok_index = main_tokens[full.outputs[0]];
+                const tok_index = main_tokens[ret_ty_node];
                 const token_starts = tree.tokens.items(.start);
                 return token_starts[tok_index];
             },
@@ -2099,7 +2110,20 @@ pub const LazySrcLoc = union(enum) {
 };
 
 pub const SemaError = error{ OutOfMemory, AnalysisFail };
-pub const CompileError = error{ OutOfMemory, AnalysisFail, NeededSourceLocation };
+pub const CompileError = error{
+    OutOfMemory,
+    /// When this is returned, the compile error for the failure has already been recorded.
+    AnalysisFail,
+    /// Returned when a compile error needed to be reported but a provided LazySrcLoc was set
+    /// to the `unneeded` tag. The source location was, in fact, needed. It is expected that
+    /// somewhere up the call stack, the operation will be retried after doing expensive work
+    /// to compute a source location.
+    NeededSourceLocation,
+    /// A Type or Value was needed to be used during semantic analysis, but it was not available
+    /// because the function is generic. This is only seen when analyzing the body of a param
+    /// instruction.
+    GenericPoison,
+};
 
 pub fn deinit(mod: *Module) void {
     const gpa = mod.gpa;
@@ -2796,14 +2820,16 @@ pub fn ensureDeclAnalyzed(mod: *Module, decl: *Decl) SemaError!void {
             }
             return error.AnalysisFail;
         },
-        else => {
+        error.NeededSourceLocation => unreachable,
+        error.GenericPoison => unreachable,
+        else => |e| {
             decl.analysis = .sema_failure_retryable;
             try mod.failed_decls.ensureUnusedCapacity(mod.gpa, 1);
             mod.failed_decls.putAssumeCapacityNoClobber(decl, try ErrorMsg.create(
                 mod.gpa,
                 decl.srcLoc(),
                 "unable to analyze: {s}",
-                .{@errorName(err)},
+                .{@errorName(e)},
             ));
             return error.AnalysisFail;
         },
@@ -2982,7 +3008,10 @@ fn semaDecl(mod: *Module, decl: *Decl) !bool {
         .inlining = null,
         .is_comptime = true,
     };
-    defer block_scope.instructions.deinit(gpa);
+    defer {
+        block_scope.instructions.deinit(gpa);
+        block_scope.params.deinit(gpa);
+    }
 
     const zir_block_index = decl.zirBlockIndex();
     const inst_data = zir_datas[zir_block_index].pl_node;
@@ -3669,7 +3698,8 @@ pub fn analyzeFnBody(mod: *Module, decl: *Decl, func: *Fn) SemaError!Air {
     try sema.air_instructions.ensureUnusedCapacity(gpa, fn_info.total_params_len * 2); // * 2 for the `addType`
     try sema.inst_map.ensureUnusedCapacity(gpa, fn_info.total_params_len);
 
-    var param_index: usize = 0;
+    var runtime_param_index: usize = 0;
+    var total_param_index: usize = 0;
     for (fn_info.param_body) |inst| {
         const name = switch (zir_tags[inst]) {
             .param, .param_comptime => blk: {
@@ -3686,16 +3716,16 @@ pub fn analyzeFnBody(mod: *Module, decl: *Decl, func: *Fn) SemaError!Air {
             else => continue,
         };
         if (func.comptime_args) |comptime_args| {
-            const arg_tv = comptime_args[param_index];
+            const arg_tv = comptime_args[total_param_index];
             if (arg_tv.val.tag() != .unreachable_value) {
                 // We have a comptime value for this parameter.
                 const arg = try sema.addConstant(arg_tv.ty, arg_tv.val);
                 sema.inst_map.putAssumeCapacityNoClobber(inst, arg);
-                param_index += 1;
+                total_param_index += 1;
                 continue;
             }
         }
-        const param_type = fn_ty.fnParamType(param_index);
+        const param_type = fn_ty.fnParamType(runtime_param_index);
         const ty_ref = try sema.addType(param_type);
         const arg_index = @intCast(u32, sema.air_instructions.len);
         inner_block.instructions.appendAssumeCapacity(arg_index);
@@ -3707,7 +3737,8 @@ pub fn analyzeFnBody(mod: *Module, decl: *Decl, func: *Fn) SemaError!Air {
             } },
         });
         sema.inst_map.putAssumeCapacityNoClobber(inst, Air.indexToRef(arg_index));
-        param_index += 1;
+        total_param_index += 1;
+        runtime_param_index += 1;
     }
 
     func.state = .in_progress;
@@ -3715,6 +3746,7 @@ pub fn analyzeFnBody(mod: *Module, decl: *Decl, func: *Fn) SemaError!Air {
 
     _ = sema.analyzeBody(&inner_block, fn_info.body) catch |err| switch (err) {
         error.NeededSourceLocation => unreachable,
+        error.GenericPoison => unreachable,
         else => |e| return e,
     };
 
diff --git a/src/Sema.zig b/src/Sema.zig
index 9a7eb6fc40..8bcdcb63c9 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -37,13 +37,15 @@ branch_count: u32 = 0,
 /// contain a mapped source location.
 src: LazySrcLoc = .{ .token_offset = 0 },
 decl_val_table: std.AutoHashMapUnmanaged(*Decl, Air.Inst.Ref) = .{},
-/// `param` instructions are collected here to be used by the `func` instruction.
-params: std.ArrayListUnmanaged(Param) = .{},
-/// When doing a generic function instantiation, this array collects a `Value` object for
-/// each parameter that is comptime known and thus elided from the generated function.
-/// This memory is allocated by a parent `Sema` and owned by the values arena of the owner_decl.
+/// When doing a generic function instantiation, this array collects a
+/// `Value` object for each parameter that is comptime known and thus elided
+/// from the generated function. This memory is allocated by a parent `Sema` and
+/// owned by the values arena of the Sema owner_decl.
 comptime_args: []TypedValue = &.{},
-next_arg_index: usize = 0,
+/// Marks the function instruction that `comptime_args` applies to so that we
+/// don't accidentally apply it to a function prototype which is used in the
+/// type expression of a generic function parameter.
+comptime_args_fn_inst: Zir.Inst.Index = 0,
 
 const std = @import("std");
 const mem = std.mem;
@@ -67,13 +69,6 @@ const LazySrcLoc = Module.LazySrcLoc;
 const RangeSet = @import("RangeSet.zig");
 const target_util = @import("target.zig");
 
-const Param = struct {
-    name: [:0]const u8,
-    /// `noreturn` means `anytype`.
-    ty: Type,
-    is_comptime: bool,
-};
-
 pub const InstMap = std.AutoHashMapUnmanaged(Zir.Inst.Index, Air.Inst.Ref);
 
 pub fn deinit(sema: *Sema) void {
@@ -83,7 +78,6 @@ pub fn deinit(sema: *Sema) void {
     sema.air_values.deinit(gpa);
     sema.inst_map.deinit(gpa);
     sema.decl_val_table.deinit(gpa);
-    sema.params.deinit(gpa);
     sema.* = undefined;
 }
 
@@ -466,6 +460,26 @@ pub fn analyzeBody(
                 i += 1;
                 continue;
             },
+            .param => {
+                try sema.zirParam(block, inst, false);
+                i += 1;
+                continue;
+            },
+            .param_comptime => {
+                try sema.zirParam(block, inst, true);
+                i += 1;
+                continue;
+            },
+            .param_anytype => {
+                try sema.zirParamAnytype(block, inst, false);
+                i += 1;
+                continue;
+            },
+            .param_anytype_comptime => {
+                try sema.zirParamAnytype(block, inst, true);
+                i += 1;
+                continue;
+            },
 
             // Special case instructions to handle comptime control flow.
             .repeat_inline => {
@@ -504,88 +518,6 @@ pub fn analyzeBody(
                     return break_inst;
                 }
             },
-            .param => blk: {
-                const inst_data = sema.code.instructions.items(.data)[inst].pl_tok;
-                const src = inst_data.src();
-                const extra = sema.code.extraData(Zir.Inst.Param, inst_data.payload_index).data;
-                const param_name = sema.code.nullTerminatedString(extra.name);
-
-                if (sema.nextArgIsComptimeElided()) {
-                    i += 1;
-                    continue;
-                }
-
-                // TODO check if param_name shadows a Decl. This only needs to be done if
-                // usingnamespace is implemented.
-
-                const param_ty = try sema.resolveType(block, src, extra.ty);
-                try sema.params.append(sema.gpa, .{
-                    .name = param_name,
-                    .ty = param_ty,
-                    .is_comptime = false,
-                });
-                break :blk try sema.addConstUndef(param_ty);
-            },
-            .param_comptime => blk: {
-                const inst_data = sema.code.instructions.items(.data)[inst].pl_tok;
-                const src = inst_data.src();
-                const extra = sema.code.extraData(Zir.Inst.Param, inst_data.payload_index).data;
-                const param_name = sema.code.nullTerminatedString(extra.name);
-
-                if (sema.nextArgIsComptimeElided()) {
-                    i += 1;
-                    continue;
-                }
-
-                // TODO check if param_name shadows a Decl. This only needs to be done if
-                // usingnamespace is implemented.
-
-                const param_ty = try sema.resolveType(block, src, extra.ty);
-                try sema.params.append(sema.gpa, .{
-                    .name = param_name,
-                    .ty = param_ty,
-                    .is_comptime = true,
-                });
-                break :blk try sema.addConstUndef(param_ty);
-            },
-            .param_anytype => blk: {
-                const inst_data = sema.code.instructions.items(.data)[inst].str_tok;
-                const param_name = inst_data.get(sema.code);
-
-                if (sema.nextArgIsComptimeElided()) {
-                    i += 1;
-                    continue;
-                }
-
-                // TODO check if param_name shadows a Decl. This only needs to be done if
-                // usingnamespace is implemented.
-
-                try sema.params.append(sema.gpa, .{
-                    .name = param_name,
-                    .ty = Type.initTag(.noreturn),
-                    .is_comptime = false,
-                });
-                break :blk try sema.addConstUndef(Type.initTag(.@"undefined"));
-            },
-            .param_anytype_comptime => blk: {
-                const inst_data = sema.code.instructions.items(.data)[inst].str_tok;
-                const param_name = inst_data.get(sema.code);
-
-                if (sema.nextArgIsComptimeElided()) {
-                    i += 1;
-                    continue;
-                }
-
-                // TODO check if param_name shadows a Decl. This only needs to be done if
-                // usingnamespace is implemented.
-
-                try sema.params.append(sema.gpa, .{
-                    .name = param_name,
-                    .ty = Type.initTag(.noreturn),
-                    .is_comptime = true,
-                });
-                break :blk try sema.addConstUndef(Type.initTag(.@"undefined"));
-            },
         };
         if (sema.typeOf(air_inst).isNoReturn())
             return always_noreturn;
@@ -697,6 +629,7 @@ fn resolveValue(
     air_ref: Air.Inst.Ref,
 ) CompileError!Value {
     if (try sema.resolveMaybeUndefValAllowVariables(block, src, air_ref)) |val| {
+        if (val.tag() == .generic_poison) return error.GenericPoison;
         return val;
     }
     return sema.failWithNeededComptime(block, src);
@@ -714,6 +647,7 @@ fn resolveConstValue(
         switch (val.tag()) {
             .undef => return sema.failWithUseOfUndef(block, src),
             .variable => return sema.failWithNeededComptime(block, src),
+            .generic_poison => return error.GenericPoison,
             else => return val,
         }
     }
@@ -2422,7 +2356,7 @@ fn analyzeCall(
     call_src: LazySrcLoc,
     modifier: std.builtin.CallOptions.Modifier,
     ensure_result_used: bool,
-    args: []const Air.Inst.Ref,
+    uncasted_args: []const Air.Inst.Ref,
 ) CompileError!Air.Inst.Ref {
     const mod = sema.mod;
 
@@ -2444,22 +2378,22 @@ fn analyzeCall(
     const fn_params_len = func_ty_info.param_types.len;
     if (func_ty_info.is_var_args) {
         assert(cc == .C);
-        if (args.len < fn_params_len) {
+        if (uncasted_args.len < fn_params_len) {
             // TODO add error note: declared here
             return mod.fail(
                 &block.base,
                 func_src,
                 "expected at least {d} argument(s), found {d}",
-                .{ fn_params_len, args.len },
+                .{ fn_params_len, uncasted_args.len },
             );
         }
-    } else if (fn_params_len != args.len) {
+    } else if (fn_params_len != uncasted_args.len) {
         // TODO add error note: declared here
         return mod.fail(
             &block.base,
             func_src,
             "expected {d} argument(s), found {d}",
-            .{ fn_params_len, args.len },
+            .{ fn_params_len, uncasted_args.len },
         );
     }
 
@@ -2485,6 +2419,14 @@ fn analyzeCall(
     const is_inline_call = is_comptime_call or modifier == .always_inline or
         func_ty_info.cc == .Inline;
     const result: Air.Inst.Ref = if (is_inline_call) res: {
+        // TODO look into not allocating this args array
+        const args = try sema.arena.alloc(Air.Inst.Ref, uncasted_args.len);
+        for (uncasted_args) |uncasted_arg, i| {
+            const param_ty = func_ty.fnParamType(i);
+            const arg_src = call_src; // TODO: better source location
+            args[i] = try sema.coerce(block, param_ty, uncasted_arg, arg_src);
+        }
+
         const func_val = try sema.resolveConstValue(block, func_src, func);
         const module_fn = switch (func_val.tag()) {
             .function => func_val.castTag(.function).?.data,
@@ -2574,13 +2516,12 @@ fn analyzeCall(
         const func_val = try sema.resolveConstValue(block, func_src, func);
         const module_fn = func_val.castTag(.function).?.data;
         // Check the Module's generic function map with an adapted context, so that we
-        // can match against `args` rather than doing the work below to create a generic Scope
-        // only to junk it if it matches an existing instantiation.
+        // can match against `uncasted_args` rather than doing the work below to create a
+        // generic Scope only to junk it if it matches an existing instantiation.
         // TODO
 
         const fn_info = sema.code.getFnInfo(module_fn.zir_body_inst);
         const zir_tags = sema.code.instructions.items(.tag);
-        var non_comptime_args_len: u32 = 0;
         const new_func = new_func: {
             const namespace = module_fn.owner_decl.namespace;
             try namespace.anon_decls.ensureUnusedCapacity(gpa, 1);
@@ -2622,7 +2563,8 @@ fn analyzeCall(
                 .namespace = namespace,
                 .func = null,
                 .owner_func = null,
-                .comptime_args = try new_decl_arena.allocator.alloc(TypedValue, args.len),
+                .comptime_args = try new_decl_arena.allocator.alloc(TypedValue, uncasted_args.len),
+                .comptime_args_fn_inst = module_fn.zir_body_inst,
             };
             defer child_sema.deinit();
 
@@ -2634,35 +2576,29 @@ fn analyzeCall(
                 .inlining = null,
                 .is_comptime = true,
             };
-            defer child_block.instructions.deinit(gpa);
+            defer {
+                child_block.instructions.deinit(gpa);
+                child_block.params.deinit(gpa);
+            }
 
-            try child_sema.inst_map.ensureUnusedCapacity(gpa, @intCast(u32, args.len));
+            try child_sema.inst_map.ensureUnusedCapacity(gpa, @intCast(u32, uncasted_args.len));
             var arg_i: usize = 0;
             for (fn_info.param_body) |inst| {
                 const is_comptime = switch (zir_tags[inst]) {
                     .param_comptime, .param_anytype_comptime => true,
-                    .param, .param_anytype => false, // TODO make true for always comptime types
+                    .param, .param_anytype => false,
                     else => continue,
                 };
-                if (is_comptime) {
-                    // TODO: pass .unneeded to resolveConstValue and then if we get
-                    // error.NeededSourceLocation resolve the arg source location and
-                    // try again.
-                    const arg_src = call_src;
-                    const arg = args[arg_i];
-                    const arg_val = try sema.resolveConstValue(block, arg_src, arg);
-                    child_sema.comptime_args[arg_i] = .{
-                        .ty = try sema.typeOf(arg).copy(&new_decl_arena.allocator),
-                        .val = try arg_val.copy(&new_decl_arena.allocator),
-                    };
+                // TODO: pass .unneeded to resolveConstValue and then if we get
+                // error.NeededSourceLocation resolve the arg source location and
+                // try again.
+                const arg_src = call_src;
+                const arg = uncasted_args[arg_i];
+                if (try sema.resolveMaybeUndefVal(block, arg_src, arg)) |arg_val| {
                     const child_arg = try child_sema.addConstant(sema.typeOf(arg), arg_val);
                     child_sema.inst_map.putAssumeCapacityNoClobber(inst, child_arg);
-                } else {
-                    non_comptime_args_len += 1;
-                    child_sema.comptime_args[arg_i] = .{
-                        .ty = Type.initTag(.noreturn),
-                        .val = Value.initTag(.unreachable_value),
-                    };
+                } else if (is_comptime) {
+                    return sema.failWithNeededComptime(block, arg_src);
                 }
                 arg_i += 1;
             }
@@ -2670,6 +2606,30 @@ fn analyzeCall(
             const new_func_val = try child_sema.resolveConstValue(&child_block, .unneeded, new_func_inst);
             const new_func = new_func_val.castTag(.function).?.data;
 
+            arg_i = 0;
+            for (fn_info.param_body) |inst| {
+                switch (zir_tags[inst]) {
+                    .param_comptime, .param_anytype_comptime, .param, .param_anytype => {},
+                    else => continue,
+                }
+                const arg = child_sema.inst_map.get(inst).?;
+                const arg_val = (child_sema.resolveMaybeUndefValAllowVariables(&child_block, .unneeded, arg) catch unreachable).?;
+
+                if (arg_val.tag() == .generic_poison) {
+                    child_sema.comptime_args[arg_i] = .{
+                        .ty = Type.initTag(.noreturn),
+                        .val = Value.initTag(.unreachable_value),
+                    };
+                } else {
+                    child_sema.comptime_args[arg_i] = .{
+                        .ty = try child_sema.typeOf(arg).copy(&new_decl_arena.allocator),
+                        .val = try arg_val.copy(&new_decl_arena.allocator),
+                    };
+                }
+
+                arg_i += 1;
+            }
+
             // Populate the Decl ty/val with the function and its type.
             new_decl.ty = try child_sema.typeOf(new_func_inst).copy(&new_decl_arena.allocator);
             new_decl.val = try Value.Tag.function.create(&new_decl_arena.allocator, new_func);
@@ -2690,31 +2650,72 @@ fn analyzeCall(
 
         // Make a runtime call to the new function, making sure to omit the comptime args.
         try sema.requireRuntimeBlock(block, call_src);
+        const new_func_val = sema.resolveConstValue(block, .unneeded, new_func) catch unreachable;
+        const new_module_func = new_func_val.castTag(.function).?.data;
+        const comptime_args = new_module_func.comptime_args.?;
+        const runtime_args_len = count: {
+            var count: u32 = 0;
+            var arg_i: usize = 0;
+            for (fn_info.param_body) |inst| {
+                switch (zir_tags[inst]) {
+                    .param_comptime, .param_anytype_comptime, .param, .param_anytype => {
+                        if (comptime_args[arg_i].val.tag() == .unreachable_value) {
+                            count += 1;
+                        }
+                        arg_i += 1;
+                    },
+                    else => continue,
+                }
+            }
+            break :count count;
+        };
+        const runtime_args = try sema.arena.alloc(Air.Inst.Ref, runtime_args_len);
+        {
+            const new_fn_ty = new_module_func.owner_decl.ty;
+            var runtime_i: u32 = 0;
+            var total_i: u32 = 0;
+            for (fn_info.param_body) |inst| {
+                switch (zir_tags[inst]) {
+                    .param_comptime, .param_anytype_comptime, .param, .param_anytype => {},
+                    else => continue,
+                }
+                const is_runtime = comptime_args[total_i].val.tag() == .unreachable_value;
+                if (is_runtime) {
+                    const param_ty = new_fn_ty.fnParamType(runtime_i);
+                    const arg_src = call_src; // TODO: better source location
+                    const uncasted_arg = uncasted_args[total_i];
+                    const casted_arg = try sema.coerce(block, param_ty, uncasted_arg, arg_src);
+                    runtime_args[runtime_i] = casted_arg;
+                    runtime_i += 1;
+                }
+                total_i += 1;
+            }
+        }
         try sema.air_extra.ensureUnusedCapacity(gpa, @typeInfo(Air.Call).Struct.fields.len +
-            non_comptime_args_len);
+            runtime_args_len);
         const func_inst = try block.addInst(.{
             .tag = .call,
             .data = .{ .pl_op = .{
                 .operand = new_func,
                 .payload = sema.addExtraAssumeCapacity(Air.Call{
-                    .args_len = non_comptime_args_len,
+                    .args_len = runtime_args_len,
                 }),
             } },
         });
-        var arg_i: usize = 0;
-        for (fn_info.param_body) |inst| {
-            const is_comptime = switch (zir_tags[inst]) {
-                .param_comptime, .param_anytype_comptime => true,
-                .param, .param_anytype => false, // TODO make true for always comptime types
-                else => continue,
-            };
-            if (is_comptime) {
-                sema.air_extra.appendAssumeCapacity(@enumToInt(args[arg_i]));
-            }
-            arg_i += 1;
-        }
+        sema.appendRefsAssumeCapacity(runtime_args);
         break :res func_inst;
     } else res: {
+        const args = try sema.arena.alloc(Air.Inst.Ref, uncasted_args.len);
+        for (uncasted_args) |uncasted_arg, i| {
+            if (i < fn_params_len) {
+                const param_ty = func_ty.fnParamType(i);
+                const arg_src = call_src; // TODO: better source location
+                args[i] = try sema.coerce(block, param_ty, uncasted_arg, arg_src);
+            } else {
+                args[i] = uncasted_arg;
+            }
+        }
+
         try sema.requireRuntimeBlock(block, call_src);
         try sema.air_extra.ensureUnusedCapacity(gpa, @typeInfo(Air.Call).Struct.fields.len +
             args.len);
@@ -3416,7 +3417,7 @@ fn funcCommon(
 
     const fn_ty: Type = fn_ty: {
         // Hot path for some common function types.
-        if (sema.params.items.len == 0 and !var_args and align_val.tag() == .null_value and
+        if (block.params.items.len == 0 and !var_args and align_val.tag() == .null_value and
             !inferred_error_set)
         {
             if (bare_return_type.zigTypeTag() == .NoReturn and cc == .Unspecified) {
@@ -3436,19 +3437,15 @@ fn funcCommon(
             }
         }
 
-        var any_are_comptime = false;
-        const param_types = try sema.arena.alloc(Type, sema.params.items.len);
-        const comptime_params = try sema.arena.alloc(bool, sema.params.items.len);
-        for (sema.params.items) |param, i| {
-            if (param.ty.tag() == .noreturn) {
-                param_types[i] = Type.initTag(.noreturn); // indicates anytype
-            } else {
-                param_types[i] = param.ty;
-            }
+        var is_generic = false;
+        const param_types = try sema.arena.alloc(Type, block.params.items.len);
+        const comptime_params = try sema.arena.alloc(bool, block.params.items.len);
+        for (block.params.items) |param, i| {
+            param_types[i] = param.ty;
             comptime_params[i] = param.is_comptime;
-            any_are_comptime = any_are_comptime or param.is_comptime;
+            is_generic = is_generic or param.is_comptime or
+                param.ty.tag() == .generic_poison or param.ty.requiresComptime();
         }
-        sema.params.clearRetainingCapacity();
 
         if (align_val.tag() != .null_value) {
             return mod.fail(&block.base, src, "TODO implement support for function prototypes to have alignment specified", .{});
@@ -3471,7 +3468,7 @@ fn funcCommon(
             .return_type = return_type,
             .cc = cc,
             .is_var_args = var_args,
-            .is_generic = any_are_comptime,
+            .is_generic = is_generic,
         });
     };
 
@@ -3530,12 +3527,16 @@ fn funcCommon(
     const is_inline = fn_ty.fnCallingConvention() == .Inline;
     const anal_state: Module.Fn.Analysis = if (is_inline) .inline_only else .queued;
 
+    const comptime_args: ?[*]TypedValue = if (sema.comptime_args_fn_inst == body_inst) blk: {
+        break :blk if (sema.comptime_args.len == 0) null else sema.comptime_args.ptr;
+    } else null;
+
     const fn_payload = try sema.arena.create(Value.Payload.Function);
     new_func.* = .{
         .state = anal_state,
         .zir_body_inst = body_inst,
         .owner_decl = sema.owner_decl,
-        .comptime_args = if (sema.comptime_args.len == 0) null else sema.comptime_args.ptr,
+        .comptime_args = comptime_args,
         .lbrace_line = src_locs.lbrace_line,
         .rbrace_line = src_locs.rbrace_line,
         .lbrace_column = @truncate(u16, src_locs.columns),
@@ -3548,6 +3549,113 @@ fn funcCommon(
     return sema.addConstant(fn_ty, Value.initPayload(&fn_payload.base));
 }
 
+fn zirParam(
+    sema: *Sema,
+    block: *Scope.Block,
+    inst: Zir.Inst.Index,
+    is_comptime: bool,
+) CompileError!void {
+    const inst_data = sema.code.instructions.items(.data)[inst].pl_tok;
+    const src = inst_data.src();
+    const extra = sema.code.extraData(Zir.Inst.Param, inst_data.payload_index);
+    const param_name = sema.code.nullTerminatedString(extra.data.name);
+    const body = sema.code.extra[extra.end..][0..extra.data.body_len];
+
+    // TODO check if param_name shadows a Decl. This only needs to be done if
+    // usingnamespace is implemented.
+    _ = param_name;
+
+    // We could be in a generic function instantiation, or we could be evaluating a generic
+    // function without any comptime args provided.
+    const param_ty = param_ty: {
+        const err = err: {
+            // Make sure any nested param instructions don't clobber our work.
+            const prev_params = block.params;
+            block.params = .{};
+            defer {
+                block.params.deinit(sema.gpa);
+                block.params = prev_params;
+            }
+
+            if (sema.resolveBody(block, body)) |param_ty_inst| {
+                if (sema.analyzeAsType(block, src, param_ty_inst)) |param_ty| {
+                    break :param_ty param_ty;
+                } else |err| break :err err;
+            } else |err| break :err err;
+        };
+        switch (err) {
+            error.GenericPoison => {
+                // The type is not available until the generic instantiation.
+                // We result the param instruction with a poison value and
+                // insert an anytype parameter.
+                try block.params.append(sema.gpa, .{
+                    .ty = Type.initTag(.generic_poison),
+                    .is_comptime = is_comptime,
+                });
+                try sema.inst_map.putNoClobber(sema.gpa, inst, .generic_poison);
+                return;
+            },
+            else => |e| return e,
+        }
+    };
+    if (sema.inst_map.get(inst)) |arg| {
+        if (is_comptime or param_ty.requiresComptime()) {
+            // We have a comptime value for this parameter so it should be elided from the
+            // function type of the function instruction in this block.
+            const coerced_arg = try sema.coerce(block, param_ty, arg, src);
+            sema.inst_map.putAssumeCapacity(inst, coerced_arg);
+            return;
+        }
+        // Even though a comptime argument is provided, the generic function wants to treat
+        // this as a runtime parameter.
+        assert(sema.inst_map.remove(inst));
+    }
+
+    try block.params.append(sema.gpa, .{
+        .ty = param_ty,
+        .is_comptime = is_comptime,
+    });
+    const result = try sema.addConstant(param_ty, Value.initTag(.generic_poison));
+    try sema.inst_map.putNoClobber(sema.gpa, inst, result);
+}
+
+fn zirParamAnytype(
+    sema: *Sema,
+    block: *Scope.Block,
+    inst: Zir.Inst.Index,
+    is_comptime: bool,
+) CompileError!void {
+    const inst_data = sema.code.instructions.items(.data)[inst].str_tok;
+    const param_name = inst_data.get(sema.code);
+
+    // TODO check if param_name shadows a Decl. This only needs to be done if
+    // usingnamespace is implemented.
+    _ = param_name;
+
+    if (sema.inst_map.get(inst)) |air_ref| {
+        const param_ty = sema.typeOf(air_ref);
+        if (is_comptime or param_ty.requiresComptime()) {
+            // We have a comptime value for this parameter so it should be elided from the
+            // function type of the function instruction in this block.
+            return;
+        }
+        // The map is already populated but we do need to add a runtime parameter.
+        try block.params.append(sema.gpa, .{
+            .ty = param_ty,
+            .is_comptime = false,
+        });
+        return;
+    }
+
+    // We are evaluating a generic function without any comptime args provided.
+
+    try block.params.append(sema.gpa, .{
+        .ty = Type.initTag(.generic_poison),
+        .is_comptime = is_comptime,
+    });
+    try sema.inst_map.put(sema.gpa, inst, .generic_poison);
+}
+
 fn zirAs(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
     const tracy = trace(@src());
     defer tracy.end();
@@ -7618,8 +7726,10 @@ fn coerce(
     inst: Air.Inst.Ref,
     inst_src: LazySrcLoc,
 ) CompileError!Air.Inst.Ref {
-    if (dest_type_unresolved.tag() == .var_args_param) {
-        return sema.coerceVarArgParam(block, inst, inst_src);
+    switch (dest_type_unresolved.tag()) {
+        .var_args_param => return sema.coerceVarArgParam(block, inst, inst_src),
+        .generic_poison => return inst,
+        else => {},
     }
     const dest_type_src = inst_src; // TODO better source location
     const dest_type = try sema.resolveTypeFields(block, dest_type_src, dest_type_unresolved);
@@ -8820,6 +8930,7 @@ fn typeHasOnePossibleValue(
 
         .inferred_alloc_const => unreachable,
         .inferred_alloc_mut => unreachable,
+        .generic_poison => unreachable,
     };
 }
 
@@ -8942,6 +9053,8 @@ pub fn addType(sema: *Sema, ty: Type) !Air.Inst.Ref {
         .fn_ccc_void_no_args => return .fn_ccc_void_no_args_type,
         .single_const_pointer_to_comptime_int => return .single_const_pointer_to_comptime_int_type,
         .const_slice_u8 => return .const_slice_u8_type,
+        .anyerror_void_error_union => return .anyerror_void_error_union_type,
+        .generic_poison => return .generic_poison_type,
         else => {},
     }
     try sema.air_instructions.append(sema.gpa, .{
@@ -9015,10 +9128,3 @@ fn isComptimeKnown(
 ) !bool {
     return (try sema.resolveMaybeUndefVal(block, src, inst)) != null;
 }
-
-fn nextArgIsComptimeElided(sema: *Sema) bool {
-    if (sema.comptime_args.len == 0) return false;
-    const result = sema.comptime_args[sema.next_arg_index].val.tag() != .unreachable_value;
-    sema.next_arg_index += 1;
-    return result;
-}
diff --git a/src/Zir.zig b/src/Zir.zig
index 0b93208564..b4cbd9c875 100644
--- a/src/Zir.zig
+++ b/src/Zir.zig
@@ -1704,6 +1704,8 @@ pub const Inst = struct {
         fn_ccc_void_no_args_type,
         single_const_pointer_to_comptime_int_type,
         const_slice_u8_type,
+        anyerror_void_error_union_type,
+        generic_poison_type,
 
         /// `undefined` (untyped)
         undef,
@@ -1731,6 +1733,9 @@ pub const Inst = struct {
         calling_convention_c,
         /// `std.builtin.CallingConvention.Inline`
         calling_convention_inline,
+        /// Used for generic parameters where the type and value
+        /// is not known until generic function instantiation.
+        generic_poison,
 
         _,
 
@@ -1909,6 +1914,14 @@ pub const Inst = struct {
                 .ty = Type.initTag(.type),
                 .val = Value.initTag(.const_slice_u8_type),
             },
+            .anyerror_void_error_union_type = .{
+                .ty = Type.initTag(.type),
+                .val = Value.initTag(.anyerror_void_error_union_type),
+            },
+            .generic_poison_type = .{
+                .ty = Type.initTag(.type),
+                .val = Value.initTag(.generic_poison_type),
+            },
             .enum_literal_type = .{
                 .ty = Type.initTag(.type),
                 .val = Value.initTag(.enum_literal_type),
@@ -2006,6 +2019,10 @@ pub const Inst = struct {
                 .ty = Type.initTag(.calling_convention),
                 .val = .{ .ptr_otherwise = &calling_convention_inline_payload.base },
             },
+            .generic_poison = .{
+                .ty = Type.initTag(.generic_poison),
+                .val = Value.initTag(.generic_poison),
+            },
         });
     };
 
@@ -2787,10 +2804,12 @@ pub const Inst = struct {
         args: Ref,
     };
 
+    /// Trailing: inst: Index // for every body_len
     pub const Param = struct {
         /// Null-terminated string index.
         name: u32,
-        ty: Ref,
+        /// The body contains the type of the parameter.
+        body_len: u32,
     };
 
     /// Trailing:
@@ -3348,11 +3367,16 @@ const Writer = struct {
 
     fn writeParam(self: *Writer, stream: anytype, inst: Inst.Index) !void {
         const inst_data = self.code.instructions.items(.data)[inst].pl_tok;
-        const extra = self.code.extraData(Inst.Param, inst_data.payload_index).data;
+        const extra = self.code.extraData(Inst.Param, inst_data.payload_index);
+        const body = self.code.extra[extra.end..][0..extra.data.body_len];
         try stream.print("\"{}\", ", .{
-            std.zig.fmtEscapes(self.code.nullTerminatedString(extra.name)),
+            std.zig.fmtEscapes(self.code.nullTerminatedString(extra.data.name)),
         });
-        try self.writeInstRef(stream, extra.ty);
+        try stream.writeAll("{\n");
+        self.indent += 2;
+        try self.writeBody(stream, body);
+        self.indent -= 2;
+        try stream.writeByteNTimes(' ', self.indent);
         try stream.writeAll(") ");
         try self.writeSrc(stream, inst_data.src());
     }
diff --git a/src/codegen/llvm.zig b/src/codegen/llvm.zig
index 8b3edcfe23..4a589ea66d 100644
--- a/src/codegen/llvm.zig
+++ b/src/codegen/llvm.zig
@@ -839,6 +839,10 @@ pub const DeclGen = struct {
                     .False,
                 );
             },
+            .ComptimeInt => unreachable,
+            .ComptimeFloat => unreachable,
+            .Type => unreachable,
+            .EnumLiteral => unreachable,
             else => return self.todo("implement const of type '{}'", .{tv.ty}),
         }
     }
diff --git a/src/type.zig b/src/type.zig
index 237614e372..0e99a929f0 100644
--- a/src/type.zig
+++ b/src/type.zig
@@ -130,6 +130,7 @@ pub const Type = extern union {
             => return .Union,
 
             .var_args_param => unreachable, // can be any type
+            .generic_poison => unreachable, // must be handled earlier
         }
     }
 
@@ -699,6 +700,7 @@ pub const Type = extern union {
             .export_options,
             .extern_options,
             .@"anyframe",
+            .generic_poison,
             => unreachable,
 
             .array_u8,
@@ -1083,11 +1085,117 @@ pub const Type = extern union {
                 },
                 .inferred_alloc_const => return writer.writeAll("(inferred_alloc_const)"),
                 .inferred_alloc_mut => return writer.writeAll("(inferred_alloc_mut)"),
+                .generic_poison => return writer.writeAll("(generic poison)"),
             }
             unreachable;
         }
     }
 
+    /// Anything that reports hasCodeGenBits() false returns false here as well.
+    pub fn requiresComptime(ty: Type) bool {
+        return switch (ty.tag()) {
+            .u1,
+            .u8,
+            .i8,
+            .u16,
+            .i16,
+            .u32,
+            .i32,
+            .u64,
+            .i64,
+            .u128,
+            .i128,
+            .usize,
+            .isize,
+            .c_short,
+            .c_ushort,
+            .c_int,
+            .c_uint,
+            .c_long,
+            .c_ulong,
+            .c_longlong,
+            .c_ulonglong,
+            .c_longdouble,
+            .f16,
+            .f32,
+            .f64,
+            .f128,
+            .c_void,
+            .bool,
+            .void,
+            .anyerror,
+            .noreturn,
+            .@"anyframe",
+            .@"null",
+            .@"undefined",
+            .atomic_ordering,
+            .atomic_rmw_op,
+            .calling_convention,
+            .float_mode,
+            .reduce_op,
+            .call_options,
+            .export_options,
+            .extern_options,
+            .manyptr_u8,
+            .manyptr_const_u8,
+            .fn_noreturn_no_args,
+            .fn_void_no_args,
+            .fn_naked_noreturn_no_args,
+            .fn_ccc_void_no_args,
+            .single_const_pointer_to_comptime_int,
+            .const_slice_u8,
+            .anyerror_void_error_union,
+            .empty_struct_literal,
+            .function,
+            .empty_struct,
+            .error_set,
+            .error_set_single,
+            .error_set_inferred,
+            .@"opaque",
+            => false,
+
+            .type,
+            .comptime_int,
+            .comptime_float,
+            .enum_literal,
+            => true,
+
+            .var_args_param => unreachable,
+            .inferred_alloc_mut => unreachable,
+            .inferred_alloc_const => unreachable,
+            .generic_poison => unreachable,
+
+            .array_u8,
+            .array_u8_sentinel_0,
+            .array,
+            .array_sentinel,
+            .vector,
+            .pointer,
+            .single_const_pointer,
+            .single_mut_pointer,
+            .many_const_pointer,
+            .many_mut_pointer,
+            .c_const_pointer,
+            .c_mut_pointer,
+            .const_slice,
+            .mut_slice,
+            .int_signed,
+            .int_unsigned,
+            .optional,
+            .optional_single_mut_pointer,
+            .optional_single_const_pointer,
+            .error_union,
+            .anyframe_T,
+            .@"struct",
+            .@"union",
+            .union_tagged,
+            .enum_simple,
+            .enum_full,
+            .enum_nonexhaustive,
+            => false, // TODO some of these should be `true` depending on their child types
+        };
+    }
+
     pub fn toValue(self: Type, allocator: *Allocator) Allocator.Error!Value {
         switch (self.tag()) {
             .u1 => return Value.initTag(.u1_type),
@@ -1287,6 +1395,7 @@ pub const Type = extern union {
             .inferred_alloc_const => unreachable,
             .inferred_alloc_mut => unreachable,
             .var_args_param => unreachable,
+            .generic_poison => unreachable,
         };
     }
 
@@ -1509,6 +1618,8 @@ pub const Type = extern union {
             .@"opaque",
             .var_args_param,
             => unreachable,
+
+            .generic_poison => unreachable,
         };
     }
 
@@ -1536,6 +1647,7 @@ pub const Type = extern union {
             .inferred_alloc_mut => unreachable,
             .@"opaque" => unreachable,
             .var_args_param => unreachable,
+            .generic_poison => unreachable,
 
             .@"struct" => {
                 const s = self.castTag(.@"struct").?.data;
@@ -1702,6 +1814,7 @@ pub const Type = extern union {
             .inferred_alloc_mut => unreachable,
             .@"opaque" => unreachable,
             .var_args_param => unreachable,
+            .generic_poison => unreachable,
 
             .@"struct" => {
                 @panic("TODO bitSize struct");
@@ -2626,6 +2739,7 @@ pub const Type = extern union {
 
             .inferred_alloc_const => unreachable,
             .inferred_alloc_mut => unreachable,
+            .generic_poison => unreachable,
         };
     }
 
@@ -3039,6 +3153,7 @@ pub const Type = extern union {
         single_const_pointer_to_comptime_int,
         const_slice_u8,
         anyerror_void_error_union,
+        generic_poison,
         /// This is a special type for variadic parameters of a function call.
         /// Casts to it will validate that the type can be passed to a c calling convetion function.
         var_args_param,
@@ -3136,6 +3251,7 @@ pub const Type = extern union {
                 .single_const_pointer_to_comptime_int,
                 .anyerror_void_error_union,
                 .const_slice_u8,
+                .generic_poison,
                 .inferred_alloc_const,
                 .inferred_alloc_mut,
                 .var_args_param,
diff --git a/src/value.zig b/src/value.zig
index 134b51e494..bd1cc57416 100644
--- a/src/value.zig
+++ b/src/value.zig
@@ -76,6 +76,8 @@ pub const Value = extern union {
         fn_ccc_void_no_args_type,
         single_const_pointer_to_comptime_int_type,
         const_slice_u8_type,
+        anyerror_void_error_union_type,
+        generic_poison_type,
 
         undef,
         zero,
@@ -85,6 +87,7 @@ pub const Value = extern union {
         null_value,
         bool_true,
         bool_false,
+        generic_poison,
 
         abi_align_default,
         empty_struct_value,
@@ -188,6 +191,8 @@ pub const Value = extern union {
                 .single_const_pointer_to_comptime_int_type,
                 .anyframe_type,
                 .const_slice_u8_type,
+                .anyerror_void_error_union_type,
+                .generic_poison_type,
                 .enum_literal_type,
                 .undef,
                 .zero,
@@ -210,6 +215,7 @@ pub const Value = extern union {
                 .call_options_type,
                 .export_options_type,
                 .extern_options_type,
+                .generic_poison,
                 => @compileError("Value Tag " ++ @tagName(t) ++ " has no payload"),
 
                 .int_big_positive,
@@ -366,6 +372,8 @@ pub const Value = extern union {
             .single_const_pointer_to_comptime_int_type,
             .anyframe_type,
             .const_slice_u8_type,
+            .anyerror_void_error_union_type,
+            .generic_poison_type,
             .enum_literal_type,
             .undef,
             .zero,
@@ -388,6 +396,7 @@ pub const Value = extern union {
             .call_options_type,
             .export_options_type,
             .extern_options_type,
+            .generic_poison,
             => unreachable,
 
             .ty => {
@@ -556,6 +565,9 @@ pub const Value = extern union {
             .single_const_pointer_to_comptime_int_type => return out_stream.writeAll("*const comptime_int"),
             .anyframe_type => return out_stream.writeAll("anyframe"),
             .const_slice_u8_type => return out_stream.writeAll("[]const u8"),
+            .anyerror_void_error_union_type => return out_stream.writeAll("anyerror!void"),
+            .generic_poison_type => return out_stream.writeAll("(generic poison type)"),
+            .generic_poison => return out_stream.writeAll("(generic poison)"),
             .enum_literal_type => return out_stream.writeAll("@Type(.EnumLiteral)"),
             .manyptr_u8_type => return out_stream.writeAll("[*]u8"),
             .manyptr_const_u8_type => return out_stream.writeAll("[*]const u8"),
@@ -709,6 +721,8 @@ pub const Value = extern union {
             .single_const_pointer_to_comptime_int_type => Type.initTag(.single_const_pointer_to_comptime_int),
             .anyframe_type => Type.initTag(.@"anyframe"),
             .const_slice_u8_type => Type.initTag(.const_slice_u8),
+            .anyerror_void_error_union_type => Type.initTag(.anyerror_void_error_union),
+            .generic_poison_type => Type.initTag(.generic_poison),
             .enum_literal_type => Type.initTag(.enum_literal),
             .manyptr_u8_type => Type.initTag(.manyptr_u8),
             .manyptr_const_u8_type => Type.initTag(.manyptr_const_u8),
@@ -732,46 +746,7 @@ pub const Value = extern union {
                 return Type.initPayload(&buffer.base);
             },
 
-            .undef,
-            .zero,
-            .one,
-            .void_value,
-            .unreachable_value,
-            .empty_array,
-            .bool_true,
-            .bool_false,
-            .null_value,
-            .int_u64,
-            .int_i64,
-            .int_big_positive,
-            .int_big_negative,
-            .function,
-            .extern_fn,
-            .variable,
-            .decl_ref,
-            .decl_ref_mut,
-            .elem_ptr,
-            .field_ptr,
-            .bytes,
-            .repeated,
-            .array,
-            .slice,
-            .float_16,
-            .float_32,
-            .float_64,
-            .float_128,
-            .enum_literal,
-            .enum_field_index,
-            .@"error",
-            .error_union,
-            .empty_struct_value,
-            .@"struct",
-            .@"union",
-            .inferred_alloc,
-            .inferred_alloc_comptime,
-            .abi_align_default,
-            .eu_payload_ptr,
-            => unreachable,
+            else => unreachable,
         };
     }
 
diff --git a/test/cases.zig b/test/cases.zig
index 840ee7a4ac..a342b91a6f 100644
--- a/test/cases.zig
+++ b/test/cases.zig
@@ -1572,7 +1572,7 @@ pub fn addCases(ctx: *TestContext) !void {
             \\    const x = asm volatile ("syscall"
             \\        : [o] "{rax}" (-> number)
             \\        : [number] "{rax}" (231),
-            \\          [arg1] "{rdi}" (code)
+            \\          [arg1] "{rdi}" (60)
             \\        : "rcx", "r11", "memory"
             \\    );
             \\    _ = x;

From f58cbef1659742e57377d3f8c92a0b9b97af91ad Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Wed, 4 Aug 2021 23:02:13 -0700
Subject: [PATCH 77/96] stage2: std.mem.eql works now

 * The `indexable_ptr_len` ZIR instruction now uses a `none_or_ref`
   ResultLoc. This prevents an unnecessary `ref` instruction from being
   emitted.
 * Sema: Fix `analyzeCall` using the incorrect ZIR object for the
   generic function callee.
 * LLVM backend: `genTypedValue` supports a `Slice` type encoded with
   the `decl_ref` `Value`.
---
 src/AstGen.zig          |  2 +-
 src/Sema.zig            | 73 ++++++++++++++++++++++-------------------
 src/codegen/llvm.zig    | 30 ++++++++++++++---
 test/behavior/basic.zig |  9 +++++
 test/behavior/misc.zig  |  8 -----
 5 files changed, 75 insertions(+), 47 deletions(-)

diff --git a/src/AstGen.zig b/src/AstGen.zig
index 493e0a75f4..9886e4d809 100644
--- a/src/AstGen.zig
+++ b/src/AstGen.zig
@@ -5423,7 +5423,7 @@ fn forExpr(
     const tree = astgen.tree;
     const token_tags = tree.tokens.items(.tag);
 
-    const array_ptr = try expr(parent_gz, scope, .ref, for_full.ast.cond_expr);
+    const array_ptr = try expr(parent_gz, scope, .none_or_ref, for_full.ast.cond_expr);
     const len = try parent_gz.addUnNode(.indexable_ptr_len, array_ptr, for_full.ast.cond_expr);
 
     const index_ptr = blk: {
diff --git a/src/Sema.zig b/src/Sema.zig
index 8bcdcb63c9..dff11301db 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -1306,38 +1306,44 @@ fn zirIndexablePtrLen(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) Co
 
     const inst_data = sema.code.instructions.items(.data)[inst].un_node;
     const src = inst_data.src();
-    const array_ptr = sema.resolveInst(inst_data.operand);
-    const array_ptr_src = src;
+    const array = sema.resolveInst(inst_data.operand);
+    const array_ty = sema.typeOf(array);
 
-    const elem_ty = sema.typeOf(array_ptr).elemType();
-    if (elem_ty.isSlice()) {
-        const slice_inst = try sema.analyzeLoad(block, src, array_ptr, array_ptr_src);
-        return sema.analyzeSliceLen(block, src, slice_inst);
+    if (array_ty.isSlice()) {
+        return sema.analyzeSliceLen(block, src, array);
     }
-    if (!elem_ty.isIndexable()) {
-        const cond_src: LazySrcLoc = .{ .node_offset_for_cond = inst_data.src_node };
-        const msg = msg: {
-            const msg = try sema.mod.errMsg(
-                &block.base,
-                cond_src,
-                "type '{}' does not support indexing",
-                .{elem_ty},
-            );
-            errdefer msg.destroy(sema.gpa);
-            try sema.mod.errNote(
-                &block.base,
-                cond_src,
-                msg,
-                "for loop operand must be an array, slice, tuple, or vector",
-                .{},
-            );
-            break :msg msg;
-        };
-        return sema.mod.failWithOwnedErrorMsg(&block.base, msg);
+
+    if (array_ty.isSinglePointer()) {
+        const elem_ty = array_ty.elemType();
+        if (elem_ty.isSlice()) {
+            const slice_inst = try sema.analyzeLoad(block, src, array, src);
+            return sema.analyzeSliceLen(block, src, slice_inst);
+        }
+        if (!elem_ty.isIndexable()) {
+            const msg = msg: {
+                const msg = try sema.mod.errMsg(
+                    &block.base,
+                    src,
+                    "type '{}' does not support indexing",
+                    .{elem_ty},
+                );
+                errdefer msg.destroy(sema.gpa);
+                try sema.mod.errNote(
+                    &block.base,
+                    src,
+                    msg,
+                    "for loop operand must be an array, slice, tuple, or vector",
+                    .{},
+                );
+                break :msg msg;
+            };
+            return sema.mod.failWithOwnedErrorMsg(&block.base, msg);
+        }
+        const result_ptr = try sema.fieldPtr(block, src, array, "len", src);
+        return sema.analyzeLoad(block, src, result_ptr, src);
     }
-    const result_ptr = try sema.fieldPtr(block, src, array_ptr, "len", src);
-    const result_ptr_src = array_ptr_src;
-    return sema.analyzeLoad(block, src, result_ptr, result_ptr_src);
+
+    return sema.mod.fail(&block.base, src, "TODO implement Sema.zirIndexablePtrLen", .{});
 }
 
 fn zirAllocExtended(
@@ -2520,10 +2526,11 @@ fn analyzeCall(
         // generic Scope only to junk it if it matches an existing instantiation.
         // TODO
 
-        const fn_info = sema.code.getFnInfo(module_fn.zir_body_inst);
-        const zir_tags = sema.code.instructions.items(.tag);
+        const namespace = module_fn.owner_decl.namespace;
+        const fn_zir = namespace.file_scope.zir;
+        const fn_info = fn_zir.getFnInfo(module_fn.zir_body_inst);
+        const zir_tags = fn_zir.instructions.items(.tag);
         const new_func = new_func: {
-            const namespace = module_fn.owner_decl.namespace;
             try namespace.anon_decls.ensureUnusedCapacity(gpa, 1);
 
             // Create a Decl for the new function.
@@ -2558,7 +2565,7 @@ fn analyzeCall(
                 .mod = mod,
                 .gpa = gpa,
                 .arena = sema.arena,
-                .code = sema.code,
+                .code = fn_zir,
                 .owner_decl = new_decl,
                 .namespace = namespace,
                 .func = null,
diff --git a/src/codegen/llvm.zig b/src/codegen/llvm.zig
index 4a589ea66d..0e73469687 100644
--- a/src/codegen/llvm.zig
+++ b/src/codegen/llvm.zig
@@ -701,11 +701,31 @@ pub const DeclGen = struct {
             },
             .Pointer => switch (tv.val.tag()) {
                 .decl_ref => {
-                    const decl = tv.val.castTag(.decl_ref).?.data;
-                    decl.alive = true;
-                    const val = try self.resolveGlobalDecl(decl);
-                    const llvm_type = try self.llvmType(tv.ty);
-                    return val.constBitCast(llvm_type);
+                    if (tv.ty.isSlice()) {
+                        var buf: Type.Payload.ElemType = undefined;
+                        const ptr_ty = tv.ty.slicePtrFieldType(&buf);
+                        var slice_len: Value.Payload.U64 = .{
+                            .base = .{ .tag = .int_u64 },
+                            .data = tv.val.sliceLen(),
+                        };
+                        const fields: [2]*const llvm.Value = .{
+                            try self.genTypedValue(.{
+                                .ty = ptr_ty,
+                                .val = tv.val,
+                            }),
+                            try self.genTypedValue(.{
+                                .ty = Type.initTag(.usize),
+                                .val = Value.initPayload(&slice_len.base),
+                            }),
+                        };
+                        return self.context.constStruct(&fields, fields.len, .False);
+                    } else {
+                        const decl = tv.val.castTag(.decl_ref).?.data;
+                        decl.alive = true;
+                        const val = try self.resolveGlobalDecl(decl);
+                        const llvm_type = try self.llvmType(tv.ty);
+                        return val.constBitCast(llvm_type);
+                    }
                 },
                 .variable => {
                     const decl = tv.val.castTag(.variable).?.data.owner_decl;
diff --git a/test/behavior/basic.zig b/test/behavior/basic.zig
index c5c2972ffc..ac1dc3889c 100644
--- a/test/behavior/basic.zig
+++ b/test/behavior/basic.zig
@@ -1,4 +1,5 @@
 const std = @import("std");
+const mem = std.mem;
 const expect = std.testing.expect;
 
 // normal comment
@@ -83,3 +84,11 @@ test "unicode escape in character literal" {
 test "unicode character in character literal" {
     try expect('💩' == 128169);
 }
+
+fn first4KeysOfHomeRow() []const u8 {
+    return "aoeu";
+}
+
+test "return string from function" {
+    try expect(mem.eql(u8, first4KeysOfHomeRow(), "aoeu"));
+}
diff --git a/test/behavior/misc.zig b/test/behavior/misc.zig
index ddb90773d8..8a0761dfd8 100644
--- a/test/behavior/misc.zig
+++ b/test/behavior/misc.zig
@@ -5,14 +5,6 @@ const expectEqualStrings = std.testing.expectEqualStrings;
 const mem = std.mem;
 const builtin = @import("builtin");
 
-fn first4KeysOfHomeRow() []const u8 {
-    return "aoeu";
-}
-
-test "return string from function" {
-    try expect(mem.eql(u8, first4KeysOfHomeRow(), "aoeu"));
-}
-
 test "memcpy and memset intrinsics" {
     var foo: [20]u8 = undefined;
     var bar: [20]u8 = undefined;

From e9e3a2994696a3131125ebc4b1f0eec7ca5306d9 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Thu, 5 Aug 2021 16:37:21 -0700
Subject: [PATCH 78/96] stage2: implement generic function memoization

Module has a new field `monomorphed_funcs` which stores the set of
`*Module.Fn` objects which are generic function instantiations.
The hash is based on hashes of comptime values of parameters known to be
comptime based on an explicit comptime keyword or must-be-comptime
type expressions that can be evaluated without performing monomorphization.
This allows function calls to be semantically analyzed cheaply for
generic functions which are already instantiated.

The table is updated with a single `getOrPutAdapted` in the semantic
analysis of `call` instructions, by pre-allocating the `Fn` object and
passing it to the child `Sema`.
---
 src/Module.zig                    |  44 +++
 src/Sema.zig                      | 468 +++++++++++++++++++-----------
 src/Zir.zig                       |   6 +-
 src/type.zig                      |  34 ++-
 src/value.zig                     | 145 ++++-----
 test/behavior.zig                 |   3 +-
 test/behavior/basic.zig           |  70 +++++
 test/behavior/generics.zig        | 169 +----------
 test/behavior/generics_stage1.zig | 169 +++++++++++
 test/behavior/misc.zig            |  72 +----
 10 files changed, 683 insertions(+), 497 deletions(-)
 create mode 100644 test/behavior/generics_stage1.zig

diff --git a/src/Module.zig b/src/Module.zig
index 2c3e745c11..2556ad3f0e 100644
--- a/src/Module.zig
+++ b/src/Module.zig
@@ -61,6 +61,11 @@ export_owners: std.AutoArrayHashMapUnmanaged(*Decl, []*Export) = .{},
 /// Keys are fully resolved file paths. This table owns the keys and values.
 import_table: std.StringArrayHashMapUnmanaged(*Scope.File) = .{},
 
+/// The set of all the generic function instantiations. This is used so that when a generic
+/// function is called twice with the same comptime parameter arguments, both calls dispatch
+/// to the same function.
+monomorphed_funcs: MonomorphedFuncsSet = .{},
+
 /// We optimize memory usage for a compilation with no compile errors by storing the
 /// error messages and mapping outside of `Decl`.
 /// The ErrorMsg memory is owned by the decl, using Module's general purpose allocator.
@@ -114,6 +119,44 @@ emit_h: ?*GlobalEmitH,
 
 test_functions: std.AutoArrayHashMapUnmanaged(*Decl, void) = .{},
 
+const MonomorphedFuncsSet = std.HashMapUnmanaged(
+    *Fn,
+    void,
+    MonomorphedFuncsContext,
+    std.hash_map.default_max_load_percentage,
+);
+
+const MonomorphedFuncsContext = struct {
+    pub fn eql(ctx: @This(), a: *Fn, b: *Fn) bool {
+        _ = ctx;
+        return a == b;
+    }
+
+    /// Must match `Sema.GenericCallAdapter.hash`.
+    pub fn hash(ctx: @This(), key: *Fn) u64 {
+        _ = ctx;
+        var hasher = std.hash.Wyhash.init(0);
+
+        // The generic function Decl is guaranteed to be the first dependency
+        // of each of its instantiations.
+        const generic_owner_decl = key.owner_decl.dependencies.keys()[0];
+        const generic_func = generic_owner_decl.val.castTag(.function).?.data;
+        std.hash.autoHash(&hasher, @ptrToInt(generic_func));
+
+        // This logic must be kept in sync with the logic in `analyzeCall` that
+        // computes the hash.
+        const comptime_args = key.comptime_args.?;
+        const generic_ty_info = generic_owner_decl.ty.fnInfo();
+        for (generic_ty_info.param_types) |param_ty, i| {
+            if (generic_ty_info.paramIsComptime(i) and param_ty.tag() != .generic_poison) {
+                comptime_args[i].val.hash(param_ty, &hasher);
+            }
+        }
+
+        return hasher.final();
+    }
+};
+
 /// A `Module` has zero or one of these depending on whether `-femit-h` is enabled.
 pub const GlobalEmitH = struct {
     /// Where to put the output.
@@ -2205,6 +2248,7 @@ pub fn deinit(mod: *Module) void {
 
     mod.error_name_list.deinit(gpa);
     mod.test_functions.deinit(gpa);
+    mod.monomorphed_funcs.deinit(gpa);
 }
 
 fn freeExportList(gpa: *Allocator, export_list: []*Export) void {
diff --git a/src/Sema.zig b/src/Sema.zig
index dff11301db..0557587fb5 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -46,6 +46,12 @@ comptime_args: []TypedValue = &.{},
 /// don't accidentally apply it to a function prototype which is used in the
 /// type expression of a generic function parameter.
 comptime_args_fn_inst: Zir.Inst.Index = 0,
+/// When `comptime_args` is provided, this field is also provided. It was used as
+/// the key in the `monomorphed_funcs` set. The `func` instruction is supposed
+/// to use this instead of allocating a fresh one. This avoids an unnecessary
+/// extra hash table lookup in the `monomorphed_funcs` set.
+/// Sema will set this to null when it takes ownership.
+preallocated_new_func: ?*Module.Fn = null,
 
 const std = @import("std");
 const mem = std.mem;
@@ -2354,6 +2360,40 @@ fn zirCall(
     return sema.analyzeCall(block, func, func_src, call_src, modifier, ensure_result_used, resolved_args);
 }
 
+const GenericCallAdapter = struct {
+    generic_fn: *Module.Fn,
+    precomputed_hash: u64,
+    func_ty_info: Type.Payload.Function.Data,
+    comptime_vals: []const Value,
+
+    pub fn eql(ctx: @This(), adapted_key: void, other_key: *Module.Fn) bool {
+        _ = adapted_key;
+        // The generic function Decl is guaranteed to be the first dependency
+        // of each of its instantiations.
+        const generic_owner_decl = other_key.owner_decl.dependencies.keys()[0];
+        if (ctx.generic_fn.owner_decl != generic_owner_decl) return false;
+
+        // This logic must be kept in sync with the logic in `analyzeCall` that
+        // computes the hash.
+        const other_comptime_args = other_key.comptime_args.?;
+        for (ctx.func_ty_info.param_types) |param_ty, i| {
+            if (ctx.func_ty_info.paramIsComptime(i) and param_ty.tag() != .generic_poison) {
+                if (!ctx.comptime_vals[i].eql(other_comptime_args[i].val, param_ty)) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+
+    /// The implementation of the hash is in semantic analysis of function calls, so
+    /// that any errors when computing the hash can be properly reported.
+    pub fn hash(ctx: @This(), adapted_key: void) u64 {
+        _ = adapted_key;
+        return ctx.precomputed_hash;
+    }
+};
+
 fn analyzeCall(
     sema: *Sema,
     block: *Scope.Block,
@@ -2524,193 +2564,192 @@ fn analyzeCall(
         // Check the Module's generic function map with an adapted context, so that we
         // can match against `uncasted_args` rather than doing the work below to create a
         // generic Scope only to junk it if it matches an existing instantiation.
-        // TODO
-
         const namespace = module_fn.owner_decl.namespace;
         const fn_zir = namespace.file_scope.zir;
         const fn_info = fn_zir.getFnInfo(module_fn.zir_body_inst);
         const zir_tags = fn_zir.instructions.items(.tag);
-        const new_func = new_func: {
-            try namespace.anon_decls.ensureUnusedCapacity(gpa, 1);
+        const new_module_func = new_func: {
+            // This hash must match `Module.MonomorphedFuncsContext.hash`.
+            // For parameters explicitly marked comptime and simple parameter type expressions,
+            // we know whether a parameter is elided from a monomorphed function, and can
+            // use it in the hash here. However, for parameter type expressions that are not
+            // explicitly marked comptime and rely on previous parameter comptime values, we
+            // don't find out until after generating a monomorphed function whether the parameter
+            // type ended up being a "must-be-comptime-known" type.
+            var hasher = std.hash.Wyhash.init(0);
+            std.hash.autoHash(&hasher, @ptrToInt(module_fn));
 
-            // Create a Decl for the new function.
-            const new_decl = try mod.allocateNewDecl(namespace, module_fn.owner_decl.src_node);
-            // TODO better names for generic function instantiations
-            const name_index = mod.getNextAnonNameIndex();
-            new_decl.name = try std.fmt.allocPrintZ(gpa, "{s}__anon_{d}", .{
-                module_fn.owner_decl.name, name_index,
-            });
-            new_decl.src_line = module_fn.owner_decl.src_line;
-            new_decl.is_pub = module_fn.owner_decl.is_pub;
-            new_decl.is_exported = module_fn.owner_decl.is_exported;
-            new_decl.has_align = module_fn.owner_decl.has_align;
-            new_decl.has_linksection = module_fn.owner_decl.has_linksection;
-            new_decl.zir_decl_index = module_fn.owner_decl.zir_decl_index;
-            new_decl.alive = true; // This Decl is called at runtime.
-            new_decl.has_tv = true;
-            new_decl.owns_tv = true;
-            new_decl.analysis = .in_progress;
-            new_decl.generation = mod.generation;
+            const comptime_vals = try sema.arena.alloc(Value, func_ty_info.param_types.len);
 
-            namespace.anon_decls.putAssumeCapacityNoClobber(new_decl, {});
+            for (func_ty_info.param_types) |param_ty, i| {
+                const is_comptime = func_ty_info.paramIsComptime(i);
+                if (is_comptime and param_ty.tag() != .generic_poison) {
+                    const arg_src = call_src; // TODO better source location
+                    const casted_arg = try sema.coerce(block, param_ty, uncasted_args[i], arg_src);
+                    if (try sema.resolveMaybeUndefVal(block, arg_src, casted_arg)) |arg_val| {
+                        arg_val.hash(param_ty, &hasher);
+                        comptime_vals[i] = arg_val;
+                    } else {
+                        return sema.failWithNeededComptime(block, arg_src);
+                    }
+                }
+            }
 
-            var new_decl_arena = std.heap.ArenaAllocator.init(sema.gpa);
-            errdefer new_decl_arena.deinit();
-
-            // Re-run the block that creates the function, with the comptime parameters
-            // pre-populated inside `inst_map`. This causes `param_comptime` and
-            // `param_anytype_comptime` ZIR instructions to be ignored, resulting in a
-            // new, monomorphized function, with the comptime parameters elided.
-            var child_sema: Sema = .{
-                .mod = mod,
-                .gpa = gpa,
-                .arena = sema.arena,
-                .code = fn_zir,
-                .owner_decl = new_decl,
-                .namespace = namespace,
-                .func = null,
-                .owner_func = null,
-                .comptime_args = try new_decl_arena.allocator.alloc(TypedValue, uncasted_args.len),
-                .comptime_args_fn_inst = module_fn.zir_body_inst,
+            const adapter: GenericCallAdapter = .{
+                .generic_fn = module_fn,
+                .precomputed_hash = hasher.final(),
+                .func_ty_info = func_ty_info,
+                .comptime_vals = comptime_vals,
             };
-            defer child_sema.deinit();
-
-            var child_block: Scope.Block = .{
-                .parent = null,
-                .sema = &child_sema,
-                .src_decl = new_decl,
-                .instructions = .{},
-                .inlining = null,
-                .is_comptime = true,
-            };
-            defer {
-                child_block.instructions.deinit(gpa);
-                child_block.params.deinit(gpa);
+            const gop = try mod.monomorphed_funcs.getOrPutAdapted(gpa, {}, adapter);
+            if (gop.found_existing) {
+                const callee_func = gop.key_ptr.*;
+                break :res try sema.finishGenericCall(
+                    block,
+                    call_src,
+                    callee_func,
+                    func_src,
+                    uncasted_args,
+                    fn_info,
+                    zir_tags,
+                );
             }
-
-            try child_sema.inst_map.ensureUnusedCapacity(gpa, @intCast(u32, uncasted_args.len));
-            var arg_i: usize = 0;
-            for (fn_info.param_body) |inst| {
-                const is_comptime = switch (zir_tags[inst]) {
-                    .param_comptime, .param_anytype_comptime => true,
-                    .param, .param_anytype => false,
-                    else => continue,
-                };
-                // TODO: pass .unneeded to resolveConstValue and then if we get
-                // error.NeededSourceLocation resolve the arg source location and
-                // try again.
-                const arg_src = call_src;
-                const arg = uncasted_args[arg_i];
-                if (try sema.resolveMaybeUndefVal(block, arg_src, arg)) |arg_val| {
-                    const child_arg = try child_sema.addConstant(sema.typeOf(arg), arg_val);
-                    child_sema.inst_map.putAssumeCapacityNoClobber(inst, child_arg);
-                } else if (is_comptime) {
-                    return sema.failWithNeededComptime(block, arg_src);
-                }
-                arg_i += 1;
-            }
-            const new_func_inst = try child_sema.resolveBody(&child_block, fn_info.param_body);
-            const new_func_val = try child_sema.resolveConstValue(&child_block, .unneeded, new_func_inst);
-            const new_func = new_func_val.castTag(.function).?.data;
-
-            arg_i = 0;
-            for (fn_info.param_body) |inst| {
-                switch (zir_tags[inst]) {
-                    .param_comptime, .param_anytype_comptime, .param, .param_anytype => {},
-                    else => continue,
-                }
-                const arg = child_sema.inst_map.get(inst).?;
-                const arg_val = (child_sema.resolveMaybeUndefValAllowVariables(&child_block, .unneeded, arg) catch unreachable).?;
-
-                if (arg_val.tag() == .generic_poison) {
-                    child_sema.comptime_args[arg_i] = .{
-                        .ty = Type.initTag(.noreturn),
-                        .val = Value.initTag(.unreachable_value),
-                    };
-                } else {
-                    child_sema.comptime_args[arg_i] = .{
-                        .ty = try child_sema.typeOf(arg).copy(&new_decl_arena.allocator),
-                        .val = try arg_val.copy(&new_decl_arena.allocator),
-                    };
-                }
-
-                arg_i += 1;
-            }
-
-            // Populate the Decl ty/val with the function and its type.
-            new_decl.ty = try child_sema.typeOf(new_func_inst).copy(&new_decl_arena.allocator);
-            new_decl.val = try Value.Tag.function.create(&new_decl_arena.allocator, new_func);
-            new_decl.analysis = .complete;
-
-            // Queue up a `codegen_func` work item for the new Fn. The `comptime_args` field
-            // will be populated, ensuring it will have `analyzeBody` called with the ZIR
-            // parameters mapped appropriately.
-            try mod.comp.bin_file.allocateDeclIndexes(new_decl);
-            try mod.comp.work_queue.writeItem(.{ .codegen_func = new_func });
-
-            try new_decl.finalizeNewArena(&new_decl_arena);
-            break :new_func try sema.analyzeDeclVal(block, func_src, new_decl);
+            gop.key_ptr.* = try gpa.create(Module.Fn);
+            break :new_func gop.key_ptr.*;
         };
 
-        // Save it into the Module's generic function map.
-        // TODO
+        try namespace.anon_decls.ensureUnusedCapacity(gpa, 1);
 
-        // Make a runtime call to the new function, making sure to omit the comptime args.
-        try sema.requireRuntimeBlock(block, call_src);
-        const new_func_val = sema.resolveConstValue(block, .unneeded, new_func) catch unreachable;
-        const new_module_func = new_func_val.castTag(.function).?.data;
-        const comptime_args = new_module_func.comptime_args.?;
-        const runtime_args_len = count: {
-            var count: u32 = 0;
-            var arg_i: usize = 0;
-            for (fn_info.param_body) |inst| {
-                switch (zir_tags[inst]) {
-                    .param_comptime, .param_anytype_comptime, .param, .param_anytype => {
-                        if (comptime_args[arg_i].val.tag() == .unreachable_value) {
-                            count += 1;
-                        }
-                        arg_i += 1;
-                    },
-                    else => continue,
-                }
-            }
-            break :count count;
-        };
-        const runtime_args = try sema.arena.alloc(Air.Inst.Ref, runtime_args_len);
-        {
-            const new_fn_ty = new_module_func.owner_decl.ty;
-            var runtime_i: u32 = 0;
-            var total_i: u32 = 0;
-            for (fn_info.param_body) |inst| {
-                switch (zir_tags[inst]) {
-                    .param_comptime, .param_anytype_comptime, .param, .param_anytype => {},
-                    else => continue,
-                }
-                const is_runtime = comptime_args[total_i].val.tag() == .unreachable_value;
-                if (is_runtime) {
-                    const param_ty = new_fn_ty.fnParamType(runtime_i);
-                    const arg_src = call_src; // TODO: better source location
-                    const uncasted_arg = uncasted_args[total_i];
-                    const casted_arg = try sema.coerce(block, param_ty, uncasted_arg, arg_src);
-                    runtime_args[runtime_i] = casted_arg;
-                    runtime_i += 1;
-                }
-                total_i += 1;
-            }
-        }
-        try sema.air_extra.ensureUnusedCapacity(gpa, @typeInfo(Air.Call).Struct.fields.len +
-            runtime_args_len);
-        const func_inst = try block.addInst(.{
-            .tag = .call,
-            .data = .{ .pl_op = .{
-                .operand = new_func,
-                .payload = sema.addExtraAssumeCapacity(Air.Call{
-                    .args_len = runtime_args_len,
-                }),
-            } },
+        // Create a Decl for the new function.
+        const new_decl = try mod.allocateNewDecl(namespace, module_fn.owner_decl.src_node);
+        // TODO better names for generic function instantiations
+        const name_index = mod.getNextAnonNameIndex();
+        new_decl.name = try std.fmt.allocPrintZ(gpa, "{s}__anon_{d}", .{
+            module_fn.owner_decl.name, name_index,
         });
-        sema.appendRefsAssumeCapacity(runtime_args);
-        break :res func_inst;
+        new_decl.src_line = module_fn.owner_decl.src_line;
+        new_decl.is_pub = module_fn.owner_decl.is_pub;
+        new_decl.is_exported = module_fn.owner_decl.is_exported;
+        new_decl.has_align = module_fn.owner_decl.has_align;
+        new_decl.has_linksection = module_fn.owner_decl.has_linksection;
+        new_decl.zir_decl_index = module_fn.owner_decl.zir_decl_index;
+        new_decl.alive = true; // This Decl is called at runtime.
+        new_decl.has_tv = true;
+        new_decl.owns_tv = true;
+        new_decl.analysis = .in_progress;
+        new_decl.generation = mod.generation;
+
+        namespace.anon_decls.putAssumeCapacityNoClobber(new_decl, {});
+
+        var new_decl_arena = std.heap.ArenaAllocator.init(sema.gpa);
+        errdefer new_decl_arena.deinit();
+
+        // Re-run the block that creates the function, with the comptime parameters
+        // pre-populated inside `inst_map`. This causes `param_comptime` and
+        // `param_anytype_comptime` ZIR instructions to be ignored, resulting in a
+        // new, monomorphized function, with the comptime parameters elided.
+        var child_sema: Sema = .{
+            .mod = mod,
+            .gpa = gpa,
+            .arena = sema.arena,
+            .code = fn_zir,
+            .owner_decl = new_decl,
+            .namespace = namespace,
+            .func = null,
+            .owner_func = null,
+            .comptime_args = try new_decl_arena.allocator.alloc(TypedValue, uncasted_args.len),
+            .comptime_args_fn_inst = module_fn.zir_body_inst,
+            .preallocated_new_func = new_module_func,
+        };
+        defer child_sema.deinit();
+
+        var child_block: Scope.Block = .{
+            .parent = null,
+            .sema = &child_sema,
+            .src_decl = new_decl,
+            .instructions = .{},
+            .inlining = null,
+            .is_comptime = true,
+        };
+        defer {
+            child_block.instructions.deinit(gpa);
+            child_block.params.deinit(gpa);
+        }
+
+        try child_sema.inst_map.ensureUnusedCapacity(gpa, @intCast(u32, uncasted_args.len));
+        var arg_i: usize = 0;
+        for (fn_info.param_body) |inst| {
+            const is_comptime = switch (zir_tags[inst]) {
+                .param_comptime, .param_anytype_comptime => true,
+                .param, .param_anytype => false,
+                else => continue,
+            } or func_ty_info.paramIsComptime(arg_i);
+            const arg_src = call_src; // TODO: better source location
+            const arg = uncasted_args[arg_i];
+            if (try sema.resolveMaybeUndefVal(block, arg_src, arg)) |arg_val| {
+                const child_arg = try child_sema.addConstant(sema.typeOf(arg), arg_val);
+                child_sema.inst_map.putAssumeCapacityNoClobber(inst, child_arg);
+            } else if (is_comptime) {
+                return sema.failWithNeededComptime(block, arg_src);
+            }
+            arg_i += 1;
+        }
+        const new_func_inst = try child_sema.resolveBody(&child_block, fn_info.param_body);
+        const new_func_val = try child_sema.resolveConstValue(&child_block, .unneeded, new_func_inst);
+        const new_func = new_func_val.castTag(.function).?.data;
+        assert(new_func == new_module_func);
+
+        arg_i = 0;
+        for (fn_info.param_body) |inst| {
+            switch (zir_tags[inst]) {
+                .param_comptime, .param_anytype_comptime, .param, .param_anytype => {},
+                else => continue,
+            }
+            const arg = child_sema.inst_map.get(inst).?;
+            const arg_val = (child_sema.resolveMaybeUndefValAllowVariables(&child_block, .unneeded, arg) catch unreachable).?;
+
+            if (arg_val.tag() == .generic_poison) {
+                child_sema.comptime_args[arg_i] = .{
+                    .ty = Type.initTag(.noreturn),
+                    .val = Value.initTag(.unreachable_value),
+                };
+            } else {
+                child_sema.comptime_args[arg_i] = .{
+                    .ty = try child_sema.typeOf(arg).copy(&new_decl_arena.allocator),
+                    .val = try arg_val.copy(&new_decl_arena.allocator),
+                };
+            }
+
+            arg_i += 1;
+        }
+
+        // Populate the Decl ty/val with the function and its type.
+        new_decl.ty = try child_sema.typeOf(new_func_inst).copy(&new_decl_arena.allocator);
+        new_decl.val = try Value.Tag.function.create(&new_decl_arena.allocator, new_func);
+        new_decl.analysis = .complete;
+
+        // Queue up a `codegen_func` work item for the new Fn. The `comptime_args` field
+        // will be populated, ensuring it will have `analyzeBody` called with the ZIR
+        // parameters mapped appropriately.
+        try mod.comp.bin_file.allocateDeclIndexes(new_decl);
+        try mod.comp.work_queue.writeItem(.{ .codegen_func = new_func });
+
+        try new_decl.finalizeNewArena(&new_decl_arena);
+
+        // The generic function Decl is guaranteed to be the first dependency
+        // of each of its instantiations.
+        assert(new_decl.dependencies.keys().len == 0);
+        try mod.declareDeclDependency(new_decl, module_fn.owner_decl);
+
+        break :res try sema.finishGenericCall(
+            block,
+            call_src,
+            new_module_func,
+            func_src,
+            uncasted_args,
+            fn_info,
+            zir_tags,
+        );
     } else res: {
         const args = try sema.arena.alloc(Air.Inst.Ref, uncasted_args.len);
         for (uncasted_args) |uncasted_arg, i| {
@@ -2745,6 +2784,75 @@ fn analyzeCall(
     return result;
 }
 
+fn finishGenericCall(
+    sema: *Sema,
+    block: *Scope.Block,
+    call_src: LazySrcLoc,
+    callee: *Module.Fn,
+    func_src: LazySrcLoc,
+    uncasted_args: []const Air.Inst.Ref,
+    fn_info: Zir.FnInfo,
+    zir_tags: []const Zir.Inst.Tag,
+) CompileError!Air.Inst.Ref {
+    const callee_inst = try sema.analyzeDeclVal(block, func_src, callee.owner_decl);
+
+    // Make a runtime call to the new function, making sure to omit the comptime args.
+    try sema.requireRuntimeBlock(block, call_src);
+
+    const comptime_args = callee.comptime_args.?;
+    const runtime_args_len = count: {
+        var count: u32 = 0;
+        var arg_i: usize = 0;
+        for (fn_info.param_body) |inst| {
+            switch (zir_tags[inst]) {
+                .param_comptime, .param_anytype_comptime, .param, .param_anytype => {
+                    if (comptime_args[arg_i].val.tag() == .unreachable_value) {
+                        count += 1;
+                    }
+                    arg_i += 1;
+                },
+                else => continue,
+            }
+        }
+        break :count count;
+    };
+    const runtime_args = try sema.arena.alloc(Air.Inst.Ref, runtime_args_len);
+    {
+        const new_fn_ty = callee.owner_decl.ty;
+        var runtime_i: u32 = 0;
+        var total_i: u32 = 0;
+        for (fn_info.param_body) |inst| {
+            switch (zir_tags[inst]) {
+                .param_comptime, .param_anytype_comptime, .param, .param_anytype => {},
+                else => continue,
+            }
+            const is_runtime = comptime_args[total_i].val.tag() == .unreachable_value;
+            if (is_runtime) {
+                const param_ty = new_fn_ty.fnParamType(runtime_i);
+                const arg_src = call_src; // TODO: better source location
+                const uncasted_arg = uncasted_args[total_i];
+                const casted_arg = try sema.coerce(block, param_ty, uncasted_arg, arg_src);
+                runtime_args[runtime_i] = casted_arg;
+                runtime_i += 1;
+            }
+            total_i += 1;
+        }
+    }
+    try sema.air_extra.ensureUnusedCapacity(sema.gpa, @typeInfo(Air.Call).Struct.fields.len +
+        runtime_args_len);
+    const func_inst = try block.addInst(.{
+        .tag = .call,
+        .data = .{ .pl_op = .{
+            .operand = callee_inst,
+            .payload = sema.addExtraAssumeCapacity(Air.Call{
+                .args_len = runtime_args_len,
+            }),
+        } },
+    });
+    sema.appendRefsAssumeCapacity(runtime_args);
+    return func_inst;
+}
+
 fn zirIntType(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
     _ = block;
     const tracy = trace(@src());
@@ -3419,7 +3527,15 @@ fn funcCommon(
 
     const mod = sema.mod;
 
-    const new_func = if (body_inst == 0) undefined else try sema.gpa.create(Module.Fn);
+    const new_func: *Module.Fn = new_func: {
+        if (body_inst == 0) break :new_func undefined;
+        if (sema.comptime_args_fn_inst == body_inst) {
+            const new_func = sema.preallocated_new_func.?;
+            sema.preallocated_new_func = null; // take ownership
+            break :new_func new_func;
+        }
+        break :new_func try sema.gpa.create(Module.Fn);
+    };
     errdefer if (body_inst != 0) sema.gpa.destroy(new_func);
 
     const fn_ty: Type = fn_ty: {
@@ -3620,7 +3736,7 @@ fn zirParam(
 
     try block.params.append(sema.gpa, .{
         .ty = param_ty,
-        .is_comptime = is_comptime,
+        .is_comptime = is_comptime or param_ty.requiresComptime(),
     });
     const result = try sema.addConstant(param_ty, Value.initTag(.generic_poison));
     try sema.inst_map.putNoClobber(sema.gpa, inst, result);
diff --git a/src/Zir.zig b/src/Zir.zig
index b4cbd9c875..862af7b033 100644
--- a/src/Zir.zig
+++ b/src/Zir.zig
@@ -4930,11 +4930,13 @@ fn findDeclsBody(
     }
 }
 
-pub fn getFnInfo(zir: Zir, fn_inst: Inst.Index) struct {
+pub const FnInfo = struct {
     param_body: []const Inst.Index,
     body: []const Inst.Index,
     total_params_len: u32,
-} {
+};
+
+pub fn getFnInfo(zir: Zir, fn_inst: Inst.Index) FnInfo {
     const tags = zir.instructions.items(.tag);
     const datas = zir.instructions.items(.data);
     const info: struct {
diff --git a/src/type.zig b/src/type.zig
index 0e99a929f0..180fb92bf0 100644
--- a/src/type.zig
+++ b/src/type.zig
@@ -549,8 +549,13 @@ pub const Type = extern union {
 
     pub fn hash(self: Type) u64 {
         var hasher = std.hash.Wyhash.init(0);
+        self.hashWithHasher(&hasher);
+        return hasher.final();
+    }
+
+    pub fn hashWithHasher(self: Type, hasher: *std.hash.Wyhash) void {
         const zig_type_tag = self.zigTypeTag();
-        std.hash.autoHash(&hasher, zig_type_tag);
+        std.hash.autoHash(hasher, zig_type_tag);
         switch (zig_type_tag) {
             .Type,
             .Void,
@@ -568,34 +573,34 @@ pub const Type = extern union {
             .Int => {
                 // Detect that e.g. u64 != usize, even if the bits match on a particular target.
                 if (self.isNamedInt()) {
-                    std.hash.autoHash(&hasher, self.tag());
+                    std.hash.autoHash(hasher, self.tag());
                 } else {
                     // Remaining cases are arbitrary sized integers.
                     // The target will not be branched upon, because we handled target-dependent cases above.
                     const info = self.intInfo(@as(Target, undefined));
-                    std.hash.autoHash(&hasher, info.signedness);
-                    std.hash.autoHash(&hasher, info.bits);
+                    std.hash.autoHash(hasher, info.signedness);
+                    std.hash.autoHash(hasher, info.bits);
                 }
             },
             .Array, .Vector => {
-                std.hash.autoHash(&hasher, self.arrayLen());
-                std.hash.autoHash(&hasher, self.elemType().hash());
+                std.hash.autoHash(hasher, self.arrayLen());
+                std.hash.autoHash(hasher, self.elemType().hash());
                 // TODO hash array sentinel
             },
             .Fn => {
-                std.hash.autoHash(&hasher, self.fnReturnType().hash());
-                std.hash.autoHash(&hasher, self.fnCallingConvention());
+                std.hash.autoHash(hasher, self.fnReturnType().hash());
+                std.hash.autoHash(hasher, self.fnCallingConvention());
                 const params_len = self.fnParamLen();
-                std.hash.autoHash(&hasher, params_len);
+                std.hash.autoHash(hasher, params_len);
                 var i: usize = 0;
                 while (i < params_len) : (i += 1) {
-                    std.hash.autoHash(&hasher, self.fnParamType(i).hash());
+                    std.hash.autoHash(hasher, self.fnParamType(i).hash());
                 }
-                std.hash.autoHash(&hasher, self.fnIsVarArgs());
+                std.hash.autoHash(hasher, self.fnIsVarArgs());
             },
             .Optional => {
                 var buf: Payload.ElemType = undefined;
-                std.hash.autoHash(&hasher, self.optionalChild(&buf).hash());
+                std.hash.autoHash(hasher, self.optionalChild(&buf).hash());
             },
             .Float,
             .Struct,
@@ -612,7 +617,6 @@ pub const Type = extern union {
                 // TODO implement more type hashing
             },
         }
-        return hasher.final();
     }
 
     pub const HashContext64 = struct {
@@ -3373,7 +3377,7 @@ pub const Type = extern union {
             data: Data,
 
             // TODO look into optimizing this memory to take fewer bytes
-            const Data = struct {
+            pub const Data = struct {
                 param_types: []Type,
                 comptime_params: [*]bool,
                 return_type: Type,
@@ -3381,7 +3385,7 @@ pub const Type = extern union {
                 is_var_args: bool,
                 is_generic: bool,
 
-                fn paramIsComptime(self: @This(), i: usize) bool {
+                pub fn paramIsComptime(self: @This(), i: usize) bool {
                     if (!self.is_generic) return false;
                     assert(i < self.param_types.len);
                     return self.comptime_params[i];
diff --git a/src/value.zig b/src/value.zig
index bd1cc57416..bf80c9d831 100644
--- a/src/value.zig
+++ b/src/value.zig
@@ -1117,12 +1117,82 @@ pub const Value = extern union {
         return order(a, b).compare(.eq);
     }
 
+    pub fn hash(val: Value, ty: Type, hasher: *std.hash.Wyhash) void {
+        switch (ty.zigTypeTag()) {
+            .BoundFn => unreachable, // TODO remove this from the language
+
+            .Void,
+            .NoReturn,
+            .Undefined,
+            .Null,
+            => {},
+
+            .Type => {
+                var buf: ToTypeBuffer = undefined;
+                return val.toType(&buf).hashWithHasher(hasher);
+            },
+            .Bool => {
+                std.hash.autoHash(hasher, val.toBool());
+            },
+            .Int, .ComptimeInt => {
+                var space: BigIntSpace = undefined;
+                const big = val.toBigInt(&space);
+                std.hash.autoHash(hasher, big.positive);
+                for (big.limbs) |limb| {
+                    std.hash.autoHash(hasher, limb);
+                }
+            },
+            .Float, .ComptimeFloat => {
+                @panic("TODO implement hashing float values");
+            },
+            .Pointer => {
+                @panic("TODO implement hashing pointer values");
+            },
+            .Array, .Vector => {
+                @panic("TODO implement hashing array/vector values");
+            },
+            .Struct => {
+                @panic("TODO implement hashing struct values");
+            },
+            .Optional => {
+                @panic("TODO implement hashing optional values");
+            },
+            .ErrorUnion => {
+                @panic("TODO implement hashing error union values");
+            },
+            .ErrorSet => {
+                @panic("TODO implement hashing error set values");
+            },
+            .Enum => {
+                @panic("TODO implement hashing enum values");
+            },
+            .Union => {
+                @panic("TODO implement hashing union values");
+            },
+            .Fn => {
+                @panic("TODO implement hashing function values");
+            },
+            .Opaque => {
+                @panic("TODO implement hashing opaque values");
+            },
+            .Frame => {
+                @panic("TODO implement hashing frame values");
+            },
+            .AnyFrame => {
+                @panic("TODO implement hashing anyframe values");
+            },
+            .EnumLiteral => {
+                @panic("TODO implement hashing enum literal values");
+            },
+        }
+    }
+
     pub const ArrayHashContext = struct {
         ty: Type,
 
-        pub fn hash(self: @This(), v: Value) u32 {
+        pub fn hash(self: @This(), val: Value) u32 {
             const other_context: HashContext = .{ .ty = self.ty };
-            return @truncate(u32, other_context.hash(v));
+            return @truncate(u32, other_context.hash(val));
         }
         pub fn eql(self: @This(), a: Value, b: Value) bool {
             return a.eql(b, self.ty);
@@ -1132,76 +1202,9 @@ pub const Value = extern union {
     pub const HashContext = struct {
         ty: Type,
 
-        pub fn hash(self: @This(), v: Value) u64 {
+        pub fn hash(self: @This(), val: Value) u64 {
             var hasher = std.hash.Wyhash.init(0);
-
-            switch (self.ty.zigTypeTag()) {
-                .BoundFn => unreachable, // TODO remove this from the language
-
-                .Void,
-                .NoReturn,
-                .Undefined,
-                .Null,
-                => {},
-
-                .Type => {
-                    var buf: ToTypeBuffer = undefined;
-                    return v.toType(&buf).hash();
-                },
-                .Bool => {
-                    std.hash.autoHash(&hasher, v.toBool());
-                },
-                .Int, .ComptimeInt => {
-                    var space: BigIntSpace = undefined;
-                    const big = v.toBigInt(&space);
-                    std.hash.autoHash(&hasher, big.positive);
-                    for (big.limbs) |limb| {
-                        std.hash.autoHash(&hasher, limb);
-                    }
-                },
-                .Float, .ComptimeFloat => {
-                    @panic("TODO implement hashing float values");
-                },
-                .Pointer => {
-                    @panic("TODO implement hashing pointer values");
-                },
-                .Array, .Vector => {
-                    @panic("TODO implement hashing array/vector values");
-                },
-                .Struct => {
-                    @panic("TODO implement hashing struct values");
-                },
-                .Optional => {
-                    @panic("TODO implement hashing optional values");
-                },
-                .ErrorUnion => {
-                    @panic("TODO implement hashing error union values");
-                },
-                .ErrorSet => {
-                    @panic("TODO implement hashing error set values");
-                },
-                .Enum => {
-                    @panic("TODO implement hashing enum values");
-                },
-                .Union => {
-                    @panic("TODO implement hashing union values");
-                },
-                .Fn => {
-                    @panic("TODO implement hashing function values");
-                },
-                .Opaque => {
-                    @panic("TODO implement hashing opaque values");
-                },
-                .Frame => {
-                    @panic("TODO implement hashing frame values");
-                },
-                .AnyFrame => {
-                    @panic("TODO implement hashing anyframe values");
-                },
-                .EnumLiteral => {
-                    @panic("TODO implement hashing enum literal values");
-                },
-            }
+            val.hash(self.ty, &hasher);
             return hasher.final();
         }
 
diff --git a/test/behavior.zig b/test/behavior.zig
index 4cc4d7fb8b..26272cb2fd 100644
--- a/test/behavior.zig
+++ b/test/behavior.zig
@@ -4,6 +4,7 @@ test {
     // Tests that pass for both.
     _ = @import("behavior/bool.zig");
     _ = @import("behavior/basic.zig");
+    _ = @import("behavior/generics.zig");
 
     if (!builtin.zig_is_stage2) {
         // Tests that only pass for stage1.
@@ -94,7 +95,7 @@ test {
         _ = @import("behavior/fn_in_struct_in_comptime.zig");
         _ = @import("behavior/fn_delegation.zig");
         _ = @import("behavior/for.zig");
-        _ = @import("behavior/generics.zig");
+        _ = @import("behavior/generics_stage1.zig");
         _ = @import("behavior/hasdecl.zig");
         _ = @import("behavior/hasfield.zig");
         _ = @import("behavior/if.zig");
diff --git a/test/behavior/basic.zig b/test/behavior/basic.zig
index ac1dc3889c..1372dfaeeb 100644
--- a/test/behavior/basic.zig
+++ b/test/behavior/basic.zig
@@ -92,3 +92,73 @@ fn first4KeysOfHomeRow() []const u8 {
 test "return string from function" {
     try expect(mem.eql(u8, first4KeysOfHomeRow(), "aoeu"));
 }
+
+test "hex escape" {
+    try expect(mem.eql(u8, "\x68\x65\x6c\x6c\x6f", "hello"));
+}
+
+test "multiline string" {
+    const s1 =
+        \\one
+        \\two)
+        \\three
+    ;
+    const s2 = "one\ntwo)\nthree";
+    try expect(mem.eql(u8, s1, s2));
+}
+
+test "multiline string comments at start" {
+    const s1 =
+        //\\one
+        \\two)
+        \\three
+    ;
+    const s2 = "two)\nthree";
+    try expect(mem.eql(u8, s1, s2));
+}
+
+test "multiline string comments at end" {
+    const s1 =
+        \\one
+        \\two)
+        //\\three
+    ;
+    const s2 = "one\ntwo)";
+    try expect(mem.eql(u8, s1, s2));
+}
+
+test "multiline string comments in middle" {
+    const s1 =
+        \\one
+        //\\two)
+        \\three
+    ;
+    const s2 = "one\nthree";
+    try expect(mem.eql(u8, s1, s2));
+}
+
+test "multiline string comments at multiple places" {
+    const s1 =
+        \\one
+        //\\two
+        \\three
+        //\\four
+        \\five
+    ;
+    const s2 = "one\nthree\nfive";
+    try expect(mem.eql(u8, s1, s2));
+}
+
+test "call result of if else expression" {
+    try expect(mem.eql(u8, f2(true), "a"));
+    try expect(mem.eql(u8, f2(false), "b"));
+}
+fn f2(x: bool) []const u8 {
+    return (if (x) fA else fB)();
+}
+fn fA() []const u8 {
+    return "a";
+}
+fn fB() []const u8 {
+    return "b";
+}
diff --git a/test/behavior/generics.zig b/test/behavior/generics.zig
index 104752607a..e3fed907df 100644
--- a/test/behavior/generics.zig
+++ b/test/behavior/generics.zig
@@ -3,167 +3,14 @@ const testing = std.testing;
 const expect = testing.expect;
 const expectEqual = testing.expectEqual;
 
-test "simple generic fn" {
-    try expect(max(i32, 3, -1) == 3);
-    try expect(max(f32, 0.123, 0.456) == 0.456);
-    try expect(add(2, 3) == 5);
+test "one param, explicit comptime" {
+    var x: usize = 0;
+    x += checkSize(i32);
+    x += checkSize(bool);
+    x += checkSize(bool);
+    try expect(x == 6);
 }
 
-fn max(comptime T: type, a: T, b: T) T {
-    return if (a > b) a else b;
-}
-
-fn add(comptime a: i32, b: i32) i32 {
-    return (comptime a) + b;
-}
-
-const the_max = max(u32, 1234, 5678);
-test "compile time generic eval" {
-    try expect(the_max == 5678);
-}
-
-fn gimmeTheBigOne(a: u32, b: u32) u32 {
-    return max(u32, a, b);
-}
-
-fn shouldCallSameInstance(a: u32, b: u32) u32 {
-    return max(u32, a, b);
-}
-
-fn sameButWithFloats(a: f64, b: f64) f64 {
-    return max(f64, a, b);
-}
-
-test "fn with comptime args" {
-    try expect(gimmeTheBigOne(1234, 5678) == 5678);
-    try expect(shouldCallSameInstance(34, 12) == 34);
-    try expect(sameButWithFloats(0.43, 0.49) == 0.49);
-}
-
-test "var params" {
-    try expect(max_i32(12, 34) == 34);
-    try expect(max_f64(1.2, 3.4) == 3.4);
-}
-
-test {
-    comptime try expect(max_i32(12, 34) == 34);
-    comptime try expect(max_f64(1.2, 3.4) == 3.4);
-}
-
-fn max_var(a: anytype, b: anytype) @TypeOf(a + b) {
-    return if (a > b) a else b;
-}
-
-fn max_i32(a: i32, b: i32) i32 {
-    return max_var(a, b);
-}
-
-fn max_f64(a: f64, b: f64) f64 {
-    return max_var(a, b);
-}
-
-pub fn List(comptime T: type) type {
-    return SmallList(T, 8);
-}
-
-pub fn SmallList(comptime T: type, comptime STATIC_SIZE: usize) type {
-    return struct {
-        items: []T,
-        length: usize,
-        prealloc_items: [STATIC_SIZE]T,
-    };
-}
-
-test "function with return type type" {
-    var list: List(i32) = undefined;
-    var list2: List(i32) = undefined;
-    list.length = 10;
-    list2.length = 10;
-    try expect(list.prealloc_items.len == 8);
-    try expect(list2.prealloc_items.len == 8);
-}
-
-test "generic struct" {
-    var a1 = GenNode(i32){
-        .value = 13,
-        .next = null,
-    };
-    var b1 = GenNode(bool){
-        .value = true,
-        .next = null,
-    };
-    try expect(a1.value == 13);
-    try expect(a1.value == a1.getVal());
-    try expect(b1.getVal());
-}
-fn GenNode(comptime T: type) type {
-    return struct {
-        value: T,
-        next: ?*GenNode(T),
-        fn getVal(n: *const GenNode(T)) T {
-            return n.value;
-        }
-    };
-}
-
-test "const decls in struct" {
-    try expect(GenericDataThing(3).count_plus_one == 4);
-}
-fn GenericDataThing(comptime count: isize) type {
-    return struct {
-        const count_plus_one = count + 1;
-    };
-}
-
-test "use generic param in generic param" {
-    try expect(aGenericFn(i32, 3, 4) == 7);
-}
-fn aGenericFn(comptime T: type, comptime a: T, b: T) T {
-    return a + b;
-}
-
-test "generic fn with implicit cast" {
-    try expect(getFirstByte(u8, &[_]u8{13}) == 13);
-    try expect(getFirstByte(u16, &[_]u16{
-        0,
-        13,
-    }) == 0);
-}
-fn getByte(ptr: ?*const u8) u8 {
-    return ptr.?.*;
-}
-fn getFirstByte(comptime T: type, mem: []const T) u8 {
-    return getByte(@ptrCast(*const u8, &mem[0]));
-}
-
-const foos = [_]fn (anytype) bool{
-    foo1,
-    foo2,
-};
-
-fn foo1(arg: anytype) bool {
-    return arg;
-}
-fn foo2(arg: anytype) bool {
-    return !arg;
-}
-
-test "array of generic fns" {
-    try expect(foos[0](true));
-    try expect(!foos[1](true));
-}
-
-test "generic fn keeps non-generic parameter types" {
-    const A = 128;
-
-    const S = struct {
-        fn f(comptime T: type, s: []T) !void {
-            try expect(A != @typeInfo(@TypeOf(s)).Pointer.alignment);
-        }
-    };
-
-    // The compiler monomorphizes `S.f` for `T=u8` on its first use, check that
-    // `x` type not affect `s` parameter type.
-    var x: [16]u8 align(A) = undefined;
-    try S.f(u8, &x);
+fn checkSize(comptime T: type) usize {
+    return @sizeOf(T);
 }
diff --git a/test/behavior/generics_stage1.zig b/test/behavior/generics_stage1.zig
new file mode 100644
index 0000000000..104752607a
--- /dev/null
+++ b/test/behavior/generics_stage1.zig
@@ -0,0 +1,169 @@
+const std = @import("std");
+const testing = std.testing;
+const expect = testing.expect;
+const expectEqual = testing.expectEqual;
+
+test "simple generic fn" {
+    try expect(max(i32, 3, -1) == 3);
+    try expect(max(f32, 0.123, 0.456) == 0.456);
+    try expect(add(2, 3) == 5);
+}
+
+fn max(comptime T: type, a: T, b: T) T {
+    return if (a > b) a else b;
+}
+
+fn add(comptime a: i32, b: i32) i32 {
+    return (comptime a) + b;
+}
+
+const the_max = max(u32, 1234, 5678);
+test "compile time generic eval" {
+    try expect(the_max == 5678);
+}
+
+fn gimmeTheBigOne(a: u32, b: u32) u32 {
+    return max(u32, a, b);
+}
+
+fn shouldCallSameInstance(a: u32, b: u32) u32 {
+    return max(u32, a, b);
+}
+
+fn sameButWithFloats(a: f64, b: f64) f64 {
+    return max(f64, a, b);
+}
+
+test "fn with comptime args" {
+    try expect(gimmeTheBigOne(1234, 5678) == 5678);
+    try expect(shouldCallSameInstance(34, 12) == 34);
+    try expect(sameButWithFloats(0.43, 0.49) == 0.49);
+}
+
+test "var params" {
+    try expect(max_i32(12, 34) == 34);
+    try expect(max_f64(1.2, 3.4) == 3.4);
+}
+
+test {
+    comptime try expect(max_i32(12, 34) == 34);
+    comptime try expect(max_f64(1.2, 3.4) == 3.4);
+}
+
+fn max_var(a: anytype, b: anytype) @TypeOf(a + b) {
+    return if (a > b) a else b;
+}
+
+fn max_i32(a: i32, b: i32) i32 {
+    return max_var(a, b);
+}
+
+fn max_f64(a: f64, b: f64) f64 {
+    return max_var(a, b);
+}
+
+pub fn List(comptime T: type) type {
+    return SmallList(T, 8);
+}
+
+pub fn SmallList(comptime T: type, comptime STATIC_SIZE: usize) type {
+    return struct {
+        items: []T,
+        length: usize,
+        prealloc_items: [STATIC_SIZE]T,
+    };
+}
+
+test "function with return type type" {
+    var list: List(i32) = undefined;
+    var list2: List(i32) = undefined;
+    list.length = 10;
+    list2.length = 10;
+    try expect(list.prealloc_items.len == 8);
+    try expect(list2.prealloc_items.len == 8);
+}
+
+test "generic struct" {
+    var a1 = GenNode(i32){
+        .value = 13,
+        .next = null,
+    };
+    var b1 = GenNode(bool){
+        .value = true,
+        .next = null,
+    };
+    try expect(a1.value == 13);
+    try expect(a1.value == a1.getVal());
+    try expect(b1.getVal());
+}
+fn GenNode(comptime T: type) type {
+    return struct {
+        value: T,
+        next: ?*GenNode(T),
+        fn getVal(n: *const GenNode(T)) T {
+            return n.value;
+        }
+    };
+}
+
+test "const decls in struct" {
+    try expect(GenericDataThing(3).count_plus_one == 4);
+}
+fn GenericDataThing(comptime count: isize) type {
+    return struct {
+        const count_plus_one = count + 1;
+    };
+}
+
+test "use generic param in generic param" {
+    try expect(aGenericFn(i32, 3, 4) == 7);
+}
+fn aGenericFn(comptime T: type, comptime a: T, b: T) T {
+    return a + b;
+}
+
+test "generic fn with implicit cast" {
+    try expect(getFirstByte(u8, &[_]u8{13}) == 13);
+    try expect(getFirstByte(u16, &[_]u16{
+        0,
+        13,
+    }) == 0);
+}
+fn getByte(ptr: ?*const u8) u8 {
+    return ptr.?.*;
+}
+fn getFirstByte(comptime T: type, mem: []const T) u8 {
+    return getByte(@ptrCast(*const u8, &mem[0]));
+}
+
+const foos = [_]fn (anytype) bool{
+    foo1,
+    foo2,
+};
+
+fn foo1(arg: anytype) bool {
+    return arg;
+}
+fn foo2(arg: anytype) bool {
+    return !arg;
+}
+
+test "array of generic fns" {
+    try expect(foos[0](true));
+    try expect(!foos[1](true));
+}
+
+test "generic fn keeps non-generic parameter types" {
+    const A = 128;
+
+    const S = struct {
+        fn f(comptime T: type, s: []T) !void {
+            try expect(A != @typeInfo(@TypeOf(s)).Pointer.alignment);
+        }
+    };
+
+    // The compiler monomorphizes `S.f` for `T=u8` on its first use, check that
+    // `x` type not affect `s` parameter type.
+    var x: [16]u8 align(A) = undefined;
+    try S.f(u8, &x);
+}
diff --git a/test/behavior/misc.zig b/test/behavior/misc.zig
index 8a0761dfd8..466be00bd3 100644
--- a/test/behavior/misc.zig
+++ b/test/behavior/misc.zig
@@ -40,10 +40,6 @@ test "constant equal function pointers" {
 
 fn emptyFn() void {}
 
-test "hex escape" {
-    try expect(mem.eql(u8, "\x68\x65\x6c\x6c\x6f", "hello"));
-}
-
 test "string concatenation" {
     try expect(mem.eql(u8, "OK" ++ " IT " ++ "WORKED", "OK IT WORKED"));
 }
@@ -62,59 +58,7 @@ test "string escapes" {
     try expectEqualStrings("\u{1234}\u{069}\u{1}", "\xe1\x88\xb4\x69\x01");
 }
 
-test "multiline string" {
-    const s1 =
-        \\one
-        \\two)
-        \\three
-    ;
-    const s2 = "one\ntwo)\nthree";
-    try expect(mem.eql(u8, s1, s2));
-}
-
-test "multiline string comments at start" {
-    const s1 =
-        //\\one
-        \\two)
-        \\three
-    ;
-    const s2 = "two)\nthree";
-    try expect(mem.eql(u8, s1, s2));
-}
-
-test "multiline string comments at end" {
-    const s1 =
-        \\one
-        \\two)
-        //\\three
-    ;
-    const s2 = "one\ntwo)";
-    try expect(mem.eql(u8, s1, s2));
-}
-
-test "multiline string comments in middle" {
-    const s1 =
-        \\one
-        //\\two)
-        \\three
-    ;
-    const s2 = "one\nthree";
-    try expect(mem.eql(u8, s1, s2));
-}
-
-test "multiline string comments at multiple places" {
-    const s1 =
-        \\one
-        //\\two
-        \\three
-        //\\four
-        \\five
-    ;
-    const s2 = "one\nthree\nfive";
-    try expect(mem.eql(u8, s1, s2));
-}
-
-test "multiline C string" {
+test "multiline string literal is null terminated" {
     const s1 =
         \\one
         \\two)
@@ -169,20 +113,6 @@ fn outer() i64 {
     return inner();
 }
 
-test "call result of if else expression" {
-    try expect(mem.eql(u8, f2(true), "a"));
-    try expect(mem.eql(u8, f2(false), "b"));
-}
-fn f2(x: bool) []const u8 {
-    return (if (x) fA else fB)();
-}
-fn fA() []const u8 {
-    return "a";
-}
-fn fB() []const u8 {
-    return "b";
-}
-
 test "constant enum initialization with differing sizes" {
     try test3_1(test3_foo);
     try test3_2(test3_bar);

From 011a468381a0217bff7f98817c0df593cbcc85ec Mon Sep 17 00:00:00 2001
From: Jakub Konka <kubkon@jakubkonka.com>
Date: Wed, 4 Aug 2021 23:28:57 +0200
Subject: [PATCH 79/96] Link system libc if natively linking frameworks on
 macOS

---
 src/Compilation.zig | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/src/Compilation.zig b/src/Compilation.zig
index f8f8cea328..33112ddb1b 100644
--- a/src/Compilation.zig
+++ b/src/Compilation.zig
@@ -944,8 +944,6 @@ pub fn create(gpa: *Allocator, options: InitOptions) !*Compilation {
             if (options.sysroot) |sysroot| {
                 break :blk sysroot;
             } else if (darwin_can_use_system_sdk) {
-                // TODO Revisit this targeting versions lower than macOS 11 when LLVM 12 is out.
-                // See https://github.com/ziglang/zig/issues/6996
                 const at_least_big_sur = options.target.os.getVersionRange().semver.min.major >= 11;
                 break :blk if (at_least_big_sur) try std.zig.system.getSDKPath(arena) else null;
             } else {
@@ -1029,7 +1027,7 @@ pub fn create(gpa: *Allocator, options: InitOptions) !*Compilation {
             options.target,
             options.is_native_abi,
             link_libc,
-            options.system_libs.len != 0,
+            options.system_libs.len != 0 or options.frameworks.len != 0,
             options.libc_installation,
         );
 

From c03a04a58942446b48e9294df991a17a3a6f7b48 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Thu, 5 Aug 2021 19:15:59 -0700
Subject: [PATCH 80/96] stage2: return type expressions of generic functions

 * ZIR encoding for function instructions have a body for the return
   type. This lets Sema for generic functions do the same thing it does
   for parameters, handling `error.GenericPoison` in the evaluation of
   the return type by marking the function as generic.

 * Sema: fix missing block around the new Decl arena finalization. This
   led to a memory corruption.

 * Added some floating point support to the LLVM backend but didn't get
   far enough to pass any new tests.
---
 src/AstGen.zig                    |  70 ++++----
 src/Module.zig                    |   3 +
 src/Sema.zig                      | 286 +++++++++++++++++-------------
 src/Zir.zig                       |  64 +++++--
 src/codegen/llvm.zig              |  16 +-
 src/codegen/llvm/bindings.zig     |  18 ++
 src/print_air.zig                 |   2 +-
 test/behavior/generics.zig        |  56 ++++++
 test/behavior/generics_stage1.zig |  39 +---
 9 files changed, 345 insertions(+), 209 deletions(-)

diff --git a/src/AstGen.zig b/src/AstGen.zig
index 9886e4d809..febe581e35 100644
--- a/src/AstGen.zig
+++ b/src/AstGen.zig
@@ -1041,6 +1041,7 @@ fn fnProtoExpr(
     fn_proto: ast.full.FnProto,
 ) InnerError!Zir.Inst.Ref {
     const astgen = gz.astgen;
+    const gpa = astgen.gpa;
     const tree = astgen.tree;
     const token_tags = tree.tokens.items(.tag);
 
@@ -1083,7 +1084,6 @@ fn fnProtoExpr(
                     .param_anytype;
                 _ = try gz.addStrTok(tag, param_name, name_token);
             } else {
-                const gpa = astgen.gpa;
                 const param_type_node = param.type_expr;
                 assert(param_type_node != 0);
                 var param_gz = gz.makeSubBlock(scope);
@@ -1113,15 +1113,13 @@ fn fnProtoExpr(
     if (is_inferred_error) {
         return astgen.failTok(maybe_bang, "function prototype may not have inferred error set", .{});
     }
-    const return_type_inst = try AstGen.expr(
-        gz,
-        scope,
-        .{ .ty = .type_type },
-        fn_proto.ast.return_type,
-    );
+    var ret_gz = gz.makeSubBlock(scope);
+    defer ret_gz.instructions.deinit(gpa);
+    const ret_ty = try expr(&ret_gz, scope, coerced_type_rl, fn_proto.ast.return_type);
+    const ret_br = try ret_gz.addBreak(.break_inline, 0, ret_ty);
 
     const cc: Zir.Inst.Ref = if (fn_proto.ast.callconv_expr != 0)
-        try AstGen.expr(
+        try expr(
             gz,
             scope,
             .{ .ty = .calling_convention_type },
@@ -1133,7 +1131,8 @@ fn fnProtoExpr(
     const result = try gz.addFunc(.{
         .src_node = fn_proto.ast.proto_node,
         .param_block = 0,
-        .ret_ty = return_type_inst,
+        .ret_ty = ret_gz.instructions.items,
+        .ret_br = ret_br,
         .body = &[0]Zir.Inst.Index{},
         .cc = cc,
         .align_inst = align_inst,
@@ -3005,12 +3004,10 @@ fn fnDecl(
         break :inst try comptimeExpr(&decl_gz, params_scope, .{ .ty = .const_slice_u8_type }, fn_proto.ast.section_expr);
     };
 
-    const return_type_inst = try AstGen.expr(
-        &decl_gz,
-        params_scope,
-        .{ .ty = .type_type },
-        fn_proto.ast.return_type,
-    );
+    var ret_gz = gz.makeSubBlock(params_scope);
+    defer ret_gz.instructions.deinit(gpa);
+    const ret_ty = try expr(&decl_gz, params_scope, coerced_type_rl, fn_proto.ast.return_type);
+    const ret_br = try ret_gz.addBreak(.break_inline, 0, ret_ty);
 
     const cc: Zir.Inst.Ref = blk: {
         if (fn_proto.ast.callconv_expr != 0) {
@@ -3021,7 +3018,7 @@ fn fnDecl(
                     .{},
                 );
             }
-            break :blk try AstGen.expr(
+            break :blk try expr(
                 &decl_gz,
                 params_scope,
                 .{ .ty = .calling_convention_type },
@@ -3046,7 +3043,8 @@ fn fnDecl(
         }
         break :func try decl_gz.addFunc(.{
             .src_node = decl_node,
-            .ret_ty = return_type_inst,
+            .ret_ty = ret_gz.instructions.items,
+            .ret_br = ret_br,
             .param_block = block_inst,
             .body = &[0]Zir.Inst.Index{},
             .cc = cc,
@@ -3085,7 +3083,8 @@ fn fnDecl(
         break :func try decl_gz.addFunc(.{
             .src_node = decl_node,
             .param_block = block_inst,
-            .ret_ty = return_type_inst,
+            .ret_ty = ret_gz.instructions.items,
+            .ret_br = ret_br,
             .body = fn_gz.instructions.items,
             .cc = cc,
             .align_inst = .none, // passed in the per-decl data
@@ -3430,7 +3429,8 @@ fn testDecl(
     const func_inst = try decl_block.addFunc(.{
         .src_node = node,
         .param_block = block_inst,
-        .ret_ty = .void_type,
+        .ret_ty = &.{},
+        .ret_br = 0,
         .body = fn_block.instructions.items,
         .cc = .none,
         .align_inst = .none,
@@ -9127,7 +9127,8 @@ const GenZir = struct {
         src_node: ast.Node.Index,
         body: []const Zir.Inst.Index,
         param_block: Zir.Inst.Index,
-        ret_ty: Zir.Inst.Ref,
+        ret_ty: []const Zir.Inst.Index,
+        ret_br: Zir.Inst.Index,
         cc: Zir.Inst.Ref,
         align_inst: Zir.Inst.Ref,
         lib_name: u32,
@@ -9137,7 +9138,6 @@ const GenZir = struct {
         is_extern: bool,
     }) !Zir.Inst.Ref {
         assert(args.src_node != 0);
-        assert(args.ret_ty != .none);
         const astgen = gz.astgen;
         const gpa = astgen.gpa;
 
@@ -9179,7 +9179,7 @@ const GenZir = struct {
             try astgen.extra.ensureUnusedCapacity(
                 gpa,
                 @typeInfo(Zir.Inst.ExtendedFunc).Struct.fields.len +
-                    args.body.len + src_locs.len +
+                    args.ret_ty.len + args.body.len + src_locs.len +
                     @boolToInt(args.lib_name != 0) +
                     @boolToInt(args.align_inst != .none) +
                     @boolToInt(args.cc != .none),
@@ -9187,7 +9187,7 @@ const GenZir = struct {
             const payload_index = astgen.addExtraAssumeCapacity(Zir.Inst.ExtendedFunc{
                 .src_node = gz.nodeIndexToRelative(args.src_node),
                 .param_block = args.param_block,
-                .return_type = args.ret_ty,
+                .ret_body_len = @intCast(u32, args.ret_ty.len),
                 .body_len = @intCast(u32, args.body.len),
             });
             if (args.lib_name != 0) {
@@ -9199,10 +9199,14 @@ const GenZir = struct {
             if (args.align_inst != .none) {
                 astgen.extra.appendAssumeCapacity(@enumToInt(args.align_inst));
             }
+            astgen.extra.appendSliceAssumeCapacity(args.ret_ty);
             astgen.extra.appendSliceAssumeCapacity(args.body);
             astgen.extra.appendSliceAssumeCapacity(src_locs);
 
             const new_index = @intCast(Zir.Inst.Index, astgen.instructions.len);
+            if (args.ret_br != 0) {
+                astgen.instructions.items(.data)[args.ret_br].@"break".block_inst = new_index;
+            }
             astgen.instructions.appendAssumeCapacity(.{
                 .tag = .extended,
                 .data = .{ .extended = .{
@@ -9222,23 +9226,27 @@ const GenZir = struct {
             gz.instructions.appendAssumeCapacity(new_index);
             return indexToRef(new_index);
         } else {
-            try gz.astgen.extra.ensureUnusedCapacity(
+            try astgen.extra.ensureUnusedCapacity(
                 gpa,
                 @typeInfo(Zir.Inst.Func).Struct.fields.len +
-                    args.body.len + src_locs.len,
+                    args.ret_ty.len + args.body.len + src_locs.len,
             );
 
-            const payload_index = gz.astgen.addExtraAssumeCapacity(Zir.Inst.Func{
+            const payload_index = astgen.addExtraAssumeCapacity(Zir.Inst.Func{
                 .param_block = args.param_block,
-                .return_type = args.ret_ty,
+                .ret_body_len = @intCast(u32, args.ret_ty.len),
                 .body_len = @intCast(u32, args.body.len),
             });
-            gz.astgen.extra.appendSliceAssumeCapacity(args.body);
-            gz.astgen.extra.appendSliceAssumeCapacity(src_locs);
+            astgen.extra.appendSliceAssumeCapacity(args.ret_ty);
+            astgen.extra.appendSliceAssumeCapacity(args.body);
+            astgen.extra.appendSliceAssumeCapacity(src_locs);
 
             const tag: Zir.Inst.Tag = if (args.is_inferred_error) .func_inferred else .func;
-            const new_index = @intCast(Zir.Inst.Index, gz.astgen.instructions.len);
-            gz.astgen.instructions.appendAssumeCapacity(.{
+            const new_index = @intCast(Zir.Inst.Index, astgen.instructions.len);
+            if (args.ret_br != 0) {
+                astgen.instructions.items(.data)[args.ret_br].@"break".block_inst = new_index;
+            }
+            astgen.instructions.appendAssumeCapacity(.{
                 .tag = tag,
                 .data = .{ .pl_node = .{
                     .src_node = gz.nodeIndexToRelative(args.src_node),
diff --git a/src/Module.zig b/src/Module.zig
index 2556ad3f0e..da11bc1c3c 100644
--- a/src/Module.zig
+++ b/src/Module.zig
@@ -842,6 +842,9 @@ pub const Fn = struct {
 
     pub fn getInferredErrorSet(func: *Fn) ?*std.StringHashMapUnmanaged(void) {
         const ret_ty = func.owner_decl.ty.fnReturnType();
+        if (ret_ty.tag() == .generic_poison) {
+            return null;
+        }
         if (ret_ty.zigTypeTag() == .ErrorUnion) {
             if (ret_ty.errorUnionSet().castTag(.error_set_inferred)) |payload| {
                 return &payload.data.map;
diff --git a/src/Sema.zig b/src/Sema.zig
index 0557587fb5..73f22aa845 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -2618,129 +2618,131 @@ fn analyzeCall(
             break :new_func gop.key_ptr.*;
         };
 
-        try namespace.anon_decls.ensureUnusedCapacity(gpa, 1);
+        {
+            try namespace.anon_decls.ensureUnusedCapacity(gpa, 1);
 
-        // Create a Decl for the new function.
-        const new_decl = try mod.allocateNewDecl(namespace, module_fn.owner_decl.src_node);
-        // TODO better names for generic function instantiations
-        const name_index = mod.getNextAnonNameIndex();
-        new_decl.name = try std.fmt.allocPrintZ(gpa, "{s}__anon_{d}", .{
-            module_fn.owner_decl.name, name_index,
-        });
-        new_decl.src_line = module_fn.owner_decl.src_line;
-        new_decl.is_pub = module_fn.owner_decl.is_pub;
-        new_decl.is_exported = module_fn.owner_decl.is_exported;
-        new_decl.has_align = module_fn.owner_decl.has_align;
-        new_decl.has_linksection = module_fn.owner_decl.has_linksection;
-        new_decl.zir_decl_index = module_fn.owner_decl.zir_decl_index;
-        new_decl.alive = true; // This Decl is called at runtime.
-        new_decl.has_tv = true;
-        new_decl.owns_tv = true;
-        new_decl.analysis = .in_progress;
-        new_decl.generation = mod.generation;
+            // Create a Decl for the new function.
+            const new_decl = try mod.allocateNewDecl(namespace, module_fn.owner_decl.src_node);
+            // TODO better names for generic function instantiations
+            const name_index = mod.getNextAnonNameIndex();
+            new_decl.name = try std.fmt.allocPrintZ(gpa, "{s}__anon_{d}", .{
+                module_fn.owner_decl.name, name_index,
+            });
+            new_decl.src_line = module_fn.owner_decl.src_line;
+            new_decl.is_pub = module_fn.owner_decl.is_pub;
+            new_decl.is_exported = module_fn.owner_decl.is_exported;
+            new_decl.has_align = module_fn.owner_decl.has_align;
+            new_decl.has_linksection = module_fn.owner_decl.has_linksection;
+            new_decl.zir_decl_index = module_fn.owner_decl.zir_decl_index;
+            new_decl.alive = true; // This Decl is called at runtime.
+            new_decl.has_tv = true;
+            new_decl.owns_tv = true;
+            new_decl.analysis = .in_progress;
+            new_decl.generation = mod.generation;
 
-        namespace.anon_decls.putAssumeCapacityNoClobber(new_decl, {});
+            namespace.anon_decls.putAssumeCapacityNoClobber(new_decl, {});
 
-        var new_decl_arena = std.heap.ArenaAllocator.init(sema.gpa);
-        errdefer new_decl_arena.deinit();
+            var new_decl_arena = std.heap.ArenaAllocator.init(sema.gpa);
+            errdefer new_decl_arena.deinit();
 
-        // Re-run the block that creates the function, with the comptime parameters
-        // pre-populated inside `inst_map`. This causes `param_comptime` and
-        // `param_anytype_comptime` ZIR instructions to be ignored, resulting in a
-        // new, monomorphized function, with the comptime parameters elided.
-        var child_sema: Sema = .{
-            .mod = mod,
-            .gpa = gpa,
-            .arena = sema.arena,
-            .code = fn_zir,
-            .owner_decl = new_decl,
-            .namespace = namespace,
-            .func = null,
-            .owner_func = null,
-            .comptime_args = try new_decl_arena.allocator.alloc(TypedValue, uncasted_args.len),
-            .comptime_args_fn_inst = module_fn.zir_body_inst,
-            .preallocated_new_func = new_module_func,
-        };
-        defer child_sema.deinit();
+            // Re-run the block that creates the function, with the comptime parameters
+            // pre-populated inside `inst_map`. This causes `param_comptime` and
+            // `param_anytype_comptime` ZIR instructions to be ignored, resulting in a
+            // new, monomorphized function, with the comptime parameters elided.
+            var child_sema: Sema = .{
+                .mod = mod,
+                .gpa = gpa,
+                .arena = sema.arena,
+                .code = fn_zir,
+                .owner_decl = new_decl,
+                .namespace = namespace,
+                .func = null,
+                .owner_func = null,
+                .comptime_args = try new_decl_arena.allocator.alloc(TypedValue, uncasted_args.len),
+                .comptime_args_fn_inst = module_fn.zir_body_inst,
+                .preallocated_new_func = new_module_func,
+            };
+            defer child_sema.deinit();
 
-        var child_block: Scope.Block = .{
-            .parent = null,
-            .sema = &child_sema,
-            .src_decl = new_decl,
-            .instructions = .{},
-            .inlining = null,
-            .is_comptime = true,
-        };
-        defer {
-            child_block.instructions.deinit(gpa);
-            child_block.params.deinit(gpa);
-        }
-
-        try child_sema.inst_map.ensureUnusedCapacity(gpa, @intCast(u32, uncasted_args.len));
-        var arg_i: usize = 0;
-        for (fn_info.param_body) |inst| {
-            const is_comptime = switch (zir_tags[inst]) {
-                .param_comptime, .param_anytype_comptime => true,
-                .param, .param_anytype => false,
-                else => continue,
-            } or func_ty_info.paramIsComptime(arg_i);
-            const arg_src = call_src; // TODO: better source location
-            const arg = uncasted_args[arg_i];
-            if (try sema.resolveMaybeUndefVal(block, arg_src, arg)) |arg_val| {
-                const child_arg = try child_sema.addConstant(sema.typeOf(arg), arg_val);
-                child_sema.inst_map.putAssumeCapacityNoClobber(inst, child_arg);
-            } else if (is_comptime) {
-                return sema.failWithNeededComptime(block, arg_src);
-            }
-            arg_i += 1;
-        }
-        const new_func_inst = try child_sema.resolveBody(&child_block, fn_info.param_body);
-        const new_func_val = try child_sema.resolveConstValue(&child_block, .unneeded, new_func_inst);
-        const new_func = new_func_val.castTag(.function).?.data;
-        assert(new_func == new_module_func);
-
-        arg_i = 0;
-        for (fn_info.param_body) |inst| {
-            switch (zir_tags[inst]) {
-                .param_comptime, .param_anytype_comptime, .param, .param_anytype => {},
-                else => continue,
-            }
-            const arg = child_sema.inst_map.get(inst).?;
-            const arg_val = (child_sema.resolveMaybeUndefValAllowVariables(&child_block, .unneeded, arg) catch unreachable).?;
-
-            if (arg_val.tag() == .generic_poison) {
-                child_sema.comptime_args[arg_i] = .{
-                    .ty = Type.initTag(.noreturn),
-                    .val = Value.initTag(.unreachable_value),
-                };
-            } else {
-                child_sema.comptime_args[arg_i] = .{
-                    .ty = try child_sema.typeOf(arg).copy(&new_decl_arena.allocator),
-                    .val = try arg_val.copy(&new_decl_arena.allocator),
-                };
+            var child_block: Scope.Block = .{
+                .parent = null,
+                .sema = &child_sema,
+                .src_decl = new_decl,
+                .instructions = .{},
+                .inlining = null,
+                .is_comptime = true,
+            };
+            defer {
+                child_block.instructions.deinit(gpa);
+                child_block.params.deinit(gpa);
             }
 
-            arg_i += 1;
+            try child_sema.inst_map.ensureUnusedCapacity(gpa, @intCast(u32, uncasted_args.len));
+            var arg_i: usize = 0;
+            for (fn_info.param_body) |inst| {
+                const is_comptime = switch (zir_tags[inst]) {
+                    .param_comptime, .param_anytype_comptime => true,
+                    .param, .param_anytype => false,
+                    else => continue,
+                } or func_ty_info.paramIsComptime(arg_i);
+                const arg_src = call_src; // TODO: better source location
+                const arg = uncasted_args[arg_i];
+                if (try sema.resolveMaybeUndefVal(block, arg_src, arg)) |arg_val| {
+                    const child_arg = try child_sema.addConstant(sema.typeOf(arg), arg_val);
+                    child_sema.inst_map.putAssumeCapacityNoClobber(inst, child_arg);
+                } else if (is_comptime) {
+                    return sema.failWithNeededComptime(block, arg_src);
+                }
+                arg_i += 1;
+            }
+            const new_func_inst = try child_sema.resolveBody(&child_block, fn_info.param_body);
+            const new_func_val = try child_sema.resolveConstValue(&child_block, .unneeded, new_func_inst);
+            const new_func = new_func_val.castTag(.function).?.data;
+            assert(new_func == new_module_func);
+
+            arg_i = 0;
+            for (fn_info.param_body) |inst| {
+                switch (zir_tags[inst]) {
+                    .param_comptime, .param_anytype_comptime, .param, .param_anytype => {},
+                    else => continue,
+                }
+                const arg = child_sema.inst_map.get(inst).?;
+                const arg_val = (child_sema.resolveMaybeUndefValAllowVariables(&child_block, .unneeded, arg) catch unreachable).?;
+
+                if (arg_val.tag() == .generic_poison) {
+                    child_sema.comptime_args[arg_i] = .{
+                        .ty = Type.initTag(.noreturn),
+                        .val = Value.initTag(.unreachable_value),
+                    };
+                } else {
+                    child_sema.comptime_args[arg_i] = .{
+                        .ty = try child_sema.typeOf(arg).copy(&new_decl_arena.allocator),
+                        .val = try arg_val.copy(&new_decl_arena.allocator),
+                    };
+                }
+
+                arg_i += 1;
+            }
+
+            // Populate the Decl ty/val with the function and its type.
+            new_decl.ty = try child_sema.typeOf(new_func_inst).copy(&new_decl_arena.allocator);
+            new_decl.val = try Value.Tag.function.create(&new_decl_arena.allocator, new_func);
+            new_decl.analysis = .complete;
+
+            // The generic function Decl is guaranteed to be the first dependency
+            // of each of its instantiations.
+            assert(new_decl.dependencies.keys().len == 0);
+            try mod.declareDeclDependency(new_decl, module_fn.owner_decl);
+
+            // Queue up a `codegen_func` work item for the new Fn. The `comptime_args` field
+            // will be populated, ensuring it will have `analyzeBody` called with the ZIR
+            // parameters mapped appropriately.
+            try mod.comp.bin_file.allocateDeclIndexes(new_decl);
+            try mod.comp.work_queue.writeItem(.{ .codegen_func = new_func });
+
+            try new_decl.finalizeNewArena(&new_decl_arena);
         }
 
-        // Populate the Decl ty/val with the function and its type.
-        new_decl.ty = try child_sema.typeOf(new_func_inst).copy(&new_decl_arena.allocator);
-        new_decl.val = try Value.Tag.function.create(&new_decl_arena.allocator, new_func);
-        new_decl.analysis = .complete;
-
-        // Queue up a `codegen_func` work item for the new Fn. The `comptime_args` field
-        // will be populated, ensuring it will have `analyzeBody` called with the ZIR
-        // parameters mapped appropriately.
-        try mod.comp.bin_file.allocateDeclIndexes(new_decl);
-        try mod.comp.work_queue.writeItem(.{ .codegen_func = new_func });
-
-        try new_decl.finalizeNewArena(&new_decl_arena);
-
-        // The generic function Decl is guaranteed to be the first dependency
-        // of each of its instantiations.
-        assert(new_decl.dependencies.keys().len == 0);
-        try mod.declareDeclDependency(new_decl, module_fn.owner_decl);
-
         break :res try sema.finishGenericCall(
             block,
             call_src,
@@ -3478,12 +3480,15 @@ fn zirFunc(
 
     const inst_data = sema.code.instructions.items(.data)[inst].pl_node;
     const extra = sema.code.extraData(Zir.Inst.Func, inst_data.payload_index);
+    var extra_index = extra.end;
+    const ret_ty_body = sema.code.extra[extra_index..][0..extra.data.ret_body_len];
+    extra_index += ret_ty_body.len;
 
     var body_inst: Zir.Inst.Index = 0;
     var src_locs: Zir.Inst.Func.SrcLocs = undefined;
     if (extra.data.body_len != 0) {
         body_inst = inst;
-        const extra_index = extra.end + extra.data.body_len;
+        extra_index += extra.data.body_len;
         src_locs = sema.code.extraData(Zir.Inst.Func.SrcLocs, extra_index).data;
     }
 
@@ -3496,7 +3501,7 @@ fn zirFunc(
         block,
         inst_data.src_node,
         body_inst,
-        extra.data.return_type,
+        ret_ty_body,
         cc,
         Value.initTag(.null_value),
         false,
@@ -3512,7 +3517,7 @@ fn funcCommon(
     block: *Scope.Block,
     src_node_offset: i32,
     body_inst: Zir.Inst.Index,
-    zir_return_type: Zir.Inst.Ref,
+    ret_ty_body: []const Zir.Inst.Index,
     cc: std.builtin.CallingConvention,
     align_val: Value,
     var_args: bool,
@@ -3523,7 +3528,37 @@ fn funcCommon(
 ) CompileError!Air.Inst.Ref {
     const src: LazySrcLoc = .{ .node_offset = src_node_offset };
     const ret_ty_src: LazySrcLoc = .{ .node_offset_fn_type_ret_ty = src_node_offset };
-    const bare_return_type = try sema.resolveType(block, ret_ty_src, zir_return_type);
+
+    // The return type body might be a type expression that depends on generic parameters.
+    // In such case we need to use a generic_poison value for the return type and mark
+    // the function as generic.
+    var is_generic = false;
+    const bare_return_type: Type = ret_ty: {
+        if (ret_ty_body.len == 0) break :ret_ty Type.initTag(.void);
+
+        const err = err: {
+            // Make sure any nested param instructions don't clobber our work.
+            const prev_params = block.params;
+            block.params = .{};
+            defer {
+                block.params.deinit(sema.gpa);
+                block.params = prev_params;
+            }
+            if (sema.resolveBody(block, ret_ty_body)) |ret_ty_inst| {
+                if (sema.analyzeAsType(block, ret_ty_src, ret_ty_inst)) |ret_ty| {
+                    break :ret_ty ret_ty;
+                } else |err| break :err err;
+            } else |err| break :err err;
+        };
+        switch (err) {
+            error.GenericPoison => {
+                // The type is not available until the generic instantiation.
+                is_generic = true;
+                break :ret_ty Type.initTag(.generic_poison);
+            },
+            else => |e| return e,
+        }
+    };
 
     const mod = sema.mod;
 
@@ -3540,8 +3575,9 @@ fn funcCommon(
 
     const fn_ty: Type = fn_ty: {
         // Hot path for some common function types.
-        if (block.params.items.len == 0 and !var_args and align_val.tag() == .null_value and
-            !inferred_error_set)
+        // TODO can we eliminate some of these Type tag values? seems unnecessarily complicated.
+        if (!is_generic and block.params.items.len == 0 and !var_args and
+            align_val.tag() == .null_value and !inferred_error_set)
         {
             if (bare_return_type.zigTypeTag() == .NoReturn and cc == .Unspecified) {
                 break :fn_ty Type.initTag(.fn_noreturn_no_args);
@@ -3560,7 +3596,6 @@ fn funcCommon(
             }
         }
 
-        var is_generic = false;
         const param_types = try sema.arena.alloc(Type, block.params.items.len);
         const comptime_params = try sema.arena.alloc(bool, block.params.items.len);
         for (block.params.items) |param, i| {
@@ -3574,7 +3609,9 @@ fn funcCommon(
             return mod.fail(&block.base, src, "TODO implement support for function prototypes to have alignment specified", .{});
         }
 
-        const return_type = if (!inferred_error_set) bare_return_type else blk: {
+        const return_type = if (!inferred_error_set or bare_return_type.tag() == .generic_poison)
+            bare_return_type
+        else blk: {
             const error_set_ty = try Type.Tag.error_set_inferred.create(sema.arena, .{
                 .func = new_func,
                 .map = .{},
@@ -6944,6 +6981,9 @@ fn zirFuncExtended(
         break :blk align_tv.val;
     } else Value.initTag(.null_value);
 
+    const ret_ty_body = sema.code.extra[extra_index..][0..extra.data.ret_body_len];
+    extra_index += ret_ty_body.len;
+
     var body_inst: Zir.Inst.Index = 0;
     var src_locs: Zir.Inst.Func.SrcLocs = undefined;
     if (extra.data.body_len != 0) {
@@ -6960,7 +7000,7 @@ fn zirFuncExtended(
         block,
         extra.data.src_node,
         body_inst,
-        extra.data.return_type,
+        ret_ty_body,
         cc,
         align_val,
         is_var_args,
diff --git a/src/Zir.zig b/src/Zir.zig
index 862af7b033..094cef3393 100644
--- a/src/Zir.zig
+++ b/src/Zir.zig
@@ -2272,11 +2272,13 @@ pub const Inst = struct {
     /// 0. lib_name: u32, // null terminated string index, if has_lib_name is set
     /// 1. cc: Ref, // if has_cc is set
     /// 2. align: Ref, // if has_align is set
-    /// 3. body: Index // for each body_len
-    /// 4. src_locs: Func.SrcLocs // if body_len != 0
+    /// 3. return_type: Index // for each ret_body_len
+    /// 4. body: Index // for each body_len
+    /// 5. src_locs: Func.SrcLocs // if body_len != 0
     pub const ExtendedFunc = struct {
         src_node: i32,
-        return_type: Ref,
+        /// If this is 0 it means a void return type.
+        ret_body_len: u32,
         /// Points to the block that contains the param instructions for this function.
         param_block: Index,
         body_len: u32,
@@ -2312,10 +2314,12 @@ pub const Inst = struct {
     };
 
     /// Trailing:
-    /// 0. body: Index // for each body_len
-    /// 1. src_locs: SrcLocs // if body_len != 0
+    /// 0. return_type: Index // for each ret_body_len
+    /// 1. body: Index // for each body_len
+    /// 2. src_locs: SrcLocs // if body_len != 0
     pub const Func = struct {
-        return_type: Ref,
+        /// If this is 0 it means a void return type.
+        ret_body_len: u32,
         /// Points to the block that contains the param instructions for this function.
         param_block: Index,
         body_len: u32,
@@ -4344,15 +4348,21 @@ const Writer = struct {
         const inst_data = self.code.instructions.items(.data)[inst].pl_node;
         const src = inst_data.src();
         const extra = self.code.extraData(Inst.Func, inst_data.payload_index);
-        const body = self.code.extra[extra.end..][0..extra.data.body_len];
+        var extra_index = extra.end;
+
+        const ret_ty_body = self.code.extra[extra_index..][0..extra.data.ret_body_len];
+        extra_index += ret_ty_body.len;
+
+        const body = self.code.extra[extra_index..][0..extra.data.body_len];
+        extra_index += body.len;
+
         var src_locs: Zir.Inst.Func.SrcLocs = undefined;
         if (body.len != 0) {
-            const extra_index = extra.end + body.len;
             src_locs = self.code.extraData(Zir.Inst.Func.SrcLocs, extra_index).data;
         }
         return self.writeFuncCommon(
             stream,
-            extra.data.return_type,
+            ret_ty_body,
             inferred_error_set,
             false,
             false,
@@ -4387,6 +4397,9 @@ const Writer = struct {
             break :blk align_inst;
         };
 
+        const ret_ty_body = self.code.extra[extra_index..][0..extra.data.ret_body_len];
+        extra_index += ret_ty_body.len;
+
         const body = self.code.extra[extra_index..][0..extra.data.body_len];
         extra_index += body.len;
 
@@ -4396,7 +4409,7 @@ const Writer = struct {
         }
         return self.writeFuncCommon(
             stream,
-            extra.data.return_type,
+            ret_ty_body,
             small.is_inferred_error,
             small.is_var_args,
             small.is_extern,
@@ -4478,7 +4491,7 @@ const Writer = struct {
     fn writeFuncCommon(
         self: *Writer,
         stream: anytype,
-        ret_ty: Inst.Ref,
+        ret_ty_body: []const Inst.Index,
         inferred_error_set: bool,
         var_args: bool,
         is_extern: bool,
@@ -4488,7 +4501,13 @@ const Writer = struct {
         src: LazySrcLoc,
         src_locs: Zir.Inst.Func.SrcLocs,
     ) !void {
-        try self.writeInstRef(stream, ret_ty);
+        try stream.writeAll("ret_ty={\n");
+        self.indent += 2;
+        try self.writeBody(stream, ret_ty_body);
+        self.indent -= 2;
+        try stream.writeByteNTimes(' ', self.indent);
+        try stream.writeAll("}");
+
         try self.writeOptionalInstRef(stream, ", cc=", cc);
         try self.writeOptionalInstRef(stream, ", align=", align_inst);
         try self.writeFlag(stream, ", vargs", var_args);
@@ -4496,9 +4515,9 @@ const Writer = struct {
         try self.writeFlag(stream, ", inferror", inferred_error_set);
 
         if (body.len == 0) {
-            try stream.writeAll(", {}) ");
+            try stream.writeAll(", body={}) ");
         } else {
-            try stream.writeAll(", {\n");
+            try stream.writeAll(", body={\n");
             self.indent += 2;
             try self.writeBody(stream, body);
             self.indent -= 2;
@@ -4932,6 +4951,7 @@ fn findDeclsBody(
 
 pub const FnInfo = struct {
     param_body: []const Inst.Index,
+    ret_ty_body: []const Inst.Index,
     body: []const Inst.Index,
     total_params_len: u32,
 };
@@ -4942,13 +4962,22 @@ pub fn getFnInfo(zir: Zir, fn_inst: Inst.Index) FnInfo {
     const info: struct {
         param_block: Inst.Index,
         body: []const Inst.Index,
+        ret_ty_body: []const Inst.Index,
     } = switch (tags[fn_inst]) {
         .func, .func_inferred => blk: {
             const inst_data = datas[fn_inst].pl_node;
             const extra = zir.extraData(Inst.Func, inst_data.payload_index);
-            const body = zir.extra[extra.end..][0..extra.data.body_len];
+            var extra_index: usize = extra.end;
+
+            const ret_ty_body = zir.extra[extra_index..][0..extra.data.ret_body_len];
+            extra_index += ret_ty_body.len;
+
+            const body = zir.extra[extra_index..][0..extra.data.body_len];
+            extra_index += body.len;
+
             break :blk .{
                 .param_block = extra.data.param_block,
+                .ret_ty_body = ret_ty_body,
                 .body = body,
             };
         },
@@ -4961,9 +4990,13 @@ pub fn getFnInfo(zir: Zir, fn_inst: Inst.Index) FnInfo {
             extra_index += @boolToInt(small.has_lib_name);
             extra_index += @boolToInt(small.has_cc);
             extra_index += @boolToInt(small.has_align);
+            const ret_ty_body = zir.extra[extra_index..][0..extra.data.ret_body_len];
+            extra_index += ret_ty_body.len;
             const body = zir.extra[extra_index..][0..extra.data.body_len];
+            extra_index += body.len;
             break :blk .{
                 .param_block = extra.data.param_block,
+                .ret_ty_body = ret_ty_body,
                 .body = body,
             };
         },
@@ -4983,6 +5016,7 @@ pub fn getFnInfo(zir: Zir, fn_inst: Inst.Index) FnInfo {
     }
     return .{
         .param_body = param_body,
+        .ret_ty_body = info.ret_ty_body,
         .body = info.body,
         .total_params_len = total_params_len,
     };
diff --git a/src/codegen/llvm.zig b/src/codegen/llvm.zig
index 0e73469687..91b48ffcfb 100644
--- a/src/codegen/llvm.zig
+++ b/src/codegen/llvm.zig
@@ -575,6 +575,14 @@ pub const DeclGen = struct {
                 const info = t.intInfo(self.module.getTarget());
                 return self.context.intType(info.bits);
             },
+            .Float => switch (t.floatBits(self.module.getTarget())) {
+                16 => return self.context.halfType(),
+                32 => return self.context.floatType(),
+                64 => return self.context.doubleType(),
+                80 => return self.context.x86FP80Type(),
+                128 => return self.context.fp128Type(),
+                else => unreachable,
+            },
             .Bool => return self.context.intType(1),
             .Pointer => {
                 if (t.isSlice()) {
@@ -661,7 +669,6 @@ pub const DeclGen = struct {
 
             .BoundFn => @panic("TODO remove BoundFn from the language"),
 
-            .Float,
             .Enum,
             .Union,
             .Opaque,
@@ -699,6 +706,13 @@ pub const DeclGen = struct {
                 }
                 return llvm_int;
             },
+            .Float => {
+                if (tv.ty.floatBits(self.module.getTarget()) <= 64) {
+                    const llvm_ty = try self.llvmType(tv.ty);
+                    return llvm_ty.constReal(tv.val.toFloat(f64));
+                }
+                return self.todo("bitcast to f128 from an integer", .{});
+            },
             .Pointer => switch (tv.val.tag()) {
                 .decl_ref => {
                     if (tv.ty.isSlice()) {
diff --git a/src/codegen/llvm/bindings.zig b/src/codegen/llvm/bindings.zig
index 4af3cadd84..675c5539fb 100644
--- a/src/codegen/llvm/bindings.zig
+++ b/src/codegen/llvm/bindings.zig
@@ -31,6 +31,21 @@ pub const Context = opaque {
     pub const intType = LLVMIntTypeInContext;
     extern fn LLVMIntTypeInContext(C: *const Context, NumBits: c_uint) *const Type;
 
+    pub const halfType = LLVMHalfTypeInContext;
+    extern fn LLVMHalfTypeInContext(C: *const Context) *const Type;
+
+    pub const floatType = LLVMFloatTypeInContext;
+    extern fn LLVMFloatTypeInContext(C: *const Context) *const Type;
+
+    pub const doubleType = LLVMDoubleTypeInContext;
+    extern fn LLVMDoubleTypeInContext(C: *const Context) *const Type;
+
+    pub const x86FP80Type = LLVMX86FP80TypeInContext;
+    extern fn LLVMX86FP80TypeInContext(C: *const Context) *const Type;
+
+    pub const fp128Type = LLVMFP128TypeInContext;
+    extern fn LLVMFP128TypeInContext(C: *const Context) *const Type;
+
     pub const voidType = LLVMVoidTypeInContext;
     extern fn LLVMVoidTypeInContext(C: *const Context) *const Type;
 
@@ -127,6 +142,9 @@ pub const Type = opaque {
     pub const constInt = LLVMConstInt;
     extern fn LLVMConstInt(IntTy: *const Type, N: c_ulonglong, SignExtend: Bool) *const Value;
 
+    pub const constReal = LLVMConstReal;
+    extern fn LLVMConstReal(RealTy: *const Type, N: f64) *const Value;
+
     pub const constArray = LLVMConstArray;
     extern fn LLVMConstArray(ElementTy: *const Type, ConstantVals: [*]*const Value, Length: c_uint) *const Value;
 
diff --git a/src/print_air.zig b/src/print_air.zig
index 00317b26e8..11f2982fc3 100644
--- a/src/print_air.zig
+++ b/src/print_air.zig
@@ -222,7 +222,7 @@ const Writer = struct {
         const extra = w.air.extraData(Air.Block, ty_pl.payload);
         const body = w.air.extra[extra.end..][0..extra.data.body_len];
 
-        try s.writeAll("{\n");
+        try s.print("{}, {{\n", .{w.air.getRefType(ty_pl.ty)});
         const old_indent = w.indent;
         w.indent += 2;
         try w.writeBody(s, body);
diff --git a/test/behavior/generics.zig b/test/behavior/generics.zig
index e3fed907df..a3c5668b39 100644
--- a/test/behavior/generics.zig
+++ b/test/behavior/generics.zig
@@ -1,4 +1,5 @@
 const std = @import("std");
+const builtin = @import("builtin");
 const testing = std.testing;
 const expect = testing.expect;
 const expectEqual = testing.expectEqual;
@@ -14,3 +15,58 @@ test "one param, explicit comptime" {
 fn checkSize(comptime T: type) usize {
     return @sizeOf(T);
 }
+
+test "simple generic fn" {
+    try expect(max(i32, 3, -1) == 3);
+    try expect(max(u8, 1, 100) == 100);
+    if (!builtin.zig_is_stage2) {
+        // TODO: stage2 is incorrectly emitting the following:
+        // error: cast of value 1.23e-01 to type 'f32' loses information
+        try expect(max(f32, 0.123, 0.456) == 0.456);
+    }
+    try expect(add(2, 3) == 5);
+}
+
+fn max(comptime T: type, a: T, b: T) T {
+    if (!builtin.zig_is_stage2) {
+        // TODO: stage2 is incorrectly emitting AIR that allocates a result
+        // value, stores to it, but then returns void instead of the result.
+        return if (a > b) a else b;
+    }
+    if (a > b) {
+        return a;
+    } else {
+        return b;
+    }
+}
+
+fn add(comptime a: i32, b: i32) i32 {
+    return (comptime a) + b;
+}
+
+const the_max = max(u32, 1234, 5678);
+test "compile time generic eval" {
+    try expect(the_max == 5678);
+}
+
+fn gimmeTheBigOne(a: u32, b: u32) u32 {
+    return max(u32, a, b);
+}
+
+fn shouldCallSameInstance(a: u32, b: u32) u32 {
+    return max(u32, a, b);
+}
+
+fn sameButWithFloats(a: f64, b: f64) f64 {
+    return max(f64, a, b);
+}
+
+test "fn with comptime args" {
+    try expect(gimmeTheBigOne(1234, 5678) == 5678);
+    try expect(shouldCallSameInstance(34, 12) == 34);
+    if (!builtin.zig_is_stage2) {
+        // TODO: stage2 llvm backend needs to use fcmp instead of icmp
+        // probably AIR should just have different instructions for floats.
+        try expect(sameButWithFloats(0.43, 0.49) == 0.49);
+    }
+}
diff --git a/test/behavior/generics_stage1.zig b/test/behavior/generics_stage1.zig
index 104752607a..c9f274c7c1 100644
--- a/test/behavior/generics_stage1.zig
+++ b/test/behavior/generics_stage1.zig
@@ -3,44 +3,7 @@ const testing = std.testing;
 const expect = testing.expect;
 const expectEqual = testing.expectEqual;
 
-test "simple generic fn" {
-    try expect(max(i32, 3, -1) == 3);
-    try expect(max(f32, 0.123, 0.456) == 0.456);
-    try expect(add(2, 3) == 5);
-}
-
-fn max(comptime T: type, a: T, b: T) T {
-    return if (a > b) a else b;
-}
-
-fn add(comptime a: i32, b: i32) i32 {
-    return (comptime a) + b;
-}
-
-const the_max = max(u32, 1234, 5678);
-test "compile time generic eval" {
-    try expect(the_max == 5678);
-}
-
-fn gimmeTheBigOne(a: u32, b: u32) u32 {
-    return max(u32, a, b);
-}
-
-fn shouldCallSameInstance(a: u32, b: u32) u32 {
-    return max(u32, a, b);
-}
-
-fn sameButWithFloats(a: f64, b: f64) f64 {
-    return max(f64, a, b);
-}
-
-test "fn with comptime args" {
-    try expect(gimmeTheBigOne(1234, 5678) == 5678);
-    try expect(shouldCallSameInstance(34, 12) == 34);
-    try expect(sameButWithFloats(0.43, 0.49) == 0.49);
-}
-
-test "var params" {
+test "anytype params" {
     try expect(max_i32(12, 34) == 34);
     try expect(max_f64(1.2, 3.4) == 3.4);
 }

From fdd97244fda948e0033034aba8042c8fdfb5d484 Mon Sep 17 00:00:00 2001
From: Chris Gregory <czipperz@gmail.com>
Date: Tue, 3 Aug 2021 22:49:10 -0700
Subject: [PATCH 81/96] Make DynamicBitSet.iterator take self as const

---
 lib/std/bit_set.zig | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/std/bit_set.zig b/lib/std/bit_set.zig
index f7339bfdcf..261c6af2df 100644
--- a/lib/std/bit_set.zig
+++ b/lib/std/bit_set.zig
@@ -872,7 +872,7 @@ pub const DynamicBitSet = struct {
     /// ascending order.  Modifications to the underlying bit set may
     /// or may not be observed by the iterator.  Resizing the underlying
     /// bit set invalidates the iterator.
-    pub fn iterator(self: *Self, comptime options: IteratorOptions) Iterator(options) {
+    pub fn iterator(self: *const Self, comptime options: IteratorOptions) Iterator(options) {
         return self.unmanaged.iterator(options);
     }
 

From 9fd3aeb8088cd9a3b0744d5f508ca256a2bbf19f Mon Sep 17 00:00:00 2001
From: Evan Haas <evan@lagerdata.com>
Date: Mon, 2 Aug 2021 22:44:20 -0700
Subject: [PATCH 82/96] translate-c: handle macros that cast to cv void

Fixes #9507
---
 lib/std/zig/c_translation.zig        |  4 ++++
 src/translate_c.zig                  | 21 +++++++++++++++++++++
 test/behavior/translate_c_macros.h   | 12 ++++++++++++
 test/behavior/translate_c_macros.zig | 13 +++++++++++++
 4 files changed, 50 insertions(+)

diff --git a/lib/std/zig/c_translation.zig b/lib/std/zig/c_translation.zig
index bcf3b310ea..7b21fba93a 100644
--- a/lib/std/zig/c_translation.zig
+++ b/lib/std/zig/c_translation.zig
@@ -404,6 +404,10 @@ pub const Macros = struct {
             else => unreachable, // return type will be a compile error otherwise
         }
     }
+
+    pub inline fn DISCARD(x: anytype) void {
+        _ = x;
+    }
 };
 
 test "Macro suffix functions" {
diff --git a/src/translate_c.zig b/src/translate_c.zig
index e6d6392a9c..e11fc5b736 100644
--- a/src/translate_c.zig
+++ b/src/translate_c.zig
@@ -4978,6 +4978,17 @@ const PatternList = struct {
             ,
             "WL_CONTAINER_OF",
         },
+
+        [2][]const u8{ "IGNORE_ME(X) ((void)(X))", "DISCARD" },
+        [2][]const u8{ "IGNORE_ME(X) (void)(X)", "DISCARD" },
+        [2][]const u8{ "IGNORE_ME(X) ((const void)(X))", "DISCARD" },
+        [2][]const u8{ "IGNORE_ME(X) (const void)(X)", "DISCARD" },
+        [2][]const u8{ "IGNORE_ME(X) ((volatile void)(X))", "DISCARD" },
+        [2][]const u8{ "IGNORE_ME(X) (volatile void)(X)", "DISCARD" },
+        [2][]const u8{ "IGNORE_ME(X) ((const volatile void)(X))", "DISCARD" },
+        [2][]const u8{ "IGNORE_ME(X) (const volatile void)(X)", "DISCARD" },
+        [2][]const u8{ "IGNORE_ME(X) ((volatile const void)(X))", "DISCARD" },
+        [2][]const u8{ "IGNORE_ME(X) (volatile const void)(X)", "DISCARD" },
     };
 
     /// Assumes that `ms` represents a tokenized function-like macro.
@@ -5152,6 +5163,16 @@ test "Macro matching" {
 
     try helper.checkMacro(allocator, pattern_list, "NO_MATCH(X, Y) (X + Y)", null);
     try helper.checkMacro(allocator, pattern_list, "CAST_OR_CALL(X, Y) (X)(Y)", "CAST_OR_CALL");
+    try helper.checkMacro(allocator, pattern_list, "IGNORE_ME(X) (void)(X)", "DISCARD");
+    try helper.checkMacro(allocator, pattern_list, "IGNORE_ME(X) ((void)(X))", "DISCARD");
+    try helper.checkMacro(allocator, pattern_list, "IGNORE_ME(X) (const void)(X)", "DISCARD");
+    try helper.checkMacro(allocator, pattern_list, "IGNORE_ME(X) ((const void)(X))", "DISCARD");
+    try helper.checkMacro(allocator, pattern_list, "IGNORE_ME(X) (volatile void)(X)", "DISCARD");
+    try helper.checkMacro(allocator, pattern_list, "IGNORE_ME(X) ((volatile void)(X))", "DISCARD");
+    try helper.checkMacro(allocator, pattern_list, "IGNORE_ME(X) (const volatile void)(X)", "DISCARD");
+    try helper.checkMacro(allocator, pattern_list, "IGNORE_ME(X) ((const volatile void)(X))", "DISCARD");
+    try helper.checkMacro(allocator, pattern_list, "IGNORE_ME(X) (volatile const void)(X)", "DISCARD");
+    try helper.checkMacro(allocator, pattern_list, "IGNORE_ME(X) ((volatile const void)(X))", "DISCARD");
 }
 
 const MacroCtx = struct {
diff --git a/test/behavior/translate_c_macros.h b/test/behavior/translate_c_macros.h
index 6f458684c7..bff4cdfe23 100644
--- a/test/behavior/translate_c_macros.h
+++ b/test/behavior/translate_c_macros.h
@@ -18,3 +18,15 @@ struct Foo {
 #define SIZE_OF_FOO sizeof(struct Foo)
 
 #define MAP_FAILED	((void *) -1)
+
+#define IGNORE_ME_1(x) ((void)(x))
+#define IGNORE_ME_2(x) ((const void)(x))
+#define IGNORE_ME_3(x) ((volatile void)(x))
+#define IGNORE_ME_4(x) ((const volatile void)(x))
+#define IGNORE_ME_5(x) ((volatile const void)(x))
+
+#define IGNORE_ME_6(x) (void)(x)
+#define IGNORE_ME_7(x) (const void)(x)
+#define IGNORE_ME_8(x) (volatile void)(x)
+#define IGNORE_ME_9(x) (const volatile void)(x)
+#define IGNORE_ME_10(x) (volatile const void)(x)
diff --git a/test/behavior/translate_c_macros.zig b/test/behavior/translate_c_macros.zig
index 8de06ae8ea..0daf4cec90 100644
--- a/test/behavior/translate_c_macros.zig
+++ b/test/behavior/translate_c_macros.zig
@@ -24,3 +24,16 @@ test "reference to a struct type" {
 test "cast negative integer to pointer" {
     try expectEqual(@intToPtr(?*c_void, @bitCast(usize, @as(isize, -1))), h.MAP_FAILED);
 }
+
+test "casting to void with a macro" {
+    h.IGNORE_ME_1(42);
+    h.IGNORE_ME_2(42);
+    h.IGNORE_ME_3(42);
+    h.IGNORE_ME_4(42);
+    h.IGNORE_ME_5(42);
+    h.IGNORE_ME_6(42);
+    h.IGNORE_ME_7(42);
+    h.IGNORE_ME_8(42);
+    h.IGNORE_ME_9(42);
+    h.IGNORE_ME_10(42);
+}

From 47f2463b5c784cb7be9593f56e6b89805dbb8f06 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Thu, 5 Aug 2021 23:17:29 -0700
Subject: [PATCH 83/96] std.HashMap: fix getPtrAdapted. AstGen: fix fn param
 iteration

There was a bug in stage2 regarding iteration of function parameter AST.
This resulted in a false negative "unused parameter" compile error,
which, when fixed, revealed a bug in the std lib HashMap implementation.
---
 lib/std/hash_map.zig | 2 +-
 lib/std/zig/ast.zig  | 3 +++
 2 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/lib/std/hash_map.zig b/lib/std/hash_map.zig
index ef97e7d7fa..77d2df2efe 100644
--- a/lib/std/hash_map.zig
+++ b/lib/std/hash_map.zig
@@ -563,7 +563,7 @@ pub fn HashMap(
             return self.unmanaged.getPtrContext(key, self.ctx);
         }
         pub fn getPtrAdapted(self: Self, key: anytype, ctx: anytype) ?*V {
-            return self.unmanaged.getPtrAdapted(key, self.ctx);
+            return self.unmanaged.getPtrAdapted(key, ctx);
         }
 
         /// Finds the key and value associated with a key in the map
diff --git a/lib/std/zig/ast.zig b/lib/std/zig/ast.zig
index abcb29f8b5..61969d9699 100644
--- a/lib/std/zig/ast.zig
+++ b/lib/std/zig/ast.zig
@@ -2198,6 +2198,9 @@ pub const full = struct {
                             .type_expr = param_type,
                         };
                     }
+                    if (token_tags[it.tok_i] == .comma) {
+                        it.tok_i += 1;
+                    }
                     if (token_tags[it.tok_i] == .r_paren) {
                         return null;
                     }

From 786e238a7f1034a09bc0471b3796051abb874e14 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Thu, 5 Aug 2021 23:20:10 -0700
Subject: [PATCH 84/96] AstGen: fix function declarations

They were putting their return type expressions into the wrong ZIR
block, resulting in a compiler crash.
---
 src/AstGen.zig | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/AstGen.zig b/src/AstGen.zig
index febe581e35..1b6cbc6c3f 100644
--- a/src/AstGen.zig
+++ b/src/AstGen.zig
@@ -3004,9 +3004,9 @@ fn fnDecl(
         break :inst try comptimeExpr(&decl_gz, params_scope, .{ .ty = .const_slice_u8_type }, fn_proto.ast.section_expr);
     };
 
-    var ret_gz = gz.makeSubBlock(params_scope);
+    var ret_gz = decl_gz.makeSubBlock(params_scope);
     defer ret_gz.instructions.deinit(gpa);
-    const ret_ty = try expr(&decl_gz, params_scope, coerced_type_rl, fn_proto.ast.return_type);
+    const ret_ty = try expr(&ret_gz, params_scope, coerced_type_rl, fn_proto.ast.return_type);
     const ret_br = try ret_gz.addBreak(.break_inline, 0, ret_ty);
 
     const cc: Zir.Inst.Ref = blk: {

From c7dc451a2a06a0ade0bb44a48cb6e5cde6e237df Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Thu, 5 Aug 2021 23:20:53 -0700
Subject: [PATCH 85/96] stage2: more debuggable panics

For now these errors are handled via `@panic` rather than `unreachable`.
These are relatively likely bugs to occur at this early stage of
development, and handling them as panics lets us ship release builds
of the compiler without worrying about undefined behavior.

Furthermore, in stage1, `@panic` is implemented to include an error
return trace, while `unreachable` is not. In this case, the error return
traces are extremely helpful in debugging the compiler.
---
 src/Module.zig | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/Module.zig b/src/Module.zig
index da11bc1c3c..a694f775da 100644
--- a/src/Module.zig
+++ b/src/Module.zig
@@ -3792,8 +3792,8 @@ pub fn analyzeFnBody(mod: *Module, decl: *Decl, func: *Fn) SemaError!Air {
     log.debug("set {s} to in_progress", .{decl.name});
 
     _ = sema.analyzeBody(&inner_block, fn_info.body) catch |err| switch (err) {
-        error.NeededSourceLocation => unreachable,
-        error.GenericPoison => unreachable,
+        error.NeededSourceLocation => @panic("zig compiler bug: NeededSourceLocation"),
+        error.GenericPoison => @panic("zig compiler bug: GenericPoison"),
         else => |e| return e,
     };
 

From 7e9b23e6dce4d87615acd635f3731731a8601d39 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Thu, 5 Aug 2021 23:23:05 -0700
Subject: [PATCH 86/96] Sema: respect requiresComptime of function return types

When doing a function call, if the return type requires comptime, the
function is analyzed as an inline/comptime call.

There is an important TODO here. I will reproduce the comment from this
commit:

> In the case of a comptime/inline function call of a generic function,
> the function return type needs to be the resolved return type based on
> the function parameter type expressions being evaluated with comptime arguments
> passed in. Otherwise, it ends up being .generic_poison and failing the
> comptime/inline function call analysis.
---
 src/Sema.zig                      | 27 ++++++++++++++++++---------
 src/Zir.zig                       | 16 ++++++++++------
 src/type.zig                      | 14 ++++++++++----
 test/behavior/generics_stage1.zig |  6 +++---
 4 files changed, 41 insertions(+), 22 deletions(-)

diff --git a/src/Sema.zig b/src/Sema.zig
index 73f22aa845..825737e4c5 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -2461,7 +2461,8 @@ fn analyzeCall(
 
     const gpa = sema.gpa;
 
-    const is_comptime_call = block.is_comptime or modifier == .compile_time;
+    const is_comptime_call = block.is_comptime or modifier == .compile_time or
+        func_ty_info.return_type.requiresComptime();
     const is_inline_call = is_comptime_call or modifier == .always_inline or
         func_ty_info.cc == .Inline;
     const result: Air.Inst.Ref = if (is_inline_call) res: {
@@ -3609,6 +3610,8 @@ fn funcCommon(
             return mod.fail(&block.base, src, "TODO implement support for function prototypes to have alignment specified", .{});
         }
 
+        is_generic = is_generic or bare_return_type.requiresComptime();
+
         const return_type = if (!inferred_error_set or bare_return_type.tag() == .generic_poison)
             bare_return_type
         else blk: {
@@ -5334,18 +5337,18 @@ fn analyzeArithmetic(
 ) CompileError!Air.Inst.Ref {
     const lhs_ty = sema.typeOf(lhs);
     const rhs_ty = sema.typeOf(rhs);
-    if (lhs_ty.zigTypeTag() == .Vector and rhs_ty.zigTypeTag() == .Vector) {
+    const lhs_zig_ty_tag = try lhs_ty.zigTypeTagOrPoison();
+    const rhs_zig_ty_tag = try rhs_ty.zigTypeTagOrPoison();
+    if (lhs_zig_ty_tag == .Vector and rhs_zig_ty_tag == .Vector) {
         if (lhs_ty.arrayLen() != rhs_ty.arrayLen()) {
             return sema.mod.fail(&block.base, src, "vector length mismatch: {d} and {d}", .{
-                lhs_ty.arrayLen(),
-                rhs_ty.arrayLen(),
+                lhs_ty.arrayLen(), rhs_ty.arrayLen(),
             });
         }
         return sema.mod.fail(&block.base, src, "TODO implement support for vectors in zirBinOp", .{});
-    } else if (lhs_ty.zigTypeTag() == .Vector or rhs_ty.zigTypeTag() == .Vector) {
+    } else if (lhs_zig_ty_tag == .Vector or rhs_zig_ty_tag == .Vector) {
         return sema.mod.fail(&block.base, src, "mixed scalar and vector operands to binary expression: '{}' and '{}'", .{
-            lhs_ty,
-            rhs_ty,
+            lhs_ty, rhs_ty,
         });
     }
 
@@ -5365,7 +5368,9 @@ fn analyzeArithmetic(
     const is_float = scalar_tag == .Float or scalar_tag == .ComptimeFloat;
 
     if (!is_int and !(is_float and floatOpAllowed(zir_tag))) {
-        return sema.mod.fail(&block.base, src, "invalid operands to binary expression: '{s}' and '{s}'", .{ @tagName(lhs_ty.zigTypeTag()), @tagName(rhs_ty.zigTypeTag()) });
+        return sema.mod.fail(&block.base, src, "invalid operands to binary expression: '{s}' and '{s}'", .{
+            @tagName(lhs_zig_ty_tag), @tagName(rhs_zig_ty_tag),
+        });
     }
 
     if (try sema.resolveMaybeUndefVal(block, lhs_src, casted_lhs)) |lhs_val| {
@@ -6164,6 +6169,10 @@ fn analyzeRet(
     const casted_operand = if (!need_coercion) operand else op: {
         const func = sema.func.?;
         const fn_ty = func.owner_decl.ty;
+        // TODO: In the case of a comptime/inline function call of a generic function,
+        // this needs to be the resolved return type based on the function parameter type
+        // expressions being evaluated with comptime arguments passed in. Otherwise, this
+        // ends up being .generic_poison and failing the comptime/inline function call analysis.
         const fn_ret_ty = fn_ty.fnReturnType();
         break :op try sema.coerce(block, fn_ret_ty, operand, src);
     };
@@ -9093,7 +9102,7 @@ fn typeHasOnePossibleValue(
 
         .inferred_alloc_const => unreachable,
         .inferred_alloc_mut => unreachable,
-        .generic_poison => unreachable,
+        .generic_poison => return error.GenericPoison,
     };
 }
 
diff --git a/src/Zir.zig b/src/Zir.zig
index 094cef3393..97a7c06273 100644
--- a/src/Zir.zig
+++ b/src/Zir.zig
@@ -4501,12 +4501,16 @@ const Writer = struct {
         src: LazySrcLoc,
         src_locs: Zir.Inst.Func.SrcLocs,
     ) !void {
-        try stream.writeAll("ret_ty={\n");
-        self.indent += 2;
-        try self.writeBody(stream, ret_ty_body);
-        self.indent -= 2;
-        try stream.writeByteNTimes(' ', self.indent);
-        try stream.writeAll("}");
+        if (ret_ty_body.len == 0) {
+            try stream.writeAll("ret_ty=void");
+        } else {
+            try stream.writeAll("ret_ty={\n");
+            self.indent += 2;
+            try self.writeBody(stream, ret_ty_body);
+            self.indent -= 2;
+            try stream.writeByteNTimes(' ', self.indent);
+            try stream.writeAll("}");
+        }
 
         try self.writeOptionalInstRef(stream, ", cc=", cc);
         try self.writeOptionalInstRef(stream, ", align=", align_inst);
diff --git a/src/type.zig b/src/type.zig
index 180fb92bf0..02b9fabe71 100644
--- a/src/type.zig
+++ b/src/type.zig
@@ -21,8 +21,14 @@ pub const Type = extern union {
     tag_if_small_enough: usize,
     ptr_otherwise: *Payload,
 
-    pub fn zigTypeTag(self: Type) std.builtin.TypeId {
-        switch (self.tag()) {
+    pub fn zigTypeTag(ty: Type) std.builtin.TypeId {
+        return ty.zigTypeTagOrPoison() catch unreachable;
+    }
+
+    pub fn zigTypeTagOrPoison(ty: Type) error{GenericPoison}!std.builtin.TypeId {
+        switch (ty.tag()) {
+            .generic_poison => return error.GenericPoison,
+
             .u1,
             .u8,
             .i8,
@@ -130,7 +136,6 @@ pub const Type = extern union {
             => return .Union,
 
             .var_args_param => unreachable, // can be any type
-            .generic_poison => unreachable, // must be handled earlier
         }
     }
 
@@ -1096,6 +1101,7 @@ pub const Type = extern union {
     }
 
     /// Anything that reports hasCodeGenBits() false returns false here as well.
+    /// `generic_poison` will return false.
     pub fn requiresComptime(ty: Type) bool {
         return switch (ty.tag()) {
             .u1,
@@ -1156,6 +1162,7 @@ pub const Type = extern union {
             .error_set_single,
             .error_set_inferred,
             .@"opaque",
+            .generic_poison,
             => false,
 
             .type,
@@ -1167,7 +1174,6 @@ pub const Type = extern union {
             .var_args_param => unreachable,
             .inferred_alloc_mut => unreachable,
             .inferred_alloc_const => unreachable,
-            .generic_poison => unreachable,
 
             .array_u8,
             .array_u8_sentinel_0,
diff --git a/test/behavior/generics_stage1.zig b/test/behavior/generics_stage1.zig
index c9f274c7c1..7ee263b1b9 100644
--- a/test/behavior/generics_stage1.zig
+++ b/test/behavior/generics_stage1.zig
@@ -13,16 +13,16 @@ test {
     comptime try expect(max_f64(1.2, 3.4) == 3.4);
 }
 
-fn max_var(a: anytype, b: anytype) @TypeOf(a + b) {
+fn max_anytype(a: anytype, b: anytype) @TypeOf(a + b) {
     return if (a > b) a else b;
 }
 
 fn max_i32(a: i32, b: i32) i32 {
-    return max_var(a, b);
+    return max_anytype(a, b);
 }
 
 fn max_f64(a: f64, b: f64) f64 {
-    return max_var(a, b);
+    return max_anytype(a, b);
 }
 
 pub fn List(comptime T: type) type {

From 05fd20dc104b3654ce9c5d7a22a2bff66a940dba Mon Sep 17 00:00:00 2001
From: Ryan Liptak <squeek502@hotmail.com>
Date: Fri, 6 Aug 2021 01:53:07 -0700
Subject: [PATCH 87/96] Make mem.split and mem.tokenize generic instead of
 assuming u8

This allows these functions to work on slices of u16, etc
---
 lib/std/mem.zig | 208 +++++++++++++++++++++++++++++-------------------
 1 file changed, 128 insertions(+), 80 deletions(-)

diff --git a/lib/std/mem.zig b/lib/std/mem.zig
index 75cb4dd9d0..93d425b692 100644
--- a/lib/std/mem.zig
+++ b/lib/std/mem.zig
@@ -1575,8 +1575,8 @@ test "bswapAllFields" {
 /// If `delimiter_bytes` does not exist in buffer,
 /// the iterator will return `buffer`, null, in that order.
 /// See also the related function `split`.
-pub fn tokenize(buffer: []const u8, delimiter_bytes: []const u8) TokenIterator {
-    return TokenIterator{
+pub fn tokenize(comptime T: type, buffer: []const T, delimiter_bytes: []const T) TokenIterator(T) {
+    return .{
         .index = 0,
         .buffer = buffer,
         .delimiter_bytes = delimiter_bytes,
@@ -1584,51 +1584,71 @@ pub fn tokenize(buffer: []const u8, delimiter_bytes: []const u8) TokenIterator {
 }
 
 test "mem.tokenize" {
-    var it = tokenize("   abc def   ghi  ", " ");
+    var it = tokenize(u8, "   abc def   ghi  ", " ");
     try testing.expect(eql(u8, it.next().?, "abc"));
     try testing.expect(eql(u8, it.next().?, "def"));
     try testing.expect(eql(u8, it.next().?, "ghi"));
     try testing.expect(it.next() == null);
 
-    it = tokenize("..\\bob", "\\");
+    it = tokenize(u8, "..\\bob", "\\");
     try testing.expect(eql(u8, it.next().?, ".."));
     try testing.expect(eql(u8, "..", "..\\bob"[0..it.index]));
     try testing.expect(eql(u8, it.next().?, "bob"));
     try testing.expect(it.next() == null);
 
-    it = tokenize("//a/b", "/");
+    it = tokenize(u8, "//a/b", "/");
     try testing.expect(eql(u8, it.next().?, "a"));
     try testing.expect(eql(u8, it.next().?, "b"));
     try testing.expect(eql(u8, "//a/b", "//a/b"[0..it.index]));
     try testing.expect(it.next() == null);
 
-    it = tokenize("|", "|");
+    it = tokenize(u8, "|", "|");
     try testing.expect(it.next() == null);
 
-    it = tokenize("", "|");
+    it = tokenize(u8, "", "|");
     try testing.expect(it.next() == null);
 
-    it = tokenize("hello", "");
+    it = tokenize(u8, "hello", "");
     try testing.expect(eql(u8, it.next().?, "hello"));
     try testing.expect(it.next() == null);
 
-    it = tokenize("hello", " ");
+    it = tokenize(u8, "hello", " ");
     try testing.expect(eql(u8, it.next().?, "hello"));
     try testing.expect(it.next() == null);
+
+    var it16 = tokenize(
+        u16,
+        std.unicode.utf8ToUtf16LeStringLiteral("hello"),
+        std.unicode.utf8ToUtf16LeStringLiteral(" "),
+    );
+    try testing.expect(eql(u16, it16.next().?, std.unicode.utf8ToUtf16LeStringLiteral("hello")));
+    try testing.expect(it16.next() == null);
 }
 
 test "mem.tokenize (multibyte)" {
-    var it = tokenize("a|b,c/d e", " /,|");
+    var it = tokenize(u8, "a|b,c/d e", " /,|");
     try testing.expect(eql(u8, it.next().?, "a"));
     try testing.expect(eql(u8, it.next().?, "b"));
     try testing.expect(eql(u8, it.next().?, "c"));
     try testing.expect(eql(u8, it.next().?, "d"));
     try testing.expect(eql(u8, it.next().?, "e"));
     try testing.expect(it.next() == null);
+
+    var it16 = tokenize(
+        u16,
+        std.unicode.utf8ToUtf16LeStringLiteral("a|b,c/d e"),
+        std.unicode.utf8ToUtf16LeStringLiteral(" /,|"),
+    );
+    try testing.expect(eql(u16, it16.next().?, std.unicode.utf8ToUtf16LeStringLiteral("a")));
+    try testing.expect(eql(u16, it16.next().?, std.unicode.utf8ToUtf16LeStringLiteral("b")));
+    try testing.expect(eql(u16, it16.next().?, std.unicode.utf8ToUtf16LeStringLiteral("c")));
+    try testing.expect(eql(u16, it16.next().?, std.unicode.utf8ToUtf16LeStringLiteral("d")));
+    try testing.expect(eql(u16, it16.next().?, std.unicode.utf8ToUtf16LeStringLiteral("e")));
+    try testing.expect(it16.next() == null);
 }
 
 test "mem.tokenize (reset)" {
-    var it = tokenize("   abc def   ghi  ", " ");
+    var it = tokenize(u8, "   abc def   ghi  ", " ");
     try testing.expect(eql(u8, it.next().?, "abc"));
     try testing.expect(eql(u8, it.next().?, "def"));
     try testing.expect(eql(u8, it.next().?, "ghi"));
@@ -1649,9 +1669,9 @@ test "mem.tokenize (reset)" {
 /// the iterator will return `buffer`, null, in that order.
 /// The delimiter length must not be zero.
 /// See also the related function `tokenize`.
-pub fn split(buffer: []const u8, delimiter: []const u8) SplitIterator {
+pub fn split(comptime T: type, buffer: []const T, delimiter: []const T) SplitIterator(T) {
     assert(delimiter.len != 0);
-    return SplitIterator{
+    return .{
         .index = 0,
         .buffer = buffer,
         .delimiter = delimiter,
@@ -1661,35 +1681,55 @@ pub fn split(buffer: []const u8, delimiter: []const u8) SplitIterator {
 pub const separate = @compileError("deprecated: renamed to split (behavior remains unchanged)");
 
 test "mem.split" {
-    var it = split("abc|def||ghi", "|");
+    var it = split(u8, "abc|def||ghi", "|");
     try testing.expect(eql(u8, it.next().?, "abc"));
     try testing.expect(eql(u8, it.next().?, "def"));
     try testing.expect(eql(u8, it.next().?, ""));
     try testing.expect(eql(u8, it.next().?, "ghi"));
     try testing.expect(it.next() == null);
 
-    it = split("", "|");
+    it = split(u8, "", "|");
     try testing.expect(eql(u8, it.next().?, ""));
     try testing.expect(it.next() == null);
 
-    it = split("|", "|");
+    it = split(u8, "|", "|");
     try testing.expect(eql(u8, it.next().?, ""));
     try testing.expect(eql(u8, it.next().?, ""));
     try testing.expect(it.next() == null);
 
-    it = split("hello", " ");
+    it = split(u8, "hello", " ");
     try testing.expect(eql(u8, it.next().?, "hello"));
     try testing.expect(it.next() == null);
+
+    var it16 = split(
+        u16,
+        std.unicode.utf8ToUtf16LeStringLiteral("hello"),
+        std.unicode.utf8ToUtf16LeStringLiteral(" "),
+    );
+    try testing.expect(eql(u16, it16.next().?, std.unicode.utf8ToUtf16LeStringLiteral("hello")));
+    try testing.expect(it16.next() == null);
 }
 
 test "mem.split (multibyte)" {
-    var it = split("a, b ,, c, d, e", ", ");
+    var it = split(u8, "a, b ,, c, d, e", ", ");
     try testing.expect(eql(u8, it.next().?, "a"));
     try testing.expect(eql(u8, it.next().?, "b ,"));
     try testing.expect(eql(u8, it.next().?, "c"));
     try testing.expect(eql(u8, it.next().?, "d"));
     try testing.expect(eql(u8, it.next().?, "e"));
     try testing.expect(it.next() == null);
+
+    var it16 = split(
+        u16,
+        std.unicode.utf8ToUtf16LeStringLiteral("a, b ,, c, d, e"),
+        std.unicode.utf8ToUtf16LeStringLiteral(", "),
+    );
+    try testing.expect(eql(u16, it16.next().?, std.unicode.utf8ToUtf16LeStringLiteral("a")));
+    try testing.expect(eql(u16, it16.next().?, std.unicode.utf8ToUtf16LeStringLiteral("b ,")));
+    try testing.expect(eql(u16, it16.next().?, std.unicode.utf8ToUtf16LeStringLiteral("c")));
+    try testing.expect(eql(u16, it16.next().?, std.unicode.utf8ToUtf16LeStringLiteral("d")));
+    try testing.expect(eql(u16, it16.next().?, std.unicode.utf8ToUtf16LeStringLiteral("e")));
+    try testing.expect(it16.next() == null);
 }
 
 pub fn startsWith(comptime T: type, haystack: []const T, needle: []const T) bool {
@@ -1710,75 +1750,83 @@ test "mem.endsWith" {
     try testing.expect(!endsWith(u8, "Bob", "Bo"));
 }
 
-pub const TokenIterator = struct {
-    buffer: []const u8,
-    delimiter_bytes: []const u8,
-    index: usize,
+pub fn TokenIterator(comptime T: type) type {
+    return struct {
+        buffer: []const T,
+        delimiter_bytes: []const T,
+        index: usize,
 
-    /// Returns a slice of the next token, or null if tokenization is complete.
-    pub fn next(self: *TokenIterator) ?[]const u8 {
-        // move to beginning of token
-        while (self.index < self.buffer.len and self.isSplitByte(self.buffer[self.index])) : (self.index += 1) {}
-        const start = self.index;
-        if (start == self.buffer.len) {
-            return null;
-        }
+        const Self = @This();
 
-        // move to end of token
-        while (self.index < self.buffer.len and !self.isSplitByte(self.buffer[self.index])) : (self.index += 1) {}
-        const end = self.index;
-
-        return self.buffer[start..end];
-    }
-
-    /// Returns a slice of the remaining bytes. Does not affect iterator state.
-    pub fn rest(self: TokenIterator) []const u8 {
-        // move to beginning of token
-        var index: usize = self.index;
-        while (index < self.buffer.len and self.isSplitByte(self.buffer[index])) : (index += 1) {}
-        return self.buffer[index..];
-    }
-
-    /// Resets the iterator to the initial token.
-    pub fn reset(self: *TokenIterator) void {
-        self.index = 0;
-    }
-
-    fn isSplitByte(self: TokenIterator, byte: u8) bool {
-        for (self.delimiter_bytes) |delimiter_byte| {
-            if (byte == delimiter_byte) {
-                return true;
+        /// Returns a slice of the next token, or null if tokenization is complete.
+        pub fn next(self: *Self) ?[]const T {
+            // move to beginning of token
+            while (self.index < self.buffer.len and self.isSplitByte(self.buffer[self.index])) : (self.index += 1) {}
+            const start = self.index;
+            if (start == self.buffer.len) {
+                return null;
             }
+
+            // move to end of token
+            while (self.index < self.buffer.len and !self.isSplitByte(self.buffer[self.index])) : (self.index += 1) {}
+            const end = self.index;
+
+            return self.buffer[start..end];
         }
-        return false;
-    }
-};
 
-pub const SplitIterator = struct {
-    buffer: []const u8,
-    index: ?usize,
-    delimiter: []const u8,
+        /// Returns a slice of the remaining bytes. Does not affect iterator state.
+        pub fn rest(self: Self) []const T {
+            // move to beginning of token
+            var index: usize = self.index;
+            while (index < self.buffer.len and self.isSplitByte(self.buffer[index])) : (index += 1) {}
+            return self.buffer[index..];
+        }
 
-    /// Returns a slice of the next field, or null if splitting is complete.
-    pub fn next(self: *SplitIterator) ?[]const u8 {
-        const start = self.index orelse return null;
-        const end = if (indexOfPos(u8, self.buffer, start, self.delimiter)) |delim_start| blk: {
-            self.index = delim_start + self.delimiter.len;
-            break :blk delim_start;
-        } else blk: {
-            self.index = null;
-            break :blk self.buffer.len;
-        };
-        return self.buffer[start..end];
-    }
+        /// Resets the iterator to the initial token.
+        pub fn reset(self: *Self) void {
+            self.index = 0;
+        }
 
-    /// Returns a slice of the remaining bytes. Does not affect iterator state.
-    pub fn rest(self: SplitIterator) []const u8 {
-        const end = self.buffer.len;
-        const start = self.index orelse end;
-        return self.buffer[start..end];
-    }
-};
+        fn isSplitByte(self: Self, byte: T) bool {
+            for (self.delimiter_bytes) |delimiter_byte| {
+                if (byte == delimiter_byte) {
+                    return true;
+                }
+            }
+            return false;
+        }
+    };
+}
+
+pub fn SplitIterator(comptime T: type) type {
+    return struct {
+        buffer: []const T,
+        index: ?usize,
+        delimiter: []const T,
+
+        const Self = @This();
+
+        /// Returns a slice of the next field, or null if splitting is complete.
+        pub fn next(self: *Self) ?[]const T {
+            const start = self.index orelse return null;
+            const end = if (indexOfPos(T, self.buffer, start, self.delimiter)) |delim_start| blk: {
+                self.index = delim_start + self.delimiter.len;
+                break :blk delim_start;
+            } else blk: {
+                self.index = null;
+                break :blk self.buffer.len;
+            };
+            return self.buffer[start..end];
+        }
+
+        /// Returns a slice of the remaining bytes. Does not affect iterator state.
+        pub fn rest(self: Self) []const T {
+            const end = self.buffer.len;
+            const start = self.index orelse end;
+            return self.buffer[start..end];
+        }
+    };
+}
 
 /// Naively combines a series of slices with a separator.
 /// Allocates memory for the result, which must be freed by the caller.

From d31352ee85d633876877d87b813cd3611aa17d88 Mon Sep 17 00:00:00 2001
From: Ryan Liptak <squeek502@hotmail.com>
Date: Fri, 6 Aug 2021 02:01:47 -0700
Subject: [PATCH 88/96] Update all usages of mem.split/mem.tokenize for generic
 version

---
 build.zig                       | 10 +++++-----
 lib/std/SemanticVersion.zig     | 10 +++++-----
 lib/std/build.zig               |  8 ++++----
 lib/std/builtin.zig             |  2 +-
 lib/std/child_process.zig       |  4 ++--
 lib/std/fs.zig                  |  2 +-
 lib/std/fs/path.zig             | 26 +++++++++++++-------------
 lib/std/net.zig                 | 12 ++++++------
 lib/std/os.zig                  |  2 +-
 lib/std/process.zig             |  2 +-
 lib/std/zig/cross_target.zig    | 10 +++++-----
 lib/std/zig/system.zig          |  6 +++---
 src/Cache.zig                   |  4 ++--
 src/Compilation.zig             |  4 ++--
 src/codegen.zig                 |  2 +-
 src/glibc.zig                   | 14 +++++++-------
 src/libc_installation.zig       | 10 +++++-----
 src/link/MachO/Dylib.zig        |  2 +-
 src/main.zig                    |  4 ++--
 src/test.zig                    |  4 ++--
 test/behavior/bugs/6456.zig     |  2 +-
 test/tests.zig                  |  2 +-
 tools/update_glibc.zig          |  8 ++++----
 tools/update_spirv_features.zig |  2 +-
 24 files changed, 76 insertions(+), 76 deletions(-)

diff --git a/build.zig b/build.zig
index f60cd573a4..449c6a7f1a 100644
--- a/build.zig
+++ b/build.zig
@@ -187,7 +187,7 @@ pub fn build(b: *Builder) !void {
             },
             2 => {
                 // Untagged development build (e.g. 0.8.0-684-gbbe2cca1a).
-                var it = mem.split(git_describe, "-");
+                var it = mem.split(u8, git_describe, "-");
                 const tagged_ancestor = it.next() orelse unreachable;
                 const commit_height = it.next() orelse unreachable;
                 const commit_id = it.next() orelse unreachable;
@@ -479,7 +479,7 @@ fn addCxxKnownPath(
         ctx.cxx_compiler,
         b.fmt("-print-file-name={s}", .{objname}),
     });
-    const path_unpadded = mem.tokenize(path_padded, "\r\n").next().?;
+    const path_unpadded = mem.tokenize(u8, path_padded, "\r\n").next().?;
     if (mem.eql(u8, path_unpadded, objname)) {
         if (errtxt) |msg| {
             warn("{s}", .{msg});
@@ -502,7 +502,7 @@ fn addCxxKnownPath(
 }
 
 fn addCMakeLibraryList(exe: *std.build.LibExeObjStep, list: []const u8) void {
-    var it = mem.tokenize(list, ";");
+    var it = mem.tokenize(u8, list, ";");
     while (it.next()) |lib| {
         if (mem.startsWith(u8, lib, "-l")) {
             exe.linkSystemLibrary(lib["-l".len..]);
@@ -596,11 +596,11 @@ fn findAndParseConfigH(b: *Builder, config_h_path_option: ?[]const u8) ?CMakeCon
         },
     };
 
-    var lines_it = mem.tokenize(config_h_text, "\r\n");
+    var lines_it = mem.tokenize(u8, config_h_text, "\r\n");
     while (lines_it.next()) |line| {
         inline for (mappings) |mapping| {
             if (mem.startsWith(u8, line, mapping.prefix)) {
-                var it = mem.split(line, "\"");
+                var it = mem.split(u8, line, "\"");
                 _ = it.next().?; // skip the stuff before the quote
                 const quoted = it.next().?; // the stuff inside the quote
                 @field(ctx, mapping.field) = toNativePathSep(b, quoted);
diff --git a/lib/std/SemanticVersion.zig b/lib/std/SemanticVersion.zig
index e029952509..17d5b65571 100644
--- a/lib/std/SemanticVersion.zig
+++ b/lib/std/SemanticVersion.zig
@@ -48,8 +48,8 @@ pub fn order(lhs: Version, rhs: Version) std.math.Order {
     if (lhs.pre == null and rhs.pre != null) return .gt;
 
     // Iterate over pre-release identifiers until a difference is found.
-    var lhs_pre_it = std.mem.split(lhs.pre.?, ".");
-    var rhs_pre_it = std.mem.split(rhs.pre.?, ".");
+    var lhs_pre_it = std.mem.split(u8, lhs.pre.?, ".");
+    var rhs_pre_it = std.mem.split(u8, rhs.pre.?, ".");
     while (true) {
         const next_lid = lhs_pre_it.next();
         const next_rid = rhs_pre_it.next();
@@ -92,7 +92,7 @@ pub fn parse(text: []const u8) !Version {
     // Parse the required major, minor, and patch numbers.
     const extra_index = std.mem.indexOfAny(u8, text, "-+");
     const required = text[0..(extra_index orelse text.len)];
-    var it = std.mem.split(required, ".");
+    var it = std.mem.split(u8, required, ".");
     var ver = Version{
         .major = try parseNum(it.next() orelse return error.InvalidVersion),
         .minor = try parseNum(it.next() orelse return error.InvalidVersion),
@@ -114,7 +114,7 @@ pub fn parse(text: []const u8) !Version {
     // Check validity of optional pre-release identifiers.
     // See: https://semver.org/#spec-item-9
     if (ver.pre) |pre| {
-        it = std.mem.split(pre, ".");
+        it = std.mem.split(u8, pre, ".");
         while (it.next()) |id| {
             // Identifiers MUST NOT be empty.
             if (id.len == 0) return error.InvalidVersion;
@@ -133,7 +133,7 @@ pub fn parse(text: []const u8) !Version {
     // Check validity of optional build metadata identifiers.
     // See: https://semver.org/#spec-item-10
     if (ver.build) |build| {
-        it = std.mem.split(build, ".");
+        it = std.mem.split(u8, build, ".");
         while (it.next()) |id| {
             // Identifiers MUST NOT be empty.
             if (id.len == 0) return error.InvalidVersion;
diff --git a/lib/std/build.zig b/lib/std/build.zig
index a88667a613..17cad016e8 100644
--- a/lib/std/build.zig
+++ b/lib/std/build.zig
@@ -1085,7 +1085,7 @@ pub const Builder = struct {
                 if (fs.path.isAbsolute(name)) {
                     return name;
                 }
-                var it = mem.tokenize(PATH, &[_]u8{fs.path.delimiter});
+                var it = mem.tokenize(u8, PATH, &[_]u8{fs.path.delimiter});
                 while (it.next()) |path| {
                     const full_path = try fs.path.join(self.allocator, &[_][]const u8{
                         path,
@@ -1211,10 +1211,10 @@ pub const Builder = struct {
         const stdout = try self.execAllowFail(&[_][]const u8{ "pkg-config", "--list-all" }, out_code, .Ignore);
         var list = ArrayList(PkgConfigPkg).init(self.allocator);
         errdefer list.deinit();
-        var line_it = mem.tokenize(stdout, "\r\n");
+        var line_it = mem.tokenize(u8, stdout, "\r\n");
         while (line_it.next()) |line| {
             if (mem.trim(u8, line, " \t").len == 0) continue;
-            var tok_it = mem.tokenize(line, " \t");
+            var tok_it = mem.tokenize(u8, line, " \t");
             try list.append(PkgConfigPkg{
                 .name = tok_it.next() orelse return error.PkgConfigInvalidOutput,
                 .desc = tok_it.rest(),
@@ -1872,7 +1872,7 @@ pub const LibExeObjStep = struct {
             error.FileNotFound => return error.PkgConfigNotInstalled,
             else => return err,
         };
-        var it = mem.tokenize(stdout, " \r\n\t");
+        var it = mem.tokenize(u8, stdout, " \r\n\t");
         while (it.next()) |tok| {
             if (mem.eql(u8, tok, "-I")) {
                 const dir = it.next() orelse return error.PkgConfigInvalidOutput;
diff --git a/lib/std/builtin.zig b/lib/std/builtin.zig
index 9d432a3a00..6643e07837 100644
--- a/lib/std/builtin.zig
+++ b/lib/std/builtin.zig
@@ -509,7 +509,7 @@ pub const Version = struct {
         // found no digits or '.' before unexpected character
         if (end == 0) return error.InvalidVersion;
 
-        var it = std.mem.split(text[0..end], ".");
+        var it = std.mem.split(u8, text[0..end], ".");
         // substring is not empty, first call will succeed
         const major = it.next().?;
         if (major.len == 0) return error.InvalidVersion;
diff --git a/lib/std/child_process.zig b/lib/std/child_process.zig
index b63153e904..3f3fa9c754 100644
--- a/lib/std/child_process.zig
+++ b/lib/std/child_process.zig
@@ -836,12 +836,12 @@ pub const ChildProcess = struct {
 
             const app_name = self.argv[0];
 
-            var it = mem.tokenize(PATH, ";");
+            var it = mem.tokenize(u8, PATH, ";");
             retry: while (it.next()) |search_path| {
                 const path_no_ext = try fs.path.join(self.allocator, &[_][]const u8{ search_path, app_name });
                 defer self.allocator.free(path_no_ext);
 
-                var ext_it = mem.tokenize(PATHEXT, ";");
+                var ext_it = mem.tokenize(u8, PATHEXT, ";");
                 while (ext_it.next()) |app_ext| {
                     const joined_path = try mem.concat(self.allocator, u8, &[_][]const u8{ path_no_ext, app_ext });
                     defer self.allocator.free(joined_path);
diff --git a/lib/std/fs.zig b/lib/std/fs.zig
index 2504965e3a..3c5399e6a4 100644
--- a/lib/std/fs.zig
+++ b/lib/std/fs.zig
@@ -2455,7 +2455,7 @@ pub fn selfExePath(out_buffer: []u8) SelfExePathError![]u8 {
             } else if (argv0.len != 0) {
                 // argv[0] is not empty (and not a path): search it inside PATH
                 const PATH = std.os.getenvZ("PATH") orelse return error.FileNotFound;
-                var path_it = mem.tokenize(PATH, &[_]u8{path.delimiter});
+                var path_it = mem.tokenize(u8, PATH, &[_]u8{path.delimiter});
                 while (path_it.next()) |a_path| {
                     var resolved_path_buf: [MAX_PATH_BYTES - 1:0]u8 = undefined;
                     const resolved_path = std.fmt.bufPrintZ(&resolved_path_buf, "{s}/{s}", .{
diff --git a/lib/std/fs/path.zig b/lib/std/fs/path.zig
index ed04f0b09d..baaadcfe59 100644
--- a/lib/std/fs/path.zig
+++ b/lib/std/fs/path.zig
@@ -345,7 +345,7 @@ pub fn windowsParsePath(path: []const u8) WindowsPath {
                 return relative_path;
             }
 
-            var it = mem.tokenize(path, &[_]u8{this_sep});
+            var it = mem.tokenize(u8, path, &[_]u8{this_sep});
             _ = (it.next() orelse return relative_path);
             _ = (it.next() orelse return relative_path);
             return WindowsPath{
@@ -407,8 +407,8 @@ fn networkShareServersEql(ns1: []const u8, ns2: []const u8) bool {
     const sep1 = ns1[0];
     const sep2 = ns2[0];
 
-    var it1 = mem.tokenize(ns1, &[_]u8{sep1});
-    var it2 = mem.tokenize(ns2, &[_]u8{sep2});
+    var it1 = mem.tokenize(u8, ns1, &[_]u8{sep1});
+    var it2 = mem.tokenize(u8, ns2, &[_]u8{sep2});
 
     // TODO ASCII is wrong, we actually need full unicode support to compare paths.
     return asciiEqlIgnoreCase(it1.next().?, it2.next().?);
@@ -428,8 +428,8 @@ fn compareDiskDesignators(kind: WindowsPath.Kind, p1: []const u8, p2: []const u8
             const sep1 = p1[0];
             const sep2 = p2[0];
 
-            var it1 = mem.tokenize(p1, &[_]u8{sep1});
-            var it2 = mem.tokenize(p2, &[_]u8{sep2});
+            var it1 = mem.tokenize(u8, p1, &[_]u8{sep1});
+            var it2 = mem.tokenize(u8, p2, &[_]u8{sep2});
 
             // TODO ASCII is wrong, we actually need full unicode support to compare paths.
             return asciiEqlIgnoreCase(it1.next().?, it2.next().?) and asciiEqlIgnoreCase(it1.next().?, it2.next().?);
@@ -551,7 +551,7 @@ pub fn resolveWindows(allocator: *Allocator, paths: []const []const u8) ![]u8 {
             },
             WindowsPath.Kind.NetworkShare => {
                 result = try allocator.alloc(u8, max_size);
-                var it = mem.tokenize(paths[first_index], "/\\");
+                var it = mem.tokenize(u8, paths[first_index], "/\\");
                 const server_name = it.next().?;
                 const other_name = it.next().?;
 
@@ -618,7 +618,7 @@ pub fn resolveWindows(allocator: *Allocator, paths: []const []const u8) ![]u8 {
         if (!correct_disk_designator) {
             continue;
         }
-        var it = mem.tokenize(p[parsed.disk_designator.len..], "/\\");
+        var it = mem.tokenize(u8, p[parsed.disk_designator.len..], "/\\");
         while (it.next()) |component| {
             if (mem.eql(u8, component, ".")) {
                 continue;
@@ -687,7 +687,7 @@ pub fn resolvePosix(allocator: *Allocator, paths: []const []const u8) ![]u8 {
     errdefer allocator.free(result);
 
     for (paths[first_index..]) |p| {
-        var it = mem.tokenize(p, "/");
+        var it = mem.tokenize(u8, p, "/");
         while (it.next()) |component| {
             if (mem.eql(u8, component, ".")) {
                 continue;
@@ -1101,8 +1101,8 @@ pub fn relativeWindows(allocator: *Allocator, from: []const u8, to: []const u8)
         return resolved_to;
     }
 
-    var from_it = mem.tokenize(resolved_from, "/\\");
-    var to_it = mem.tokenize(resolved_to, "/\\");
+    var from_it = mem.tokenize(u8, resolved_from, "/\\");
+    var to_it = mem.tokenize(u8, resolved_to, "/\\");
     while (true) {
         const from_component = from_it.next() orelse return allocator.dupe(u8, to_it.rest());
         const to_rest = to_it.rest();
@@ -1131,7 +1131,7 @@ pub fn relativeWindows(allocator: *Allocator, from: []const u8, to: []const u8)
         // shave off the trailing slash
         result_index -= 1;
 
-        var rest_it = mem.tokenize(to_rest, "/\\");
+        var rest_it = mem.tokenize(u8, to_rest, "/\\");
         while (rest_it.next()) |to_component| {
             result[result_index] = '\\';
             result_index += 1;
@@ -1152,8 +1152,8 @@ pub fn relativePosix(allocator: *Allocator, from: []const u8, to: []const u8) ![
     const resolved_to = try resolvePosix(allocator, &[_][]const u8{to});
     defer allocator.free(resolved_to);
 
-    var from_it = mem.tokenize(resolved_from, "/");
-    var to_it = mem.tokenize(resolved_to, "/");
+    var from_it = mem.tokenize(u8, resolved_from, "/");
+    var to_it = mem.tokenize(u8, resolved_to, "/");
     while (true) {
         const from_component = from_it.next() orelse return allocator.dupe(u8, to_it.rest());
         const to_rest = to_it.rest();
diff --git a/lib/std/net.zig b/lib/std/net.zig
index 46d9bee15d..1b53399fd1 100644
--- a/lib/std/net.zig
+++ b/lib/std/net.zig
@@ -1130,9 +1130,9 @@ fn linuxLookupNameFromHosts(
         },
         else => |e| return e,
     }) |line| {
-        const no_comment_line = mem.split(line, "#").next().?;
+        const no_comment_line = mem.split(u8, line, "#").next().?;
 
-        var line_it = mem.tokenize(no_comment_line, " \t");
+        var line_it = mem.tokenize(u8, no_comment_line, " \t");
         const ip_text = line_it.next() orelse continue;
         var first_name_text: ?[]const u8 = null;
         while (line_it.next()) |name_text| {
@@ -1211,7 +1211,7 @@ fn linuxLookupNameFromDnsSearch(
     mem.copy(u8, canon.items, canon_name);
     try canon.append('.');
 
-    var tok_it = mem.tokenize(search, " \t");
+    var tok_it = mem.tokenize(u8, search, " \t");
     while (tok_it.next()) |tok| {
         canon.shrinkRetainingCapacity(canon_name.len + 1);
         try canon.appendSlice(tok);
@@ -1328,13 +1328,13 @@ fn getResolvConf(allocator: *mem.Allocator, rc: *ResolvConf) !void {
         },
         else => |e| return e,
     }) |line| {
-        const no_comment_line = mem.split(line, "#").next().?;
-        var line_it = mem.tokenize(no_comment_line, " \t");
+        const no_comment_line = mem.split(u8, line, "#").next().?;
+        var line_it = mem.tokenize(u8, no_comment_line, " \t");
 
         const token = line_it.next() orelse continue;
         if (mem.eql(u8, token, "options")) {
             while (line_it.next()) |sub_tok| {
-                var colon_it = mem.split(sub_tok, ":");
+                var colon_it = mem.split(u8, sub_tok, ":");
                 const name = colon_it.next().?;
                 const value_txt = colon_it.next() orelse continue;
                 const value = std.fmt.parseInt(u8, value_txt, 10) catch |err| switch (err) {
diff --git a/lib/std/os.zig b/lib/std/os.zig
index 4fd0998b0d..9a1c584b75 100644
--- a/lib/std/os.zig
+++ b/lib/std/os.zig
@@ -1378,7 +1378,7 @@ pub fn execvpeZ_expandArg0(
     // Use of MAX_PATH_BYTES here is valid as the path_buf will be passed
     // directly to the operating system in execveZ.
     var path_buf: [MAX_PATH_BYTES]u8 = undefined;
-    var it = mem.tokenize(PATH, ":");
+    var it = mem.tokenize(u8, PATH, ":");
     var seen_eacces = false;
     var err: ExecveError = undefined;
 
diff --git a/lib/std/process.zig b/lib/std/process.zig
index 4e875e7ebd..3690b67a14 100644
--- a/lib/std/process.zig
+++ b/lib/std/process.zig
@@ -109,7 +109,7 @@ pub fn getEnvMap(allocator: *Allocator) !BufMap {
 
         for (environ) |env| {
             const pair = mem.spanZ(env);
-            var parts = mem.split(pair, "=");
+            var parts = mem.split(u8, pair, "=");
             const key = parts.next().?;
             const value = parts.next().?;
             try result.put(key, value);
diff --git a/lib/std/zig/cross_target.zig b/lib/std/zig/cross_target.zig
index 1058628633..4a8879db57 100644
--- a/lib/std/zig/cross_target.zig
+++ b/lib/std/zig/cross_target.zig
@@ -233,7 +233,7 @@ pub const CrossTarget = struct {
             .dynamic_linker = DynamicLinker.init(args.dynamic_linker),
         };
 
-        var it = mem.split(args.arch_os_abi, "-");
+        var it = mem.split(u8, args.arch_os_abi, "-");
         const arch_name = it.next().?;
         const arch_is_native = mem.eql(u8, arch_name, "native");
         if (!arch_is_native) {
@@ -251,7 +251,7 @@ pub const CrossTarget = struct {
 
         const opt_abi_text = it.next();
         if (opt_abi_text) |abi_text| {
-            var abi_it = mem.split(abi_text, ".");
+            var abi_it = mem.split(u8, abi_text, ".");
             const abi = std.meta.stringToEnum(Target.Abi, abi_it.next().?) orelse
                 return error.UnknownApplicationBinaryInterface;
             result.abi = abi;
@@ -699,7 +699,7 @@ pub const CrossTarget = struct {
     }
 
     fn parseOs(result: *CrossTarget, diags: *ParseOptions.Diagnostics, text: []const u8) !void {
-        var it = mem.split(text, ".");
+        var it = mem.split(u8, text, ".");
         const os_name = it.next().?;
         diags.os_name = os_name;
         const os_is_native = mem.eql(u8, os_name, "native");
@@ -757,7 +757,7 @@ pub const CrossTarget = struct {
             .linux,
             .dragonfly,
             => {
-                var range_it = mem.split(version_text, "...");
+                var range_it = mem.split(u8, version_text, "...");
 
                 const min_text = range_it.next().?;
                 const min_ver = SemVer.parse(min_text) catch |err| switch (err) {
@@ -777,7 +777,7 @@ pub const CrossTarget = struct {
             },
 
             .windows => {
-                var range_it = mem.split(version_text, "...");
+                var range_it = mem.split(u8, version_text, "...");
 
                 const min_text = range_it.next().?;
                 const min_ver = std.meta.stringToEnum(Target.Os.WindowsVersion, min_text) orelse
diff --git a/lib/std/zig/system.zig b/lib/std/zig/system.zig
index a4939b8347..4d671efe94 100644
--- a/lib/std/zig/system.zig
+++ b/lib/std/zig/system.zig
@@ -44,7 +44,7 @@ pub const NativePaths = struct {
             defer allocator.free(nix_cflags_compile);
 
             is_nix = true;
-            var it = mem.tokenize(nix_cflags_compile, " ");
+            var it = mem.tokenize(u8, nix_cflags_compile, " ");
             while (true) {
                 const word = it.next() orelse break;
                 if (mem.eql(u8, word, "-isystem")) {
@@ -69,7 +69,7 @@ pub const NativePaths = struct {
             defer allocator.free(nix_ldflags);
 
             is_nix = true;
-            var it = mem.tokenize(nix_ldflags, " ");
+            var it = mem.tokenize(u8, nix_ldflags, " ");
             while (true) {
                 const word = it.next() orelse break;
                 if (mem.eql(u8, word, "-rpath")) {
@@ -839,7 +839,7 @@ pub const NativeTargetInfo = struct {
                         error.Overflow => return error.InvalidElfFile,
                     };
                     const rpath_list = mem.spanZ(std.meta.assumeSentinel(strtab[rpoff_usize..].ptr, 0));
-                    var it = mem.tokenize(rpath_list, ":");
+                    var it = mem.tokenize(u8, rpath_list, ":");
                     while (it.next()) |rpath| {
                         var dir = fs.cwd().openDir(rpath, .{}) catch |err| switch (err) {
                             error.NameTooLong => unreachable,
diff --git a/src/Cache.zig b/src/Cache.zig
index 94c1b41c61..28401c3d18 100644
--- a/src/Cache.zig
+++ b/src/Cache.zig
@@ -356,7 +356,7 @@ pub const Manifest = struct {
 
         const input_file_count = self.files.items.len;
         var any_file_changed = false;
-        var line_iter = mem.tokenize(file_contents, "\n");
+        var line_iter = mem.tokenize(u8, file_contents, "\n");
         var idx: usize = 0;
         while (line_iter.next()) |line| {
             defer idx += 1;
@@ -373,7 +373,7 @@ pub const Manifest = struct {
                 break :blk new;
             };
 
-            var iter = mem.tokenize(line, " ");
+            var iter = mem.tokenize(u8, line, " ");
             const size = iter.next() orelse return error.InvalidFormat;
             const inode = iter.next() orelse return error.InvalidFormat;
             const mtime_nsec_str = iter.next() orelse return error.InvalidFormat;
diff --git a/src/Compilation.zig b/src/Compilation.zig
index 4e9d94c6a4..a80849b26e 100644
--- a/src/Compilation.zig
+++ b/src/Compilation.zig
@@ -3341,7 +3341,7 @@ pub fn hasSharedLibraryExt(filename: []const u8) bool {
         return true;
     }
     // Look for .so.X, .so.X.Y, .so.X.Y.Z
-    var it = mem.split(filename, ".");
+    var it = mem.split(u8, filename, ".");
     _ = it.next().?;
     var so_txt = it.next() orelse return false;
     while (!mem.eql(u8, so_txt, "so")) {
@@ -4086,7 +4086,7 @@ fn updateStage1Module(comp: *Compilation, main_progress_node: *std.Progress.Node
             };
 
             if (directory.handle.readFileAlloc(comp.gpa, libs_txt_basename, 10 * 1024 * 1024)) |libs_txt| {
-                var it = mem.tokenize(libs_txt, "\n");
+                var it = mem.tokenize(u8, libs_txt, "\n");
                 while (it.next()) |lib_name| {
                     try comp.stage1AddLinkLib(lib_name);
                 }
diff --git a/src/codegen.zig b/src/codegen.zig
index 3864479d2d..7fd51d3cd8 100644
--- a/src/codegen.zig
+++ b/src/codegen.zig
@@ -3656,7 +3656,7 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
                     }
 
                     {
-                        var iter = std.mem.tokenize(asm_source, "\n\r");
+                        var iter = std.mem.tokenize(u8, asm_source, "\n\r");
                         while (iter.next()) |ins| {
                             if (mem.eql(u8, ins, "syscall")) {
                                 try self.code.appendSlice(&[_]u8{ 0x0f, 0x05 });
diff --git a/src/glibc.zig b/src/glibc.zig
index 1a6756e467..aed1a24437 100644
--- a/src/glibc.zig
+++ b/src/glibc.zig
@@ -107,7 +107,7 @@ pub fn loadMetaData(gpa: *Allocator, zig_lib_dir: std.fs.Dir) LoadMetaDataError!
     defer gpa.free(abi_txt_contents);
 
     {
-        var it = mem.tokenize(vers_txt_contents, "\r\n");
+        var it = mem.tokenize(u8, vers_txt_contents, "\r\n");
         var line_i: usize = 1;
         while (it.next()) |line| : (line_i += 1) {
             const prefix = "GLIBC_";
@@ -124,10 +124,10 @@ pub fn loadMetaData(gpa: *Allocator, zig_lib_dir: std.fs.Dir) LoadMetaDataError!
         }
     }
     {
-        var file_it = mem.tokenize(fns_txt_contents, "\r\n");
+        var file_it = mem.tokenize(u8, fns_txt_contents, "\r\n");
         var line_i: usize = 1;
         while (file_it.next()) |line| : (line_i += 1) {
-            var line_it = mem.tokenize(line, " ");
+            var line_it = mem.tokenize(u8, line, " ");
             const fn_name = line_it.next() orelse {
                 std.log.err("fns.txt:{d}: expected function name", .{line_i});
                 return error.ZigInstallationCorrupt;
@@ -147,7 +147,7 @@ pub fn loadMetaData(gpa: *Allocator, zig_lib_dir: std.fs.Dir) LoadMetaDataError!
         }
     }
     {
-        var file_it = mem.split(abi_txt_contents, "\n");
+        var file_it = mem.split(u8, abi_txt_contents, "\n");
         var line_i: usize = 0;
         while (true) {
             const ver_list_base: []VerList = blk: {
@@ -155,9 +155,9 @@ pub fn loadMetaData(gpa: *Allocator, zig_lib_dir: std.fs.Dir) LoadMetaDataError!
                 if (line.len == 0) break;
                 line_i += 1;
                 const ver_list_base = try arena.alloc(VerList, all_functions.items.len);
-                var line_it = mem.tokenize(line, " ");
+                var line_it = mem.tokenize(u8, line, " ");
                 while (line_it.next()) |target_string| {
-                    var component_it = mem.tokenize(target_string, "-");
+                    var component_it = mem.tokenize(u8, target_string, "-");
                     const arch_name = component_it.next() orelse {
                         std.log.err("abi.txt:{d}: expected arch name", .{line_i});
                         return error.ZigInstallationCorrupt;
@@ -203,7 +203,7 @@ pub fn loadMetaData(gpa: *Allocator, zig_lib_dir: std.fs.Dir) LoadMetaDataError!
                     .versions = undefined,
                     .len = 0,
                 };
-                var line_it = mem.tokenize(line, " ");
+                var line_it = mem.tokenize(u8, line, " ");
                 while (line_it.next()) |version_index_string| {
                     if (ver_list.len >= ver_list.versions.len) {
                         // If this happens with legit data, increase the array len in the type.
diff --git a/src/libc_installation.zig b/src/libc_installation.zig
index 783f76b9bd..b639e0f2f8 100644
--- a/src/libc_installation.zig
+++ b/src/libc_installation.zig
@@ -60,10 +60,10 @@ pub const LibCInstallation = struct {
         const contents = try std.fs.cwd().readFileAlloc(allocator, libc_file, std.math.maxInt(usize));
         defer allocator.free(contents);
 
-        var it = std.mem.tokenize(contents, "\n");
+        var it = std.mem.tokenize(u8, contents, "\n");
         while (it.next()) |line| {
             if (line.len == 0 or line[0] == '#') continue;
-            var line_it = std.mem.split(line, "=");
+            var line_it = std.mem.split(u8, line, "=");
             const name = line_it.next() orelse {
                 log.err("missing equal sign after field name\n", .{});
                 return error.ParseError;
@@ -298,7 +298,7 @@ pub const LibCInstallation = struct {
             },
         }
 
-        var it = std.mem.tokenize(exec_res.stderr, "\n\r");
+        var it = std.mem.tokenize(u8, exec_res.stderr, "\n\r");
         var search_paths = std.ArrayList([]const u8).init(allocator);
         defer search_paths.deinit();
         while (it.next()) |line| {
@@ -616,7 +616,7 @@ fn ccPrintFileName(args: CCPrintFileNameOptions) ![:0]u8 {
         },
     }
 
-    var it = std.mem.tokenize(exec_res.stdout, "\n\r");
+    var it = std.mem.tokenize(u8, exec_res.stdout, "\n\r");
     const line = it.next() orelse return error.LibCRuntimeNotFound;
     // When this command fails, it returns exit code 0 and duplicates the input file name.
     // So we detect failure by checking if the output matches exactly the input.
@@ -695,7 +695,7 @@ fn appendCcExe(args: *std.ArrayList([]const u8), skip_cc_env_var: bool) !void {
         return;
     };
     // Respect space-separated flags to the C compiler.
-    var it = std.mem.tokenize(cc_env_var, " ");
+    var it = std.mem.tokenize(u8, cc_env_var, " ");
     while (it.next()) |arg| {
         try args.append(arg);
     }
diff --git a/src/link/MachO/Dylib.zig b/src/link/MachO/Dylib.zig
index 1d2833c764..4763203c3b 100644
--- a/src/link/MachO/Dylib.zig
+++ b/src/link/MachO/Dylib.zig
@@ -106,7 +106,7 @@ pub const Id = struct {
         var out: u32 = 0;
         var values: [3][]const u8 = undefined;
 
-        var split = mem.split(string, ".");
+        var split = mem.split(u8, string, ".");
         var count: u4 = 0;
         while (split.next()) |value| {
             if (count > 2) {
diff --git a/src/main.zig b/src/main.zig
index 8c1964fc43..0987a46989 100644
--- a/src/main.zig
+++ b/src/main.zig
@@ -1200,7 +1200,7 @@ fn buildOutputType(
                     },
                     .rdynamic => rdynamic = true,
                     .wl => {
-                        var split_it = mem.split(it.only_arg, ",");
+                        var split_it = mem.split(u8, it.only_arg, ",");
                         while (split_it.next()) |linker_arg| {
                             // Handle nested-joined args like `-Wl,-rpath=foo`.
                             // Must be prefixed with 1 or 2 dashes.
@@ -3655,7 +3655,7 @@ pub const ClangArgIterator = struct {
             defer allocator.free(resp_contents);
             // TODO is there a specification for this file format? Let's find it and make this parsing more robust
             // at the very least I'm guessing this needs to handle quotes and `#` comments.
-            var it = mem.tokenize(resp_contents, " \t\r\n");
+            var it = mem.tokenize(u8, resp_contents, " \t\r\n");
             var resp_arg_list = std.ArrayList([]const u8).init(allocator);
             defer resp_arg_list.deinit();
             {
diff --git a/src/test.zig b/src/test.zig
index af7b3a1736..960aac7bc7 100644
--- a/src/test.zig
+++ b/src/test.zig
@@ -228,7 +228,7 @@ pub const TestContext = struct {
                     continue;
                 }
                 // example: "file.zig:1:2: error: bad thing happened"
-                var it = std.mem.split(err_msg_line, ":");
+                var it = std.mem.split(u8, err_msg_line, ":");
                 const src_path = it.next() orelse @panic("missing colon");
                 const line_text = it.next() orelse @panic("missing line");
                 const col_text = it.next() orelse @panic("missing column");
@@ -779,7 +779,7 @@ pub const TestContext = struct {
                     }
                     var ok = true;
                     if (case.expect_exact) {
-                        var err_iter = std.mem.split(result.stderr, "\n");
+                        var err_iter = std.mem.split(u8, result.stderr, "\n");
                         var i: usize = 0;
                         ok = while (err_iter.next()) |line| : (i += 1) {
                             if (i >= case_error_list.len) break false;
diff --git a/test/behavior/bugs/6456.zig b/test/behavior/bugs/6456.zig
index 8078ab147f..44fdfd69ba 100644
--- a/test/behavior/bugs/6456.zig
+++ b/test/behavior/bugs/6456.zig
@@ -13,7 +13,7 @@ test "issue 6456" {
     comptime {
         var fields: []const StructField = &[0]StructField{};
 
-        var it = std.mem.tokenize(text, "\n");
+        var it = std.mem.tokenize(u8, text, "\n");
         while (it.next()) |name| {
             fields = fields ++ &[_]StructField{StructField{
                 .alignment = 0,
diff --git a/test/tests.zig b/test/tests.zig
index fc83137bc4..89a2492386 100644
--- a/test/tests.zig
+++ b/test/tests.zig
@@ -768,7 +768,7 @@ pub const StackTracesContext = struct {
                 var buf = ArrayList(u8).init(b.allocator);
                 defer buf.deinit();
                 if (stderr.len != 0 and stderr[stderr.len - 1] == '\n') stderr = stderr[0 .. stderr.len - 1];
-                var it = mem.split(stderr, "\n");
+                var it = mem.split(u8, stderr, "\n");
                 process_lines: while (it.next()) |line| {
                     if (line.len == 0) continue;
 
diff --git a/tools/update_glibc.zig b/tools/update_glibc.zig
index ba12f6e0e6..0b25d97572 100644
--- a/tools/update_glibc.zig
+++ b/tools/update_glibc.zig
@@ -188,9 +188,9 @@ pub fn main() !void {
                 std.debug.warn("unable to open {s}: {}\n", .{ abi_list_filename, err });
                 std.process.exit(1);
             };
-            var lines_it = std.mem.tokenize(contents, "\n");
+            var lines_it = std.mem.tokenize(u8, contents, "\n");
             while (lines_it.next()) |line| {
-                var tok_it = std.mem.tokenize(line, " ");
+                var tok_it = std.mem.tokenize(u8, line, " ");
                 const ver = tok_it.next().?;
                 const name = tok_it.next().?;
                 const category = tok_it.next().?;
@@ -319,8 +319,8 @@ pub fn strCmpLessThan(context: void, a: []const u8, b: []const u8) bool {
 pub fn versionLessThan(context: void, a: []const u8, b: []const u8) bool {
     _ = context;
     const sep_chars = "GLIBC_.";
-    var a_tokens = std.mem.tokenize(a, sep_chars);
-    var b_tokens = std.mem.tokenize(b, sep_chars);
+    var a_tokens = std.mem.tokenize(u8, a, sep_chars);
+    var b_tokens = std.mem.tokenize(u8, b, sep_chars);
 
     while (true) {
         const a_next = a_tokens.next();
diff --git a/tools/update_spirv_features.zig b/tools/update_spirv_features.zig
index 0de1c56934..69e8237f98 100644
--- a/tools/update_spirv_features.zig
+++ b/tools/update_spirv_features.zig
@@ -19,7 +19,7 @@ const Version = struct {
     minor: u32,
 
     fn parse(str: []const u8) !Version {
-        var it = std.mem.split(str, ".");
+        var it = std.mem.split(u8, str, ".");
 
         const major = it.next() orelse return error.InvalidVersion;
         const minor = it.next() orelse return error.InvalidVersion;

From ede76f4fe31e6fc935ae10f030eb2c97ed36aaaa Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Fri, 6 Aug 2021 16:24:39 -0700
Subject: [PATCH 89/96] stage2: fix generics with non-comptime anytype
 parameters

The `comptime_args` field of Fn has a clarified purpose:
For generic function instantiations, there is a `TypedValue` here
for each parameter of the function:
 * Non-comptime parameters are marked with a `generic_poison` for the value.
 * Non-anytype parameters are marked with a `generic_poison` for the type.

Sema now has a `fn_ret_ty` field. Doc comments reproduced here:
> When semantic analysis needs to know the return type of the function whose body
> is being analyzed, this `Type` should be used instead of going through `func`.
> This will correctly handle the case of a comptime/inline function call of a
> generic function which uses a type expression for the return type.
> The type will be `void` in the case that `func` is `null`.
Various places in Sema are modified in accordance with this guidance.

Fixed `resolveMaybeUndefVal` not returning `error.GenericPoison` when
Value Tag of `generic_poison` is encountered.

Fixed generic function memoization incorrect equality checking. The
logic now clearly deals properly with any combination of anytype and
comptime parameters.

Fixed not removing generic function instantiation from the table in case
a compile errors in the rest of `call` semantic analysis. This required
introduction of yet another adapter which I have called
`GenericRemoveAdapter`. This one is nice and simple - it's the same hash
function (the same precomputed hash is passed in) but the equality
function checks pointers rather than doing any logic.

Inline/comptime function calls coerce each argument in accordance with
the function parameter type expressions. Likewise the return type
expression is evaluated and provided (see `fn_ret_ty` above).

There's a new compile error "unable to monomorphize function". It's
pretty unhelpful and will need to get improved in the future. It happens
when a type expression in a generic function did not end up getting
resolved at a callsite. This can happen, for example, if a runtime
parameter is attempted to be used where it needed to be comptime known:

```zig
fn foo(x: anytype) [x]u8 { _ = x; }
```

In this example, even if we pass a number such as `10` for `x`, it is
not marked `comptime`, so `x` will have a runtime known value, making
the return type unable to resolve.

In the LLVM backend I implement cmp instructions for float types to pass
some behavior tests that used floats.
---
 src/Module.zig                    |  12 +-
 src/Sema.zig                      | 315 ++++++++++++++++++++----------
 src/codegen/llvm.zig              |  41 ++--
 src/codegen/llvm/bindings.zig     |  22 ++-
 test/behavior/generics.zig        |  38 +++-
 test/behavior/generics_stage1.zig |  22 ---
 6 files changed, 301 insertions(+), 149 deletions(-)

diff --git a/src/Module.zig b/src/Module.zig
index a694f775da..3652a27927 100644
--- a/src/Module.zig
+++ b/src/Module.zig
@@ -801,8 +801,9 @@ pub const Fn = struct {
     /// The Decl that corresponds to the function itself.
     owner_decl: *Decl,
     /// If this is not null, this function is a generic function instantiation, and
-    /// there is a `Value` here for each parameter of the function. Non-comptime
-    /// parameters are marked with an `unreachable_value`.
+    /// there is a `TypedValue` here for each parameter of the function.
+    /// Non-comptime parameters are marked with a `generic_poison` for the value.
+    /// Non-anytype parameters are marked with a `generic_poison` for the type.
     comptime_args: ?[*]TypedValue = null,
     /// The ZIR instruction that is a function instruction. Use this to find
     /// the body. We store this rather than the body directly so that when ZIR
@@ -2975,6 +2976,7 @@ pub fn semaFile(mod: *Module, file: *Scope.File) SemaError!void {
             .owner_decl = new_decl,
             .namespace = &struct_obj.namespace,
             .func = null,
+            .fn_ret_ty = Type.initTag(.void),
             .owner_func = null,
         };
         defer sema.deinit();
@@ -3029,6 +3031,7 @@ fn semaDecl(mod: *Module, decl: *Decl) !bool {
         .owner_decl = decl,
         .namespace = decl.namespace,
         .func = null,
+        .fn_ret_ty = Type.initTag(.void),
         .owner_func = null,
     };
     defer sema.deinit();
@@ -3712,6 +3715,7 @@ pub fn analyzeFnBody(mod: *Module, decl: *Decl, func: *Fn) SemaError!Air {
         .owner_decl = decl,
         .namespace = decl.namespace,
         .func = func,
+        .fn_ret_ty = func.owner_decl.ty.fnReturnType(),
         .owner_func = func,
     };
     defer sema.deinit();
@@ -3764,7 +3768,7 @@ pub fn analyzeFnBody(mod: *Module, decl: *Decl, func: *Fn) SemaError!Air {
         };
         if (func.comptime_args) |comptime_args| {
             const arg_tv = comptime_args[total_param_index];
-            if (arg_tv.val.tag() != .unreachable_value) {
+            if (arg_tv.val.tag() != .generic_poison) {
                 // We have a comptime value for this parameter.
                 const arg = try sema.addConstant(arg_tv.ty, arg_tv.val);
                 sema.inst_map.putAssumeCapacityNoClobber(inst, arg);
@@ -4447,6 +4451,7 @@ pub fn analyzeStructFields(mod: *Module, struct_obj: *Struct) CompileError!void
         .namespace = &struct_obj.namespace,
         .owner_func = null,
         .func = null,
+        .fn_ret_ty = Type.initTag(.void),
     };
     defer sema.deinit();
 
@@ -4600,6 +4605,7 @@ pub fn analyzeUnionFields(mod: *Module, union_obj: *Union) CompileError!void {
         .namespace = &union_obj.namespace,
         .owner_func = null,
         .func = null,
+        .fn_ret_ty = Type.initTag(.void),
     };
     defer sema.deinit();
 
diff --git a/src/Sema.zig b/src/Sema.zig
index 825737e4c5..8bf4111566 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -29,6 +29,12 @@ owner_func: ?*Module.Fn,
 /// This starts out the same as `owner_func` and then diverges in the case of
 /// an inline or comptime function call.
 func: ?*Module.Fn,
+/// When semantic analysis needs to know the return type of the function whose body
+/// is being analyzed, this `Type` should be used instead of going through `func`.
+/// This will correctly handle the case of a comptime/inline function call of a
+/// generic function which uses a type expression for the return type.
+/// The type will be `void` in the case that `func` is `null`.
+fn_ret_ty: Type,
 branch_quota: u32 = 1000,
 branch_count: u32 = 0,
 /// This field is updated when a new source location becomes active, so that
@@ -628,6 +634,7 @@ fn analyzeAsType(
 
 /// May return Value Tags: `variable`, `undef`.
 /// See `resolveConstValue` for an alternative.
+/// Value Tag `generic_poison` causes `error.GenericPoison` to be returned.
 fn resolveValue(
     sema: *Sema,
     block: *Scope.Block,
@@ -679,6 +686,7 @@ fn resolveDefinedValue(
 
 /// Value Tag `variable` causes this function to return `null`.
 /// Value Tag `undef` causes this function to return the Value.
+/// Value Tag `generic_poison` causes `error.GenericPoison` to be returned.
 fn resolveMaybeUndefVal(
     sema: *Sema,
     block: *Scope.Block,
@@ -686,10 +694,11 @@ fn resolveMaybeUndefVal(
     inst: Air.Inst.Ref,
 ) CompileError!?Value {
     const val = (try sema.resolveMaybeUndefValAllowVariables(block, src, inst)) orelse return null;
-    if (val.tag() == .variable) {
-        return null;
+    switch (val.tag()) {
+        .variable => return null,
+        .generic_poison => return error.GenericPoison,
+        else => return val,
     }
-    return val;
 }
 
 /// Returns all Value tags including `variable` and `undef`.
@@ -1033,6 +1042,7 @@ fn zirEnumDecl(
             .namespace = &enum_obj.namespace,
             .owner_func = null,
             .func = null,
+            .fn_ret_ty = Type.initTag(.void),
             .branch_quota = sema.branch_quota,
             .branch_count = sema.branch_count,
         };
@@ -1238,9 +1248,7 @@ fn zirRetPtr(
 
     const src: LazySrcLoc = .{ .node_offset = @bitCast(i32, extended.operand) };
     try sema.requireFunctionBlock(block, src);
-    const fn_ty = sema.func.?.owner_decl.ty;
-    const ret_type = fn_ty.fnReturnType();
-    const ptr_type = try Module.simplePtrType(sema.arena, ret_type, true, .One);
+    const ptr_type = try Module.simplePtrType(sema.arena, sema.fn_ret_ty, true, .One);
     return block.addTy(.alloc, ptr_type);
 }
 
@@ -1263,9 +1271,7 @@ fn zirRetType(
 
     const src: LazySrcLoc = .{ .node_offset = @bitCast(i32, extended.operand) };
     try sema.requireFunctionBlock(block, src);
-    const fn_ty = sema.func.?.owner_decl.ty;
-    const ret_type = fn_ty.fnReturnType();
-    return sema.addType(ret_type);
+    return sema.addType(sema.fn_ret_ty);
 }
 
 fn zirEnsureResultUsed(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) CompileError!void {
@@ -2364,7 +2370,7 @@ const GenericCallAdapter = struct {
     generic_fn: *Module.Fn,
     precomputed_hash: u64,
     func_ty_info: Type.Payload.Function.Data,
-    comptime_vals: []const Value,
+    comptime_tvs: []const TypedValue,
 
     pub fn eql(ctx: @This(), adapted_key: void, other_key: *Module.Fn) bool {
         _ = adapted_key;
@@ -2373,12 +2379,22 @@ const GenericCallAdapter = struct {
         const generic_owner_decl = other_key.owner_decl.dependencies.keys()[0];
         if (ctx.generic_fn.owner_decl != generic_owner_decl) return false;
 
-        // This logic must be kept in sync with the logic in `analyzeCall` that
-        // computes the hash.
         const other_comptime_args = other_key.comptime_args.?;
-        for (ctx.func_ty_info.param_types) |param_ty, i| {
-            if (ctx.func_ty_info.paramIsComptime(i) and param_ty.tag() != .generic_poison) {
-                if (!ctx.comptime_vals[i].eql(other_comptime_args[i].val, param_ty)) {
+        for (other_comptime_args[0..ctx.func_ty_info.param_types.len]) |other_arg, i| {
+            if (other_arg.ty.tag() != .generic_poison) {
+                // anytype parameter
+                if (!other_arg.ty.eql(ctx.comptime_tvs[i].ty)) {
+                    return false;
+                }
+            }
+            if (other_arg.val.tag() != .generic_poison) {
+                // comptime parameter
+                if (ctx.comptime_tvs[i].val.tag() == .generic_poison) {
+                    // No match because the instantiation has a comptime parameter
+                    // but the callsite does not.
+                    return false;
+                }
+                if (!other_arg.val.eql(ctx.comptime_tvs[i].val, other_arg.ty)) {
                     return false;
                 }
             }
@@ -2394,6 +2410,22 @@ const GenericCallAdapter = struct {
     }
 };
 
+const GenericRemoveAdapter = struct {
+    precomputed_hash: u64,
+
+    pub fn eql(ctx: @This(), adapted_key: *Module.Fn, other_key: *Module.Fn) bool {
+        _ = ctx;
+        return adapted_key == other_key;
+    }
+
+    /// The implementation of the hash is in semantic analysis of function calls, so
+    /// that any errors when computing the hash can be properly reported.
+    pub fn hash(ctx: @This(), adapted_key: *Module.Fn) u64 {
+        _ = adapted_key;
+        return ctx.precomputed_hash;
+    }
+};
+
 fn analyzeCall(
     sema: *Sema,
     block: *Scope.Block,
@@ -2466,14 +2498,6 @@ fn analyzeCall(
     const is_inline_call = is_comptime_call or modifier == .always_inline or
         func_ty_info.cc == .Inline;
     const result: Air.Inst.Ref = if (is_inline_call) res: {
-        // TODO look into not allocating this args array
-        const args = try sema.arena.alloc(Air.Inst.Ref, uncasted_args.len);
-        for (uncasted_args) |uncasted_arg, i| {
-            const param_ty = func_ty.fnParamType(i);
-            const arg_src = call_src; // TODO: better source location
-            args[i] = try sema.coerce(block, param_ty, uncasted_arg, arg_src);
-        }
-
         const func_val = try sema.resolveConstValue(block, func_src, func);
         const module_fn = switch (func_val.tag()) {
             .function => func_val.castTag(.function).?.data,
@@ -2544,19 +2568,62 @@ fn analyzeCall(
         // This will have return instructions analyzed as break instructions to
         // the block_inst above. Here we are performing "comptime/inline semantic analysis"
         // for a function body, which means we must map the parameter ZIR instructions to
-        // the AIR instructions of the callsite.
+        // the AIR instructions of the callsite. The callee could be a generic function
+        // which means its parameter type expressions must be resolved in order and used
+        // to successively coerce the arguments.
         const fn_info = sema.code.getFnInfo(module_fn.zir_body_inst);
         const zir_tags = sema.code.instructions.items(.tag);
         var arg_i: usize = 0;
-        try sema.inst_map.ensureUnusedCapacity(gpa, @intCast(u32, args.len));
-        for (fn_info.param_body) |inst| {
-            switch (zir_tags[inst]) {
-                .param, .param_comptime, .param_anytype, .param_anytype_comptime => {},
-                else => continue,
+        for (fn_info.param_body) |inst| switch (zir_tags[inst]) {
+            .param, .param_comptime => {
+                // Evaluate the parameter type expression now that previous ones have
+                // been mapped, and coerce the corresponding argument to it.
+                const pl_tok = sema.code.instructions.items(.data)[inst].pl_tok;
+                const param_src = pl_tok.src();
+                const extra = sema.code.extraData(Zir.Inst.Param, pl_tok.payload_index);
+                const param_body = sema.code.extra[extra.end..][0..extra.data.body_len];
+                const param_ty_inst = try sema.resolveBody(&child_block, param_body);
+                const param_ty = try sema.analyzeAsType(&child_block, param_src, param_ty_inst);
+                const arg_src = call_src; // TODO: better source location
+                const casted_arg = try sema.coerce(&child_block, param_ty, uncasted_args[arg_i], arg_src);
+                try sema.inst_map.putNoClobber(gpa, inst, casted_arg);
+                arg_i += 1;
+                continue;
+            },
+            .param_anytype, .param_anytype_comptime => {
+                // No coercion needed.
+                try sema.inst_map.putNoClobber(gpa, inst, uncasted_args[arg_i]);
+                arg_i += 1;
+                continue;
+            },
+            else => continue,
+        };
+
+        // In case it is a generic function with an expression for the return type that depends
+        // on parameters, we must now do the same for the return type as we just did with
+        // each of the parameters, resolving the return type and providing it to the child
+        // `Sema` so that it can be used for the `ret_ptr` instruction.
+        const ret_ty_inst = try sema.resolveBody(&child_block, fn_info.ret_ty_body);
+        const ret_ty_src = func_src; // TODO better source location
+        const bare_return_type = try sema.analyzeAsType(&child_block, ret_ty_src, ret_ty_inst);
+        // If the function has an inferred error set, `bare_return_type` is the payload type only.
+        const fn_ret_ty = blk: {
+            // TODO instead of reusing the function's inferred error set, this code should
+            // create a temporary error set which is used for the comptime/inline function
+            // call alone, independent from the runtime instantiation.
+            if (func_ty_info.return_type.castTag(.error_union)) |payload| {
+                const error_set_ty = payload.data.error_set;
+                break :blk try Type.Tag.error_union.create(sema.arena, .{
+                    .error_set = error_set_ty,
+                    .payload = bare_return_type,
+                });
             }
-            sema.inst_map.putAssumeCapacityNoClobber(inst, args[arg_i]);
-            arg_i += 1;
-        }
+            break :blk bare_return_type;
+        };
+        const parent_fn_ret_ty = sema.fn_ret_ty;
+        sema.fn_ret_ty = fn_ret_ty;
+        defer sema.fn_ret_ty = parent_fn_ret_ty;
+
         _ = try sema.analyzeBody(&child_block, fn_info.body);
         break :res try sema.analyzeBlockBody(block, call_src, &child_block, merges);
     } else if (func_ty_info.is_generic) res: {
@@ -2569,57 +2636,74 @@ fn analyzeCall(
         const fn_zir = namespace.file_scope.zir;
         const fn_info = fn_zir.getFnInfo(module_fn.zir_body_inst);
         const zir_tags = fn_zir.instructions.items(.tag);
-        const new_module_func = new_func: {
-            // This hash must match `Module.MonomorphedFuncsContext.hash`.
-            // For parameters explicitly marked comptime and simple parameter type expressions,
-            // we know whether a parameter is elided from a monomorphed function, and can
-            // use it in the hash here. However, for parameter type expressions that are not
-            // explicitly marked comptime and rely on previous parameter comptime values, we
-            // don't find out until after generating a monomorphed function whether the parameter
-            // type ended up being a "must-be-comptime-known" type.
-            var hasher = std.hash.Wyhash.init(0);
-            std.hash.autoHash(&hasher, @ptrToInt(module_fn));
 
-            const comptime_vals = try sema.arena.alloc(Value, func_ty_info.param_types.len);
+        // This hash must match `Module.MonomorphedFuncsContext.hash`.
+        // For parameters explicitly marked comptime and simple parameter type expressions,
+        // we know whether a parameter is elided from a monomorphed function, and can
+        // use it in the hash here. However, for parameter type expressions that are not
+        // explicitly marked comptime and rely on previous parameter comptime values, we
+        // don't find out until after generating a monomorphed function whether the parameter
+        // type ended up being a "must-be-comptime-known" type.
+        var hasher = std.hash.Wyhash.init(0);
+        std.hash.autoHash(&hasher, @ptrToInt(module_fn));
 
-            for (func_ty_info.param_types) |param_ty, i| {
-                const is_comptime = func_ty_info.paramIsComptime(i);
-                if (is_comptime and param_ty.tag() != .generic_poison) {
-                    const arg_src = call_src; // TODO better source location
-                    const casted_arg = try sema.coerce(block, param_ty, uncasted_args[i], arg_src);
-                    if (try sema.resolveMaybeUndefVal(block, arg_src, casted_arg)) |arg_val| {
+        const comptime_tvs = try sema.arena.alloc(TypedValue, func_ty_info.param_types.len);
+
+        for (func_ty_info.param_types) |param_ty, i| {
+            const is_comptime = func_ty_info.paramIsComptime(i);
+            if (is_comptime) {
+                const arg_src = call_src; // TODO better source location
+                const casted_arg = try sema.coerce(block, param_ty, uncasted_args[i], arg_src);
+                if (try sema.resolveMaybeUndefVal(block, arg_src, casted_arg)) |arg_val| {
+                    if (param_ty.tag() != .generic_poison) {
                         arg_val.hash(param_ty, &hasher);
-                        comptime_vals[i] = arg_val;
-                    } else {
-                        return sema.failWithNeededComptime(block, arg_src);
                     }
+                    comptime_tvs[i] = .{
+                        // This will be different than `param_ty` in the case of `generic_poison`.
+                        .ty = sema.typeOf(casted_arg),
+                        .val = arg_val,
+                    };
+                } else {
+                    return sema.failWithNeededComptime(block, arg_src);
                 }
+            } else {
+                comptime_tvs[i] = .{
+                    .ty = sema.typeOf(uncasted_args[i]),
+                    .val = Value.initTag(.generic_poison),
+                };
             }
+        }
 
-            const adapter: GenericCallAdapter = .{
-                .generic_fn = module_fn,
-                .precomputed_hash = hasher.final(),
-                .func_ty_info = func_ty_info,
-                .comptime_vals = comptime_vals,
-            };
-            const gop = try mod.monomorphed_funcs.getOrPutAdapted(gpa, {}, adapter);
-            if (gop.found_existing) {
-                const callee_func = gop.key_ptr.*;
-                break :res try sema.finishGenericCall(
-                    block,
-                    call_src,
-                    callee_func,
-                    func_src,
-                    uncasted_args,
-                    fn_info,
-                    zir_tags,
-                );
-            }
-            gop.key_ptr.* = try gpa.create(Module.Fn);
-            break :new_func gop.key_ptr.*;
+        const precomputed_hash = hasher.final();
+
+        const adapter: GenericCallAdapter = .{
+            .generic_fn = module_fn,
+            .precomputed_hash = precomputed_hash,
+            .func_ty_info = func_ty_info,
+            .comptime_tvs = comptime_tvs,
         };
-
+        const gop = try mod.monomorphed_funcs.getOrPutAdapted(gpa, {}, adapter);
+        if (gop.found_existing) {
+            const callee_func = gop.key_ptr.*;
+            break :res try sema.finishGenericCall(
+                block,
+                call_src,
+                callee_func,
+                func_src,
+                uncasted_args,
+                fn_info,
+                zir_tags,
+            );
+        }
+        const new_module_func = try gpa.create(Module.Fn);
+        gop.key_ptr.* = new_module_func;
         {
+            errdefer gpa.destroy(new_module_func);
+            const remove_adapter: GenericRemoveAdapter = .{
+                .precomputed_hash = precomputed_hash,
+            };
+            errdefer assert(mod.monomorphed_funcs.removeAdapted(new_module_func, remove_adapter));
+
             try namespace.anon_decls.ensureUnusedCapacity(gpa, 1);
 
             // Create a Decl for the new function.
@@ -2658,6 +2742,7 @@ fn analyzeCall(
                 .owner_decl = new_decl,
                 .namespace = namespace,
                 .func = null,
+                .fn_ret_ty = Type.initTag(.void),
                 .owner_func = null,
                 .comptime_args = try new_decl_arena.allocator.alloc(TypedValue, uncasted_args.len),
                 .comptime_args_fn_inst = module_fn.zir_body_inst,
@@ -2681,11 +2766,25 @@ fn analyzeCall(
             try child_sema.inst_map.ensureUnusedCapacity(gpa, @intCast(u32, uncasted_args.len));
             var arg_i: usize = 0;
             for (fn_info.param_body) |inst| {
-                const is_comptime = switch (zir_tags[inst]) {
-                    .param_comptime, .param_anytype_comptime => true,
-                    .param, .param_anytype => false,
+                var is_comptime = false;
+                var is_anytype = false;
+                switch (zir_tags[inst]) {
+                    .param => {
+                        is_comptime = func_ty_info.paramIsComptime(arg_i);
+                    },
+                    .param_comptime => {
+                        is_comptime = true;
+                    },
+                    .param_anytype => {
+                        is_anytype = true;
+                        is_comptime = func_ty_info.paramIsComptime(arg_i);
+                    },
+                    .param_anytype_comptime => {
+                        is_anytype = true;
+                        is_comptime = true;
+                    },
                     else => continue,
-                } or func_ty_info.paramIsComptime(arg_i);
+                }
                 const arg_src = call_src; // TODO: better source location
                 const arg = uncasted_args[arg_i];
                 if (try sema.resolveMaybeUndefVal(block, arg_src, arg)) |arg_val| {
@@ -2693,6 +2792,12 @@ fn analyzeCall(
                     child_sema.inst_map.putAssumeCapacityNoClobber(inst, child_arg);
                 } else if (is_comptime) {
                     return sema.failWithNeededComptime(block, arg_src);
+                } else if (is_anytype) {
+                    const child_arg = try child_sema.addConstant(
+                        sema.typeOf(arg),
+                        Value.initTag(.generic_poison),
+                    );
+                    child_sema.inst_map.putAssumeCapacityNoClobber(inst, child_arg);
                 }
                 arg_i += 1;
             }
@@ -2710,17 +2815,10 @@ fn analyzeCall(
                 const arg = child_sema.inst_map.get(inst).?;
                 const arg_val = (child_sema.resolveMaybeUndefValAllowVariables(&child_block, .unneeded, arg) catch unreachable).?;
 
-                if (arg_val.tag() == .generic_poison) {
-                    child_sema.comptime_args[arg_i] = .{
-                        .ty = Type.initTag(.noreturn),
-                        .val = Value.initTag(.unreachable_value),
-                    };
-                } else {
-                    child_sema.comptime_args[arg_i] = .{
-                        .ty = try child_sema.typeOf(arg).copy(&new_decl_arena.allocator),
-                        .val = try arg_val.copy(&new_decl_arena.allocator),
-                    };
-                }
+                child_sema.comptime_args[arg_i] = .{
+                    .ty = try child_sema.typeOf(arg).copy(&new_decl_arena.allocator),
+                    .val = try arg_val.copy(&new_decl_arena.allocator),
+                };
 
                 arg_i += 1;
             }
@@ -2730,6 +2828,18 @@ fn analyzeCall(
             new_decl.val = try Value.Tag.function.create(&new_decl_arena.allocator, new_func);
             new_decl.analysis = .complete;
 
+            if (new_decl.ty.fnInfo().is_generic) {
+                // TODO improve this error message. This can happen because of the parameter
+                // type expression or return type expression depending on runtime-provided values.
+                // The error message should be emitted in zirParam or funcCommon when it
+                // is determined that we are trying to instantiate a generic function.
+                return mod.fail(&block.base, call_src, "unable to monomorphize function", .{});
+            }
+
+            log.debug("generic function '{s}' instantiated with type {}", .{
+                new_decl.name, new_decl.ty,
+            });
+
             // The generic function Decl is guaranteed to be the first dependency
             // of each of its instantiations.
             assert(new_decl.dependencies.keys().len == 0);
@@ -2809,7 +2919,7 @@ fn finishGenericCall(
         for (fn_info.param_body) |inst| {
             switch (zir_tags[inst]) {
                 .param_comptime, .param_anytype_comptime, .param, .param_anytype => {
-                    if (comptime_args[arg_i].val.tag() == .unreachable_value) {
+                    if (comptime_args[arg_i].val.tag() == .generic_poison) {
                         count += 1;
                     }
                     arg_i += 1;
@@ -2829,7 +2939,7 @@ fn finishGenericCall(
                 .param_comptime, .param_anytype_comptime, .param, .param_anytype => {},
                 else => continue,
             }
-            const is_runtime = comptime_args[total_i].val.tag() == .unreachable_value;
+            const is_runtime = comptime_args[total_i].val.tag() == .generic_poison;
             if (is_runtime) {
                 const param_ty = new_fn_ty.fnParamType(runtime_i);
                 const arg_src = call_src; // TODO: better source location
@@ -6162,28 +6272,23 @@ fn zirRetNode(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) CompileErr
 fn analyzeRet(
     sema: *Sema,
     block: *Scope.Block,
-    operand: Air.Inst.Ref,
+    uncasted_operand: Air.Inst.Ref,
     src: LazySrcLoc,
     need_coercion: bool,
 ) CompileError!Zir.Inst.Index {
-    const casted_operand = if (!need_coercion) operand else op: {
-        const func = sema.func.?;
-        const fn_ty = func.owner_decl.ty;
-        // TODO: In the case of a comptime/inline function call of a generic function,
-        // this needs to be the resolved return type based on the function parameter type
-        // expressions being evaluated with comptime arguments passed in. Otherwise, this
-        // ends up being .generic_poison and failing the comptime/inline function call analysis.
-        const fn_ret_ty = fn_ty.fnReturnType();
-        break :op try sema.coerce(block, fn_ret_ty, operand, src);
-    };
+    const operand = if (!need_coercion)
+        uncasted_operand
+    else
+        try sema.coerce(block, sema.fn_ret_ty, uncasted_operand, src);
+
     if (block.inlining) |inlining| {
         // We are inlining a function call; rewrite the `ret` as a `break`.
-        try inlining.merges.results.append(sema.gpa, casted_operand);
-        _ = try block.addBr(inlining.merges.block_inst, casted_operand);
+        try inlining.merges.results.append(sema.gpa, operand);
+        _ = try block.addBr(inlining.merges.block_inst, operand);
         return always_noreturn;
     }
 
-    _ = try block.addUnOp(.ret, casted_operand);
+    _ = try block.addUnOp(.ret, operand);
     return always_noreturn;
 }
 
diff --git a/src/codegen/llvm.zig b/src/codegen/llvm.zig
index 91b48ffcfb..4b7454d878 100644
--- a/src/codegen/llvm.zig
+++ b/src/codegen/llvm.zig
@@ -1093,21 +1093,32 @@ pub const FuncGen = struct {
         const rhs = try self.resolveInst(bin_op.rhs);
         const inst_ty = self.air.typeOfIndex(inst);
 
-        if (!inst_ty.isInt())
-            if (inst_ty.tag() != .bool)
-                return self.todo("implement 'airCmp' for type {}", .{inst_ty});
-
-        const is_signed = inst_ty.isSignedInt();
-        const operation = switch (op) {
-            .eq => .EQ,
-            .neq => .NE,
-            .lt => @as(llvm.IntPredicate, if (is_signed) .SLT else .ULT),
-            .lte => @as(llvm.IntPredicate, if (is_signed) .SLE else .ULE),
-            .gt => @as(llvm.IntPredicate, if (is_signed) .SGT else .UGT),
-            .gte => @as(llvm.IntPredicate, if (is_signed) .SGE else .UGE),
-        };
-
-        return self.builder.buildICmp(operation, lhs, rhs, "");
+        switch (self.air.typeOf(bin_op.lhs).zigTypeTag()) {
+            .Int, .Bool, .Pointer => {
+                const is_signed = inst_ty.isSignedInt();
+                const operation = switch (op) {
+                    .eq => .EQ,
+                    .neq => .NE,
+                    .lt => @as(llvm.IntPredicate, if (is_signed) .SLT else .ULT),
+                    .lte => @as(llvm.IntPredicate, if (is_signed) .SLE else .ULE),
+                    .gt => @as(llvm.IntPredicate, if (is_signed) .SGT else .UGT),
+                    .gte => @as(llvm.IntPredicate, if (is_signed) .SGE else .UGE),
+                };
+                return self.builder.buildICmp(operation, lhs, rhs, "");
+            },
+            .Float => {
+                const operation: llvm.RealPredicate = switch (op) {
+                    .eq => .OEQ,
+                    .neq => .UNE,
+                    .lt => .OLT,
+                    .lte => .OLE,
+                    .gt => .OGT,
+                    .gte => .OGE,
+                };
+                return self.builder.buildFCmp(operation, lhs, rhs, "");
+            },
+            else => unreachable,
+        }
     }
 
     fn airBlock(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
diff --git a/src/codegen/llvm/bindings.zig b/src/codegen/llvm/bindings.zig
index 675c5539fb..096cd4a5b4 100644
--- a/src/codegen/llvm/bindings.zig
+++ b/src/codegen/llvm/bindings.zig
@@ -409,6 +409,9 @@ pub const Builder = opaque {
     pub const buildICmp = LLVMBuildICmp;
     extern fn LLVMBuildICmp(*const Builder, Op: IntPredicate, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
 
+    pub const buildFCmp = LLVMBuildFCmp;
+    extern fn LLVMBuildFCmp(*const Builder, Op: RealPredicate, LHS: *const Value, RHS: *const Value, Name: [*:0]const u8) *const Value;
+
     pub const buildBr = LLVMBuildBr;
     extern fn LLVMBuildBr(*const Builder, Dest: *const BasicBlock) *const Value;
 
@@ -451,7 +454,7 @@ pub const Builder = opaque {
     ) *const Value;
 };
 
-pub const IntPredicate = enum(c_int) {
+pub const IntPredicate = enum(c_uint) {
     EQ = 32,
     NE = 33,
     UGT = 34,
@@ -464,6 +467,23 @@ pub const IntPredicate = enum(c_int) {
     SLE = 41,
 };
 
+pub const RealPredicate = enum(c_uint) {
+    OEQ = 1,
+    OGT = 2,
+    OGE = 3,
+    OLT = 4,
+    OLE = 5,
+    ONE = 6,
+    ORD = 7,
+    UNO = 8,
+    UEQ = 9,
+    UGT = 10,
+    UGE = 11,
+    ULT = 12,
+    ULE = 13,
+    UNE = 14,
+};
+
 pub const BasicBlock = opaque {
     pub const deleteBasicBlock = LLVMDeleteBasicBlock;
     extern fn LLVMDeleteBasicBlock(BB: *const BasicBlock) void;
diff --git a/test/behavior/generics.zig b/test/behavior/generics.zig
index a3c5668b39..bb5504b479 100644
--- a/test/behavior/generics.zig
+++ b/test/behavior/generics.zig
@@ -64,9 +64,41 @@ fn sameButWithFloats(a: f64, b: f64) f64 {
 test "fn with comptime args" {
     try expect(gimmeTheBigOne(1234, 5678) == 5678);
     try expect(shouldCallSameInstance(34, 12) == 34);
+    try expect(sameButWithFloats(0.43, 0.49) == 0.49);
+}
+
+test "anytype params" {
+    try expect(max_i32(12, 34) == 34);
+    try expect(max_f64(1.2, 3.4) == 3.4);
     if (!builtin.zig_is_stage2) {
-        // TODO: stage2 llvm backend needs to use fcmp instead of icmp
-        // probably AIR should just have different instructions for floats.
-        try expect(sameButWithFloats(0.43, 0.49) == 0.49);
+        // TODO: stage2 is incorrectly hitting the following problem:
+        // error: unable to resolve comptime value
+        //     return max_anytype(a, b);
+        //                       ^
+        comptime {
+            try expect(max_i32(12, 34) == 34);
+            try expect(max_f64(1.2, 3.4) == 3.4);
+        }
     }
 }
+
+fn max_anytype(a: anytype, b: anytype) @TypeOf(a, b) {
+    if (!builtin.zig_is_stage2) {
+        // TODO: stage2 is incorrectly emitting AIR that allocates a result
+        // value, stores to it, but then returns void instead of the result.
+        return if (a > b) a else b;
+    }
+    if (a > b) {
+        return a;
+    } else {
+        return b;
+    }
+}
+
+fn max_i32(a: i32, b: i32) i32 {
+    return max_anytype(a, b);
+}
+
+fn max_f64(a: f64, b: f64) f64 {
+    return max_anytype(a, b);
+}
diff --git a/test/behavior/generics_stage1.zig b/test/behavior/generics_stage1.zig
index 7ee263b1b9..4b768a5b4f 100644
--- a/test/behavior/generics_stage1.zig
+++ b/test/behavior/generics_stage1.zig
@@ -3,28 +3,6 @@ const testing = std.testing;
 const expect = testing.expect;
 const expectEqual = testing.expectEqual;
 
-test "anytype params" {
-    try expect(max_i32(12, 34) == 34);
-    try expect(max_f64(1.2, 3.4) == 3.4);
-}
-
-test {
-    comptime try expect(max_i32(12, 34) == 34);
-    comptime try expect(max_f64(1.2, 3.4) == 3.4);
-}
-
-fn max_anytype(a: anytype, b: anytype) @TypeOf(a + b) {
-    return if (a > b) a else b;
-}
-
-fn max_i32(a: i32, b: i32) i32 {
-    return max_anytype(a, b);
-}
-
-fn max_f64(a: f64, b: f64) f64 {
-    return max_anytype(a, b);
-}
-
 pub fn List(comptime T: type) type {
     return SmallList(T, 8);
 }

From e974d4c4295c4fbdbc239caa2cf2d653f65662f1 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Fri, 6 Aug 2021 17:26:37 -0700
Subject: [PATCH 90/96] stage2: get rid of "unable to monomorphize function"
 error

This commit solves the problem in a much simpler way: putting
runtime-known values in place of non-comptime arguments when
instantiating a generic function.
---
 src/Module.zig | 10 +++++++++
 src/Sema.zig   | 55 ++++++++++++++++++++++++++++++--------------------
 2 files changed, 43 insertions(+), 22 deletions(-)

diff --git a/src/Module.zig b/src/Module.zig
index 3652a27927..42b36b5a04 100644
--- a/src/Module.zig
+++ b/src/Module.zig
@@ -1376,6 +1376,16 @@ pub const Scope = struct {
             });
         }
 
+        pub fn addArg(block: *Block, ty: Type, name: u32) error{OutOfMemory}!Air.Inst.Ref {
+            return block.addInst(.{
+                .tag = .arg,
+                .data = .{ .ty_str = .{
+                    .ty = try block.sema.addType(ty),
+                    .str = name,
+                } },
+            });
+        }
+
         pub fn addInst(block: *Block, inst: Air.Inst) error{OutOfMemory}!Air.Inst.Ref {
             return Air.indexToRef(try block.addInstAsIndex(inst));
         }
diff --git a/src/Sema.zig b/src/Sema.zig
index 8bf4111566..87df3c375f 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -2793,16 +2793,24 @@ fn analyzeCall(
                 } else if (is_comptime) {
                     return sema.failWithNeededComptime(block, arg_src);
                 } else if (is_anytype) {
-                    const child_arg = try child_sema.addConstant(
-                        sema.typeOf(arg),
-                        Value.initTag(.generic_poison),
-                    );
+                    // We insert into the map an instruction which is runtime-known
+                    // but has the type of the comptime argument.
+                    const child_arg = try child_block.addArg(sema.typeOf(arg), 0);
                     child_sema.inst_map.putAssumeCapacityNoClobber(inst, child_arg);
                 }
                 arg_i += 1;
             }
-            const new_func_inst = try child_sema.resolveBody(&child_block, fn_info.param_body);
-            const new_func_val = try child_sema.resolveConstValue(&child_block, .unneeded, new_func_inst);
+            const new_func_inst = child_sema.resolveBody(&child_block, fn_info.param_body) catch |err| {
+                // TODO look up the compile error that happened here and attach a note to it
+                // pointing here, at the generic instantiation callsite.
+                if (sema.owner_func) |owner_func| {
+                    owner_func.state = .dependency_failure;
+                } else {
+                    sema.owner_decl.analysis = .dependency_failure;
+                }
+                return err;
+            };
+            const new_func_val = child_sema.resolveConstValue(&child_block, .unneeded, new_func_inst) catch unreachable;
             const new_func = new_func_val.castTag(.function).?.data;
             assert(new_func == new_module_func);
 
@@ -2813,12 +2821,22 @@ fn analyzeCall(
                     else => continue,
                 }
                 const arg = child_sema.inst_map.get(inst).?;
-                const arg_val = (child_sema.resolveMaybeUndefValAllowVariables(&child_block, .unneeded, arg) catch unreachable).?;
-
-                child_sema.comptime_args[arg_i] = .{
-                    .ty = try child_sema.typeOf(arg).copy(&new_decl_arena.allocator),
-                    .val = try arg_val.copy(&new_decl_arena.allocator),
-                };
+                const copied_arg_ty = try child_sema.typeOf(arg).copy(&new_decl_arena.allocator);
+                if (child_sema.resolveMaybeUndefValAllowVariables(
+                    &child_block,
+                    .unneeded,
+                    arg,
+                ) catch unreachable) |arg_val| {
+                    child_sema.comptime_args[arg_i] = .{
+                        .ty = copied_arg_ty,
+                        .val = try arg_val.copy(&new_decl_arena.allocator),
+                    };
+                } else {
+                    child_sema.comptime_args[arg_i] = .{
+                        .ty = copied_arg_ty,
+                        .val = Value.initTag(.generic_poison),
+                    };
+                }
 
                 arg_i += 1;
             }
@@ -2828,17 +2846,10 @@ fn analyzeCall(
             new_decl.val = try Value.Tag.function.create(&new_decl_arena.allocator, new_func);
             new_decl.analysis = .complete;
 
-            if (new_decl.ty.fnInfo().is_generic) {
-                // TODO improve this error message. This can happen because of the parameter
-                // type expression or return type expression depending on runtime-provided values.
-                // The error message should be emitted in zirParam or funcCommon when it
-                // is determined that we are trying to instantiate a generic function.
-                return mod.fail(&block.base, call_src, "unable to monomorphize function", .{});
-            }
-
             log.debug("generic function '{s}' instantiated with type {}", .{
                 new_decl.name, new_decl.ty,
             });
+            assert(!new_decl.ty.fnInfo().is_generic);
 
             // The generic function Decl is guaranteed to be the first dependency
             // of each of its instantiations.
@@ -8371,8 +8382,8 @@ fn analyzeDeclVal(
 fn analyzeDeclRef(sema: *Sema, decl: *Decl) CompileError!Air.Inst.Ref {
     try sema.mod.declareDeclDependency(sema.owner_decl, decl);
     sema.mod.ensureDeclAnalyzed(decl) catch |err| {
-        if (sema.func) |func| {
-            func.state = .dependency_failure;
+        if (sema.owner_func) |owner_func| {
+            owner_func.state = .dependency_failure;
         } else {
             sema.owner_decl.analysis = .dependency_failure;
         }

From 7d0de54ad44832589379a4bcbba493db2087bebf Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Fri, 6 Aug 2021 19:40:55 -0700
Subject: [PATCH 91/96] stage2: fix return pointer result locations

 * Introduce `ret_load` ZIR instruction which does return semantics
   based on a corresponding `ret_ptr` instruction. If the return type of
   the function has storage for the return type, it simply returns.
   However if the return type of the function is by-value, it loads the
   return value from the `ret_ptr` allocation and returns that.

 * AstGen: improve `finishThenElseBlock` to not emit break instructions
   after a return instruction in the same block.

 * Sema: `ret_ptr` instruction works correctly in comptime contexts.
   Same with `alloc_mut`.

The test case with a recursive inline function having an implicitly
comptime return value now has a runtime return value because of the fact
that it calls a function in a non-comptime context.
---
 src/AstGen.zig             | 34 ++++++++++++++------
 src/Sema.zig               | 66 ++++++++++++++++++++++++++++----------
 src/Zir.zig                |  8 +++++
 test/behavior/generics.zig | 34 +++-----------------
 test/stage2/cbe.zig        |  6 +++-
 5 files changed, 92 insertions(+), 56 deletions(-)

diff --git a/src/AstGen.zig b/src/AstGen.zig
index 1b6cbc6c3f..ae37866b97 100644
--- a/src/AstGen.zig
+++ b/src/AstGen.zig
@@ -2131,6 +2131,7 @@ fn unusedResultExpr(gz: *GenZir, scope: *Scope, statement: ast.Node.Index) Inner
             .condbr_inline,
             .compile_error,
             .ret_node,
+            .ret_load,
             .ret_coerce,
             .ret_err_value,
             .@"unreachable",
@@ -4791,11 +4792,10 @@ fn finishThenElseBlock(
     const strat = rl.strategy(block_scope);
     switch (strat.tag) {
         .break_void => {
-            if (!parent_gz.refIsNoReturn(then_result)) {
+            if (!then_scope.endsWithNoReturn()) {
                 _ = try then_scope.addBreak(break_tag, then_break_block, .void_value);
             }
-            const elide_else = if (else_result != .none) parent_gz.refIsNoReturn(else_result) else false;
-            if (!elide_else) {
+            if (!else_scope.endsWithNoReturn()) {
                 _ = try else_scope.addBreak(break_tag, main_block, .void_value);
             }
             assert(!strat.elide_store_to_block_ptr_instructions);
@@ -4803,11 +4803,11 @@ fn finishThenElseBlock(
             return indexToRef(main_block);
         },
         .break_operand => {
-            if (!parent_gz.refIsNoReturn(then_result)) {
+            if (!then_scope.endsWithNoReturn()) {
                 _ = try then_scope.addBreak(break_tag, then_break_block, then_result);
             }
             if (else_result != .none) {
-                if (!parent_gz.refIsNoReturn(else_result)) {
+                if (!else_scope.endsWithNoReturn()) {
                     _ = try else_scope.addBreak(break_tag, main_block, else_result);
                 }
             } else {
@@ -6236,7 +6236,7 @@ fn ret(gz: *GenZir, scope: *Scope, node: ast.Node.Index) InnerError!Zir.Inst.Ref
             // Value is always an error. Emit both error defers and regular defers.
             const err_code = try gz.addUnNode(.err_union_code, operand, node);
             try genDefers(gz, defer_outer, scope, .{ .both = err_code });
-            _ = try gz.addUnNode(.ret_node, operand, node);
+            try gz.addRet(rl, operand, node);
             return Zir.Inst.Ref.unreachable_value;
         },
         .maybe => {
@@ -6244,7 +6244,7 @@ fn ret(gz: *GenZir, scope: *Scope, node: ast.Node.Index) InnerError!Zir.Inst.Ref
             if (!defer_counts.have_err) {
                 // Only regular defers; no branch needed.
                 try genDefers(gz, defer_outer, scope, .normal_only);
-                _ = try gz.addUnNode(.ret_node, operand, node);
+                try gz.addRet(rl, operand, node);
                 return Zir.Inst.Ref.unreachable_value;
             }
 
@@ -6256,7 +6256,7 @@ fn ret(gz: *GenZir, scope: *Scope, node: ast.Node.Index) InnerError!Zir.Inst.Ref
             defer then_scope.instructions.deinit(astgen.gpa);
 
             try genDefers(&then_scope, defer_outer, scope, .normal_only);
-            _ = try then_scope.addUnNode(.ret_node, operand, node);
+            try then_scope.addRet(rl, operand, node);
 
             var else_scope = gz.makeSubBlock(scope);
             defer else_scope.instructions.deinit(astgen.gpa);
@@ -6265,7 +6265,7 @@ fn ret(gz: *GenZir, scope: *Scope, node: ast.Node.Index) InnerError!Zir.Inst.Ref
                 .both = try else_scope.addUnNode(.err_union_code, operand, node),
             };
             try genDefers(&else_scope, defer_outer, scope, which_ones);
-            _ = try else_scope.addUnNode(.ret_node, operand, node);
+            try else_scope.addRet(rl, operand, node);
 
             try setCondBrPayload(condbr, is_non_err, &then_scope, &else_scope);
 
@@ -9003,6 +9003,14 @@ const GenZir = struct {
         used: bool = false,
     };
 
+    fn endsWithNoReturn(gz: GenZir) bool {
+        const tags = gz.astgen.instructions.items(.tag);
+        if (gz.instructions.items.len == 0) return false;
+        const last_inst = gz.instructions.items[gz.instructions.items.len - 1];
+        return tags[last_inst].isNoReturn();
+    }
+
+    /// TODO all uses of this should be replaced with uses of `endsWithNoReturn`.
     fn refIsNoReturn(gz: GenZir, inst_ref: Zir.Inst.Ref) bool {
         if (inst_ref == .unreachable_value) return true;
         if (refToIndex(inst_ref)) |inst_index| {
@@ -9977,6 +9985,14 @@ const GenZir = struct {
         gz.instructions.appendAssumeCapacity(new_index);
         return new_index;
     }
+
+    fn addRet(gz: *GenZir, rl: ResultLoc, operand: Zir.Inst.Ref, node: ast.Node.Index) !void {
+        switch (rl) {
+            .ptr => |ret_ptr| _ = try gz.addUnNode(.ret_load, ret_ptr, node),
+            .ty => _ = try gz.addUnNode(.ret_node, operand, node),
+            else => unreachable,
+        }
+    }
 };
 
 /// This can only be for short-lived references; the memory becomes invalidated
diff --git a/src/Sema.zig b/src/Sema.zig
index 87df3c375f..109c1c9335 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -366,6 +366,7 @@ pub fn analyzeBody(
             .compile_error  => return sema.zirCompileError(block, inst),
             .ret_coerce     => return sema.zirRetCoerce(block, inst),
             .ret_node       => return sema.zirRetNode(block, inst),
+            .ret_load       => return sema.zirRetLoad(block, inst),
             .ret_err_value  => return sema.zirRetErrValue(block, inst),
             .@"unreachable" => return sema.zirUnreachable(block, inst),
             .repeat         => return sema.zirRepeat(block, inst),
@@ -718,8 +719,8 @@ fn resolveMaybeUndefValAllowVariables(
     if (try sema.typeHasOnePossibleValue(block, src, sema.typeOf(inst))) |opv| {
         return opv;
     }
-
-    switch (sema.air_instructions.items(.tag)[i]) {
+    const air_tags = sema.air_instructions.items(.tag);
+    switch (air_tags[i]) {
         .constant => {
             const ty_pl = sema.air_instructions.items(.data)[i].ty_pl;
             return sema.air_values.items[ty_pl.payload];
@@ -1248,6 +1249,11 @@ fn zirRetPtr(
 
     const src: LazySrcLoc = .{ .node_offset = @bitCast(i32, extended.operand) };
     try sema.requireFunctionBlock(block, src);
+
+    if (block.is_comptime) {
+        return sema.analyzeComptimeAlloc(block, sema.fn_ret_ty);
+    }
+
     const ptr_type = try Module.simplePtrType(sema.arena, sema.fn_ret_ty, true, .One);
     return block.addTy(.alloc, ptr_type);
 }
@@ -1375,21 +1381,7 @@ fn zirAllocComptime(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) Comp
     const inst_data = sema.code.instructions.items(.data)[inst].un_node;
     const ty_src: LazySrcLoc = .{ .node_offset_var_decl_ty = inst_data.src_node };
     const var_type = try sema.resolveType(block, ty_src, inst_data.operand);
-    const ptr_type = try Module.simplePtrType(sema.arena, var_type, true, .One);
-
-    var anon_decl = try block.startAnonDecl();
-    defer anon_decl.deinit();
-    const decl = try anon_decl.finish(
-        try var_type.copy(anon_decl.arena()),
-        // AstGen guarantees there will be a store before the first load, so we put a value
-        // here indicating there is no valid value.
-        Value.initTag(.unreachable_value),
-    );
-    try sema.mod.declareDeclDependency(sema.owner_decl, decl);
-    return sema.addConstant(ptr_type, try Value.Tag.decl_ref_mut.create(sema.arena, .{
-        .runtime_index = block.runtime_index,
-        .decl = decl,
-    }));
+    return sema.analyzeComptimeAlloc(block, var_type);
 }
 
 fn zirAllocInferredComptime(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
@@ -1419,6 +1411,9 @@ fn zirAllocMut(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) CompileEr
     const var_decl_src = inst_data.src();
     const ty_src: LazySrcLoc = .{ .node_offset_var_decl_ty = inst_data.src_node };
     const var_type = try sema.resolveType(block, ty_src, inst_data.operand);
+    if (block.is_comptime) {
+        return sema.analyzeComptimeAlloc(block, var_type);
+    }
     try sema.validateVarType(block, ty_src, var_type);
     const ptr_type = try Module.simplePtrType(sema.arena, var_type, true, .One);
     try sema.requireRuntimeBlock(block, var_decl_src);
@@ -6280,6 +6275,21 @@ fn zirRetNode(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) CompileErr
     return sema.analyzeRet(block, operand, src, false);
 }
 
+fn zirRetLoad(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) CompileError!Zir.Inst.Index {
+    const tracy = trace(@src());
+    defer tracy.end();
+
+    const inst_data = sema.code.instructions.items(.data)[inst].un_node;
+    const src = inst_data.src();
+    // TODO: when implementing functions that accept a result location pointer,
+    // this logic will be updated to only do a load in case that the function's return
+    // type in fact does not need a result location pointer. Until then we assume
+    // the `ret_ptr` is the same as an `alloc` and do a load here.
+    const ret_ptr = sema.resolveInst(inst_data.operand);
+    const operand = try sema.analyzeLoad(block, src, ret_ptr, src);
+    return sema.analyzeRet(block, operand, src, false);
+}
+
 fn analyzeRet(
     sema: *Sema,
     block: *Scope.Block,
@@ -9416,3 +9426,25 @@ fn isComptimeKnown(
 ) !bool {
     return (try sema.resolveMaybeUndefVal(block, src, inst)) != null;
 }
+
+fn analyzeComptimeAlloc(
+    sema: *Sema,
+    block: *Scope.Block,
+    var_type: Type,
+) CompileError!Air.Inst.Ref {
+    const ptr_type = try Module.simplePtrType(sema.arena, var_type, true, .One);
+
+    var anon_decl = try block.startAnonDecl();
+    defer anon_decl.deinit();
+    const decl = try anon_decl.finish(
+        try var_type.copy(anon_decl.arena()),
+        // AstGen guarantees there will be a store before the first load, so we put a value
+        // here indicating there is no valid value.
+        Value.initTag(.unreachable_value),
+    );
+    try sema.mod.declareDeclDependency(sema.owner_decl, decl);
+    return sema.addConstant(ptr_type, try Value.Tag.decl_ref_mut.create(sema.arena, .{
+        .runtime_index = block.runtime_index,
+        .decl = decl,
+    }));
+}
diff --git a/src/Zir.zig b/src/Zir.zig
index 97a7c06273..1aed609de9 100644
--- a/src/Zir.zig
+++ b/src/Zir.zig
@@ -465,6 +465,11 @@ pub const Inst = struct {
         /// Uses the `un_node` union field.
         ret_node,
         /// Sends control flow back to the function's callee.
+        /// The operand is a `ret_ptr` instruction, where the return value can be found.
+        /// Includes an AST node source location.
+        /// Uses the `un_node` union field.
+        ret_load,
+        /// Sends control flow back to the function's callee.
         /// Includes an operand as the return value.
         /// Includes a token source location.
         /// Uses the `un_tok` union field.
@@ -1231,6 +1236,7 @@ pub const Inst = struct {
                 .condbr_inline,
                 .compile_error,
                 .ret_node,
+                .ret_load,
                 .ret_coerce,
                 .ret_err_value,
                 .@"unreachable",
@@ -1335,6 +1341,7 @@ pub const Inst = struct {
                 .param_type = .param_type,
                 .ref = .un_tok,
                 .ret_node = .un_node,
+                .ret_load = .un_node,
                 .ret_coerce = .un_tok,
                 .ret_err_value = .str_tok,
                 .ret_err_value_code = .str_tok,
@@ -2912,6 +2919,7 @@ const Writer = struct {
             .ensure_result_used,
             .ensure_result_non_error,
             .ret_node,
+            .ret_load,
             .resolve_inferred_alloc,
             .optional_type,
             .optional_payload_safe,
diff --git a/test/behavior/generics.zig b/test/behavior/generics.zig
index bb5504b479..67fb1def8b 100644
--- a/test/behavior/generics.zig
+++ b/test/behavior/generics.zig
@@ -28,16 +28,7 @@ test "simple generic fn" {
 }
 
 fn max(comptime T: type, a: T, b: T) T {
-    if (!builtin.zig_is_stage2) {
-        // TODO: stage2 is incorrectly emitting AIR that allocates a result
-        // value, stores to it, but then returns void instead of the result.
-        return if (a > b) a else b;
-    }
-    if (a > b) {
-        return a;
-    } else {
-        return b;
-    }
+    return if (a > b) a else b;
 }
 
 fn add(comptime a: i32, b: i32) i32 {
@@ -70,29 +61,14 @@ test "fn with comptime args" {
 test "anytype params" {
     try expect(max_i32(12, 34) == 34);
     try expect(max_f64(1.2, 3.4) == 3.4);
-    if (!builtin.zig_is_stage2) {
-        // TODO: stage2 is incorrectly hitting the following problem:
-        // error: unable to resolve comptime value
-        //     return max_anytype(a, b);
-        //                       ^
-        comptime {
-            try expect(max_i32(12, 34) == 34);
-            try expect(max_f64(1.2, 3.4) == 3.4);
-        }
+    comptime {
+        try expect(max_i32(12, 34) == 34);
+        try expect(max_f64(1.2, 3.4) == 3.4);
     }
 }
 
 fn max_anytype(a: anytype, b: anytype) @TypeOf(a, b) {
-    if (!builtin.zig_is_stage2) {
-        // TODO: stage2 is incorrectly emitting AIR that allocates a result
-        // value, stores to it, but then returns void instead of the result.
-        return if (a > b) a else b;
-    }
-    if (a > b) {
-        return a;
-    } else {
-        return b;
-    }
+    return if (a > b) a else b;
 }
 
 fn max_i32(a: i32, b: i32) i32 {
diff --git a/test/stage2/cbe.zig b/test/stage2/cbe.zig
index 4f7d80d1fa..aa1022257b 100644
--- a/test/stage2/cbe.zig
+++ b/test/stage2/cbe.zig
@@ -240,6 +240,10 @@ pub fn addCases(ctx: *TestContext) !void {
     if (host_supports_custom_stack_size) {
         var case = ctx.exeFromCompiledC("@setEvalBranchQuota", .{});
 
+        // TODO when adding result location support to function calls, revisit this test
+        // case. It can go back to what it was before, with `y` being comptime known.
+        // Because the ret_ptr will passed in with the inline fn call, and there will
+        // only be 1 store to it, and it will be comptime known.
         case.addCompareOutput(
             \\pub export fn main() i32 {
             \\    @setEvalBranchQuota(1001);
@@ -247,7 +251,7 @@ pub fn addCases(ctx: *TestContext) !void {
             \\    return y - 1;
             \\}
             \\
-            \\fn rec(n: usize) callconv(.Inline) usize {
+            \\inline fn rec(n: i32) i32 {
             \\    if (n <= 1) return n;
             \\    return rec(n - 1);
             \\}

From 5789036b86bcc95b2e017ed7330aaf7ccbfa3d5f Mon Sep 17 00:00:00 2001
From: Klecko <david.mateos.romero@gmail.com>
Date: Sat, 7 Aug 2021 13:34:33 +0200
Subject: [PATCH 92/96] linux: add missing FUTEX definitions

---
 lib/std/os/bits/linux.zig | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/lib/std/os/bits/linux.zig b/lib/std/os/bits/linux.zig
index 28683d47a9..fdf240e954 100644
--- a/lib/std/os/bits/linux.zig
+++ b/lib/std/os/bits/linux.zig
@@ -119,6 +119,9 @@ pub const FUTEX_LOCK_PI = 6;
 pub const FUTEX_UNLOCK_PI = 7;
 pub const FUTEX_TRYLOCK_PI = 8;
 pub const FUTEX_WAIT_BITSET = 9;
+pub const FUTEX_WAKE_BITSET = 10;
+pub const FUTEX_WAIT_REQUEUE_PI = 11;
+pub const FUTEX_CMP_REQUEUE_PI = 12;
 
 pub const FUTEX_PRIVATE_FLAG = 128;
 

From 259f3458a162120288eb80dea4e55cd4ed9cf4c5 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Sat, 7 Aug 2021 11:07:48 -0700
Subject: [PATCH 93/96] Sema: implement alloc_inferred_comptime

---
 src/Sema.zig                  |  10 +-
 test/behavior.zig             |   3 +-
 test/behavior/eval.zig        | 714 ---------------------------------
 test/behavior/eval_stage1.zig | 717 ++++++++++++++++++++++++++++++++++
 4 files changed, 726 insertions(+), 718 deletions(-)
 create mode 100644 test/behavior/eval_stage1.zig

diff --git a/src/Sema.zig b/src/Sema.zig
index 109c1c9335..6c68ceaf2a 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -139,7 +139,7 @@ pub fn analyzeBody(
             .alloc                        => try sema.zirAlloc(block, inst),
             .alloc_inferred               => try sema.zirAllocInferred(block, inst, Type.initTag(.inferred_alloc_const)),
             .alloc_inferred_mut           => try sema.zirAllocInferred(block, inst, Type.initTag(.inferred_alloc_mut)),
-            .alloc_inferred_comptime      => try sema.zirAllocInferredComptime(block, inst),
+            .alloc_inferred_comptime      => try sema.zirAllocInferredComptime(inst),
             .alloc_mut                    => try sema.zirAllocMut(block, inst),
             .alloc_comptime               => try sema.zirAllocComptime(block, inst),
             .anyframe_type                => try sema.zirAnyframeType(block, inst),
@@ -1384,10 +1384,14 @@ fn zirAllocComptime(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) Comp
     return sema.analyzeComptimeAlloc(block, var_type);
 }
 
-fn zirAllocInferredComptime(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
+fn zirAllocInferredComptime(sema: *Sema, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
     const src_node = sema.code.instructions.items(.data)[inst].node;
     const src: LazySrcLoc = .{ .node_offset = src_node };
-    return sema.mod.fail(&block.base, src, "TODO implement Sema.zirAllocInferredComptime", .{});
+    sema.src = src;
+    return sema.addConstant(
+        Type.initTag(.inferred_alloc_mut),
+        try Value.Tag.inferred_alloc_comptime.create(sema.arena, undefined),
+    );
 }
 
 fn zirAlloc(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
diff --git a/test/behavior.zig b/test/behavior.zig
index 26272cb2fd..f1c6fa3a35 100644
--- a/test/behavior.zig
+++ b/test/behavior.zig
@@ -5,6 +5,7 @@ test {
     _ = @import("behavior/bool.zig");
     _ = @import("behavior/basic.zig");
     _ = @import("behavior/generics.zig");
+    _ = @import("behavior/eval.zig");
 
     if (!builtin.zig_is_stage2) {
         // Tests that only pass for stage1.
@@ -88,7 +89,7 @@ test {
         _ = @import("behavior/enum.zig");
         _ = @import("behavior/enum_with_members.zig");
         _ = @import("behavior/error.zig");
-        _ = @import("behavior/eval.zig");
+        _ = @import("behavior/eval_stage1.zig");
         _ = @import("behavior/field_parent_ptr.zig");
         _ = @import("behavior/floatop.zig");
         _ = @import("behavior/fn.zig");
diff --git a/test/behavior/eval.zig b/test/behavior/eval.zig
index 566ed74e2d..a97aab7bb3 100644
--- a/test/behavior/eval.zig
+++ b/test/behavior/eval.zig
@@ -63,146 +63,12 @@ fn constExprEvalOnSingleExprBlocksFn(x: i32, b: bool) i32 {
     return result;
 }
 
-test "statically initialized list" {
-    try expect(static_point_list[0].x == 1);
-    try expect(static_point_list[0].y == 2);
-    try expect(static_point_list[1].x == 3);
-    try expect(static_point_list[1].y == 4);
-}
-const Point = struct {
-    x: i32,
-    y: i32,
-};
-const static_point_list = [_]Point{
-    makePoint(1, 2),
-    makePoint(3, 4),
-};
-fn makePoint(x: i32, y: i32) Point {
-    return Point{
-        .x = x,
-        .y = y,
-    };
-}
-
-test "static eval list init" {
-    try expect(static_vec3.data[2] == 1.0);
-    try expect(vec3(0.0, 0.0, 3.0).data[2] == 3.0);
-}
-const static_vec3 = vec3(0.0, 0.0, 1.0);
-pub const Vec3 = struct {
-    data: [3]f32,
-};
-pub fn vec3(x: f32, y: f32, z: f32) Vec3 {
-    return Vec3{
-        .data = [_]f32{
-            x,
-            y,
-            z,
-        },
-    };
-}
-
 test "constant expressions" {
     var array: [array_size]u8 = undefined;
     try expect(@sizeOf(@TypeOf(array)) == 20);
 }
 const array_size: u8 = 20;
 
-test "constant struct with negation" {
-    try expect(vertices[0].x == -0.6);
-}
-const Vertex = struct {
-    x: f32,
-    y: f32,
-    r: f32,
-    g: f32,
-    b: f32,
-};
-const vertices = [_]Vertex{
-    Vertex{
-        .x = -0.6,
-        .y = -0.4,
-        .r = 1.0,
-        .g = 0.0,
-        .b = 0.0,
-    },
-    Vertex{
-        .x = 0.6,
-        .y = -0.4,
-        .r = 0.0,
-        .g = 1.0,
-        .b = 0.0,
-    },
-    Vertex{
-        .x = 0.0,
-        .y = 0.6,
-        .r = 0.0,
-        .g = 0.0,
-        .b = 1.0,
-    },
-};
-
-test "statically initialized struct" {
-    st_init_str_foo.x += 1;
-    try expect(st_init_str_foo.x == 14);
-}
-const StInitStrFoo = struct {
-    x: i32,
-    y: bool,
-};
-var st_init_str_foo = StInitStrFoo{
-    .x = 13,
-    .y = true,
-};
-
-test "statically initalized array literal" {
-    const y: [4]u8 = st_init_arr_lit_x;
-    try expect(y[3] == 4);
-}
-const st_init_arr_lit_x = [_]u8{
-    1,
-    2,
-    3,
-    4,
-};
-
-test "const slice" {
-    comptime {
-        const a = "1234567890";
-        try expect(a.len == 10);
-        const b = a[1..2];
-        try expect(b.len == 1);
-        try expect(b[0] == '2');
-    }
-}
-
-test "try to trick eval with runtime if" {
-    try expect(testTryToTrickEvalWithRuntimeIf(true) == 10);
-}
-
-fn testTryToTrickEvalWithRuntimeIf(b: bool) usize {
-    comptime var i: usize = 0;
-    inline while (i < 10) : (i += 1) {
-        const result = if (b) false else true;
-        _ = result;
-    }
-    comptime {
-        return i;
-    }
-}
-
-test "inlined loop has array literal with elided runtime scope on first iteration but not second iteration" {
-    var runtime = [1]i32{3};
-    comptime var i: usize = 0;
-    inline while (i < 2) : (i += 1) {
-        const result = if (i == 0) [1]i32{2} else runtime;
-        _ = result;
-    }
-    comptime {
-        try expect(i == 2);
-    }
-}
-
 fn max(comptime T: type, a: T, b: T) T {
     if (T == bool) {
         return a or b;
@@ -229,52 +95,6 @@ test "inlined block and runtime block phi" {
     }
 }
 
-const CmdFn = struct {
-    name: []const u8,
-    func: fn (i32) i32,
-};
-
-const cmd_fns = [_]CmdFn{
-    CmdFn{
-        .name = "one",
-        .func = one,
-    },
-    CmdFn{
-        .name = "two",
-        .func = two,
-    },
-    CmdFn{
-        .name = "three",
-        .func = three,
-    },
-};
-fn one(value: i32) i32 {
-    return value + 1;
-}
-fn two(value: i32) i32 {
-    return value + 2;
-}
-fn three(value: i32) i32 {
-    return value + 3;
-}
-
-fn performFn(comptime prefix_char: u8, start_value: i32) i32 {
-    var result: i32 = start_value;
-    comptime var i = 0;
-    inline while (i < cmd_fns.len) : (i += 1) {
-        if (cmd_fns[i].name[0] == prefix_char) {
-            result = cmd_fns[i].func(result);
-        }
-    }
-    return result;
-}
-
-test "comptime iterate over fn ptr list" {
-    try expect(performFn('t', 1) == 6);
-    try expect(performFn('o', 0) == 1);
-    try expect(performFn('w', 99) == 99);
-}
-
 test "eval @setRuntimeSafety at compile-time" {
     const result = comptime fnWithSetRuntimeSafety();
     try expect(result == 1234);
@@ -285,90 +105,6 @@ fn fnWithSetRuntimeSafety() i32 {
     return 1234;
 }
 
-test "eval @setFloatMode at compile-time" {
-    const result = comptime fnWithFloatMode();
-    try expect(result == 1234.0);
-}
-
-fn fnWithFloatMode() f32 {
-    @setFloatMode(std.builtin.FloatMode.Strict);
-    return 1234.0;
-}
-
-const SimpleStruct = struct {
-    field: i32,
-
-    fn method(self: *const SimpleStruct) i32 {
-        return self.field + 3;
-    }
-};
-
-var simple_struct = SimpleStruct{ .field = 1234 };
-
-const bound_fn = simple_struct.method;
-
-test "call method on bound fn referring to var instance" {
-    try expect(bound_fn() == 1237);
-}
-
-test "ptr to local array argument at comptime" {
-    comptime {
-        var bytes: [10]u8 = undefined;
-        modifySomeBytes(bytes[0..]);
-        try expect(bytes[0] == 'a');
-        try expect(bytes[9] == 'b');
-    }
-}
-
-fn modifySomeBytes(bytes: []u8) void {
-    bytes[0] = 'a';
-    bytes[9] = 'b';
-}
-
-test "comparisons 0 <= uint and 0 > uint should be comptime" {
-    testCompTimeUIntComparisons(1234);
-}
-fn testCompTimeUIntComparisons(x: u32) void {
-    if (!(0 <= x)) {
-        @compileError("this condition should be comptime known");
-    }
-    if (0 > x) {
-        @compileError("this condition should be comptime known");
-    }
-    if (!(x >= 0)) {
-        @compileError("this condition should be comptime known");
-    }
-    if (x < 0) {
-        @compileError("this condition should be comptime known");
-    }
-}
-
-test "const ptr to variable data changes at runtime" {
-    try expect(foo_ref.name[0] == 'a');
-    foo_ref.name = "b";
-    try expect(foo_ref.name[0] == 'b');
-}
-
-const Foo = struct {
-    name: []const u8,
-};
-
-var foo_contents = Foo{ .name = "a" };
-const foo_ref = &foo_contents;
-
-test "create global array with for loop" {
-    try expect(global_array[5] == 5 * 5);
-    try expect(global_array[9] == 9 * 9);
-}
-
-const global_array = x: {
-    var result: [10]usize = undefined;
-    for (result) |*item, index| {
-        item.* = index * index;
-    }
-    break :x result;
-};
-
 test "compile-time downcast when the bits fit" {
     comptime {
         const spartan_count: u16 = 255;
@@ -377,231 +113,6 @@ test "compile-time downcast when the bits fit" {
     }
 }
 
-const hi1 = "hi";
-const hi2 = hi1;
-test "const global shares pointer with other same one" {
-    try assertEqualPtrs(&hi1[0], &hi2[0]);
-    comptime try expect(&hi1[0] == &hi2[0]);
-}
-fn assertEqualPtrs(ptr1: *const u8, ptr2: *const u8) !void {
-    try expect(ptr1 == ptr2);
-}
-
-test "@setEvalBranchQuota" {
-    comptime {
-        // 1001 for the loop and then 1 more for the expect fn call
-        @setEvalBranchQuota(1002);
-        var i = 0;
-        var sum = 0;
-        while (i < 1001) : (i += 1) {
-            sum += i;
-        }
-        try expect(sum == 500500);
-    }
-}
-
-test "float literal at compile time not lossy" {
-    try expect(16777216.0 + 1.0 == 16777217.0);
-    try expect(9007199254740992.0 + 1.0 == 9007199254740993.0);
-}
-
-test "f32 at compile time is lossy" {
-    try expect(@as(f32, 1 << 24) + 1 == 1 << 24);
-}
-
-test "f64 at compile time is lossy" {
-    try expect(@as(f64, 1 << 53) + 1 == 1 << 53);
-}
-
-test "f128 at compile time is lossy" {
-    try expect(@as(f128, 10384593717069655257060992658440192.0) + 1 == 10384593717069655257060992658440192.0);
-}
-
-test {
-    comptime try expect(@as(f128, 1 << 113) == 10384593717069655257060992658440192);
-}
-
-pub fn TypeWithCompTimeSlice(comptime field_name: []const u8) type {
-    _ = field_name;
-    return struct {
-        pub const Node = struct {};
-    };
-}
-
-test "string literal used as comptime slice is memoized" {
-    const a = "link";
-    const b = "link";
-    comptime try expect(TypeWithCompTimeSlice(a).Node == TypeWithCompTimeSlice(b).Node);
-    comptime try expect(TypeWithCompTimeSlice("link").Node == TypeWithCompTimeSlice("link").Node);
-}
-
-test "comptime slice of undefined pointer of length 0" {
-    const slice1 = @as([*]i32, undefined)[0..0];
-    try expect(slice1.len == 0);
-    const slice2 = @as([*]i32, undefined)[100..100];
-    try expect(slice2.len == 0);
-}
-
-fn copyWithPartialInline(s: []u32, b: []u8) void {
-    comptime var i: usize = 0;
-    inline while (i < 4) : (i += 1) {
-        s[i] = 0;
-        s[i] |= @as(u32, b[i * 4 + 0]) << 24;
-        s[i] |= @as(u32, b[i * 4 + 1]) << 16;
-        s[i] |= @as(u32, b[i * 4 + 2]) << 8;
-        s[i] |= @as(u32, b[i * 4 + 3]) << 0;
-    }
-}
-
-test "binary math operator in partially inlined function" {
-    var s: [4]u32 = undefined;
-    var b: [16]u8 = undefined;
-
-    for (b) |*r, i|
-        r.* = @intCast(u8, i + 1);
-
-    copyWithPartialInline(s[0..], b[0..]);
-    try expect(s[0] == 0x1020304);
-    try expect(s[1] == 0x5060708);
-    try expect(s[2] == 0x90a0b0c);
-    try expect(s[3] == 0xd0e0f10);
-}
-
-test "comptime function with the same args is memoized" {
-    comptime {
-        try expect(MakeType(i32) == MakeType(i32));
-        try expect(MakeType(i32) != MakeType(f64));
-    }
-}
-
-fn MakeType(comptime T: type) type {
-    return struct {
-        field: T,
-    };
-}
-
-test "comptime function with mutable pointer is not memoized" {
-    comptime {
-        var x: i32 = 1;
-        const ptr = &x;
-        increment(ptr);
-        increment(ptr);
-        try expect(x == 3);
-    }
-}
-
-fn increment(value: *i32) void {
-    value.* += 1;
-}
-
-fn generateTable(comptime T: type) [1010]T {
-    var res: [1010]T = undefined;
-    var i: usize = 0;
-    while (i < 1010) : (i += 1) {
-        res[i] = @intCast(T, i);
-    }
-    return res;
-}
-
-fn doesAlotT(comptime T: type, value: usize) T {
-    @setEvalBranchQuota(5000);
-    const table = comptime blk: {
-        break :blk generateTable(T);
-    };
-    return table[value];
-}
-
-test "@setEvalBranchQuota at same scope as generic function call" {
-    try expect(doesAlotT(u32, 2) == 2);
-}
-
-test "comptime slice of slice preserves comptime var" {
-    comptime {
-        var buff: [10]u8 = undefined;
-        buff[0..][0..][0] = 1;
-        try expect(buff[0..][0..][0] == 1);
-    }
-}
-
-test "comptime slice of pointer preserves comptime var" {
-    comptime {
-        var buff: [10]u8 = undefined;
-        var a = @ptrCast([*]u8, &buff);
-        a[0..1][0] = 1;
-        try expect(buff[0..][0..][0] == 1);
-    }
-}
-
-const SingleFieldStruct = struct {
-    x: i32,
-
-    fn read_x(self: *const SingleFieldStruct) i32 {
-        return self.x;
-    }
-};
-test "const ptr to comptime mutable data is not memoized" {
-    comptime {
-        var foo = SingleFieldStruct{ .x = 1 };
-        try expect(foo.read_x() == 1);
-        foo.x = 2;
-        try expect(foo.read_x() == 2);
-    }
-}
-
-test "array concat of slices gives slice" {
-    comptime {
-        var a: []const u8 = "aoeu";
-        var b: []const u8 = "asdf";
-        const c = a ++ b;
-        try expect(std.mem.eql(u8, c, "aoeuasdf"));
-    }
-}
-
-test "comptime shlWithOverflow" {
-    const ct_shifted: u64 = comptime amt: {
-        var amt = @as(u64, 0);
-        _ = @shlWithOverflow(u64, ~@as(u64, 0), 16, &amt);
-        break :amt amt;
-    };
-
-    const rt_shifted: u64 = amt: {
-        var amt = @as(u64, 0);
-        _ = @shlWithOverflow(u64, ~@as(u64, 0), 16, &amt);
-        break :amt amt;
-    };
-
-    try expect(ct_shifted == rt_shifted);
-}
-
-test "comptime shl" {
-    var a: u128 = 3;
-    var b: u7 = 63;
-    var c: u128 = 3 << 63;
-    try expectEqual(a << b, c);
-}
-
-test "runtime 128 bit integer division" {
-    var a: u128 = 152313999999999991610955792383;
-    var b: u128 = 10000000000000000000;
-    var c = a / b;
-    try expect(c == 15231399999);
-}
-
-pub const Info = struct {
-    version: u8,
-};
-
-pub const diamond_info = Info{ .version = 0 };
-
-test "comptime modification of const struct field" {
-    comptime {
-        var res = diamond_info;
-        res.version = 1;
-        try expect(diamond_info.version == 0);
-        try expect(res.version == 1);
-    }
-}
-
 test "pointer to type" {
     comptime {
         var T: type = i32;
@@ -614,233 +125,8 @@ test "pointer to type" {
     }
 }
 
-test "slice of type" {
-    comptime {
-        var types_array = [_]type{ i32, f64, type };
-        for (types_array) |T, i| {
-            switch (i) {
-                0 => try expect(T == i32),
-                1 => try expect(T == f64),
-                2 => try expect(T == type),
-                else => unreachable,
-            }
-        }
-        for (types_array[0..]) |T, i| {
-            switch (i) {
-                0 => try expect(T == i32),
-                1 => try expect(T == f64),
-                2 => try expect(T == type),
-                else => unreachable,
-            }
-        }
-    }
-}
-
-const Wrapper = struct {
-    T: type,
-};
-
-fn wrap(comptime T: type) Wrapper {
-    return Wrapper{ .T = T };
-}
-
-test "function which returns struct with type field causes implicit comptime" {
-    const ty = wrap(i32).T;
-    try expect(ty == i32);
-}
-
-test "call method with comptime pass-by-non-copying-value self parameter" {
-    const S = struct {
-        a: u8,
-
-        fn b(comptime s: @This()) u8 {
-            return s.a;
-        }
-    };
-
-    const s = S{ .a = 2 };
-    var b = s.b();
-    try expect(b == 2);
-}
-
-test "@tagName of @typeInfo" {
-    const str = @tagName(@typeInfo(u8));
-    try expect(std.mem.eql(u8, str, "Int"));
-}
-
-test "setting backward branch quota just before a generic fn call" {
-    @setEvalBranchQuota(1001);
-    loopNTimes(1001);
-}
-
-fn loopNTimes(comptime n: usize) void {
-    comptime var i = 0;
-    inline while (i < n) : (i += 1) {}
-}
-
-test "variable inside inline loop that has different types on different iterations" {
-    try testVarInsideInlineLoop(.{ true, @as(u32, 42) });
-}
-
-fn testVarInsideInlineLoop(args: anytype) !void {
-    comptime var i = 0;
-    inline while (i < args.len) : (i += 1) {
-        const x = args[i];
-        if (i == 0) try expect(x);
-        if (i == 1) try expect(x == 42);
-    }
-}
-
-test "inline for with same type but different values" {
-    var res: usize = 0;
-    inline for ([_]type{ [2]u8, [1]u8, [2]u8 }) |T| {
-        var a: T = undefined;
-        res += a.len;
-    }
-    try expect(res == 5);
-}
-
-test "refer to the type of a generic function" {
-    const Func = fn (type) void;
-    const f: Func = doNothingWithType;
-    f(i32);
-}
-
-fn doNothingWithType(comptime T: type) void {
-    _ = T;
-}
-
-test "zero extend from u0 to u1" {
-    var zero_u0: u0 = 0;
-    var zero_u1: u1 = zero_u0;
-    try expect(zero_u1 == 0);
-}
-
-test "bit shift a u1" {
-    var x: u1 = 1;
-    var y = x << 0;
-    try expect(y == 1);
-}
-
-test "comptime pointer cast array and then slice" {
-    const array = [_]u8{ 1, 2, 3, 4, 5, 6, 7, 8 };
-
-    const ptrA: [*]const u8 = @ptrCast([*]const u8, &array);
-    const sliceA: []const u8 = ptrA[0..2];
-
-    const ptrB: [*]const u8 = &array;
-    const sliceB: []const u8 = ptrB[0..2];
-
-    try expect(sliceA[1] == 2);
-    try expect(sliceB[1] == 2);
-}
-
-test "slice bounds in comptime concatenation" {
-    const bs = comptime blk: {
-        const b = "........1........";
-        break :blk b[8..9];
-    };
-    const str = "" ++ bs;
-    try expect(str.len == 1);
-    try expect(std.mem.eql(u8, str, "1"));
-
-    const str2 = bs ++ "";
-    try expect(str2.len == 1);
-    try expect(std.mem.eql(u8, str2, "1"));
-}
-
-test "comptime bitwise operators" {
-    comptime {
-        try expect(3 & 1 == 1);
-        try expect(3 & -1 == 3);
-        try expect(-3 & -1 == -3);
-        try expect(3 | -1 == -1);
-        try expect(-3 | -1 == -1);
-        try expect(3 ^ -1 == -4);
-        try expect(-3 ^ -1 == 2);
-        try expect(~@as(i8, -1) == 0);
-        try expect(~@as(i128, -1) == 0);
-        try expect(18446744073709551615 & 18446744073709551611 == 18446744073709551611);
-        try expect(-18446744073709551615 & -18446744073709551611 == -18446744073709551615);
-        try expect(~@as(u128, 0) == 0xffffffffffffffffffffffffffffffff);
-    }
-}
-
-test "*align(1) u16 is the same as *align(1:0:2) u16" {
-    comptime {
-        try expect(*align(1:0:2) u16 == *align(1) u16);
-        try expect(*align(2:0:2) u16 == *u16);
-    }
-}
-
-test "array concatenation forces comptime" {
-    var a = oneItem(3) ++ oneItem(4);
-    try expect(std.mem.eql(i32, &a, &[_]i32{ 3, 4 }));
-}
-
-test "array multiplication forces comptime" {
-    var a = oneItem(3) ** scalar(2);
-    try expect(std.mem.eql(i32, &a, &[_]i32{ 3, 3 }));
-}
-
-fn oneItem(x: i32) [1]i32 {
-    return [_]i32{x};
-}
-
-fn scalar(x: u32) u32 {
-    return x;
-}
-
 test "no undeclared identifier error in unanalyzed branches" {
     if (false) {
         lol_this_doesnt_exist = nonsense;
     }
 }
-
-test "comptime assign int to optional int" {
-    comptime {
-        var x: ?i32 = null;
-        x = 2;
-        x.? *= 10;
-        try expectEqual(20, x.?);
-    }
-}
-
-test "return 0 from function that has u0 return type" {
-    const S = struct {
-        fn foo_zero() u0 {
-            return 0;
-        }
-    };
-    comptime {
-        if (S.foo_zero() != 0) {
-            @compileError("test failed");
-        }
-    }
-}
-
-test "two comptime calls with array default initialized to undefined" {
-    const S = struct {
-        const CrossTarget = struct {
-            dynamic_linker: DynamicLinker = DynamicLinker{},
-
-            pub fn parse() void {
-                var result: CrossTarget = .{};
-                result.getCpuArch();
-            }
-
-            pub fn getCpuArch(self: CrossTarget) void {
-                _ = self;
-            }
-        };
-
-        const DynamicLinker = struct {
-            buffer: [255]u8 = undefined,
-        };
-    };
-
-    comptime {
-        S.CrossTarget.parse();
-        S.CrossTarget.parse();
-    }
-}
diff --git a/test/behavior/eval_stage1.zig b/test/behavior/eval_stage1.zig
new file mode 100644
index 0000000000..3599d5a477
--- /dev/null
+++ b/test/behavior/eval_stage1.zig
@@ -0,0 +1,717 @@
+const std = @import("std");
+const expect = std.testing.expect;
+const expectEqual = std.testing.expectEqual;
+
+test "statically initialized list" {
+    try expect(static_point_list[0].x == 1);
+    try expect(static_point_list[0].y == 2);
+    try expect(static_point_list[1].x == 3);
+    try expect(static_point_list[1].y == 4);
+}
+const Point = struct {
+    x: i32,
+    y: i32,
+};
+const static_point_list = [_]Point{
+    makePoint(1, 2),
+    makePoint(3, 4),
+};
+fn makePoint(x: i32, y: i32) Point {
+    return Point{
+        .x = x,
+        .y = y,
+    };
+}
+
+test "static eval list init" {
+    try expect(static_vec3.data[2] == 1.0);
+    try expect(vec3(0.0, 0.0, 3.0).data[2] == 3.0);
+}
+const static_vec3 = vec3(0.0, 0.0, 1.0);
+pub const Vec3 = struct {
+    data: [3]f32,
+};
+pub fn vec3(x: f32, y: f32, z: f32) Vec3 {
+    return Vec3{
+        .data = [_]f32{
+            x,
+            y,
+            z,
+        },
+    };
+}
+
+test "constant struct with negation" {
+    try expect(vertices[0].x == -0.6);
+}
+const Vertex = struct {
+    x: f32,
+    y: f32,
+    r: f32,
+    g: f32,
+    b: f32,
+};
+const vertices = [_]Vertex{
+    Vertex{
+        .x = -0.6,
+        .y = -0.4,
+        .r = 1.0,
+        .g = 0.0,
+        .b = 0.0,
+    },
+    Vertex{
+        .x = 0.6,
+        .y = -0.4,
+        .r = 0.0,
+        .g = 1.0,
+        .b = 0.0,
+    },
+    Vertex{
+        .x = 0.0,
+        .y = 0.6,
+        .r = 0.0,
+        .g = 0.0,
+        .b = 1.0,
+    },
+};
+
+test "statically initialized struct" {
+    st_init_str_foo.x += 1;
+    try expect(st_init_str_foo.x == 14);
+}
+const StInitStrFoo = struct {
+    x: i32,
+    y: bool,
+};
+var st_init_str_foo = StInitStrFoo{
+    .x = 13,
+    .y = true,
+};
+
+test "statically initalized array literal" {
+    const y: [4]u8 = st_init_arr_lit_x;
+    try expect(y[3] == 4);
+}
+const st_init_arr_lit_x = [_]u8{
+    1,
+    2,
+    3,
+    4,
+};
+
+test "const slice" {
+    comptime {
+        const a = "1234567890";
+        try expect(a.len == 10);
+        const b = a[1..2];
+        try expect(b.len == 1);
+        try expect(b[0] == '2');
+    }
+}
+
+test "try to trick eval with runtime if" {
+    try expect(testTryToTrickEvalWithRuntimeIf(true) == 10);
+}
+
+fn testTryToTrickEvalWithRuntimeIf(b: bool) usize {
+    comptime var i: usize = 0;
+    inline while (i < 10) : (i += 1) {
+        const result = if (b) false else true;
+        _ = result;
+    }
+    comptime {
+        return i;
+    }
+}
+
+test "inlined loop has array literal with elided runtime scope on first iteration but not second iteration" {
+    var runtime = [1]i32{3};
+    comptime var i: usize = 0;
+    inline while (i < 2) : (i += 1) {
+        const result = if (i == 0) [1]i32{2} else runtime;
+        _ = result;
+    }
+    comptime {
+        try expect(i == 2);
+    }
+}
+
+const CmdFn = struct {
+    name: []const u8,
+    func: fn (i32) i32,
+};
+
+const cmd_fns = [_]CmdFn{
+    CmdFn{
+        .name = "one",
+        .func = one,
+    },
+    CmdFn{
+        .name = "two",
+        .func = two,
+    },
+    CmdFn{
+        .name = "three",
+        .func = three,
+    },
+};
+fn one(value: i32) i32 {
+    return value + 1;
+}
+fn two(value: i32) i32 {
+    return value + 2;
+}
+fn three(value: i32) i32 {
+    return value + 3;
+}
+
+fn performFn(comptime prefix_char: u8, start_value: i32) i32 {
+    var result: i32 = start_value;
+    comptime var i = 0;
+    inline while (i < cmd_fns.len) : (i += 1) {
+        if (cmd_fns[i].name[0] == prefix_char) {
+            result = cmd_fns[i].func(result);
+        }
+    }
+    return result;
+}
+
+test "comptime iterate over fn ptr list" {
+    try expect(performFn('t', 1) == 6);
+    try expect(performFn('o', 0) == 1);
+    try expect(performFn('w', 99) == 99);
+}
+
+test "eval @setFloatMode at compile-time" {
+    const result = comptime fnWithFloatMode();
+    try expect(result == 1234.0);
+}
+
+fn fnWithFloatMode() f32 {
+    @setFloatMode(std.builtin.FloatMode.Strict);
+    return 1234.0;
+}
+
+const SimpleStruct = struct {
+    field: i32,
+
+    fn method(self: *const SimpleStruct) i32 {
+        return self.field + 3;
+    }
+};
+
+var simple_struct = SimpleStruct{ .field = 1234 };
+
+const bound_fn = simple_struct.method;
+
+test "call method on bound fn referring to var instance" {
+    try expect(bound_fn() == 1237);
+}
+
+test "ptr to local array argument at comptime" {
+    comptime {
+        var bytes: [10]u8 = undefined;
+        modifySomeBytes(bytes[0..]);
+        try expect(bytes[0] == 'a');
+        try expect(bytes[9] == 'b');
+    }
+}
+
+fn modifySomeBytes(bytes: []u8) void {
+    bytes[0] = 'a';
+    bytes[9] = 'b';
+}
+
+test "comparisons 0 <= uint and 0 > uint should be comptime" {
+    testCompTimeUIntComparisons(1234);
+}
+fn testCompTimeUIntComparisons(x: u32) void {
+    if (!(0 <= x)) {
+        @compileError("this condition should be comptime known");
+    }
+    if (0 > x) {
+        @compileError("this condition should be comptime known");
+    }
+    if (!(x >= 0)) {
+        @compileError("this condition should be comptime known");
+    }
+    if (x < 0) {
+        @compileError("this condition should be comptime known");
+    }
+}
+
+test "const ptr to variable data changes at runtime" {
+    try expect(foo_ref.name[0] == 'a');
+    foo_ref.name = "b";
+    try expect(foo_ref.name[0] == 'b');
+}
+
+const Foo = struct {
+    name: []const u8,
+};
+
+var foo_contents = Foo{ .name = "a" };
+const foo_ref = &foo_contents;
+
+test "create global array with for loop" {
+    try expect(global_array[5] == 5 * 5);
+    try expect(global_array[9] == 9 * 9);
+}
+
+const global_array = x: {
+    var result: [10]usize = undefined;
+    for (result) |*item, index| {
+        item.* = index * index;
+    }
+    break :x result;
+};
+
+const hi1 = "hi";
+const hi2 = hi1;
+test "const global shares pointer with other same one" {
+    try assertEqualPtrs(&hi1[0], &hi2[0]);
+    comptime try expect(&hi1[0] == &hi2[0]);
+}
+fn assertEqualPtrs(ptr1: *const u8, ptr2: *const u8) !void {
+    try expect(ptr1 == ptr2);
+}
+
+test "@setEvalBranchQuota" {
+    comptime {
+        // 1001 for the loop and then 1 more for the expect fn call
+        @setEvalBranchQuota(1002);
+        var i = 0;
+        var sum = 0;
+        while (i < 1001) : (i += 1) {
+            sum += i;
+        }
+        try expect(sum == 500500);
+    }
+}
+
+test "float literal at compile time not lossy" {
+    try expect(16777216.0 + 1.0 == 16777217.0);
+    try expect(9007199254740992.0 + 1.0 == 9007199254740993.0);
+}
+
+test "f32 at compile time is lossy" {
+    try expect(@as(f32, 1 << 24) + 1 == 1 << 24);
+}
+
+test "f64 at compile time is lossy" {
+    try expect(@as(f64, 1 << 53) + 1 == 1 << 53);
+}
+
+test "f128 at compile time is lossy" {
+    try expect(@as(f128, 10384593717069655257060992658440192.0) + 1 == 10384593717069655257060992658440192.0);
+}
+
+test {
+    comptime try expect(@as(f128, 1 << 113) == 10384593717069655257060992658440192);
+}
+
+pub fn TypeWithCompTimeSlice(comptime field_name: []const u8) type {
+    _ = field_name;
+    return struct {
+        pub const Node = struct {};
+    };
+}
+
+test "string literal used as comptime slice is memoized" {
+    const a = "link";
+    const b = "link";
+    comptime try expect(TypeWithCompTimeSlice(a).Node == TypeWithCompTimeSlice(b).Node);
+    comptime try expect(TypeWithCompTimeSlice("link").Node == TypeWithCompTimeSlice("link").Node);
+}
+
+test "comptime slice of undefined pointer of length 0" {
+    const slice1 = @as([*]i32, undefined)[0..0];
+    try expect(slice1.len == 0);
+    const slice2 = @as([*]i32, undefined)[100..100];
+    try expect(slice2.len == 0);
+}
+
+fn copyWithPartialInline(s: []u32, b: []u8) void {
+    comptime var i: usize = 0;
+    inline while (i < 4) : (i += 1) {
+        s[i] = 0;
+        s[i] |= @as(u32, b[i * 4 + 0]) << 24;
+        s[i] |= @as(u32, b[i * 4 + 1]) << 16;
+        s[i] |= @as(u32, b[i * 4 + 2]) << 8;
+        s[i] |= @as(u32, b[i * 4 + 3]) << 0;
+    }
+}
+
+test "binary math operator in partially inlined function" {
+    var s: [4]u32 = undefined;
+    var b: [16]u8 = undefined;
+
+    for (b) |*r, i|
+        r.* = @intCast(u8, i + 1);
+
+    copyWithPartialInline(s[0..], b[0..]);
+    try expect(s[0] == 0x1020304);
+    try expect(s[1] == 0x5060708);
+    try expect(s[2] == 0x90a0b0c);
+    try expect(s[3] == 0xd0e0f10);
+}
+
+test "comptime function with the same args is memoized" {
+    comptime {
+        try expect(MakeType(i32) == MakeType(i32));
+        try expect(MakeType(i32) != MakeType(f64));
+    }
+}
+
+fn MakeType(comptime T: type) type {
+    return struct {
+        field: T,
+    };
+}
+
+test "comptime function with mutable pointer is not memoized" {
+    comptime {
+        var x: i32 = 1;
+        const ptr = &x;
+        increment(ptr);
+        increment(ptr);
+        try expect(x == 3);
+    }
+}
+
+fn increment(value: *i32) void {
+    value.* += 1;
+}
+
+fn generateTable(comptime T: type) [1010]T {
+    var res: [1010]T = undefined;
+    var i: usize = 0;
+    while (i < 1010) : (i += 1) {
+        res[i] = @intCast(T, i);
+    }
+    return res;
+}
+
+fn doesAlotT(comptime T: type, value: usize) T {
+    @setEvalBranchQuota(5000);
+    const table = comptime blk: {
+        break :blk generateTable(T);
+    };
+    return table[value];
+}
+
+test "@setEvalBranchQuota at same scope as generic function call" {
+    try expect(doesAlotT(u32, 2) == 2);
+}
+
+test "comptime slice of slice preserves comptime var" {
+    comptime {
+        var buff: [10]u8 = undefined;
+        buff[0..][0..][0] = 1;
+        try expect(buff[0..][0..][0] == 1);
+    }
+}
+
+test "comptime slice of pointer preserves comptime var" {
+    comptime {
+        var buff: [10]u8 = undefined;
+        var a = @ptrCast([*]u8, &buff);
+        a[0..1][0] = 1;
+        try expect(buff[0..][0..][0] == 1);
+    }
+}
+
+const SingleFieldStruct = struct {
+    x: i32,
+
+    fn read_x(self: *const SingleFieldStruct) i32 {
+        return self.x;
+    }
+};
+test "const ptr to comptime mutable data is not memoized" {
+    comptime {
+        var foo = SingleFieldStruct{ .x = 1 };
+        try expect(foo.read_x() == 1);
+        foo.x = 2;
+        try expect(foo.read_x() == 2);
+    }
+}
+
+test "array concat of slices gives slice" {
+    comptime {
+        var a: []const u8 = "aoeu";
+        var b: []const u8 = "asdf";
+        const c = a ++ b;
+        try expect(std.mem.eql(u8, c, "aoeuasdf"));
+    }
+}
+
+test "comptime shlWithOverflow" {
+    const ct_shifted: u64 = comptime amt: {
+        var amt = @as(u64, 0);
+        _ = @shlWithOverflow(u64, ~@as(u64, 0), 16, &amt);
+        break :amt amt;
+    };
+
+    const rt_shifted: u64 = amt: {
+        var amt = @as(u64, 0);
+        _ = @shlWithOverflow(u64, ~@as(u64, 0), 16, &amt);
+        break :amt amt;
+    };
+
+    try expect(ct_shifted == rt_shifted);
+}
+
+test "comptime shl" {
+    var a: u128 = 3;
+    var b: u7 = 63;
+    var c: u128 = 3 << 63;
+    try expectEqual(a << b, c);
+}
+
+test "runtime 128 bit integer division" {
+    var a: u128 = 152313999999999991610955792383;
+    var b: u128 = 10000000000000000000;
+    var c = a / b;
+    try expect(c == 15231399999);
+}
+
+pub const Info = struct {
+    version: u8,
+};
+
+pub const diamond_info = Info{ .version = 0 };
+
+test "comptime modification of const struct field" {
+    comptime {
+        var res = diamond_info;
+        res.version = 1;
+        try expect(diamond_info.version == 0);
+        try expect(res.version == 1);
+    }
+}
+
+test "slice of type" {
+    comptime {
+        var types_array = [_]type{ i32, f64, type };
+        for (types_array) |T, i| {
+            switch (i) {
+                0 => try expect(T == i32),
+                1 => try expect(T == f64),
+                2 => try expect(T == type),
+                else => unreachable,
+            }
+        }
+        for (types_array[0..]) |T, i| {
+            switch (i) {
+                0 => try expect(T == i32),
+                1 => try expect(T == f64),
+                2 => try expect(T == type),
+                else => unreachable,
+            }
+        }
+    }
+}
+
+const Wrapper = struct {
+    T: type,
+};
+
+fn wrap(comptime T: type) Wrapper {
+    return Wrapper{ .T = T };
+}
+
+test "function which returns struct with type field causes implicit comptime" {
+    const ty = wrap(i32).T;
+    try expect(ty == i32);
+}
+
+test "call method with comptime pass-by-non-copying-value self parameter" {
+    const S = struct {
+        a: u8,
+
+        fn b(comptime s: @This()) u8 {
+            return s.a;
+        }
+    };
+
+    const s = S{ .a = 2 };
+    var b = s.b();
+    try expect(b == 2);
+}
+
+test "@tagName of @typeInfo" {
+    const str = @tagName(@typeInfo(u8));
+    try expect(std.mem.eql(u8, str, "Int"));
+}
+
+test "setting backward branch quota just before a generic fn call" {
+    @setEvalBranchQuota(1001);
+    loopNTimes(1001);
+}
+
+fn loopNTimes(comptime n: usize) void {
+    comptime var i = 0;
+    inline while (i < n) : (i += 1) {}
+}
+
+test "variable inside inline loop that has different types on different iterations" {
+    try testVarInsideInlineLoop(.{ true, @as(u32, 42) });
+}
+
+fn testVarInsideInlineLoop(args: anytype) !void {
+    comptime var i = 0;
+    inline while (i < args.len) : (i += 1) {
+        const x = args[i];
+        if (i == 0) try expect(x);
+        if (i == 1) try expect(x == 42);
+    }
+}
+
+test "inline for with same type but different values" {
+    var res: usize = 0;
+    inline for ([_]type{ [2]u8, [1]u8, [2]u8 }) |T| {
+        var a: T = undefined;
+        res += a.len;
+    }
+    try expect(res == 5);
+}
+
+test "refer to the type of a generic function" {
+    const Func = fn (type) void;
+    const f: Func = doNothingWithType;
+    f(i32);
+}
+
+fn doNothingWithType(comptime T: type) void {
+    _ = T;
+}
+
+test "zero extend from u0 to u1" {
+    var zero_u0: u0 = 0;
+    var zero_u1: u1 = zero_u0;
+    try expect(zero_u1 == 0);
+}
+
+test "bit shift a u1" {
+    var x: u1 = 1;
+    var y = x << 0;
+    try expect(y == 1);
+}
+
+test "comptime pointer cast array and then slice" {
+    const array = [_]u8{ 1, 2, 3, 4, 5, 6, 7, 8 };
+
+    const ptrA: [*]const u8 = @ptrCast([*]const u8, &array);
+    const sliceA: []const u8 = ptrA[0..2];
+
+    const ptrB: [*]const u8 = &array;
+    const sliceB: []const u8 = ptrB[0..2];
+
+    try expect(sliceA[1] == 2);
+    try expect(sliceB[1] == 2);
+}
+
+test "slice bounds in comptime concatenation" {
+    const bs = comptime blk: {
+        const b = "........1........";
+        break :blk b[8..9];
+    };
+    const str = "" ++ bs;
+    try expect(str.len == 1);
+    try expect(std.mem.eql(u8, str, "1"));
+
+    const str2 = bs ++ "";
+    try expect(str2.len == 1);
+    try expect(std.mem.eql(u8, str2, "1"));
+}
+
+test "comptime bitwise operators" {
+    comptime {
+        try expect(3 & 1 == 1);
+        try expect(3 & -1 == 3);
+        try expect(-3 & -1 == -3);
+        try expect(3 | -1 == -1);
+        try expect(-3 | -1 == -1);
+        try expect(3 ^ -1 == -4);
+        try expect(-3 ^ -1 == 2);
+        try expect(~@as(i8, -1) == 0);
+        try expect(~@as(i128, -1) == 0);
+        try expect(18446744073709551615 & 18446744073709551611 == 18446744073709551611);
+        try expect(-18446744073709551615 & -18446744073709551611 == -18446744073709551615);
+        try expect(~@as(u128, 0) == 0xffffffffffffffffffffffffffffffff);
+    }
+}
+
+test "*align(1) u16 is the same as *align(1:0:2) u16" {
+    comptime {
+        try expect(*align(1:0:2) u16 == *align(1) u16);
+        try expect(*align(2:0:2) u16 == *u16);
+    }
+}
+
+test "array concatenation forces comptime" {
+    var a = oneItem(3) ++ oneItem(4);
+    try expect(std.mem.eql(i32, &a, &[_]i32{ 3, 4 }));
+}
+
+test "array multiplication forces comptime" {
+    var a = oneItem(3) ** scalar(2);
+    try expect(std.mem.eql(i32, &a, &[_]i32{ 3, 3 }));
+}
+
+fn oneItem(x: i32) [1]i32 {
+    return [_]i32{x};
+}
+
+fn scalar(x: u32) u32 {
+    return x;
+}
+
+test "comptime assign int to optional int" {
+    comptime {
+        var x: ?i32 = null;
+        x = 2;
+        x.? *= 10;
+        try expectEqual(20, x.?);
+    }
+}
+
+test "return 0 from function that has u0 return type" {
+    const S = struct {
+        fn foo_zero() u0 {
+            return 0;
+        }
+    };
+    comptime {
+        if (S.foo_zero() != 0) {
+            @compileError("test failed");
+        }
+    }
+}
+
+test "two comptime calls with array default initialized to undefined" {
+    const S = struct {
+        const CrossTarget = struct {
+            dynamic_linker: DynamicLinker = DynamicLinker{},
+
+            pub fn parse() void {
+                var result: CrossTarget = .{};
+                result.getCpuArch();
+            }
+
+            pub fn getCpuArch(self: CrossTarget) void {
+                _ = self;
+            }
+        };
+
+        const DynamicLinker = struct {
+            buffer: [255]u8 = undefined,
+        };
+    };
+
+    comptime {
+        S.CrossTarget.parse();
+        S.CrossTarget.parse();
+    }
+}

From ade85471e2cdab466ba685a38c2c7949c9dd1632 Mon Sep 17 00:00:00 2001
From: Dimenus <ryan.saunderson88@gmail.com>
Date: Fri, 6 Aug 2021 12:18:20 -0500
Subject: [PATCH 94/96] include builtin & std packages in all defined packages

---
 src/Compilation.zig | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/src/Compilation.zig b/src/Compilation.zig
index a80849b26e..24e2d9e67f 100644
--- a/src/Compilation.zig
+++ b/src/Compilation.zig
@@ -1227,6 +1227,12 @@ pub fn create(gpa: *Allocator, options: InitOptions) !*Compilation {
             } else main_pkg;
             errdefer if (options.is_test) root_pkg.destroy(gpa);
 
+            var other_pkg_iter = main_pkg.table.valueIterator();
+            while (other_pkg_iter.next()) |pkg| {
+                try pkg.*.add(gpa, "builtin", builtin_pkg);
+                try pkg.*.add(gpa, "std", std_pkg);
+            }
+
             try main_pkg.addAndAdopt(gpa, "builtin", builtin_pkg);
             try main_pkg.add(gpa, "root", root_pkg);
             try main_pkg.addAndAdopt(gpa, "std", std_pkg);

From f81b2531cb4904064446f84a06f6e09e4120e28a Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Sat, 7 Aug 2021 15:41:52 -0700
Subject: [PATCH 95/96] stage2: pass some pointer tests

 * New AIR instructions: ptr_add, ptr_sub, ptr_elem_val, ptr_ptr_elem_val
   - See the doc comments for details.
 * Sema: implement runtime pointer arithmetic.
 * Sema: implement elem_val for many-pointers.
 * Sema: support coercion from `*[N:s]T` to `[*]T`.
 * Type: isIndexable handles many-pointers.
---
 src/Air.zig                       |  33 +++-
 src/Liveness.zig                  |   4 +
 src/Sema.zig                      | 148 +++++++++++----
 src/codegen.zig                   |  40 +++-
 src/codegen/c.zig                 |  28 ++-
 src/codegen/llvm.zig              |  60 +++++-
 src/codegen/llvm/bindings.zig     |   3 +
 src/print_air.zig                 |   4 +
 src/type.zig                      |  14 +-
 test/behavior.zig                 |   3 +-
 test/behavior/pointers.zig        | 301 -----------------------------
 test/behavior/pointers_stage1.zig | 305 ++++++++++++++++++++++++++++++
 12 files changed, 577 insertions(+), 366 deletions(-)
 create mode 100644 test/behavior/pointers_stage1.zig

diff --git a/src/Air.zig b/src/Air.zig
index d923bf0b02..391683afd5 100644
--- a/src/Air.zig
+++ b/src/Air.zig
@@ -69,6 +69,18 @@ pub const Inst = struct {
         /// is the same as both operands.
         /// Uses the `bin_op` field.
         div,
+        /// Add an offset to a pointer, returning a new pointer.
+        /// The offset is in element type units, not bytes.
+        /// Wrapping is undefined behavior.
+        /// The lhs is the pointer, rhs is the offset. Result type is the same as lhs.
+        /// Uses the `bin_op` field.
+        ptr_add,
+        /// Subtract an offset from a pointer, returning a new pointer.
+        /// The offset is in element type units, not bytes.
+        /// Wrapping is undefined behavior.
+        /// The lhs is the pointer, rhs is the offset. Result type is the same as lhs.
+        /// Uses the `bin_op` field.
+        ptr_sub,
         /// Allocates stack local memory.
         /// Uses the `ty` field.
         alloc,
@@ -264,6 +276,15 @@ pub const Inst = struct {
         /// Result type is the element type of the slice operand (2 element type operations).
         /// Uses the `bin_op` field.
         ptr_slice_elem_val,
+        /// Given a pointer value, and element index, return the element value at that index.
+        /// Result type is the element type of the pointer operand.
+        /// Uses the `bin_op` field.
+        ptr_elem_val,
+        /// Given a pointer to a pointer, and element index, return the element value of the inner
+        /// pointer at that index.
+        /// Result type is the element type of the inner pointer operand.
+        /// Uses the `bin_op` field.
+        ptr_ptr_elem_val,
 
         pub fn fromCmpOp(op: std.math.CompareOperator) Tag {
             return switch (op) {
@@ -422,6 +443,8 @@ pub fn typeOfIndex(air: Air, inst: Air.Inst.Index) Type {
         .bit_and,
         .bit_or,
         .xor,
+        .ptr_add,
+        .ptr_sub,
         => return air.typeOf(datas[inst].bin_op.lhs),
 
         .cmp_lt,
@@ -495,14 +518,14 @@ pub fn typeOfIndex(air: Air, inst: Air.Inst.Index) Type {
             return callee_ty.fnReturnType();
         },
 
-        .slice_elem_val => {
+        .slice_elem_val, .ptr_elem_val => {
             const slice_ty = air.typeOf(datas[inst].bin_op.lhs);
             return slice_ty.elemType();
         },
-        .ptr_slice_elem_val => {
-            const ptr_slice_ty = air.typeOf(datas[inst].bin_op.lhs);
-            const slice_ty = ptr_slice_ty.elemType();
-            return slice_ty.elemType();
+        .ptr_slice_elem_val, .ptr_ptr_elem_val => {
+            const outer_ptr_ty = air.typeOf(datas[inst].bin_op.lhs);
+            const inner_ptr_ty = outer_ptr_ty.elemType();
+            return inner_ptr_ty.elemType();
         },
     }
 }
diff --git a/src/Liveness.zig b/src/Liveness.zig
index 4e22febc5a..48603fc7c9 100644
--- a/src/Liveness.zig
+++ b/src/Liveness.zig
@@ -231,6 +231,8 @@ fn analyzeInst(
         .mul,
         .mulwrap,
         .div,
+        .ptr_add,
+        .ptr_sub,
         .bit_and,
         .bit_or,
         .xor,
@@ -245,6 +247,8 @@ fn analyzeInst(
         .store,
         .slice_elem_val,
         .ptr_slice_elem_val,
+        .ptr_elem_val,
+        .ptr_ptr_elem_val,
         => {
             const o = inst_datas[inst].bin_op;
             return trackOperands(a, new_set, inst, main_tomb, .{ o.lhs, o.rhs, .none });
diff --git a/src/Sema.zig b/src/Sema.zig
index 6c68ceaf2a..a783a48c64 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -5471,6 +5471,41 @@ fn analyzeArithmetic(
             lhs_ty, rhs_ty,
         });
     }
+    if (lhs_zig_ty_tag == .Pointer) switch (lhs_ty.ptrSize()) {
+        .One, .Slice => {},
+        .Many, .C => {
+            // Pointer arithmetic.
+            const op_src = src; // TODO better source location
+            const air_tag: Air.Inst.Tag = switch (zir_tag) {
+                .add => .ptr_add,
+                .sub => .ptr_sub,
+                else => return sema.mod.fail(
+                    &block.base,
+                    op_src,
+                    "invalid pointer arithmetic operand: '{s}''",
+                    .{@tagName(zir_tag)},
+                ),
+            };
+            // TODO if the operand is comptime-known to be negative, or is a negative int,
+            // coerce to isize instead of usize.
+            const casted_rhs = try sema.coerce(block, Type.initTag(.usize), rhs, rhs_src);
+            const runtime_src = runtime_src: {
+                if (try sema.resolveDefinedValue(block, lhs_src, lhs)) |lhs_val| {
+                    if (try sema.resolveDefinedValue(block, rhs_src, casted_rhs)) |rhs_val| {
+                        _ = lhs_val;
+                        _ = rhs_val;
+                        return sema.mod.fail(&block.base, src, "TODO implement Sema for comptime pointer arithmetic", .{});
+                    } else {
+                        break :runtime_src rhs_src;
+                    }
+                } else {
+                    break :runtime_src lhs_src;
+                }
+            };
+            try sema.requireRuntimeBlock(block, runtime_src);
+            return block.addBinOp(air_tag, lhs, casted_rhs);
+        },
+    };
 
     const instructions = &[_]Air.Inst.Ref{ lhs, rhs };
     const resolved_type = try sema.resolvePeerTypes(block, src, instructions);
@@ -7959,38 +7994,83 @@ fn elemVal(
 ) CompileError!Air.Inst.Ref {
     const array_ptr_src = src; // TODO better source location
     const maybe_ptr_ty = sema.typeOf(array_maybe_ptr);
-    if (maybe_ptr_ty.isSinglePointer()) {
-        const indexable_ty = maybe_ptr_ty.elemType();
-        if (indexable_ty.isSlice()) {
-            // We have a pointer to a slice and we want an element value.
-            if (try sema.isComptimeKnown(block, src, array_maybe_ptr)) {
-                const slice = try sema.analyzeLoad(block, src, array_maybe_ptr, array_ptr_src);
-                if (try sema.resolveDefinedValue(block, src, slice)) |slice_val| {
+    switch (maybe_ptr_ty.zigTypeTag()) {
+        .Pointer => switch (maybe_ptr_ty.ptrSize()) {
+            .Slice => {
+                if (try sema.resolveDefinedValue(block, src, array_maybe_ptr)) |slice_val| {
                     _ = slice_val;
                     return sema.mod.fail(&block.base, src, "TODO implement Sema for elemVal for comptime known slice", .{});
                 }
                 try sema.requireRuntimeBlock(block, src);
-                return block.addBinOp(.slice_elem_val, slice, elem_index);
-            }
-            try sema.requireRuntimeBlock(block, src);
-            return block.addBinOp(.ptr_slice_elem_val, array_maybe_ptr, elem_index);
-        }
+                return block.addBinOp(.slice_elem_val, array_maybe_ptr, elem_index);
+            },
+            .Many, .C => {
+                if (try sema.resolveDefinedValue(block, src, array_maybe_ptr)) |ptr_val| {
+                    _ = ptr_val;
+                    return sema.mod.fail(&block.base, src, "TODO implement Sema for elemVal for comptime known pointer", .{});
+                }
+                try sema.requireRuntimeBlock(block, src);
+                return block.addBinOp(.ptr_elem_val, array_maybe_ptr, elem_index);
+            },
+            .One => {
+                const indexable_ty = maybe_ptr_ty.elemType();
+                switch (indexable_ty.zigTypeTag()) {
+                    .Pointer => switch (indexable_ty.ptrSize()) {
+                        .Slice => {
+                            // We have a pointer to a slice and we want an element value.
+                            if (try sema.isComptimeKnown(block, src, array_maybe_ptr)) {
+                                const slice = try sema.analyzeLoad(block, src, array_maybe_ptr, array_ptr_src);
+                                if (try sema.resolveDefinedValue(block, src, slice)) |slice_val| {
+                                    _ = slice_val;
+                                    return sema.mod.fail(&block.base, src, "TODO implement Sema for elemVal for comptime known slice", .{});
+                                }
+                                try sema.requireRuntimeBlock(block, src);
+                                return block.addBinOp(.slice_elem_val, slice, elem_index);
+                            }
+                            try sema.requireRuntimeBlock(block, src);
+                            return block.addBinOp(.ptr_slice_elem_val, array_maybe_ptr, elem_index);
+                        },
+                        .Many, .C => {
+                            // We have a pointer to a pointer and we want an element value.
+                            if (try sema.isComptimeKnown(block, src, array_maybe_ptr)) {
+                                const ptr = try sema.analyzeLoad(block, src, array_maybe_ptr, array_ptr_src);
+                                if (try sema.resolveDefinedValue(block, src, ptr)) |ptr_val| {
+                                    _ = ptr_val;
+                                    return sema.mod.fail(&block.base, src, "TODO implement Sema for elemVal for comptime known pointer", .{});
+                                }
+                                try sema.requireRuntimeBlock(block, src);
+                                return block.addBinOp(.ptr_elem_val, ptr, elem_index);
+                            }
+                            try sema.requireRuntimeBlock(block, src);
+                            return block.addBinOp(.ptr_ptr_elem_val, array_maybe_ptr, elem_index);
+                        },
+                        .One => return sema.mod.fail(
+                            &block.base,
+                            array_ptr_src,
+                            "expected pointer, found '{}'",
+                            .{indexable_ty.elemType()},
+                        ),
+                    },
+                    .Array => {
+                        const ptr = try sema.elemPtr(block, src, array_maybe_ptr, elem_index, elem_index_src);
+                        return sema.analyzeLoad(block, src, ptr, elem_index_src);
+                    },
+                    else => return sema.mod.fail(
+                        &block.base,
+                        array_ptr_src,
+                        "expected pointer, found '{}'",
+                        .{indexable_ty},
+                    ),
+                }
+            },
+        },
+        else => return sema.mod.fail(
+            &block.base,
+            array_ptr_src,
+            "expected pointer, found '{}'",
+            .{maybe_ptr_ty},
+        ),
     }
-    if (maybe_ptr_ty.isSlice()) {
-        if (try sema.resolveDefinedValue(block, src, array_maybe_ptr)) |slice_val| {
-            _ = slice_val;
-            return sema.mod.fail(&block.base, src, "TODO implement Sema for elemVal for comptime known slice", .{});
-        }
-        try sema.requireRuntimeBlock(block, src);
-        return block.addBinOp(.slice_elem_val, array_maybe_ptr, elem_index);
-    }
-
-    const array_ptr = if (maybe_ptr_ty.zigTypeTag() == .Pointer)
-        array_maybe_ptr
-    else
-        try sema.analyzeRef(block, src, array_maybe_ptr);
-    const ptr = try sema.elemPtr(block, src, array_ptr, elem_index, elem_index_src);
-    return sema.analyzeLoad(block, src, ptr, elem_index_src);
 }
 
 fn elemPtrArray(
@@ -8107,17 +8187,15 @@ fn coerce(
                     .Many => {
                         // *[N]T to [*]T
                         // *[N:s]T to [*:s]T
-                        const src_sentinel = array_type.sentinel();
-                        const dst_sentinel = dest_type.sentinel();
-                        if (src_sentinel == null and dst_sentinel == null)
-                            return sema.coerceArrayPtrToMany(block, dest_type, inst, inst_src);
-
-                        if (src_sentinel) |src_s| {
-                            if (dst_sentinel) |dst_s| {
-                                if (src_s.eql(dst_s, dst_elem_type)) {
+                        // *[N:s]T to [*]T
+                        if (dest_type.sentinel()) |dst_sentinel| {
+                            if (array_type.sentinel()) |src_sentinel| {
+                                if (src_sentinel.eql(dst_sentinel, dst_elem_type)) {
                                     return sema.coerceArrayPtrToMany(block, dest_type, inst, inst_src);
                                 }
                             }
+                        } else {
+                            return sema.coerceArrayPtrToMany(block, dest_type, inst, inst_src);
                         }
                     },
                     .One => {},
diff --git a/src/codegen.zig b/src/codegen.zig
index 7fd51d3cd8..f5cdc518f6 100644
--- a/src/codegen.zig
+++ b/src/codegen.zig
@@ -802,13 +802,13 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
 
                 switch (air_tags[inst]) {
                     // zig fmt: off
-                    .add     => try self.airAdd(inst),
-                    .addwrap => try self.airAddWrap(inst),
-                    .sub     => try self.airSub(inst),
-                    .subwrap => try self.airSubWrap(inst),
-                    .mul     => try self.airMul(inst),
-                    .mulwrap => try self.airMulWrap(inst),
-                    .div     => try self.airDiv(inst),
+                    .add, .ptr_add => try self.airAdd(inst),
+                    .addwrap       => try self.airAddWrap(inst),
+                    .sub, .ptr_sub => try self.airSub(inst),
+                    .subwrap       => try self.airSubWrap(inst),
+                    .mul           => try self.airMul(inst),
+                    .mulwrap       => try self.airMulWrap(inst),
+                    .div           => try self.airDiv(inst),
 
                     .cmp_lt  => try self.airCmp(inst, .lt),
                     .cmp_lte => try self.airCmp(inst, .lte),
@@ -859,6 +859,8 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
 
                     .slice_elem_val      => try self.airSliceElemVal(inst),
                     .ptr_slice_elem_val  => try self.airPtrSliceElemVal(inst),
+                    .ptr_elem_val        => try self.airPtrElemVal(inst),
+                    .ptr_ptr_elem_val    => try self.airPtrPtrElemVal(inst),
 
                     .constant => unreachable, // excluded from function bodies
                     .const_ty => unreachable, // excluded from function bodies
@@ -1369,21 +1371,41 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
         }
 
         fn airSliceElemVal(self: *Self, inst: Air.Inst.Index) !void {
+            const is_volatile = false; // TODO
             const bin_op = self.air.instructions.items(.data)[inst].bin_op;
-            const result: MCValue = if (self.liveness.isUnused(inst)) .dead else switch (arch) {
+            const result: MCValue = if (!is_volatile and self.liveness.isUnused(inst)) .dead else switch (arch) {
                 else => return self.fail("TODO implement slice_elem_val for {}", .{self.target.cpu.arch}),
             };
             return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
         }
 
         fn airPtrSliceElemVal(self: *Self, inst: Air.Inst.Index) !void {
+            const is_volatile = false; // TODO
             const bin_op = self.air.instructions.items(.data)[inst].bin_op;
-            const result: MCValue = if (self.liveness.isUnused(inst)) .dead else switch (arch) {
+            const result: MCValue = if (!is_volatile and self.liveness.isUnused(inst)) .dead else switch (arch) {
                 else => return self.fail("TODO implement ptr_slice_elem_val for {}", .{self.target.cpu.arch}),
             };
             return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
         }
 
+        fn airPtrElemVal(self: *Self, inst: Air.Inst.Index) !void {
+            const is_volatile = false; // TODO
+            const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+            const result: MCValue = if (!is_volatile and self.liveness.isUnused(inst)) .dead else switch (arch) {
+                else => return self.fail("TODO implement ptr_elem_val for {}", .{self.target.cpu.arch}),
+            };
+            return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
+        }
+
+        fn airPtrPtrElemVal(self: *Self, inst: Air.Inst.Index) !void {
+            const is_volatile = false; // TODO
+            const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+            const result: MCValue = if (!is_volatile and self.liveness.isUnused(inst)) .dead else switch (arch) {
+                else => return self.fail("TODO implement ptr_ptr_elem_val for {}", .{self.target.cpu.arch}),
+            };
+            return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
+        }
+
         fn reuseOperand(self: *Self, inst: Air.Inst.Index, operand: Air.Inst.Ref, op_index: Liveness.OperandInt, mcv: MCValue) bool {
             if (!self.liveness.operandDies(inst, op_index))
                 return false;
diff --git a/src/codegen/c.zig b/src/codegen/c.zig
index 22420aca45..65ad4bac8e 100644
--- a/src/codegen/c.zig
+++ b/src/codegen/c.zig
@@ -850,19 +850,19 @@ fn genBody(o: *Object, body: []const Air.Inst.Index) error{ AnalysisFail, OutOfM
 
             // TODO use a different strategy for add that communicates to the optimizer
             // that wrapping is UB.
-            .add     => try airBinOp( o, inst, " + "),
-            .addwrap => try airWrapOp(o, inst, " + ", "addw_"),
+            .add, .ptr_add => try airBinOp( o, inst, " + "),
+            .addwrap       => try airWrapOp(o, inst, " + ", "addw_"),
             // TODO use a different strategy for sub that communicates to the optimizer
             // that wrapping is UB.
-            .sub     => try airBinOp( o, inst, " - "),
-            .subwrap => try airWrapOp(o, inst, " - ", "subw_"),
+            .sub, .ptr_sub => try airBinOp( o, inst, " - "),
+            .subwrap       => try airWrapOp(o, inst, " - ", "subw_"),
             // TODO use a different strategy for mul that communicates to the optimizer
             // that wrapping is UB.
-            .mul     => try airBinOp( o, inst, " * "),
-            .mulwrap => try airWrapOp(o, inst, " * ", "mulw_"),
+            .mul           => try airBinOp( o, inst, " * "),
+            .mulwrap       => try airWrapOp(o, inst, " * ", "mulw_"),
             // TODO use a different strategy for div that communicates to the optimizer
             // that wrapping is UB.
-            .div     => try airBinOp( o, inst, " / "),
+            .div           => try airBinOp( o, inst, " / "),
 
             .cmp_eq  => try airBinOp(o, inst, " == "),
             .cmp_gt  => try airBinOp(o, inst, " > "),
@@ -915,6 +915,8 @@ fn genBody(o: *Object, body: []const Air.Inst.Index) error{ AnalysisFail, OutOfM
             .slice_ptr        => try airSliceField(o, inst, ".ptr;\n"),
             .slice_len        => try airSliceField(o, inst, ".len;\n"),
 
+            .ptr_elem_val       => try airPtrElemVal(o, inst, "["),
+            .ptr_ptr_elem_val   => try airPtrElemVal(o, inst, "[0]["),
             .slice_elem_val     => try airSliceElemVal(o, inst, "["),
             .ptr_slice_elem_val => try airSliceElemVal(o, inst, "[0]["),
 
@@ -953,8 +955,18 @@ fn airSliceField(o: *Object, inst: Air.Inst.Index, suffix: []const u8) !CValue {
     return local;
 }
 
+fn airPtrElemVal(o: *Object, inst: Air.Inst.Index, prefix: []const u8) !CValue {
+    const is_volatile = false; // TODO
+    if (!is_volatile and o.liveness.isUnused(inst))
+        return CValue.none;
+
+    _ = prefix;
+    return o.dg.fail("TODO: C backend: airPtrElemVal", .{});
+}
+
 fn airSliceElemVal(o: *Object, inst: Air.Inst.Index, prefix: []const u8) !CValue {
-    if (o.liveness.isUnused(inst))
+    const is_volatile = false; // TODO
+    if (!is_volatile and o.liveness.isUnused(inst))
         return CValue.none;
 
     const bin_op = o.air.instructions.items(.data)[inst].bin_op;
diff --git a/src/codegen/llvm.zig b/src/codegen/llvm.zig
index 4b7454d878..eccd5fa04f 100644
--- a/src/codegen/llvm.zig
+++ b/src/codegen/llvm.zig
@@ -966,6 +966,8 @@ pub const FuncGen = struct {
                 .mul     => try self.airMul(inst, false),
                 .mulwrap => try self.airMul(inst, true),
                 .div     => try self.airDiv(inst),
+                .ptr_add => try self.airPtrAdd(inst),
+                .ptr_sub => try self.airPtrSub(inst),
 
                 .bit_and, .bool_and => try self.airAnd(inst),
                 .bit_or, .bool_or   => try self.airOr(inst),
@@ -1015,6 +1017,8 @@ pub const FuncGen = struct {
 
                 .slice_elem_val     => try self.airSliceElemVal(inst),
                 .ptr_slice_elem_val => try self.airPtrSliceElemVal(inst),
+                .ptr_elem_val       => try self.airPtrElemVal(inst),
+                .ptr_ptr_elem_val   => try self.airPtrPtrElemVal(inst),
 
                 .optional_payload     => try self.airOptionalPayload(inst, false),
                 .optional_payload_ptr => try self.airOptionalPayload(inst, true),
@@ -1229,7 +1233,8 @@ pub const FuncGen = struct {
     }
 
     fn airSliceElemVal(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
-        if (self.liveness.isUnused(inst))
+        const is_volatile = false; // TODO
+        if (!is_volatile and self.liveness.isUnused(inst))
             return null;
 
         const bin_op = self.air.instructions.items(.data)[inst].bin_op;
@@ -1242,7 +1247,8 @@ pub const FuncGen = struct {
     }
 
     fn airPtrSliceElemVal(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
-        if (self.liveness.isUnused(inst))
+        const is_volatile = false; // TODO
+        if (!is_volatile and self.liveness.isUnused(inst))
             return null;
 
         const bin_op = self.air.instructions.items(.data)[inst].bin_op;
@@ -1264,6 +1270,33 @@ pub const FuncGen = struct {
         return self.builder.buildLoad(ptr, "");
     }
 
+    fn airPtrElemVal(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+        const is_volatile = false; // TODO
+        if (!is_volatile and self.liveness.isUnused(inst))
+            return null;
+
+        const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+        const base_ptr = try self.resolveInst(bin_op.lhs);
+        const rhs = try self.resolveInst(bin_op.rhs);
+        const indices: [1]*const llvm.Value = .{rhs};
+        const ptr = self.builder.buildInBoundsGEP(base_ptr, &indices, indices.len, "");
+        return self.builder.buildLoad(ptr, "");
+    }
+
+    fn airPtrPtrElemVal(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+        const is_volatile = false; // TODO
+        if (!is_volatile and self.liveness.isUnused(inst))
+            return null;
+
+        const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+        const lhs = try self.resolveInst(bin_op.lhs);
+        const rhs = try self.resolveInst(bin_op.rhs);
+        const base_ptr = self.builder.buildLoad(lhs, "");
+        const indices: [1]*const llvm.Value = .{rhs};
+        const ptr = self.builder.buildInBoundsGEP(base_ptr, &indices, indices.len, "");
+        return self.builder.buildLoad(ptr, "");
+    }
+
     fn airStructFieldPtr(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
         if (self.liveness.isUnused(inst))
             return null;
@@ -1624,6 +1657,29 @@ pub const FuncGen = struct {
         return self.builder.buildUDiv(lhs, rhs, "");
     }
 
+    fn airPtrAdd(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+        if (self.liveness.isUnused(inst))
+            return null;
+
+        const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+        const base_ptr = try self.resolveInst(bin_op.lhs);
+        const offset = try self.resolveInst(bin_op.rhs);
+        const indices: [1]*const llvm.Value = .{offset};
+        return self.builder.buildInBoundsGEP(base_ptr, &indices, indices.len, "");
+    }
+
+    fn airPtrSub(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+        if (self.liveness.isUnused(inst))
+            return null;
+
+        const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+        const base_ptr = try self.resolveInst(bin_op.lhs);
+        const offset = try self.resolveInst(bin_op.rhs);
+        const negative_offset = self.builder.buildNeg(offset, "");
+        const indices: [1]*const llvm.Value = .{negative_offset};
+        return self.builder.buildInBoundsGEP(base_ptr, &indices, indices.len, "");
+    }
+
     fn airAnd(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
         if (self.liveness.isUnused(inst))
             return null;
diff --git a/src/codegen/llvm/bindings.zig b/src/codegen/llvm/bindings.zig
index 096cd4a5b4..4bb8a4a18b 100644
--- a/src/codegen/llvm/bindings.zig
+++ b/src/codegen/llvm/bindings.zig
@@ -324,6 +324,9 @@ pub const Builder = opaque {
     pub const buildLoad = LLVMBuildLoad;
     extern fn LLVMBuildLoad(*const Builder, PointerVal: *const Value, Name: [*:0]const u8) *const Value;
 
+    pub const buildNeg = LLVMBuildNeg;
+    extern fn LLVMBuildNeg(*const Builder, V: *const Value, Name: [*:0]const u8) *const Value;
+
     pub const buildNot = LLVMBuildNot;
     extern fn LLVMBuildNot(*const Builder, V: *const Value, Name: [*:0]const u8) *const Value;
 
diff --git a/src/print_air.zig b/src/print_air.zig
index 11f2982fc3..66490b6512 100644
--- a/src/print_air.zig
+++ b/src/print_air.zig
@@ -109,6 +109,8 @@ const Writer = struct {
             .mul,
             .mulwrap,
             .div,
+            .ptr_add,
+            .ptr_sub,
             .bit_and,
             .bit_or,
             .xor,
@@ -123,6 +125,8 @@ const Writer = struct {
             .store,
             .slice_elem_val,
             .ptr_slice_elem_val,
+            .ptr_elem_val,
+            .ptr_ptr_elem_val,
             => try w.writeBinOp(s, inst),
 
             .is_null,
diff --git a/src/type.zig b/src/type.zig
index 02b9fabe71..28b87a8afe 100644
--- a/src/type.zig
+++ b/src/type.zig
@@ -2753,11 +2753,15 @@ pub const Type = extern union {
         };
     }
 
-    pub fn isIndexable(self: Type) bool {
-        const zig_tag = self.zigTypeTag();
-        // TODO tuples are indexable
-        return zig_tag == .Array or zig_tag == .Vector or self.isSlice() or
-            (self.isSinglePointer() and self.elemType().zigTypeTag() == .Array);
+    pub fn isIndexable(ty: Type) bool {
+        return switch (ty.zigTypeTag()) {
+            .Array, .Vector => true,
+            .Pointer => switch (ty.ptrSize()) {
+                .Slice, .Many, .C => true,
+                .One => ty.elemType().zigTypeTag() == .Array,
+            },
+            else => false, // TODO tuples are indexable
+        };
     }
 
     /// Returns null if the type has no namespace.
diff --git a/test/behavior.zig b/test/behavior.zig
index f1c6fa3a35..936268af9c 100644
--- a/test/behavior.zig
+++ b/test/behavior.zig
@@ -6,6 +6,7 @@ test {
     _ = @import("behavior/basic.zig");
     _ = @import("behavior/generics.zig");
     _ = @import("behavior/eval.zig");
+    _ = @import("behavior/pointers.zig");
 
     if (!builtin.zig_is_stage2) {
         // Tests that only pass for stage1.
@@ -112,7 +113,7 @@ test {
         _ = @import("behavior/namespace_depends_on_compile_var.zig");
         _ = @import("behavior/null.zig");
         _ = @import("behavior/optional.zig");
-        _ = @import("behavior/pointers.zig");
+        _ = @import("behavior/pointers_stage1.zig");
         _ = @import("behavior/popcount.zig");
         _ = @import("behavior/ptrcast.zig");
         _ = @import("behavior/pub_enum.zig");
diff --git a/test/behavior/pointers.zig b/test/behavior/pointers.zig
index bb95d3c219..4fcd78b1d6 100644
--- a/test/behavior/pointers.zig
+++ b/test/behavior/pointers.zig
@@ -15,22 +15,6 @@ fn testDerefPtr() !void {
     try expect(x == 1235);
 }
 
-const Foo1 = struct {
-    x: void,
-};
-
-test "dereference pointer again" {
-    try testDerefPtrOneVal();
-    comptime try testDerefPtrOneVal();
-}
-
-fn testDerefPtrOneVal() !void {
-    // Foo1 satisfies the OnePossibleValueYes criteria
-    const x = &Foo1{ .x = {} };
-    const y = x.*;
-    try expect(@TypeOf(y.x) == void);
-}
-
 test "pointer arithmetic" {
     var ptr: [*]const u8 = "abcd";
 
@@ -60,288 +44,3 @@ test "double pointer parsing" {
 fn PtrOf(comptime T: type) type {
     return *T;
 }
-
-test "assigning integer to C pointer" {
-    var x: i32 = 0;
-    var ptr: [*c]u8 = 0;
-    var ptr2: [*c]u8 = x;
-    if (false) {
-        ptr;
-        ptr2;
-    }
-}
-
-test "implicit cast single item pointer to C pointer and back" {
-    var y: u8 = 11;
-    var x: [*c]u8 = &y;
-    var z: *u8 = x;
-    z.* += 1;
-    try expect(y == 12);
-}
-
-test "C pointer comparison and arithmetic" {
-    const S = struct {
-        fn doTheTest() !void {
-            var ptr1: [*c]u32 = 0;
-            var ptr2 = ptr1 + 10;
-            try expect(ptr1 == 0);
-            try expect(ptr1 >= 0);
-            try expect(ptr1 <= 0);
-            // expect(ptr1 < 1);
-            // expect(ptr1 < one);
-            // expect(1 > ptr1);
-            // expect(one > ptr1);
-            try expect(ptr1 < ptr2);
-            try expect(ptr2 > ptr1);
-            try expect(ptr2 >= 40);
-            try expect(ptr2 == 40);
-            try expect(ptr2 <= 40);
-            ptr2 -= 10;
-            try expect(ptr1 == ptr2);
-        }
-    };
-    try S.doTheTest();
-    comptime try S.doTheTest();
-}
-
-test "peer type resolution with C pointers" {
-    var ptr_one: *u8 = undefined;
-    var ptr_many: [*]u8 = undefined;
-    var ptr_c: [*c]u8 = undefined;
-    var t = true;
-    var x1 = if (t) ptr_one else ptr_c;
-    var x2 = if (t) ptr_many else ptr_c;
-    var x3 = if (t) ptr_c else ptr_one;
-    var x4 = if (t) ptr_c else ptr_many;
-    try expect(@TypeOf(x1) == [*c]u8);
-    try expect(@TypeOf(x2) == [*c]u8);
-    try expect(@TypeOf(x3) == [*c]u8);
-    try expect(@TypeOf(x4) == [*c]u8);
-}
-
-test "implicit casting between C pointer and optional non-C pointer" {
-    var slice: []const u8 = "aoeu";
-    const opt_many_ptr: ?[*]const u8 = slice.ptr;
-    var ptr_opt_many_ptr = &opt_many_ptr;
-    var c_ptr: [*c]const [*c]const u8 = ptr_opt_many_ptr;
-    try expect(c_ptr.*.* == 'a');
-    ptr_opt_many_ptr = c_ptr;
-    try expect(ptr_opt_many_ptr.*.?[1] == 'o');
-}
-
-test "implicit cast error unions with non-optional to optional pointer" {
-    const S = struct {
-        fn doTheTest() !void {
-            try expectError(error.Fail, foo());
-        }
-        fn foo() anyerror!?*u8 {
-            return bar() orelse error.Fail;
-        }
-        fn bar() ?*u8 {
-            return null;
-        }
-    };
-    try S.doTheTest();
-    comptime try S.doTheTest();
-}
-
-test "initialize const optional C pointer to null" {
-    const a: ?[*c]i32 = null;
-    try expect(a == null);
-    comptime try expect(a == null);
-}
-
-test "compare equality of optional and non-optional pointer" {
-    const a = @intToPtr(*const usize, 0x12345678);
-    const b = @intToPtr(?*usize, 0x12345678);
-    try expect(a == b);
-    try expect(b == a);
-}
-
-test "allowzero pointer and slice" {
-    var ptr = @intToPtr([*]allowzero i32, 0);
-    var opt_ptr: ?[*]allowzero i32 = ptr;
-    try expect(opt_ptr != null);
-    try expect(@ptrToInt(ptr) == 0);
-    var runtime_zero: usize = 0;
-    var slice = ptr[runtime_zero..10];
-    comptime try expect(@TypeOf(slice) == []allowzero i32);
-    try expect(@ptrToInt(&slice[5]) == 20);
-
-    comptime try expect(@typeInfo(@TypeOf(ptr)).Pointer.is_allowzero);
-    comptime try expect(@typeInfo(@TypeOf(slice)).Pointer.is_allowzero);
-}
-
-test "assign null directly to C pointer and test null equality" {
-    var x: [*c]i32 = null;
-    try expect(x == null);
-    try expect(null == x);
-    try expect(!(x != null));
-    try expect(!(null != x));
-    if (x) |same_x| {
-        _ = same_x;
-        @panic("fail");
-    }
-    var otherx: i32 = undefined;
-    try expect((x orelse &otherx) == &otherx);
-
-    const y: [*c]i32 = null;
-    comptime try expect(y == null);
-    comptime try expect(null == y);
-    comptime try expect(!(y != null));
-    comptime try expect(!(null != y));
-    if (y) |same_y| {
-        _ = same_y;
-        @panic("fail");
-    }
-    const othery: i32 = undefined;
-    comptime try expect((y orelse &othery) == &othery);
-
-    var n: i32 = 1234;
-    var x1: [*c]i32 = &n;
-    try expect(!(x1 == null));
-    try expect(!(null == x1));
-    try expect(x1 != null);
-    try expect(null != x1);
-    try expect(x1.?.* == 1234);
-    if (x1) |same_x1| {
-        try expect(same_x1.* == 1234);
-    } else {
-        @panic("fail");
-    }
-    try expect((x1 orelse &otherx) == x1);
-
-    const nc: i32 = 1234;
-    const y1: [*c]const i32 = &nc;
-    comptime try expect(!(y1 == null));
-    comptime try expect(!(null == y1));
-    comptime try expect(y1 != null);
-    comptime try expect(null != y1);
-    comptime try expect(y1.?.* == 1234);
-    if (y1) |same_y1| {
-        try expect(same_y1.* == 1234);
-    } else {
-        @compileError("fail");
-    }
-    comptime try expect((y1 orelse &othery) == y1);
-}
-
-test "null terminated pointer" {
-    const S = struct {
-        fn doTheTest() !void {
-            var array_with_zero = [_:0]u8{ 'h', 'e', 'l', 'l', 'o' };
-            var zero_ptr: [*:0]const u8 = @ptrCast([*:0]const u8, &array_with_zero);
-            var no_zero_ptr: [*]const u8 = zero_ptr;
-            var zero_ptr_again = @ptrCast([*:0]const u8, no_zero_ptr);
-            try expect(std.mem.eql(u8, std.mem.spanZ(zero_ptr_again), "hello"));
-        }
-    };
-    try S.doTheTest();
-    comptime try S.doTheTest();
-}
-
-test "allow any sentinel" {
-    const S = struct {
-        fn doTheTest() !void {
-            var array = [_:std.math.minInt(i32)]i32{ 1, 2, 3, 4 };
-            var ptr: [*:std.math.minInt(i32)]i32 = &array;
-            try expect(ptr[4] == std.math.minInt(i32));
-        }
-    };
-    try S.doTheTest();
-    comptime try S.doTheTest();
-}
-
-test "pointer sentinel with enums" {
-    const S = struct {
-        const Number = enum {
-            one,
-            two,
-            sentinel,
-        };
-
-        fn doTheTest() !void {
-            var ptr: [*:.sentinel]const Number = &[_:.sentinel]Number{ .one, .two, .two, .one };
-            try expect(ptr[4] == .sentinel); // TODO this should be comptime try expect, see #3731
-        }
-    };
-    try S.doTheTest();
-    comptime try S.doTheTest();
-}
-
-test "pointer sentinel with optional element" {
-    const S = struct {
-        fn doTheTest() !void {
-            var ptr: [*:null]const ?i32 = &[_:null]?i32{ 1, 2, 3, 4 };
-            try expect(ptr[4] == null); // TODO this should be comptime try expect, see #3731
-        }
-    };
-    try S.doTheTest();
-    comptime try S.doTheTest();
-}
-
-test "pointer sentinel with +inf" {
-    const S = struct {
-        fn doTheTest() !void {
-            const inf = std.math.inf_f32;
-            var ptr: [*:inf]const f32 = &[_:inf]f32{ 1.1, 2.2, 3.3, 4.4 };
-            try expect(ptr[4] == inf); // TODO this should be comptime try expect, see #3731
-        }
-    };
-    try S.doTheTest();
-    comptime try S.doTheTest();
-}
-
-test "pointer to array at fixed address" {
-    const array = @intToPtr(*volatile [1]u32, 0x10);
-    // Silly check just to reference `array`
-    try expect(@ptrToInt(&array[0]) == 0x10);
-}
-
-test "pointer arithmetic affects the alignment" {
-    {
-        var ptr: [*]align(8) u32 = undefined;
-        var x: usize = 1;
-
-        try expect(@typeInfo(@TypeOf(ptr)).Pointer.alignment == 8);
-        const ptr1 = ptr + 1; // 1 * 4 = 4 -> lcd(4,8) = 4
-        try expect(@typeInfo(@TypeOf(ptr1)).Pointer.alignment == 4);
-        const ptr2 = ptr + 4; // 4 * 4 = 16 -> lcd(16,8) = 8
-        try expect(@typeInfo(@TypeOf(ptr2)).Pointer.alignment == 8);
-        const ptr3 = ptr + 0; // no-op
-        try expect(@typeInfo(@TypeOf(ptr3)).Pointer.alignment == 8);
-        const ptr4 = ptr + x; // runtime-known addend
-        try expect(@typeInfo(@TypeOf(ptr4)).Pointer.alignment == 4);
-    }
-    {
-        var ptr: [*]align(8) [3]u8 = undefined;
-        var x: usize = 1;
-
-        const ptr1 = ptr + 17; // 3 * 17 = 51
-        try expect(@typeInfo(@TypeOf(ptr1)).Pointer.alignment == 1);
-        const ptr2 = ptr + x; // runtime-known addend
-        try expect(@typeInfo(@TypeOf(ptr2)).Pointer.alignment == 1);
-        const ptr3 = ptr + 8; // 3 * 8 = 24 -> lcd(8,24) = 8
-        try expect(@typeInfo(@TypeOf(ptr3)).Pointer.alignment == 8);
-        const ptr4 = ptr + 4; // 3 * 4 = 12 -> lcd(8,12) = 4
-        try expect(@typeInfo(@TypeOf(ptr4)).Pointer.alignment == 4);
-    }
-}
-
-test "@ptrToInt on null optional at comptime" {
-    {
-        const pointer = @intToPtr(?*u8, 0x000);
-        const x = @ptrToInt(pointer);
-        _ = x;
-        comptime try expect(0 == @ptrToInt(pointer));
-    }
-    {
-        const pointer = @intToPtr(?*u8, 0xf00);
-        comptime try expect(0xf00 == @ptrToInt(pointer));
-    }
-}
-
-test "indexing array with sentinel returns correct type" {
-    var s: [:0]const u8 = "abc";
-    try testing.expectEqualSlices(u8, "*const u8", @typeName(@TypeOf(&s[0])));
-}
diff --git a/test/behavior/pointers_stage1.zig b/test/behavior/pointers_stage1.zig
new file mode 100644
index 0000000000..aea123a5c3
--- /dev/null
+++ b/test/behavior/pointers_stage1.zig
@@ -0,0 +1,305 @@
+const std = @import("std");
+const testing = std.testing;
+const expect = testing.expect;
+const expectError = testing.expectError;
+
+const Foo1 = struct {
+    x: void,
+};
+
+test "dereference pointer again" {
+    try testDerefPtrOneVal();
+    comptime try testDerefPtrOneVal();
+}
+
+fn testDerefPtrOneVal() !void {
+    // Foo1 satisfies the OnePossibleValueYes criteria
+    const x = &Foo1{ .x = {} };
+    const y = x.*;
+    try expect(@TypeOf(y.x) == void);
+}
+
+test "assigning integer to C pointer" {
+    var x: i32 = 0;
+    var ptr: [*c]u8 = 0;
+    var ptr2: [*c]u8 = x;
+    if (false) {
+        ptr;
+        ptr2;
+    }
+}
+
+test "implicit cast single item pointer to C pointer and back" {
+    var y: u8 = 11;
+    var x: [*c]u8 = &y;
+    var z: *u8 = x;
+    z.* += 1;
+    try expect(y == 12);
+}
+
+test "C pointer comparison and arithmetic" {
+    const S = struct {
+        fn doTheTest() !void {
+            var ptr1: [*c]u32 = 0;
+            var ptr2 = ptr1 + 10;
+            try expect(ptr1 == 0);
+            try expect(ptr1 >= 0);
+            try expect(ptr1 <= 0);
+            // expect(ptr1 < 1);
+            // expect(ptr1 < one);
+            // expect(1 > ptr1);
+            // expect(one > ptr1);
+            try expect(ptr1 < ptr2);
+            try expect(ptr2 > ptr1);
+            try expect(ptr2 >= 40);
+            try expect(ptr2 == 40);
+            try expect(ptr2 <= 40);
+            ptr2 -= 10;
+            try expect(ptr1 == ptr2);
+        }
+    };
+    try S.doTheTest();
+    comptime try S.doTheTest();
+}
+
+test "peer type resolution with C pointers" {
+    var ptr_one: *u8 = undefined;
+    var ptr_many: [*]u8 = undefined;
+    var ptr_c: [*c]u8 = undefined;
+    var t = true;
+    var x1 = if (t) ptr_one else ptr_c;
+    var x2 = if (t) ptr_many else ptr_c;
+    var x3 = if (t) ptr_c else ptr_one;
+    var x4 = if (t) ptr_c else ptr_many;
+    try expect(@TypeOf(x1) == [*c]u8);
+    try expect(@TypeOf(x2) == [*c]u8);
+    try expect(@TypeOf(x3) == [*c]u8);
+    try expect(@TypeOf(x4) == [*c]u8);
+}
+
+test "implicit casting between C pointer and optional non-C pointer" {
+    var slice: []const u8 = "aoeu";
+    const opt_many_ptr: ?[*]const u8 = slice.ptr;
+    var ptr_opt_many_ptr = &opt_many_ptr;
+    var c_ptr: [*c]const [*c]const u8 = ptr_opt_many_ptr;
+    try expect(c_ptr.*.* == 'a');
+    ptr_opt_many_ptr = c_ptr;
+    try expect(ptr_opt_many_ptr.*.?[1] == 'o');
+}
+
+test "implicit cast error unions with non-optional to optional pointer" {
+    const S = struct {
+        fn doTheTest() !void {
+            try expectError(error.Fail, foo());
+        }
+        fn foo() anyerror!?*u8 {
+            return bar() orelse error.Fail;
+        }
+        fn bar() ?*u8 {
+            return null;
+        }
+    };
+    try S.doTheTest();
+    comptime try S.doTheTest();
+}
+
+test "initialize const optional C pointer to null" {
+    const a: ?[*c]i32 = null;
+    try expect(a == null);
+    comptime try expect(a == null);
+}
+
+test "compare equality of optional and non-optional pointer" {
+    const a = @intToPtr(*const usize, 0x12345678);
+    const b = @intToPtr(?*usize, 0x12345678);
+    try expect(a == b);
+    try expect(b == a);
+}
+
+test "allowzero pointer and slice" {
+    var ptr = @intToPtr([*]allowzero i32, 0);
+    var opt_ptr: ?[*]allowzero i32 = ptr;
+    try expect(opt_ptr != null);
+    try expect(@ptrToInt(ptr) == 0);
+    var runtime_zero: usize = 0;
+    var slice = ptr[runtime_zero..10];
+    comptime try expect(@TypeOf(slice) == []allowzero i32);
+    try expect(@ptrToInt(&slice[5]) == 20);
+
+    comptime try expect(@typeInfo(@TypeOf(ptr)).Pointer.is_allowzero);
+    comptime try expect(@typeInfo(@TypeOf(slice)).Pointer.is_allowzero);
+}
+
+test "assign null directly to C pointer and test null equality" {
+    var x: [*c]i32 = null;
+    try expect(x == null);
+    try expect(null == x);
+    try expect(!(x != null));
+    try expect(!(null != x));
+    if (x) |same_x| {
+        _ = same_x;
+        @panic("fail");
+    }
+    var otherx: i32 = undefined;
+    try expect((x orelse &otherx) == &otherx);
+
+    const y: [*c]i32 = null;
+    comptime try expect(y == null);
+    comptime try expect(null == y);
+    comptime try expect(!(y != null));
+    comptime try expect(!(null != y));
+    if (y) |same_y| {
+        _ = same_y;
+        @panic("fail");
+    }
+    const othery: i32 = undefined;
+    comptime try expect((y orelse &othery) == &othery);
+
+    var n: i32 = 1234;
+    var x1: [*c]i32 = &n;
+    try expect(!(x1 == null));
+    try expect(!(null == x1));
+    try expect(x1 != null);
+    try expect(null != x1);
+    try expect(x1.?.* == 1234);
+    if (x1) |same_x1| {
+        try expect(same_x1.* == 1234);
+    } else {
+        @panic("fail");
+    }
+    try expect((x1 orelse &otherx) == x1);
+
+    const nc: i32 = 1234;
+    const y1: [*c]const i32 = &nc;
+    comptime try expect(!(y1 == null));
+    comptime try expect(!(null == y1));
+    comptime try expect(y1 != null);
+    comptime try expect(null != y1);
+    comptime try expect(y1.?.* == 1234);
+    if (y1) |same_y1| {
+        try expect(same_y1.* == 1234);
+    } else {
+        @compileError("fail");
+    }
+    comptime try expect((y1 orelse &othery) == y1);
+}
+
+test "null terminated pointer" {
+    const S = struct {
+        fn doTheTest() !void {
+            var array_with_zero = [_:0]u8{ 'h', 'e', 'l', 'l', 'o' };
+            var zero_ptr: [*:0]const u8 = @ptrCast([*:0]const u8, &array_with_zero);
+            var no_zero_ptr: [*]const u8 = zero_ptr;
+            var zero_ptr_again = @ptrCast([*:0]const u8, no_zero_ptr);
+            try expect(std.mem.eql(u8, std.mem.spanZ(zero_ptr_again), "hello"));
+        }
+    };
+    try S.doTheTest();
+    comptime try S.doTheTest();
+}
+
+test "allow any sentinel" {
+    const S = struct {
+        fn doTheTest() !void {
+            var array = [_:std.math.minInt(i32)]i32{ 1, 2, 3, 4 };
+            var ptr: [*:std.math.minInt(i32)]i32 = &array;
+            try expect(ptr[4] == std.math.minInt(i32));
+        }
+    };
+    try S.doTheTest();
+    comptime try S.doTheTest();
+}
+
+test "pointer sentinel with enums" {
+    const S = struct {
+        const Number = enum {
+            one,
+            two,
+            sentinel,
+        };
+
+        fn doTheTest() !void {
+            var ptr: [*:.sentinel]const Number = &[_:.sentinel]Number{ .one, .two, .two, .one };
+            try expect(ptr[4] == .sentinel); // TODO this should be comptime try expect, see #3731
+        }
+    };
+    try S.doTheTest();
+    comptime try S.doTheTest();
+}
+
+test "pointer sentinel with optional element" {
+    const S = struct {
+        fn doTheTest() !void {
+            var ptr: [*:null]const ?i32 = &[_:null]?i32{ 1, 2, 3, 4 };
+            try expect(ptr[4] == null); // TODO this should be comptime try expect, see #3731
+        }
+    };
+    try S.doTheTest();
+    comptime try S.doTheTest();
+}
+
+test "pointer sentinel with +inf" {
+    const S = struct {
+        fn doTheTest() !void {
+            const inf = std.math.inf_f32;
+            var ptr: [*:inf]const f32 = &[_:inf]f32{ 1.1, 2.2, 3.3, 4.4 };
+            try expect(ptr[4] == inf); // TODO this should be comptime try expect, see #3731
+        }
+    };
+    try S.doTheTest();
+    comptime try S.doTheTest();
+}
+
+test "pointer to array at fixed address" {
+    const array = @intToPtr(*volatile [1]u32, 0x10);
+    // Silly check just to reference `array`
+    try expect(@ptrToInt(&array[0]) == 0x10);
+}
+
+test "pointer arithmetic affects the alignment" {
+    {
+        var ptr: [*]align(8) u32 = undefined;
+        var x: usize = 1;
+
+        try expect(@typeInfo(@TypeOf(ptr)).Pointer.alignment == 8);
+        const ptr1 = ptr + 1; // 1 * 4 = 4 -> lcd(4,8) = 4
+        try expect(@typeInfo(@TypeOf(ptr1)).Pointer.alignment == 4);
+        const ptr2 = ptr + 4; // 4 * 4 = 16 -> lcd(16,8) = 8
+        try expect(@typeInfo(@TypeOf(ptr2)).Pointer.alignment == 8);
+        const ptr3 = ptr + 0; // no-op
+        try expect(@typeInfo(@TypeOf(ptr3)).Pointer.alignment == 8);
+        const ptr4 = ptr + x; // runtime-known addend
+        try expect(@typeInfo(@TypeOf(ptr4)).Pointer.alignment == 4);
+    }
+    {
+        var ptr: [*]align(8) [3]u8 = undefined;
+        var x: usize = 1;
+
+        const ptr1 = ptr + 17; // 3 * 17 = 51
+        try expect(@typeInfo(@TypeOf(ptr1)).Pointer.alignment == 1);
+        const ptr2 = ptr + x; // runtime-known addend
+        try expect(@typeInfo(@TypeOf(ptr2)).Pointer.alignment == 1);
+        const ptr3 = ptr + 8; // 3 * 8 = 24 -> lcd(8,24) = 8
+        try expect(@typeInfo(@TypeOf(ptr3)).Pointer.alignment == 8);
+        const ptr4 = ptr + 4; // 3 * 4 = 12 -> lcd(8,12) = 4
+        try expect(@typeInfo(@TypeOf(ptr4)).Pointer.alignment == 4);
+    }
+}
+
+test "@ptrToInt on null optional at comptime" {
+    {
+        const pointer = @intToPtr(?*u8, 0x000);
+        const x = @ptrToInt(pointer);
+        _ = x;
+        comptime try expect(0 == @ptrToInt(pointer));
+    }
+    {
+        const pointer = @intToPtr(?*u8, 0xf00);
+        comptime try expect(0xf00 == @ptrToInt(pointer));
+    }
+}
+
+test "indexing array with sentinel returns correct type" {
+    var s: [:0]const u8 = "abc";
+    try testing.expectEqualSlices(u8, "*const u8", @typeName(@TypeOf(&s[0])));
+}

From 799fedf612aa8742c446b015c12d21707a1dbec0 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Sat, 7 Aug 2021 20:34:28 -0700
Subject: [PATCH 96/96] stage2: pass some error union tests

 * Value: rename `error_union` to `eu_payload` and clarify the intended
   usage in the doc comments. The way error unions is represented with
   Value is fixed to not have ambiguous values.
 * Fix codegen for error union constants in all the backends.
 * Implement the AIR instructions having to do with error unions in the
   LLVM backend.
---
 src/Sema.zig                | 16 ++++----
 src/codegen.zig             |  2 +-
 src/codegen/c.zig           | 25 +++++-------
 src/codegen/llvm.zig        | 78 ++++++++++++++++++++++++-------------
 src/codegen/wasm.zig        | 18 ++++-----
 src/value.zig               | 43 ++++++++++++++------
 test/behavior.zig           |  3 +-
 test/behavior/if.zig        | 42 --------------------
 test/behavior/if_stage1.zig | 45 +++++++++++++++++++++
 9 files changed, 155 insertions(+), 117 deletions(-)
 create mode 100644 test/behavior/if_stage1.zig

diff --git a/src/Sema.zig b/src/Sema.zig
index a783a48c64..96a09553f5 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -3468,7 +3468,7 @@ fn zirErrUnionPayload(
         if (val.getError()) |name| {
             return sema.mod.fail(&block.base, src, "caught unexpected error '{s}'", .{name});
         }
-        const data = val.castTag(.error_union).?.data;
+        const data = val.castTag(.eu_payload).?.data;
         const result_ty = operand_ty.errorUnionPayload();
         return sema.addConstant(result_ty, data);
     }
@@ -3539,8 +3539,7 @@ fn zirErrUnionCode(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) Compi
 
     if (try sema.resolveDefinedValue(block, src, operand)) |val| {
         assert(val.getError() != null);
-        const data = val.castTag(.error_union).?.data;
-        return sema.addConstant(result_ty, data);
+        return sema.addConstant(result_ty, val);
     }
 
     try sema.requireRuntimeBlock(block, src);
@@ -3566,8 +3565,7 @@ fn zirErrUnionCodePtr(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) Co
     if (try sema.resolveDefinedValue(block, src, operand)) |pointer_val| {
         if (try pointer_val.pointerDeref(sema.arena)) |val| {
             assert(val.getError() != null);
-            const data = val.castTag(.error_union).?.data;
-            return sema.addConstant(result_ty, data);
+            return sema.addConstant(result_ty, val);
         }
     }
 
@@ -8900,7 +8898,9 @@ fn wrapErrorUnion(
     if (try sema.resolveMaybeUndefVal(block, inst_src, inst)) |val| {
         if (inst_ty.zigTypeTag() != .ErrorSet) {
             _ = try sema.coerce(block, dest_payload_ty, inst, inst_src);
-        } else switch (dest_err_set_ty.tag()) {
+            return sema.addConstant(dest_type, try Value.Tag.eu_payload.create(sema.arena, val));
+        }
+        switch (dest_err_set_ty.tag()) {
             .anyerror => {},
             .error_set_single => {
                 const expected_name = val.castTag(.@"error").?.data.name;
@@ -8946,9 +8946,7 @@ fn wrapErrorUnion(
             },
             else => unreachable,
         }
-
-        // Create a SubValue for the error_union payload.
-        return sema.addConstant(dest_type, try Value.Tag.error_union.create(sema.arena, val));
+        return sema.addConstant(dest_type, val);
     }
 
     try sema.requireRuntimeBlock(block, inst_src);
diff --git a/src/codegen.zig b/src/codegen.zig
index f5cdc518f6..38cc27d5bc 100644
--- a/src/codegen.zig
+++ b/src/codegen.zig
@@ -4815,7 +4815,7 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
                 .ErrorUnion => {
                     const error_type = typed_value.ty.errorUnionSet();
                     const payload_type = typed_value.ty.errorUnionPayload();
-                    const sub_val = typed_value.val.castTag(.error_union).?.data;
+                    const sub_val = typed_value.val.castTag(.eu_payload).?.data;
 
                     if (!payload_type.hasCodeGenBits()) {
                         // We use the error type directly as the type.
diff --git a/src/codegen/c.zig b/src/codegen/c.zig
index 65ad4bac8e..a67e2438c2 100644
--- a/src/codegen/c.zig
+++ b/src/codegen/c.zig
@@ -350,32 +350,25 @@ pub const DeclGen = struct {
             .ErrorUnion => {
                 const error_type = t.errorUnionSet();
                 const payload_type = t.errorUnionPayload();
-                const sub_val = val.castTag(.error_union).?.data;
 
                 if (!payload_type.hasCodeGenBits()) {
                     // We use the error type directly as the type.
-                    return dg.renderValue(writer, error_type, sub_val);
+                    const err_val = if (val.errorUnionIsPayload()) Value.initTag(.zero) else val;
+                    return dg.renderValue(writer, error_type, err_val);
                 }
 
                 try writer.writeByte('(');
                 try dg.renderType(writer, t);
                 try writer.writeAll("){");
-                if (val.getError()) |_| {
-                    try writer.writeAll(" .error = ");
-                    try dg.renderValue(
-                        writer,
-                        error_type,
-                        sub_val,
-                    );
-                    try writer.writeAll(" }");
-                } else {
+                if (val.castTag(.eu_payload)) |pl| {
+                    const payload_val = pl.data;
                     try writer.writeAll(" .payload = ");
-                    try dg.renderValue(
-                        writer,
-                        payload_type,
-                        sub_val,
-                    );
+                    try dg.renderValue(writer, payload_type, payload_val);
                     try writer.writeAll(", .error = 0 }");
+                } else {
+                    try writer.writeAll(" .error = ");
+                    try dg.renderValue(writer, error_type, val);
+                    try writer.writeAll(" }");
                 }
             },
             .Enum => {
diff --git a/src/codegen/llvm.zig b/src/codegen/llvm.zig
index eccd5fa04f..7cfbc8da5e 100644
--- a/src/codegen/llvm.zig
+++ b/src/codegen/llvm.zig
@@ -593,7 +593,7 @@ pub const DeclGen = struct {
                         try self.llvmType(ptr_type),
                         try self.llvmType(Type.initTag(.usize)),
                     };
-                    return self.context.structType(&fields, 2, .False);
+                    return self.context.structType(&fields, fields.len, .False);
                 } else {
                     const elem_type = try self.llvmType(t.elemType());
                     return elem_type.pointerType(0);
@@ -621,10 +621,14 @@ pub const DeclGen = struct {
             .ErrorUnion => {
                 const error_type = t.errorUnionSet();
                 const payload_type = t.errorUnionPayload();
+                const llvm_error_type = try self.llvmType(error_type);
                 if (!payload_type.hasCodeGenBits()) {
-                    return self.llvmType(error_type);
+                    return llvm_error_type;
                 }
-                return self.todo("implement llvmType for error unions", .{});
+                const llvm_payload_type = try self.llvmType(payload_type);
+
+                const fields: [2]*const llvm.Type = .{ llvm_error_type, llvm_payload_type };
+                return self.context.structType(&fields, fields.len, .False);
             },
             .ErrorSet => {
                 return self.context.intType(16);
@@ -846,14 +850,25 @@ pub const DeclGen = struct {
             .ErrorUnion => {
                 const error_type = tv.ty.errorUnionSet();
                 const payload_type = tv.ty.errorUnionPayload();
-                const sub_val = tv.val.castTag(.error_union).?.data;
+                const is_pl = tv.val.errorUnionIsPayload();
 
                 if (!payload_type.hasCodeGenBits()) {
                     // We use the error type directly as the type.
-                    return self.genTypedValue(.{ .ty = error_type, .val = sub_val });
+                    const err_val = if (!is_pl) tv.val else Value.initTag(.zero);
+                    return self.genTypedValue(.{ .ty = error_type, .val = err_val });
                 }
 
-                return self.todo("implement error union const of type '{}'", .{tv.ty});
+                const fields: [2]*const llvm.Value = .{
+                    try self.genTypedValue(.{
+                        .ty = error_type,
+                        .val = if (is_pl) Value.initTag(.zero) else tv.val,
+                    }),
+                    try self.genTypedValue(.{
+                        .ty = payload_type,
+                        .val = if (tv.val.castTag(.eu_payload)) |pl| pl.data else Value.initTag(.undef),
+                    }),
+                };
+                return self.context.constStruct(&fields, fields.len, .False);
             },
             .Struct => {
                 const fields_len = tv.ty.structFieldCount();
@@ -984,10 +999,10 @@ pub const FuncGen = struct {
                 .is_non_null_ptr => try self.airIsNonNull(inst, true),
                 .is_null         => try self.airIsNull(inst, false),
                 .is_null_ptr     => try self.airIsNull(inst, true),
-                .is_non_err      => try self.airIsErr(inst, true, false),
-                .is_non_err_ptr  => try self.airIsErr(inst, true, true),
-                .is_err          => try self.airIsErr(inst, false, false),
-                .is_err_ptr      => try self.airIsErr(inst, false, true),
+                .is_non_err      => try self.airIsErr(inst, .EQ, false),
+                .is_non_err_ptr  => try self.airIsErr(inst, .EQ, true),
+                .is_err          => try self.airIsErr(inst, .NE, false),
+                .is_err_ptr      => try self.airIsErr(inst, .NE, true),
 
                 .alloc      => try self.airAlloc(inst),
                 .arg        => try self.airArg(inst),
@@ -1098,7 +1113,7 @@ pub const FuncGen = struct {
         const inst_ty = self.air.typeOfIndex(inst);
 
         switch (self.air.typeOf(bin_op.lhs).zigTypeTag()) {
-            .Int, .Bool, .Pointer => {
+            .Int, .Bool, .Pointer, .ErrorSet => {
                 const is_signed = inst_ty.isSignedInt();
                 const operation = switch (op) {
                     .eq => .EQ,
@@ -1256,12 +1271,7 @@ pub const FuncGen = struct {
         const rhs = try self.resolveInst(bin_op.rhs);
 
         const base_ptr = ptr: {
-            const index_type = self.context.intType(32);
-            const indices: [2]*const llvm.Value = .{
-                index_type.constNull(),
-                index_type.constInt(0, .False),
-            };
-            const ptr_field_ptr = self.builder.buildInBoundsGEP(lhs, &indices, 2, "");
+            const ptr_field_ptr = self.builder.buildStructGEP(lhs, 0, "");
             break :ptr self.builder.buildLoad(ptr_field_ptr, "");
         };
 
@@ -1472,7 +1482,7 @@ pub const FuncGen = struct {
                 index_type.constInt(1, .False),
             };
 
-            return self.builder.buildLoad(self.builder.buildInBoundsGEP(operand, &indices, 2, ""), "");
+            return self.builder.buildLoad(self.builder.buildInBoundsGEP(operand, &indices, indices.len, ""), "");
         } else {
             return self.builder.buildExtractValue(operand, 1, "");
         }
@@ -1488,7 +1498,7 @@ pub const FuncGen = struct {
     fn airIsErr(
         self: *FuncGen,
         inst: Air.Inst.Index,
-        invert_logic: bool,
+        op: llvm.IntPredicate,
         operand_is_ptr: bool,
     ) !?*const llvm.Value {
         if (self.liveness.isUnused(inst))
@@ -1498,16 +1508,22 @@ pub const FuncGen = struct {
         const operand = try self.resolveInst(un_op);
         const err_union_ty = self.air.typeOf(un_op);
         const payload_ty = err_union_ty.errorUnionPayload();
+        const err_set_ty = try self.dg.llvmType(Type.initTag(.anyerror));
+        const zero = err_set_ty.constNull();
 
         if (!payload_ty.hasCodeGenBits()) {
             const loaded = if (operand_is_ptr) self.builder.buildLoad(operand, "") else operand;
-            const op: llvm.IntPredicate = if (invert_logic) .EQ else .NE;
-            const err_set_ty = try self.dg.llvmType(Type.initTag(.anyerror));
-            const zero = err_set_ty.constNull();
             return self.builder.buildICmp(op, loaded, zero, "");
         }
 
-        return self.todo("implement 'airIsErr' for error unions with nonzero payload", .{});
+        if (operand_is_ptr) {
+            const err_field_ptr = self.builder.buildStructGEP(operand, 0, "");
+            const loaded = self.builder.buildLoad(err_field_ptr, "");
+            return self.builder.buildICmp(op, loaded, zero, "");
+        }
+
+        const loaded = self.builder.buildExtractValue(operand, 0, "");
+        return self.builder.buildICmp(op, loaded, zero, "");
     }
 
     fn airOptionalPayload(
@@ -1552,9 +1568,11 @@ pub const FuncGen = struct {
             return null;
         }
 
-        _ = operand;
-        _ = operand_is_ptr;
-        return self.todo("implement llvm codegen for 'airErrUnionPayload' for type {}", .{self.air.typeOf(ty_op.operand)});
+        if (operand_is_ptr) {
+            return self.builder.buildStructGEP(operand, 1, "");
+        }
+
+        return self.builder.buildExtractValue(operand, 1, "");
     }
 
     fn airErrUnionErr(
@@ -1574,7 +1592,13 @@ pub const FuncGen = struct {
             if (!operand_is_ptr) return operand;
             return self.builder.buildLoad(operand, "");
         }
-        return self.todo("implement llvm codegen for 'airErrUnionErr'", .{});
+
+        if (operand_is_ptr) {
+            const err_field_ptr = self.builder.buildStructGEP(operand, 0, "");
+            return self.builder.buildLoad(err_field_ptr, "");
+        }
+
+        return self.builder.buildExtractValue(operand, 0, "");
     }
 
     fn airWrapOptional(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
diff --git a/src/codegen/wasm.zig b/src/codegen/wasm.zig
index e21645d1ee..4814ba0b55 100644
--- a/src/codegen/wasm.zig
+++ b/src/codegen/wasm.zig
@@ -1167,12 +1167,18 @@ pub const Context = struct {
                 try leb.writeULEB128(writer, error_index);
             },
             .ErrorUnion => {
-                const data = val.castTag(.error_union).?.data;
                 const error_type = ty.errorUnionSet();
                 const payload_type = ty.errorUnionPayload();
-                if (val.getError()) |_| {
+                if (val.castTag(.eu_payload)) |pl| {
+                    const payload_val = pl.data;
+                    // no error, so write a '0' const
+                    try writer.writeByte(wasm.opcode(.i32_const));
+                    try leb.writeULEB128(writer, @as(u32, 0));
+                    // after the error code, we emit the payload
+                    try self.emitConstant(payload_val, payload_type);
+                } else {
                     // write the error val
-                    try self.emitConstant(data, error_type);
+                    try self.emitConstant(val, error_type);
 
                     // no payload, so write a '0' const
                     const opcode: wasm.Opcode = buildOpcode(.{
@@ -1181,12 +1187,6 @@ pub const Context = struct {
                     });
                     try writer.writeByte(wasm.opcode(opcode));
                     try leb.writeULEB128(writer, @as(u32, 0));
-                } else {
-                    // no error, so write a '0' const
-                    try writer.writeByte(wasm.opcode(.i32_const));
-                    try leb.writeULEB128(writer, @as(u32, 0));
-                    // after the error code, we emit the payload
-                    try self.emitConstant(data, payload_type);
                 }
             },
             .Optional => {
diff --git a/src/value.zig b/src/value.zig
index bf80c9d831..562d7171e8 100644
--- a/src/value.zig
+++ b/src/value.zig
@@ -129,7 +129,13 @@ pub const Value = extern union {
         /// A specific enum tag, indicated by the field index (declaration order).
         enum_field_index,
         @"error",
-        error_union,
+        /// When the type is error union:
+        /// * If the tag is `.@"error"`, the error union is an error.
+        /// * If the tag is `.eu_payload`, the error union is a payload.
+        /// * A nested error such as `((anyerror!T1)!T2)` in which the the outer error union
+        ///   is non-error, but the inner error union is an error, is represented as
+        ///   a tag of `.eu_payload`, with a sub-tag of `.@"error"`.
+        eu_payload,
         /// A pointer to the payload of an error union, based on a pointer to an error union.
         eu_payload_ptr,
         /// An instance of a struct.
@@ -228,7 +234,7 @@ pub const Value = extern union {
                 => Payload.Decl,
 
                 .repeated,
-                .error_union,
+                .eu_payload,
                 .eu_payload_ptr,
                 => Payload.SubValue,
 
@@ -450,7 +456,7 @@ pub const Value = extern union {
                 return Value{ .ptr_otherwise = &new_payload.base };
             },
             .bytes => return self.copyPayloadShallow(allocator, Payload.Bytes),
-            .repeated, .error_union, .eu_payload_ptr => {
+            .repeated, .eu_payload, .eu_payload_ptr => {
                 const payload = self.cast(Payload.SubValue).?;
                 const new_payload = try allocator.create(Payload.SubValue);
                 new_payload.* = .{
@@ -642,7 +648,10 @@ pub const Value = extern union {
             .float_128 => return out_stream.print("{}", .{val.castTag(.float_128).?.data}),
             .@"error" => return out_stream.print("error.{s}", .{val.castTag(.@"error").?.data.name}),
             // TODO to print this it should be error{ Set, Items }!T(val), but we need the type for that
-            .error_union => return out_stream.print("error_union_val({})", .{val.castTag(.error_union).?.data}),
+            .eu_payload => {
+                try out_stream.writeAll("(eu_payload) ");
+                val = val.castTag(.eu_payload).?.data;
+            },
             .inferred_alloc => return out_stream.writeAll("(inferred allocation value)"),
             .inferred_alloc_comptime => return out_stream.writeAll("(inferred comptime allocation value)"),
             .eu_payload_ptr => {
@@ -1241,7 +1250,7 @@ pub const Value = extern union {
             .eu_payload_ptr => blk: {
                 const err_union_ptr = self.castTag(.eu_payload_ptr).?.data;
                 const err_union_val = (try err_union_ptr.pointerDeref(allocator)) orelse return null;
-                break :blk err_union_val.castTag(.error_union).?.data;
+                break :blk err_union_val.castTag(.eu_payload).?.data;
             },
 
             .zero,
@@ -1351,16 +1360,16 @@ pub const Value = extern union {
     }
 
     /// Valid for all types. Asserts the value is not undefined and not unreachable.
+    /// Prefer `errorUnionIsPayload` to find out whether something is an error or not
+    /// because it works without having to figure out the string.
     pub fn getError(self: Value) ?[]const u8 {
         return switch (self.tag()) {
-            .error_union => {
-                const data = self.castTag(.error_union).?.data;
-                return if (data.tag() == .@"error")
-                    data.castTag(.@"error").?.data.name
-                else
-                    null;
-            },
             .@"error" => self.castTag(.@"error").?.data.name,
+            .int_u64 => @panic("TODO"),
+            .int_i64 => @panic("TODO"),
+            .int_big_positive => @panic("TODO"),
+            .int_big_negative => @panic("TODO"),
+            .one => @panic("TODO"),
             .undef => unreachable,
             .unreachable_value => unreachable,
             .inferred_alloc => unreachable,
@@ -1369,6 +1378,16 @@ pub const Value = extern union {
             else => null,
         };
     }
+
+    /// Assumes the type is an error union. Returns true if and only if the value is
+    /// the error union payload, not an error.
+    pub fn errorUnionIsPayload(val: Value) bool {
+        return switch (val.tag()) {
+            .eu_payload => true,
+            else => false,
+        };
+    }
+
     /// Valid for all types. Asserts the value is not undefined.
     pub fn isFloat(self: Value) bool {
         return switch (self.tag()) {
diff --git a/test/behavior.zig b/test/behavior.zig
index 936268af9c..a800b38458 100644
--- a/test/behavior.zig
+++ b/test/behavior.zig
@@ -7,6 +7,7 @@ test {
     _ = @import("behavior/generics.zig");
     _ = @import("behavior/eval.zig");
     _ = @import("behavior/pointers.zig");
+    _ = @import("behavior/if.zig");
 
     if (!builtin.zig_is_stage2) {
         // Tests that only pass for stage1.
@@ -100,7 +101,7 @@ test {
         _ = @import("behavior/generics_stage1.zig");
         _ = @import("behavior/hasdecl.zig");
         _ = @import("behavior/hasfield.zig");
-        _ = @import("behavior/if.zig");
+        _ = @import("behavior/if_stage1.zig");
         _ = @import("behavior/import.zig");
         _ = @import("behavior/incomplete_struct_param_tld.zig");
         _ = @import("behavior/inttoptr.zig");
diff --git a/test/behavior/if.zig b/test/behavior/if.zig
index e8c84f4570..191d4817df 100644
--- a/test/behavior/if.zig
+++ b/test/behavior/if.zig
@@ -65,45 +65,3 @@ test "labeled break inside comptime if inside runtime if" {
     }
     try expect(answer == 42);
 }
-
-test "const result loc, runtime if cond, else unreachable" {
-    const Num = enum {
-        One,
-        Two,
-    };
-
-    var t = true;
-    const x = if (t) Num.Two else unreachable;
-    try expect(x == .Two);
-}
-
-test "if prongs cast to expected type instead of peer type resolution" {
-    const S = struct {
-        fn doTheTest(f: bool) !void {
-            var x: i32 = 0;
-            x = if (f) 1 else 2;
-            try expect(x == 2);
-
-            var b = true;
-            const y: i32 = if (b) 1 else 2;
-            try expect(y == 1);
-        }
-    };
-    try S.doTheTest(false);
-    comptime try S.doTheTest(false);
-}
-
-test "while copies its payload" {
-    const S = struct {
-        fn doTheTest() !void {
-            var tmp: ?i32 = 10;
-            if (tmp) |value| {
-                // Modify the original variable
-                tmp = null;
-                try expectEqual(@as(i32, 10), value);
-            } else unreachable;
-        }
-    };
-    try S.doTheTest();
-    comptime try S.doTheTest();
-}
diff --git a/test/behavior/if_stage1.zig b/test/behavior/if_stage1.zig
new file mode 100644
index 0000000000..36500fbaee
--- /dev/null
+++ b/test/behavior/if_stage1.zig
@@ -0,0 +1,45 @@
+const std = @import("std");
+const expect = std.testing.expect;
+const expectEqual = std.testing.expectEqual;
+
+test "const result loc, runtime if cond, else unreachable" {
+    const Num = enum {
+        One,
+        Two,
+    };
+
+    var t = true;
+    const x = if (t) Num.Two else unreachable;
+    try expect(x == .Two);
+}
+
+test "if prongs cast to expected type instead of peer type resolution" {
+    const S = struct {
+        fn doTheTest(f: bool) !void {
+            var x: i32 = 0;
+            x = if (f) 1 else 2;
+            try expect(x == 2);
+
+            var b = true;
+            const y: i32 = if (b) 1 else 2;
+            try expect(y == 1);
+        }
+    };
+    try S.doTheTest(false);
+    comptime try S.doTheTest(false);
+}
+
+test "while copies its payload" {
+    const S = struct {
+        fn doTheTest() !void {
+            var tmp: ?i32 = 10;
+            if (tmp) |value| {
+                // Modify the original variable
+                tmp = null;
+                try expectEqual(@as(i32, 10), value);
+            } else unreachable;
+        }
+    };
+    try S.doTheTest();
+    comptime try S.doTheTest();
+}