srctree

#define zig_builtin8_rev(name, val) __builtin_##name(val)

 

#define zig_builtin16_rev(name, val) __builtin_##name(val)

 

#if INT_MIN <= INT32_MIN

#define zig_builtin32_rev(name, val) __builtin_##name(val)

#elif LONG_MIN <= INT32_MIN

#define zig_builtin32_rev(name, val) __builtin_l##name(val)

#endif

 

#if INT_MIN <= INT64_MIN

#define zig_builtin64_rev(name, val) __builtin_##name(val)

#elif LONG_MIN <= INT64_MIN

#define zig_builtin64_rev(name, val) __builtin_l##name(val)

#elif LLONG_MIN <= INT64_MIN

#define zig_builtin64_rev(name, val) __builtin_ll##name(val)

#endif

 

#if zig_has_builtin(abs) || defined(zig_gnuc)

#define zig_builtin_abs(w) \

static inline int##w##_t zig_abs_i##w(int##w##_t val) { \

return zig_builtin##w##_rev(abs, val); \

}

#else

#define zig_builtin_abs(w) \

static inline int##w##_t zig_abs_i##w(int##w##_t val) { \

if (val == INT##w##_MIN) return val; \

int##w##_t tmp = val >> (w - 1); \

return (val ^ tmp) - tmp; \

}

#endif

zig_builtin_abs(8)

zig_builtin_abs(16)

zig_builtin_abs(32)

zig_builtin_abs(64)

 

zig_expand_concat(zig_expand_import_, zig_expand_has_builtin(zig_libc_name_f##w(sqrt)))(zig_f##w, zig_float_fn_f##w##_sqrt, zig_libc_name_f##w(sqrt), (zig_f##w x), (x)) \

zig_expand_concat(zig_expand_import_, zig_expand_has_builtin(zig_libc_name_f##w(sin)))(zig_f##w, zig_float_fn_f##w##_sin, zig_libc_name_f##w(sin), (zig_f##w x), (x)) \

zig_expand_concat(zig_expand_import_, zig_expand_has_builtin(zig_libc_name_f##w(cos)))(zig_f##w, zig_float_fn_f##w##_cos, zig_libc_name_f##w(cos), (zig_f##w x), (x)) \

zig_expand_concat(zig_expand_import_, zig_expand_has_builtin(zig_libc_name_f##w(tan)))(zig_f##w, zig_float_fn_f##w##_tan, zig_libc_name_f##w(tan), (zig_f##w x), (x)) \

zig_expand_concat(zig_expand_import_, zig_expand_has_builtin(zig_libc_name_f##w(exp)))(zig_f##w, zig_float_fn_f##w##_exp, zig_libc_name_f##w(exp), (zig_f##w x), (x)) \

zig_expand_concat(zig_expand_import_, zig_expand_has_builtin(zig_libc_name_f##w(exp2)))(zig_f##w, zig_float_fn_f##w##_exp2, zig_libc_name_f##w(exp2), (zig_f##w x), (x)) \

zig_expand_concat(zig_expand_import_, zig_expand_has_builtin(zig_libc_name_f##w(log)))(zig_f##w, zig_float_fn_f##w##_log, zig_libc_name_f##w(log), (zig_f##w x), (x)) \

zig_expand_concat(zig_expand_import_, zig_expand_has_builtin(zig_libc_name_f##w(log2)))(zig_f##w, zig_float_fn_f##w##_log2, zig_libc_name_f##w(log2), (zig_f##w x), (x)) \

zig_expand_concat(zig_expand_import_, zig_expand_has_builtin(zig_libc_name_f##w(log10)))(zig_f##w, zig_float_fn_f##w##_log10, zig_libc_name_f##w(log10), (zig_f##w x), (x)) \

zig_expand_concat(zig_expand_import_, zig_expand_has_builtin(zig_libc_name_f##w(fabs)))(zig_f##w, zig_float_fn_f##w##_fabs, zig_libc_name_f##w(fabs), (zig_f##w x), (x)) \

zig_expand_concat(zig_expand_import_, zig_expand_has_builtin(zig_libc_name_f##w(floor)))(zig_f##w, zig_float_fn_f##w##_floor, zig_libc_name_f##w(floor), (zig_f##w x), (x)) \

zig_expand_concat(zig_expand_import_, zig_expand_has_builtin(zig_libc_name_f##w(ceil)))(zig_f##w, zig_float_fn_f##w##_ceil, zig_libc_name_f##w(ceil), (zig_f##w x), (x)) \

zig_expand_concat(zig_expand_import_, zig_expand_has_builtin(zig_libc_name_f##w(round)))(zig_f##w, zig_float_fn_f##w##_round, zig_libc_name_f##w(round), (zig_f##w x), (x)) \

zig_expand_concat(zig_expand_import_, zig_expand_has_builtin(zig_libc_name_f##w(trunc)))(zig_f##w, zig_float_fn_f##w##_trunc, zig_libc_name_f##w(trunc), (zig_f##w x), (x)) \

zig_expand_concat(zig_expand_import_, zig_expand_has_builtin(zig_libc_name_f##w(fmod)))(zig_f##w, zig_float_fn_f##w##_fmod, zig_libc_name_f##w(fmod), (zig_f##w x, zig_f##w y), (x, y)) \

zig_expand_concat(zig_expand_import_, zig_expand_has_builtin(zig_libc_name_f##w(fmin)))(zig_f##w, zig_float_fn_f##w##_fmin, zig_libc_name_f##w(fmin), (zig_f##w x, zig_f##w y), (x, y)) \

zig_expand_concat(zig_expand_import_, zig_expand_has_builtin(zig_libc_name_f##w(fmax)))(zig_f##w, zig_float_fn_f##w##_fmax, zig_libc_name_f##w(fmax), (zig_f##w x, zig_f##w y), (x, y)) \

zig_expand_concat(zig_expand_import_, zig_expand_has_builtin(zig_libc_name_f##w(fma)))(zig_f##w, zig_float_fn_f##w##_fma, zig_libc_name_f##w(fma), (zig_f##w x, zig_f##w y, zig_f##w z), (x, y, z)) \

return zig_float_fn_f##w##_trunc(zig_div_f##w(lhs, rhs)); \

return zig_float_fn_f##w##_floor(zig_div_f##w(lhs, rhs)); \

zig_atomicrmw_desired = zig_float_fn_##Type##_fmin(zig_atomicrmw_expected, arg); \

zig_atomicrmw_desired = zig_float_fn_##Type##_fmax(zig_atomicrmw_expected, arg); \

.neg => try airFloatNeg(f, inst),

const bin_op = f.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;

try airBinFloatOp(f, inst, "fmod");

.abs => try airAbs(f, inst),

.sqrt => try airUnFloatOp(f, inst, "sqrt"),

.sin => try airUnFloatOp(f, inst, "sin"),

.cos => try airUnFloatOp(f, inst, "cos"),

.tan => try airUnFloatOp(f, inst, "tan"),

.exp => try airUnFloatOp(f, inst, "exp"),

.exp2 => try airUnFloatOp(f, inst, "exp2"),

.log => try airUnFloatOp(f, inst, "log"),

.log2 => try airUnFloatOp(f, inst, "log2"),

.log10 => try airUnFloatOp(f, inst, "log10"),

.floor => try airUnFloatOp(f, inst, "floor"),

.ceil => try airUnFloatOp(f, inst, "ceil"),

.round => try airUnFloatOp(f, inst, "round"),

.trunc_float => try airUnFloatOp(f, inst, "trunc"),

.min => try airMinMax(f, inst, '<', "fmin"),

.max => try airMinMax(f, inst, '>', "fmax"),

.cmp_gt => try airCmpOp(f, inst, f.air.instructions.items(.data)[@intFromEnum(inst)].bin_op, .gt),

.cmp_gte => try airCmpOp(f, inst, f.air.instructions.items(.data)[@intFromEnum(inst)].bin_op, .gte),

.cmp_lt => try airCmpOp(f, inst, f.air.instructions.items(.data)[@intFromEnum(inst)].bin_op, .lt),

.cmp_lte => try airCmpOp(f, inst, f.air.instructions.items(.data)[@intFromEnum(inst)].bin_op, .lte),

const ty_pl = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;

.clz => try airUnBuiltinCall(f, inst, "clz", .bits),

.ctz => try airUnBuiltinCall(f, inst, "ctz", .bits),

.popcount => try airUnBuiltinCall(f, inst, "popcount", .bits),

.byte_swap => try airUnBuiltinCall(f, inst, "byte_swap", .bits),

.bit_reverse => try airUnBuiltinCall(f, inst, "bit_reverse", .bits),

if (scalar_ty.toIntern() != .bool_type) return try airUnBuiltinCall(f, inst, "not", .bits);

if (inst_scalar_ty.isInt(zcu) and inst_scalar_ty.bitSize(zcu) > 64)

return try airBinBuiltinCall(f, inst, operation[1..], .none);

if (inst_scalar_ty.isRuntimeFloat())

return try airBinFloatOp(f, inst, operation);

const ty_op = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;

const operand = try f.resolveInst(ty_op.operand);

try reap(f, inst, &.{ty_op.operand});

const operand_ty = f.typeOf(ty_op.operand);

float_op: Func,

.Int => if (use_operator) .{ .ternary = " < " } else .{

.builtin = .{ .operation = "min" },

},

.Float => .{ .float_op = .{ .operation = "fmin" } },

.Int => if (use_operator) .{ .ternary = " > " } else .{

.builtin = .{ .operation = "max" },

},

.Float => .{ .float_op = .{ .operation = "fmax" } },

.Int => if (use_operator) .{ .infix = " += " } else .{

.builtin = .{ .operation = "addw", .info = .bits },

},

.Int => if (use_operator) .{ .infix = " *= " } else .{

.builtin = .{ .operation = "mulw", .info = .bits },

},

.float_op => |func| {

try writer.writeAll(" = zig_float_fn_");

try f.object.dg.renderTypeForBuiltinFnName(writer, scalar_ty);

try writer.print("_{s}(", .{func.operation});

try f.writeCValue(writer, accum, .FunctionArgument);

try writer.writeAll(", ");

try f.writeCValue(writer, operand, .Other);

try v.elem(f, writer);

try f.object.dg.renderBuiltinInfo(writer, scalar_ty, func.info);

try writer.writeByte(')');

},

fn airFloatNeg(f: *Function, inst: Air.Inst.Index) !CValue {

const zcu = f.object.dg.zcu;

const un_op = f.air.instructions.items(.data)[@intFromEnum(inst)].un_op;

 

const operand = try f.resolveInst(un_op);

try reap(f, inst, &.{un_op});

 

const operand_ty = f.typeOf(un_op);

const scalar_ty = operand_ty.scalarType(zcu);

 

const writer = f.object.writer();

const local = try f.allocLocal(inst, operand_ty);

const v = try Vectorize.start(f, inst, writer, operand_ty);

try f.writeCValue(writer, local, .Other);

try v.elem(f, writer);

try writer.writeAll(" = zig_neg_");

try f.object.dg.renderTypeForBuiltinFnName(writer, scalar_ty);

try writer.writeByte('(');

try f.writeCValue(writer, operand, .FunctionArgument);

try v.elem(f, writer);

try writer.writeAll(");\n");

try v.end(f, inst, writer);

 

return local;

}

 

fn airAbs(f: *Function, inst: Air.Inst.Index) !CValue {

const zcu = f.object.dg.zcu;

const ty_op = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;

const operand = try f.resolveInst(ty_op.operand);

const ty = f.typeOf(ty_op.operand);

const scalar_ty = ty.scalarType(zcu);

 

switch (scalar_ty.zigTypeTag(zcu)) {

.Int => if (ty.zigTypeTag(zcu) == .Vector) {

return f.fail("TODO implement airAbs for '{}'", .{ty.fmt(zcu)});

} else {

return airUnBuiltinCall(f, inst, "abs", .none);

},

.Float => return unFloatOp(f, inst, operand, ty, "fabs"),

else => unreachable,

}

}

 

fn unFloatOp(f: *Function, inst: Air.Inst.Index, operand: CValue, ty: Type, operation: []const u8) !CValue {

const zcu = f.object.dg.zcu;

const scalar_ty = ty.scalarType(zcu);

 

const writer = f.object.writer();

const local = try f.allocLocal(inst, ty);

const v = try Vectorize.start(f, inst, writer, ty);

try f.writeCValue(writer, local, .Other);

try v.elem(f, writer);

try writer.writeAll(" = zig_float_fn_");

try f.object.dg.renderTypeForBuiltinFnName(writer, scalar_ty);

try writer.print("_{s}(", .{operation});

try f.writeCValue(writer, operand, .FunctionArgument);

try v.elem(f, writer);

try writer.writeAll(");\n");

try v.end(f, inst, writer);

 

return local;

}

 

fn airUnFloatOp(f: *Function, inst: Air.Inst.Index, operation: []const u8) !CValue {

const un_op = f.air.instructions.items(.data)[@intFromEnum(inst)].un_op;

 

const operand = try f.resolveInst(un_op);

try reap(f, inst, &.{un_op});

 

const inst_ty = f.typeOfIndex(inst);

return unFloatOp(f, inst, operand, inst_ty, operation);

}

 

fn airBinFloatOp(f: *Function, inst: Air.Inst.Index, operation: []const u8) !CValue {

const zcu = f.object.dg.zcu;

const bin_op = f.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;

 

const lhs = try f.resolveInst(bin_op.lhs);

const rhs = try f.resolveInst(bin_op.rhs);

try reap(f, inst, &.{ bin_op.lhs, bin_op.rhs });

 

const inst_ty = f.typeOfIndex(inst);

const inst_scalar_ty = inst_ty.scalarType(zcu);

 

const writer = f.object.writer();

const local = try f.allocLocal(inst, inst_ty);

const v = try Vectorize.start(f, inst, writer, inst_ty);

try f.writeCValue(writer, local, .Other);

try v.elem(f, writer);

try writer.writeAll(" = zig_float_fn_");

try f.object.dg.renderTypeForBuiltinFnName(writer, inst_scalar_ty);

try writer.print("_{s}(", .{operation});

try f.writeCValue(writer, lhs, .FunctionArgument);

try v.elem(f, writer);

try writer.writeAll(", ");

try f.writeCValue(writer, rhs, .FunctionArgument);

try v.elem(f, writer);

try writer.writeAll(");\n");

try v.end(f, inst, writer);

 

return local;

}

 

try writer.writeAll(" = zig_float_fn_");

try writer.writeAll("_fma(");