nv2a: Fix R12 input in paired/multiout ops writing to oPos

Paired MAC+ILU and duplicate output instructions can write to oPos while reading
from R12. This leads to a case where xemu's serialized emulation erroneously
uses the output of a previous instruction when calculating the value of a later
one.

E.g., in

```
 /* 0x00000000 0x0080201A 0xC4002868 0x7CB0E800 */
 MAD oPos.xyz, R12.xyz, R1.x, C[1].xyz
   +  MAD R11.xy, R12.xyz, R1.x, C[1].xyz
```

the value of oPos prior to the first instruction should be used for both MAD
calculations.

This could alternatively be fixed by writing oPos to a temp vector and deferring
the output vector update until after the token is fully processed.

Fixes #1864

Author: abaire

hw/xbox/nv2a/pgraph/glsl/vsh-prog.c

@@ -296,15 +296,15 @@ static MString *decode_swizzle(const uint32_t *shader_token,
 
 static MString *decode_opcode_input(const uint32_t *shader_token,
                                     VshParameterType param,
-                                    VshFieldName neg_field, int reg_num)
+                                    VshFieldName neg_field, int reg_num,
+                                    bool *uses_r12_latch)
 {
     /* This function decodes a vertex shader opcode parameter into a string.
      * Input A, B or C is controlled via the Param and NEG fieldnames,
      * the R-register address for each input is already given by caller. */
 
     MString *ret_str = mstring_new();
 
-
     if (vsh_get_field(shader_token, neg_field) > 0) {
         mstring_append_fmt(ret_str, "-");
     }
@@ -315,6 +315,9 @@ static MString *decode_opcode_input(const uint32_t *shader_token,
     switch (param) {
     case PARAM_R:
         snprintf(tmp, sizeof(tmp), "R%d", reg_num);
+        if (reg_num == 12) {
+            *uses_r12_latch = true;
+        }
         break;
     case PARAM_V:
         reg_num = vsh_get_field(shader_token, FLD_V);
@@ -346,12 +349,11 @@ static MString *decode_opcode_input(const uint32_t *shader_token,
     return ret_str;
 }
 
-static MString *decode_opcode(const uint32_t *shader_token,
-                              VshOutputMux out_mux, uint32_t mask,
-                              const char *opcode, const char *inputs,
-                              MString **suffix)
+static void decode_opcode(MString *ret, const uint32_t *shader_token,
+                          VshOutputMux out_mux, uint32_t mask,
+                          const char *opcode, const char *inputs,
+                          MString **suffix)
 {
-    MString *ret = mstring_new();
     int reg_num = vsh_get_field(shader_token, FLD_OUT_R);
     bool use_temp_var = false;
 
@@ -427,14 +429,10 @@ static MString *decode_opcode(const uint32_t *shader_token,
                                opcode, reg_num, mask_str[mask], inputs);
         }
     }
-
-    return ret;
 }
 
 static MString *decode_token(const uint32_t *shader_token)
 {
-    MString *ret;
-
     /* See what MAC opcode is written to (if not masked away): */
     VshMAC mac = vsh_get_field(shader_token, FLD_MAC);
     /* See if a ILU opcode is present too: */
@@ -443,23 +441,28 @@ static MString *decode_token(const uint32_t *shader_token)
         return mstring_new();
     }
 
+    bool uses_r12 = false;
+
     /* Since it's potentially used twice, decode input C once: */
     MString *input_c =
         decode_opcode_input(shader_token,
                             vsh_get_field(shader_token, FLD_C_MUX),
                             FLD_C_NEG,
                             (vsh_get_field(shader_token, FLD_C_R_HIGH) << 2)
-                                | vsh_get_field(shader_token, FLD_C_R_LOW));
+                                | vsh_get_field(shader_token, FLD_C_R_LOW),
+                            &uses_r12);
 
     MString *mac_suffix = NULL;
+    MString *inputs_mac = mstring_new();
+
     if (mac != MAC_NOP) {
-        MString *inputs_mac = mstring_new();
         if (mac_opcode_params[mac].A) {
             MString *input_a =
                 decode_opcode_input(shader_token,
                                     vsh_get_field(shader_token, FLD_A_MUX),
                                     FLD_A_NEG,
-                                    vsh_get_field(shader_token, FLD_A_R));
+                                    vsh_get_field(shader_token, FLD_A_R),
+                                    &uses_r12);
             mstring_append(inputs_mac, ", ");
             mstring_append(inputs_mac, mstring_get_str(input_a));
             mstring_unref(input_a);
@@ -469,7 +472,8 @@ static MString *decode_token(const uint32_t *shader_token)
                 decode_opcode_input(shader_token,
                                     vsh_get_field(shader_token, FLD_B_MUX),
                                     FLD_B_NEG,
-                                    vsh_get_field(shader_token, FLD_B_R));
+                                    vsh_get_field(shader_token, FLD_B_R),
+                                    &uses_r12);
             mstring_append(inputs_mac, ", ");
             mstring_append(inputs_mac, mstring_get_str(input_b));
             mstring_unref(input_b);
@@ -478,36 +482,39 @@ static MString *decode_token(const uint32_t *shader_token)
             mstring_append(inputs_mac, ", ");
             mstring_append(inputs_mac, mstring_get_str(input_c));
         }
+    }
 
+    MString *ret = mstring_new();
+    if (uses_r12) {
+        mstring_append(ret, "  R12 = oPos;\n");
+    }
+
+    if (mac != MAC_NOP) {
         /* Then prepend these inputs with the actual opcode, mask, and input : */
-        ret = decode_opcode(shader_token,
-                            OMUX_MAC,
-                            vsh_get_field(shader_token, FLD_OUT_MAC_MASK),
-                            mac_opcode[mac],
-                            mstring_get_str(inputs_mac),
-                            &mac_suffix);
+        decode_opcode(ret,
+                      shader_token,
+                      OMUX_MAC,
+                      vsh_get_field(shader_token, FLD_OUT_MAC_MASK),
+                      mac_opcode[mac],
+                      mstring_get_str(inputs_mac),
+                      &mac_suffix);
         mstring_unref(inputs_mac);
-    } else {
-        ret = mstring_new();
     }
 
     if (ilu != ILU_NOP) {
         MString *inputs_c = mstring_from_str(", ");
         mstring_append(inputs_c, mstring_get_str(input_c));
 
         /* Append the ILU opcode, mask and (the already determined) input C: */
-        MString *ilu_op =
-            decode_opcode(shader_token,
-                          OMUX_ILU,
-                          vsh_get_field(shader_token, FLD_OUT_ILU_MASK),
-                          ilu_opcode[ilu],
-                          mstring_get_str(inputs_c),
-                          NULL);
-
-        mstring_append(ret, mstring_get_str(ilu_op));
+        decode_opcode(ret,
+                      shader_token,
+                      OMUX_ILU,
+                      vsh_get_field(shader_token, FLD_OUT_ILU_MASK),
+                      ilu_opcode[ilu],
+                      mstring_get_str(inputs_c),
+                      NULL);
 
         mstring_unref(inputs_c);
-        mstring_unref(ilu_op);
     }
 
     mstring_unref(input_c);
@@ -536,7 +543,11 @@ static const char* vsh_header =
     "vec4 R9 = vec4(0.0,0.0,0.0,0.0);\n"
     "vec4 R10 = vec4(0.0,0.0,0.0,0.0);\n"
     "vec4 R11 = vec4(0.0,0.0,0.0,0.0);\n"
-    "#define R12 oPos\n" /* R12 is a mirror of oPos */
+
+    /* R12 is a mirror of oPos and is updated on demand to facilitate
+     * multi-output / MAC+ILU pairs
+     */
+    "vec4 R12 = vec4(0.0,0.0,0.0,0.0);\n"
     "\n"
 
     /* Used to emulate concurrency of paired MAC+ILU instructions */