[stinkytofu] Add DPP modifier support in RawAsmParser

VOP instructions with DPP modifiers (row_xmask, row_shl, row_ror,
etc.) were falling to TEXTBLOCK because VOP microcode formats have
no modKey mapping. DPP is an add-on encoding variant layered on top
of the base VOP format — the assembler picks a wider encoding when
DPP modifiers are present.

Add field-based DPP detection after modifier token collection via
hasDPPFields() helper. When modKey is empty and DPP fields are
present, assign modKey = "mod.dpp" post-hoc. This avoids mapping all
VOP formats to DPP which would interfere with non-DPP VOP modifiers.

Add dppCtrl string field to DPPModifiers for unmodelled DPP modes
(row_xmask, row_shl, etc.). Existing typed fields (row_shr,
row_bcast, bound_ctrl) preserved for rocisa pipeline compatibility.

Add mod.dpp deserialize support in ModifierSerializer.

Author: darrenhsieh-amd

shared/stinkytofu/include/stinkytofu/ir/asm/StinkyModifiers.hpp

@@ -272,11 +272,17 @@ struct DPPModifiers : public TypedModifier<DPPModifiers> {
     int row_bcast;
     int bound_ctrl;
 
-    DPPModifiers(int row_shr = -1, int row_bcast = -1, int bound_ctrl = -1)
+    // Raw dpp_ctrl string for modes not modelled as typed fields
+    // (e.g. "row_xmask:8", "row_shl:4"). Emitted verbatim.
+    std::string dppCtrl;
+
+    DPPModifiers(int row_shr = -1, int row_bcast = -1, int bound_ctrl = -1,
+                 const std::string& dppCtrl = "")
         : TypedModifier<DPPModifiers>(),
           row_shr(row_shr),
           row_bcast(row_bcast),
-          bound_ctrl(bound_ctrl) {}
+          bound_ctrl(bound_ctrl),
+          dppCtrl(dppCtrl) {}
 };
 
 struct VOP3Modifiers : public TypedModifier<VOP3Modifiers> {

shared/stinkytofu/src/serialization/asm/ModifierSerializer.cpp

@@ -468,8 +468,12 @@ void deserializeVisit(StinkyInstruction* inst, const std::string& attrKey,
         if (fields.count("tokens")) {
             inst->addModifier(MemTokenData(getIntVector(fields, "tokens")));
         }
+    } else if (attrKey == "mod.dpp") {
+        inst->addModifier(
+            DPPModifiers(getInt(fields, "row_shr", -1), getInt(fields, "row_bcast", -1),
+                         getInt(fields, "bound_ctrl", -1), getStr(fields, "dppCtrl")));
     }
-    // mod.sdwa, mod.dpp, mod.vop3p, mod.true16: no deserialize support yet
+    // mod.sdwa, mod.vop3p, mod.true16: no deserialize support yet
 }
 
 }  // namespace

shared/stinkytofu/src/serialization/asm/RawAsmParser.cpp

@@ -491,6 +491,24 @@ bool parseWaitAluSyntax(IRLexer& lexer, ParsedInstruction& inst) {
     return true;
 }
 
+/// Map of string key → string value used for parsed modifier fields.
+using FieldMap = std::unordered_map<std::string, std::string>;
+
+/// Returns true if the field map contains any DPP control modifier key.
+/// DPP is an add-on encoding variant layered on top of VOP formats —
+/// the assembler picks a wider encoding when DPP modifiers are present.
+bool hasDPPFields(const FieldMap& fields) {
+    // dpp_ctrl modes (13 symbolic names)
+    return fields.count("quad_perm") || fields.count("row_shl") || fields.count("row_shr") ||
+           fields.count("row_ror") || fields.count("wave_shl") || fields.count("wave_shr") ||
+           fields.count("wave_rol") || fields.count("wave_ror") || fields.count("row_mirror") ||
+           fields.count("row_half_mirror") || fields.count("row_bcast") ||
+           fields.count("row_share") || fields.count("row_xmask") ||
+           // other DPP encoding fields
+           fields.count("bound_ctrl") || fields.count("row_mask") || fields.count("bank_mask") ||
+           fields.count("fi");
+}
+
 /// Parse hwreg(id, offset, width) syntax and store as a LiteralString
 /// register on the instruction for verbatim round-trip emission.
 void parseHwregOperand(IRLexer& lexer, ParsedInstruction& inst,
@@ -698,7 +716,16 @@ bool parseModifiers(IRLexer& lexer, ParsedInstruction& inst, const HwInstDesc* h
     // would be silently discarded below at the `modKey.empty()` early-return,
     // so flag the line as unrepresentable instead and let the caller fall
     // back to TEXTBLOCK pass-through.
-    if (modKey.empty() && sawAnyModifier) sawUnrepresentable = true;
+    // When no modKey was assigned from the microcode format, check if the
+    // collected fields match a known add-on modifier pattern. DPP is an
+    // add-on encoding variant whose base microcode format doesn't have a
+    // dedicated modKey — detect by checking for DPP-specific field names.
+    if (modKey.empty() && sawAnyModifier) {
+        if (hasDPPFields(fields))
+            modKey = "mod.dpp";
+        else
+            sawUnrepresentable = true;
+    }
 
     if (modKey.empty() || fields.empty()) return !sawUnrepresentable;
 
@@ -739,6 +766,22 @@ bool parseModifiers(IRLexer& lexer, ParsedInstruction& inst, const HwInstDesc* h
         if (fields.count("glc")) modFields["glc"] = "true";
         if (fields.count("nv")) modFields["nv"] = "true";
 
+    } else if (modKey == "mod.dpp") {
+        if (fields.count("row_shr")) modFields["row_shr"] = fields["row_shr"];
+        if (fields.count("row_bcast")) modFields["row_bcast"] = fields["row_bcast"];
+        if (fields.count("bound_ctrl")) modFields["bound_ctrl"] = fields["bound_ctrl"];
+        // Collect remaining (unmodelled) DPP fields into dppCtrl string for
+        // verbatim round-trip. Skip the typed fields handled above.
+        std::string dppCtrl;
+        for (const auto& [key, val] : fields) {
+            if (key == "row_shr" || key == "row_bcast" || key == "bound_ctrl") continue;
+            // Boolean flags (e.g. row_mirror) are stored as "true" —
+            // emit just the key, not "key:true".
+            dppCtrl = (val == "true") ? key : key + ":" + val;
+            break;
+        }
+        if (!dppCtrl.empty()) modFields["dppCtrl"] = dppCtrl;
+
     } else if (modKey == "mod.mfma") {
         if (fields.count("matrix_a_fmt")) modFields["matrix_a_fmt"] = fields["matrix_a_fmt"];
         if (fields.count("matrix_b_fmt")) modFields["matrix_b_fmt"] = fields["matrix_b_fmt"];

shared/stinkytofu/src/serialization/asm/StinkyAsmEmitter.cpp

@@ -272,6 +272,7 @@ inline std::ostream& operator<<(std::ostream& os, const SDWAModifiers& sdwaMod)
 }
 
 inline std::ostream& operator<<(std::ostream& os, const DPPModifiers& dppMod) {
+    if (!dppMod.dppCtrl.empty()) os << " " << dppMod.dppCtrl;
     if (dppMod.row_shr != -1) os << " row_shr:" << dppMod.row_shr;
     if (dppMod.row_bcast != -1) os << " row_bcast:" << dppMod.row_bcast;
     if (dppMod.bound_ctrl != -1) os << " bound_ctrl:" << dppMod.bound_ctrl;