implement an FMA op

Author: Hugobros3

include/shady/primops.json

@@ -66,6 +66,10 @@
       "name": "div",
       "class": "arithmetic"
     },
+    {
+      "name": "fma",
+      "class": "arithmetic"
+    },
     {
       "name": "mod",
       "class": "arithmetic"

src/frontends/llvm/l2s_instr.c

@@ -497,8 +497,9 @@ EmittedInstr convert_instruction(Parser* p, Node* fn_or_bb, BodyBuilder* b, LLVM
                 } else if (string_starts_with(intrinsic, "llvm.fmuladd")) {
                     Nodes ops = convert_operands(p, num_ops, instr);
                     num_results = 1;
-                    r = prim_op_helper(a, mul_op, empty(a), nodes(a, 2, ops.nodes));
-                    r = prim_op_helper(a, add_op, empty(a), mk_nodes(a, first(BIND_PREV_R(convert_type(p, LLVMTypeOf(LLVMGetOperand(instr, 0))))), ops.nodes[2]));
+                    r = prim_op_helper(a, fma_op, empty(a), nodes(a, 3, ops.nodes));
+                    // r = prim_op_helper(a, mul_op, empty(a), nodes(a, 2, ops.nodes));
+                    // r = prim_op_helper(a, add_op, empty(a), mk_nodes(a, first(BIND_PREV_R(convert_type(p, LLVMTypeOf(LLVMGetOperand(instr, 0))))), ops.nodes[2]));
                     break;
                 } else if (string_starts_with(intrinsic, "llvm.fabs")) {
                     Nodes ops = convert_operands(p, num_ops, instr);

src/shady/emit/c/emit_c_instructions.c

@@ -270,6 +270,23 @@ static void emit_primop(Emitter* emitter, Printer* p, const Node* node, Instruct
             term = term_from_cvalue(format_string_arena(arena->arena, "(%s > 0 ? 1 : -1)", src));
             break;
         }
+        case fma_op: {
+            CValue a = to_cvalue(emitter, emit_value(emitter, p, prim_op->operands.nodes[0]));
+            CValue b = to_cvalue(emitter, emit_value(emitter, p, prim_op->operands.nodes[1]));
+            CValue c = to_cvalue(emitter, emit_value(emitter, p, prim_op->operands.nodes[2]));
+            switch (emitter->config.dialect) {
+                case CDialect_C11:
+                case CDialect_CUDA: {
+                    term = term_from_cvalue(format_string_arena(arena->arena, "fmaf(%s, %s, %s)", a, b, c));
+                    break;
+                }
+                default: {
+                    term = term_from_cvalue(format_string_arena(arena->arena, "(%s * %s) + %s", a, b, c));
+                    break;
+                }
+            }
+            break;
+        }
         case lshift_op:
         case rshift_arithm_op:
         case rshift_logical_op: {

src/shady/emit/spirv/emit_spv_instructions.c

@@ -124,10 +124,11 @@ static const IselTableEntry isel_table[] = {
     [abs_op] =  { Plain, FirstOp, Same, .extended_set = "GLSL.std.450", .fo = { (SpvOp) GLSLstd450SAbs,  ISEL_ILLEGAL, (SpvOp) GLSLstd450FAbs,  ISEL_ILLEGAL }},
     [sign_op] = { Plain, FirstOp, Same, .extended_set = "GLSL.std.450", .fo = { (SpvOp) GLSLstd450SSign, ISEL_ILLEGAL, (SpvOp) GLSLstd450FSign, ISEL_ILLEGAL }},
 
-    [min_op] = {Plain, FirstOp, Same, .extended_set = "GLSL.std.450", .fo = {(SpvOp) GLSLstd450SMin, (SpvOp) GLSLstd450UMin, (SpvOp) GLSLstd450FMin, ISEL_ILLEGAL, ISEL_ILLEGAL }},
-    [max_op] = {Plain, FirstOp, Same, .extended_set = "GLSL.std.450", .fo = {(SpvOp) GLSLstd450SMax, (SpvOp) GLSLstd450UMax, (SpvOp) GLSLstd450FMax, ISEL_ILLEGAL, ISEL_ILLEGAL }},
-    [exp_op] = {Plain, FirstOp, Same, .extended_set = "GLSL.std.450", .op = (SpvOp) GLSLstd450Exp},
-    [pow_op] = {Plain, FirstOp, Same, .extended_set = "GLSL.std.450", .op = (SpvOp) GLSLstd450Pow},
+    [min_op] = { Plain, FirstOp, Same, .extended_set = "GLSL.std.450", .fo = {(SpvOp) GLSLstd450SMin, (SpvOp) GLSLstd450UMin, (SpvOp) GLSLstd450FMin, ISEL_ILLEGAL, ISEL_ILLEGAL }},
+    [max_op] = { Plain, FirstOp, Same, .extended_set = "GLSL.std.450", .fo = {(SpvOp) GLSLstd450SMax, (SpvOp) GLSLstd450UMax, (SpvOp) GLSLstd450FMax, ISEL_ILLEGAL, ISEL_ILLEGAL }},
+    [exp_op] = { Plain, Monomorphic, Same, .extended_set = "GLSL.std.450", .op = (SpvOp) GLSLstd450Exp },
+    [pow_op] = { Plain, Monomorphic, Same, .extended_set = "GLSL.std.450", .op = (SpvOp) GLSLstd450Pow },
+    [fma_op] = { Plain, Monomorphic, Same, .extended_set = "GLSL.std.450", .op = (SpvOp) GLSLstd450Fma },
 
     [debug_printf_op] = {Plain, Monomorphic, Void, .extended_set = "NonSemantic.DebugPrintf", .op = (SpvOp) NonSemanticDebugPrintfDebugPrintf},
 

src/shady/type.c

@@ -698,6 +698,25 @@ const Type* check_type_prim_op(IrArena* arena, PrimOp prim_op) {
 
             return qualified_type_helper(first_operand_type, result_uniform);
         }
+        case fma_op: {
+            assert(prim_op.type_arguments.count == 0);
+            assert(prim_op.operands.count == 3);
+            const Type* first_operand_type = get_unqualified_type(first(prim_op.operands)->type);
+
+            bool result_uniform = true;
+            for (size_t i = 0; i < prim_op.operands.count; i++) {
+                const Node* arg = prim_op.operands.nodes[i];
+                const Type* operand_type = arg->type;
+                bool operand_uniform = deconstruct_qualified_type(&operand_type);
+
+                assert(get_maybe_packed_type_element(operand_type)->tag == Float_TAG);
+                assert(first_operand_type == operand_type &&  "operand type mismatch");
+
+                result_uniform &= operand_uniform;
+            }
+
+            return qualified_type_helper(first_operand_type, result_uniform);
+        }
         case abs_op:
         case sign_op:
         {