From 5bf0d60df5b3b9cbfa2d8d5a9fe5cabfcb1f4ea4 Mon Sep 17 00:00:00 2001 From: Giacomo Travaglini Date: Wed, 4 Dec 2019 14:38:01 +0000 Subject: [PATCH] arch-arm: Be more verbose on load/store construction This is achieved by using keyword arguments to improve readibility. Some of the building helpers are using native types and can be annoying for a reader to understand what those sequences of number and boolean mean. It is also easier in this way to commit mistakes. Change-Id: I63081d09a1f621550c5b6522b8107f349939b21d Signed-off-by: Giacomo Travaglini Reviewed-by: Ciro Santilli Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/24044 Tested-by: kokoro --- src/arch/arm/isa/insts/ldr64.isa | 201 ++++++++++++++++--------------- src/arch/arm/isa/insts/str64.isa | 105 ++++++++-------- 2 files changed, 160 insertions(+), 146 deletions(-) diff --git a/src/arch/arm/isa/insts/ldr64.isa b/src/arch/arm/isa/insts/ldr64.isa index 16c0d930d..17789df16 100644 --- a/src/arch/arm/isa/insts/ldr64.isa +++ b/src/arch/arm/isa/insts/ldr64.isa @@ -390,82 +390,93 @@ let {{ LoadPost64(mnem, NameBase + "_POST", size, sign, flavor=flavor).emit() LoadReg64(mnem, NameBase + "_REG", size, sign, flavor=flavor).emit() - - LoadPre64("ldraa", "LDRAA_PRE", 8, False, flavor="authDA").emit() - LoadImm64("ldraa", "LDRAA_REG", 8, False, flavor="authDA").emit() - LoadPre64("ldrab", "LDRAB_PRE", 8, False, flavor="authDB").emit() - LoadImm64("ldrab", "LDRAB_REG", 8, False, flavor="authDB").emit() - - buildLoads64("ldrb", "LDRB64", 1, False) - buildLoads64("ldrsb", "LDRSBW64", 1, True) - buildLoads64("ldrsb", "LDRSBX64", 1, True, flavor="widen") - buildLoads64("ldrh", "LDRH64", 2, False) - buildLoads64("ldrsh", "LDRSHW64", 2, True) - buildLoads64("ldrsh", "LDRSHX64", 2, True, flavor="widen") - buildLoads64("ldrsw", "LDRSW64", 4, True, flavor="widen") - buildLoads64("ldr", "LDRW64", 4, False) - buildLoads64("ldr", "LDRX64", 8, False) - buildLoads64("ldr", "LDRBFP64", 1, False, flavor="fp") - buildLoads64("ldr", "LDRHFP64", 2, False, flavor="fp") - buildLoads64("ldr", "LDRSFP64", 4, False, flavor="fp") - buildLoads64("ldr", "LDRDFP64", 8, False, flavor="fp") - - LoadImm64("prfm", "PRFM64_IMM", 8, flavor="mprefetch").emit() - LoadReg64("prfm", "PRFM64_REG", 8, flavor="mprefetch").emit() - LoadLit64("prfm", "PRFM64_LIT", 8, literal=True, + LoadPre64("ldraa", "LDRAA_PRE", size=8, sign=False, flavor="authDA").emit() + LoadImm64("ldraa", "LDRAA_REG", size=8, sign=False, flavor="authDA").emit() + LoadPre64("ldrab", "LDRAB_PRE", size=8, sign=False, flavor="authDB").emit() + LoadImm64("ldrab", "LDRAB_REG", size=8, sign=False, flavor="authDB").emit() + + buildLoads64("ldrb", "LDRB64", size=1, sign=False) + buildLoads64("ldrsb", "LDRSBW64", size=1, sign=True) + buildLoads64("ldrsb", "LDRSBX64", size=1, sign=True, flavor="widen") + buildLoads64("ldrh", "LDRH64", size=2, sign=False) + buildLoads64("ldrsh", "LDRSHW64", size=2, sign=True) + buildLoads64("ldrsh", "LDRSHX64", size=2, sign=True, flavor="widen") + buildLoads64("ldrsw", "LDRSW64", size=4, sign=True, flavor="widen") + buildLoads64("ldr", "LDRW64", size=4, sign=False) + buildLoads64("ldr", "LDRX64", size=8, sign=False) + buildLoads64("ldr", "LDRBFP64", size=1, sign=False, flavor="fp") + buildLoads64("ldr", "LDRHFP64", size=2, sign=False, flavor="fp") + buildLoads64("ldr", "LDRSFP64", size=4, sign=False, flavor="fp") + buildLoads64("ldr", "LDRDFP64", size=8, sign=False, flavor="fp") + + LoadImm64("prfm", "PRFM64_IMM", size=8, flavor="mprefetch").emit() + LoadReg64("prfm", "PRFM64_REG", size=8, flavor="mprefetch").emit() + LoadLit64("prfm", "PRFM64_LIT", size=8, literal=True, flavor="mprefetch").emit() - LoadImm64("prfum", "PRFUM64_IMM", 8, flavor="mprefetch").emit() - - LoadImm64("ldurb", "LDURB64_IMM", 1, False).emit() - LoadImm64("ldursb", "LDURSBW64_IMM", 1, True).emit() - LoadImm64("ldursb", "LDURSBX64_IMM", 1, True, flavor="widen").emit() - LoadImm64("ldurh", "LDURH64_IMM", 2, False).emit() - LoadImm64("ldursh", "LDURSHW64_IMM", 2, True).emit() - LoadImm64("ldursh", "LDURSHX64_IMM", 2, True, flavor="widen").emit() - LoadImm64("ldursw", "LDURSW64_IMM", 4, True, flavor="widen").emit() - LoadImm64("ldur", "LDURW64_IMM", 4, False).emit() - LoadImm64("ldur", "LDURX64_IMM", 8, False).emit() - LoadImm64("ldur", "LDURBFP64_IMM", 1, flavor="fp").emit() - LoadImm64("ldur", "LDURHFP64_IMM", 2, flavor="fp").emit() - LoadImm64("ldur", "LDURSFP64_IMM", 4, flavor="fp").emit() - LoadImm64("ldur", "LDURDFP64_IMM", 8, flavor="fp").emit() - - LoadImm64("ldtrb", "LDTRB64_IMM", 1, False, True).emit() - LoadImm64("ldtrsb", "LDTRSBW64_IMM", 1, True, True).emit() - LoadImm64("ldtrsb", "LDTRSBX64_IMM", 1, True, True, flavor="widen").emit() - LoadImm64("ldtrh", "LDTRH64_IMM", 2, False, True).emit() - LoadImm64("ldtrsh", "LDTRSHW64_IMM", 2, True, True).emit() - LoadImm64("ldtrsh", "LDTRSHX64_IMM", 2, True, True, flavor="widen").emit() - LoadImm64("ldtrsw", "LDTRSW64_IMM", 4, True, True, flavor="widen").emit() - LoadImm64("ldtr", "LDTRW64_IMM", 4, False, True).emit() - LoadImm64("ldtr", "LDTRX64_IMM", 8, False, True).emit() - - LoadLit64("ldrsw", "LDRSWL64_LIT", 4, True, \ + LoadImm64("prfum", "PRFUM64_IMM", size=8, flavor="mprefetch").emit() + + LoadImm64("ldurb", "LDURB64_IMM", size=1, sign=False).emit() + LoadImm64("ldursb", "LDURSBW64_IMM", size=1, sign=True).emit() + LoadImm64("ldursb", "LDURSBX64_IMM", size=1, + sign=True, flavor="widen").emit() + LoadImm64("ldurh", "LDURH64_IMM", size=2, sign=False).emit() + LoadImm64("ldursh", "LDURSHW64_IMM", size=2, sign=True).emit() + LoadImm64("ldursh", "LDURSHX64_IMM", size=2, + sign=True, flavor="widen").emit() + LoadImm64("ldursw", "LDURSW64_IMM", size=4, + sign=True, flavor="widen").emit() + LoadImm64("ldur", "LDURW64_IMM", size=4, sign=False).emit() + LoadImm64("ldur", "LDURX64_IMM", size=8, sign=False).emit() + LoadImm64("ldur", "LDURBFP64_IMM", size=1, flavor="fp").emit() + LoadImm64("ldur", "LDURHFP64_IMM", size=2, flavor="fp").emit() + LoadImm64("ldur", "LDURSFP64_IMM", size=4, flavor="fp").emit() + LoadImm64("ldur", "LDURDFP64_IMM", size=8, flavor="fp").emit() + + LoadImm64("ldtrb", "LDTRB64_IMM", size=1, + sign=False, user=True).emit() + LoadImm64("ldtrsb", "LDTRSBW64_IMM", size=1, + sign=True, user=True).emit() + LoadImm64("ldtrsb", "LDTRSBX64_IMM", size=1, + sign=True, user=True, flavor="widen").emit() + LoadImm64("ldtrh", "LDTRH64_IMM", size=2, + sign=False, user=True).emit() + LoadImm64("ldtrsh", "LDTRSHW64_IMM", size=2, + sign=True, user=True).emit() + LoadImm64("ldtrsh", "LDTRSHX64_IMM", size=2, + sign=True, user=True, flavor="widen").emit() + LoadImm64("ldtrsw", "LDTRSW64_IMM", size=4, + sign=True, user=True, flavor="widen").emit() + LoadImm64("ldtr", "LDTRW64_IMM", size=4, + sign=False, user=True).emit() + LoadImm64("ldtr", "LDTRX64_IMM", size=8, + sign=False, user=True).emit() + + LoadLit64("ldrsw", "LDRSWL64_LIT", size=4, sign=True, \ literal=True, flavor="widen").emit() - LoadLit64("ldr", "LDRWL64_LIT", 4, False, literal=True).emit() - LoadLit64("ldr", "LDRXL64_LIT", 8, False, literal=True).emit() - LoadLit64("ldr", "LDRSFP64_LIT", 4, literal=True, flavor="fp").emit() - LoadLit64("ldr", "LDRDFP64_LIT", 8, literal=True, flavor="fp").emit() - - LoadRaw64("ldar", "LDARX64", 8, flavor="acquire").emit() - LoadRaw64("ldar", "LDARW64", 4, flavor="acquire").emit() - LoadRaw64("ldarh", "LDARH64", 2, flavor="acquire").emit() - LoadRaw64("ldarb", "LDARB64", 1, flavor="acquire").emit() - - LoadEx64("ldaxr", "LDAXRX64", 8, flavor="acex").emit() - LoadEx64("ldaxr", "LDAXRW64", 4, flavor="acex").emit() - LoadEx64("ldaxrh", "LDAXRH64", 2, flavor="acex").emit() - LoadEx64("ldaxrb", "LDAXRB64", 1, flavor="acex").emit() - - LoadEx64("ldxr", "LDXRX64", 8, flavor="exclusive").emit() - LoadEx64("ldxr", "LDXRW64", 4, flavor="exclusive").emit() - LoadEx64("ldxrh", "LDXRH64", 2, flavor="exclusive").emit() - LoadEx64("ldxrb", "LDXRB64", 1, flavor="exclusive").emit() - - LoadRaw64("ldapr", "LDAPRX64", 8, flavor="acquire").emit() - LoadRaw64("ldapr", "LDAPRW64", 4, flavor="acquire").emit() - LoadRaw64("ldaprh", "LDAPRH64", 2, flavor="acquire").emit() - LoadRaw64("ldaprb", "LDAPRB64", 1, flavor="acquire").emit() + LoadLit64("ldr", "LDRWL64_LIT", size=4, sign=False, literal=True).emit() + LoadLit64("ldr", "LDRXL64_LIT", size=8, sign=False, literal=True).emit() + LoadLit64("ldr", "LDRSFP64_LIT", size=4, literal=True, flavor="fp").emit() + LoadLit64("ldr", "LDRDFP64_LIT", size=8, literal=True, flavor="fp").emit() + + LoadRaw64("ldar", "LDARX64", size=8, flavor="acquire").emit() + LoadRaw64("ldar", "LDARW64", size=4, flavor="acquire").emit() + LoadRaw64("ldarh", "LDARH64", size=2, flavor="acquire").emit() + LoadRaw64("ldarb", "LDARB64", size=1, flavor="acquire").emit() + + LoadEx64("ldaxr", "LDAXRX64", size=8, flavor="acex").emit() + LoadEx64("ldaxr", "LDAXRW64", size=4, flavor="acex").emit() + LoadEx64("ldaxrh", "LDAXRH64", size=2, flavor="acex").emit() + LoadEx64("ldaxrb", "LDAXRB64", size=1, flavor="acex").emit() + + LoadEx64("ldxr", "LDXRX64", size=8, flavor="exclusive").emit() + LoadEx64("ldxr", "LDXRW64", size=4, flavor="exclusive").emit() + LoadEx64("ldxrh", "LDXRH64", size=2, flavor="exclusive").emit() + LoadEx64("ldxrb", "LDXRB64", size=1, flavor="exclusive").emit() + + LoadRaw64("ldapr", "LDAPRX64", size=8, flavor="acquire").emit() + LoadRaw64("ldapr", "LDAPRW64", size=4, flavor="acquire").emit() + LoadRaw64("ldaprh", "LDAPRH64", size=2, flavor="acquire").emit() + LoadRaw64("ldaprb", "LDAPRB64", size=1, flavor="acquire").emit() class LoadImmU64(LoadImm64): decConstBase = 'LoadStoreImmU64' @@ -493,26 +504,28 @@ let {{ decConstBase = 'LoadStoreLitU64' micro = True - LoadImmDU64("ldp_uop", "MicroLdPairUop", 8).emit() - LoadImmDU64("ldp_fp8_uop", "MicroLdPairFp8Uop", 8, flavor="fp").emit() - LoadImmU64("ldfp16_uop", "MicroLdFp16Uop", 16, flavor="fp").emit() - LoadReg64("ldfp16reg_uop", "MicroLdFp16RegUop", 16, flavor="fp").emit() - - LoadImmDouble64("ldaxp", "LDAXPW64", 4, flavor="acexp").emit() - LoadImmDouble64("ldaxp", "LDAXPX64", 8, flavor="acexp").emit() - LoadImmDouble64("ldxp", "LDXPW64", 4, flavor="exp").emit() - LoadImmDouble64("ldxp", "LDXPX64", 8, flavor="exp").emit() - - LoadImmU64("ldrxi_uop", "MicroLdrXImmUop", 8).emit() - LoadRegU64("ldrxr_uop", "MicroLdrXRegUop", 8).emit() - LoadLitU64("ldrxl_uop", "MicroLdrXLitUop", 8, literal=True).emit() - LoadImmU64("ldrfpxi_uop", "MicroLdrFpXImmUop", 8, flavor="fp").emit() - LoadRegU64("ldrfpxr_uop", "MicroLdrFpXRegUop", 8, flavor="fp").emit() - LoadLitU64("ldrfpxl_uop", "MicroLdrFpXLitUop", 8, literal=True, + LoadImmDU64("ldp_uop", "MicroLdPairUop", size=8).emit() + LoadImmDU64("ldp_fp8_uop", "MicroLdPairFp8Uop", size=8, flavor="fp").emit() + LoadImmU64("ldfp16_uop", "MicroLdFp16Uop", size=16, flavor="fp").emit() + LoadReg64("ldfp16reg_uop", "MicroLdFp16RegUop", size=16, + flavor="fp").emit() + + LoadImmDouble64("ldaxp", "LDAXPW64", size=4, flavor="acexp").emit() + LoadImmDouble64("ldaxp", "LDAXPX64", size=8, flavor="acexp").emit() + LoadImmDouble64("ldxp", "LDXPW64", size=4, flavor="exp").emit() + LoadImmDouble64("ldxp", "LDXPX64", size=8, flavor="exp").emit() + + LoadImmU64("ldrxi_uop", "MicroLdrXImmUop", size=8).emit() + LoadRegU64("ldrxr_uop", "MicroLdrXRegUop", size=8).emit() + LoadLitU64("ldrxl_uop", "MicroLdrXLitUop", size=8, literal=True).emit() + LoadImmU64("ldrfpxi_uop", "MicroLdrFpXImmUop", size=8, flavor="fp").emit() + LoadRegU64("ldrfpxr_uop", "MicroLdrFpXRegUop", size=8, flavor="fp").emit() + LoadLitU64("ldrfpxl_uop", "MicroLdrFpXLitUop", size=8, literal=True, flavor="fp").emit() LoadLitU64("ldfp16_lit__uop", "MicroLdFp16LitUop", - 16, literal=True, flavor="fp").emit() - LoadImmDU64("ldrduxi_uop", "MicroLdrDUXImmUop", 4, sign=False).emit() - LoadImmDU64("ldrdsxi_uop", "MicroLdrDSXImmUop", 4, sign=True).emit() - LoadImmDU64("ldrdfpxi_uop", "MicroLdrDFpXImmUop", 4, flavor="fp").emit() + size=16, literal=True, flavor="fp").emit() + LoadImmDU64("ldrduxi_uop", "MicroLdrDUXImmUop", size=4, sign=False).emit() + LoadImmDU64("ldrdsxi_uop", "MicroLdrDSXImmUop", size=4, sign=True).emit() + LoadImmDU64("ldrdfpxi_uop", "MicroLdrDFpXImmUop", size=4, + flavor="fp").emit() }}; diff --git a/src/arch/arm/isa/insts/str64.isa b/src/arch/arm/isa/insts/str64.isa index 0c55b4b64..ec42a532b 100644 --- a/src/arch/arm/isa/insts/str64.isa +++ b/src/arch/arm/isa/insts/str64.isa @@ -1,6 +1,6 @@ // -*- mode:c++ -*- -// Copyright (c) 2011-2013,2017 ARM Limited +// Copyright (c) 2011-2013,2017,2019 ARM Limited // All rights reserved // // The license below extends only to copyright in the software and shall @@ -290,43 +290,43 @@ let {{ StorePost64(mnem, NameBase + "_POST", size, flavor=flavor).emit() StoreReg64(mnem, NameBase + "_REG", size, flavor=flavor).emit() - buildStores64("strb", "STRB64", 1) - buildStores64("strh", "STRH64", 2) - buildStores64("str", "STRW64", 4) - buildStores64("str", "STRX64", 8) - buildStores64("str", "STRBFP64", 1, flavor="fp") - buildStores64("str", "STRHFP64", 2, flavor="fp") - buildStores64("str", "STRSFP64", 4, flavor="fp") - buildStores64("str", "STRDFP64", 8, flavor="fp") - - StoreImm64("sturb", "STURB64_IMM", 1).emit() - StoreImm64("sturh", "STURH64_IMM", 2).emit() - StoreImm64("stur", "STURW64_IMM", 4).emit() - StoreImm64("stur", "STURX64_IMM", 8).emit() - StoreImm64("stur", "STURBFP64_IMM", 1, flavor="fp").emit() - StoreImm64("stur", "STURHFP64_IMM", 2, flavor="fp").emit() - StoreImm64("stur", "STURSFP64_IMM", 4, flavor="fp").emit() - StoreImm64("stur", "STURDFP64_IMM", 8, flavor="fp").emit() - - StoreImm64("sttrb", "STTRB64_IMM", 1, user=True).emit() - StoreImm64("sttrh", "STTRH64_IMM", 2, user=True).emit() - StoreImm64("sttr", "STTRW64_IMM", 4, user=True).emit() - StoreImm64("sttr", "STTRX64_IMM", 8, user=True).emit() - - StoreRaw64("stlr", "STLRX64", 8, flavor="release").emit() - StoreRaw64("stlr", "STLRW64", 4, flavor="release").emit() - StoreRaw64("stlrh", "STLRH64", 2, flavor="release").emit() - StoreRaw64("stlrb", "STLRB64", 1, flavor="release").emit() - - StoreEx64("stlxr", "STLXRX64", 8, flavor="relex").emit() - StoreEx64("stlxr", "STLXRW64", 4, flavor="relex").emit() - StoreEx64("stlxrh", "STLXRH64", 2, flavor="relex").emit() - StoreEx64("stlxrb", "STLXRB64", 1, flavor="relex").emit() - - StoreEx64("stxr", "STXRX64", 8, flavor="exclusive").emit() - StoreEx64("stxr", "STXRW64", 4, flavor="exclusive").emit() - StoreEx64("stxrh", "STXRH64", 2, flavor="exclusive").emit() - StoreEx64("stxrb", "STXRB64", 1, flavor="exclusive").emit() + buildStores64("strb", "STRB64", size=1) + buildStores64("strh", "STRH64", size=2) + buildStores64("str", "STRW64", size=4) + buildStores64("str", "STRX64", size=8) + buildStores64("str", "STRBFP64", size=1, flavor="fp") + buildStores64("str", "STRHFP64", size=2, flavor="fp") + buildStores64("str", "STRSFP64", size=4, flavor="fp") + buildStores64("str", "STRDFP64", size=8, flavor="fp") + + StoreImm64("sturb", "STURB64_IMM", size=1).emit() + StoreImm64("sturh", "STURH64_IMM", size=2).emit() + StoreImm64("stur", "STURW64_IMM", size=4).emit() + StoreImm64("stur", "STURX64_IMM", size=8).emit() + StoreImm64("stur", "STURBFP64_IMM", size=1, flavor="fp").emit() + StoreImm64("stur", "STURHFP64_IMM", size=2, flavor="fp").emit() + StoreImm64("stur", "STURSFP64_IMM", size=4, flavor="fp").emit() + StoreImm64("stur", "STURDFP64_IMM", size=8, flavor="fp").emit() + + StoreImm64("sttrb", "STTRB64_IMM", size=1, user=True).emit() + StoreImm64("sttrh", "STTRH64_IMM", size=2, user=True).emit() + StoreImm64("sttr", "STTRW64_IMM", size=4, user=True).emit() + StoreImm64("sttr", "STTRX64_IMM", size=8, user=True).emit() + + StoreRaw64("stlr", "STLRX64", size=8, flavor="release").emit() + StoreRaw64("stlr", "STLRW64", size=4, flavor="release").emit() + StoreRaw64("stlrh", "STLRH64", size=2, flavor="release").emit() + StoreRaw64("stlrb", "STLRB64", size=1, flavor="release").emit() + + StoreEx64("stlxr", "STLXRX64", size=8, flavor="relex").emit() + StoreEx64("stlxr", "STLXRW64", size=4, flavor="relex").emit() + StoreEx64("stlxrh", "STLXRH64", size=2, flavor="relex").emit() + StoreEx64("stlxrb", "STLXRB64", size=1, flavor="relex").emit() + + StoreEx64("stxr", "STXRX64", size=8, flavor="exclusive").emit() + StoreEx64("stxr", "STXRW64", size=4, flavor="exclusive").emit() + StoreEx64("stxrh", "STXRH64", size=2, flavor="exclusive").emit() + StoreEx64("stxrb", "STXRB64", size=1, flavor="exclusive").emit() class StoreImmU64(StoreImm64): decConstBase = 'LoadStoreImmU64' @@ -355,24 +355,25 @@ let {{ decConstBase = 'LoadStoreRegU64' micro = True - StoreImmDEx64("stlxp", "STLXPW64", 4, flavor="relexp").emit() - StoreImmDEx64("stlxp", "STLXPX64", 8, flavor="relexp").emit() - StoreImmDEx64("stxp", "STXPW64", 4, flavor="exp").emit() - StoreImmDEx64("stxp", "STXPX64", 8, flavor="exp").emit() + StoreImmDEx64("stlxp", "STLXPW64", size=4, flavor="relexp").emit() + StoreImmDEx64("stlxp", "STLXPX64", size=8, flavor="relexp").emit() + StoreImmDEx64("stxp", "STXPW64", size=4, flavor="exp").emit() + StoreImmDEx64("stxp", "STXPX64", size=8, flavor="exp").emit() - StoreImmU64("strxi_uop", "MicroStrXImmUop", 8).emit() - StoreRegU64("strxr_uop", "MicroStrXRegUop", 8).emit() - StoreImmU64("strfpxi_uop", "MicroStrFpXImmUop", 8, flavor="fp").emit() - StoreRegU64("strfpxr_uop", "MicroStrFpXRegUop", 8, flavor="fp").emit() + StoreImmU64("strxi_uop", "MicroStrXImmUop", size=8).emit() + StoreRegU64("strxr_uop", "MicroStrXRegUop", size=8).emit() + StoreImmU64("strfpxi_uop", "MicroStrFpXImmUop", size=8, flavor="fp").emit() + StoreRegU64("strfpxr_uop", "MicroStrFpXRegUop", size=8, flavor="fp").emit() StoreImmU64("strqbfpxi_uop", "MicroStrQBFpXImmUop", - 16, flavor="fp", top=False).emit() + size=16, flavor="fp", top=False).emit() StoreRegU64("strqbfpxr_uop", "MicroStrQBFpXRegUop", - 16, flavor="fp", top=False).emit() + size=16, flavor="fp", top=False).emit() StoreImmU64("strqtfpxi_uop", "MicroStrQTFpXImmUop", - 16, flavor="fp", top=True).emit() + size=16, flavor="fp", top=True).emit() StoreRegU64("strqtfpxr_uop", "MicroStrQTFpXRegUop", - 16, flavor="fp", top=True).emit() - StoreImmDU64("strdxi_uop", "MicroStrDXImmUop", 4).emit() - StoreImmDU64("strdfpxi_uop", "MicroStrDFpXImmUop", 4, flavor="fp").emit() + size=16, flavor="fp", top=True).emit() + StoreImmDU64("strdxi_uop", "MicroStrDXImmUop", size=4).emit() + StoreImmDU64("strdfpxi_uop", "MicroStrDFpXImmUop", + size=4, flavor="fp").emit() }}; -- 2.30.2