From patchwork Mon Nov 21 11:06:02 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Aleksandar Rikalo X-Patchwork-Id: 60920 Return-Path: X-Original-To: patchwork@sourceware.org Delivered-To: patchwork@sourceware.org Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 8A7F5384F4BF for ; Mon, 21 Nov 2022 11:06:40 +0000 (GMT) X-Original-To: gdb-patches@sourceware.org Delivered-To: gdb-patches@sourceware.org Received: from EUR05-DB8-obe.outbound.protection.outlook.com (mail-db8eur05on2101.outbound.protection.outlook.com [40.107.20.101]) by sourceware.org (Postfix) with ESMTPS id BAABC3857BB2 for ; Mon, 21 Nov 2022 11:06:15 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org BAABC3857BB2 Authentication-Results: sourceware.org; dmarc=none (p=none dis=none) header.from=syrmia.com Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=syrmia.com ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=RX7TeQ7T63crPTk63ZfftYosIbTEhD3xTgy9E7ddxQ988DUordsMHXczCmC+vKu3O9Y48WTOXL8JG16ZouMHw7sRFgvpu+vNMjpZ6Yz4ScUUfwu7cJI+KMWEYgs9GhyGMsdL3jRqsDfPhiZ4uDmKQr2DYIr1ylAHwwOz8bKyY0mS2erqts89AdgiS+R1QqsjLH+UabllYzH2X6ElE2gqRp2CIdnH2/MMbwtnFkFQ9qaJirGPvAPxbrlLGSuI4w3e7wSSBIS+Ol/K2/6cjq+3youd1KNRsyxBwDoNTxJDvVeb1tqbc4NaC/qy1cuogqe976ih7AH7Edg0186ltSpxvw== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com; s=arcselector9901; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-AntiSpam-MessageData-ChunkCount:X-MS-Exchange-AntiSpam-MessageData-0:X-MS-Exchange-AntiSpam-MessageData-1; bh=RtADv3mEquDCgrt7Yr1vRHcxXJidrYclfLsmBQq3vzE=; b=TF9qtIIZhc6MVRAjCLzEEbnpCPYGtbSglE6Ylkm5JX7ud42PuZG3WU46hcqY7+VquWogO2Fb3zQCpkKXBiCqjRZlyyu09ZEm1+cHX/oBJ63ctLcsI7S0Qm/wdBEgeC0dVvyul3nJQ31rVC8F9HPji+6cygxtZ3G0HkmguR+JDsk8RfWtfwYyQXkUojqDrnasMyixSRGL8Mz22LquJcnOB4fEJTIZllc4lBbf6kXs5EVnYk30V/FHkwxOWNFEOEUXa/bna1A9dBA7A43mlaGjBodTZAB9NNtr2WUanbQgYuV+UxXq8NIgsxcVwVaExVHnD9u0Y4TZQJivQ2tfF0E00w== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=pass smtp.mailfrom=syrmia.com; dmarc=pass action=none header.from=syrmia.com; dkim=pass header.d=syrmia.com; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=syrmia.com; s=selector1; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=RtADv3mEquDCgrt7Yr1vRHcxXJidrYclfLsmBQq3vzE=; b=Uv2TAa9rFcw+QIXts0zXva83jFyn+ALaCHKYk+vmUV/46mY0ulFhJNRF6V7sG/BF+dccC4RlK2++SVklVq/4ABBeOgh1mEHO+hEaz5ks5QMBk1RwLsJArLKsOieTPlboidlhuUq9EpdIfH63DQi1HXgDdKgXXrMNCMA45P/RoeQ= Authentication-Results: dkim=none (message not signed) header.d=none;dmarc=none action=none header.from=syrmia.com; Received: from VI1PR0302MB3486.eurprd03.prod.outlook.com (2603:10a6:803:1e::32) by PAXPR03MB7806.eurprd03.prod.outlook.com (2603:10a6:102:201::19) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.5834.15; Mon, 21 Nov 2022 11:06:10 +0000 Received: from VI1PR0302MB3486.eurprd03.prod.outlook.com ([fe80::19fa:5ce5:280a:b98e]) by VI1PR0302MB3486.eurprd03.prod.outlook.com ([fe80::19fa:5ce5:280a:b98e%3]) with mapi id 15.20.5834.015; Mon, 21 Nov 2022 11:06:09 +0000 From: Aleksandar Rikalo To: gdb-patches@sourceware.org Cc: aleksandar.rikalo@syrmia.com, arikalo@gmail.com Subject: [PATCH v3 1/2] sim: Add nanoMIPS port Date: Mon, 21 Nov 2022 12:06:02 +0100 Message-Id: <20221121110603.124056-1-aleksandar.rikalo@syrmia.com> X-Mailer: git-send-email 2.25.1 X-ClientProxiedBy: VE1PR03CA0031.eurprd03.prod.outlook.com (2603:10a6:803:118::20) To VI1PR0302MB3486.eurprd03.prod.outlook.com (2603:10a6:803:1e::32) MIME-Version: 1.0 X-MS-PublicTrafficType: Email X-MS-TrafficTypeDiagnostic: VI1PR0302MB3486:EE_|PAXPR03MB7806:EE_ X-MS-Office365-Filtering-Correlation-Id: 51906fde-1f60-428d-1daf-08dacbb064fd X-MS-Exchange-SenderADCheck: 1 X-MS-Exchange-AntiSpam-Relay: 0 X-Microsoft-Antispam: BCL:0; X-Microsoft-Antispam-Message-Info: jBaq8myKwGlcmR8r4BaYsUPRMWF/iK5dSujzBajPZvd/n8MX6KHIkjG/2151/1guentMiJZQsqvE6HJnv595IhKPp9x4O6Ms3HBmZDNIA5NKh5ygiu6WwIUA+RhnP0HAX4f5iHMns5+OMjwpo7ry5pqCSWIqdfPKzl5WX161K5l/AZ0eG8Ttbc2WaCahSlTPIWVGCasD9Ud6PlXnz8zrnpeIJOOgQKUFACpHBpiIJiKsMKnHtZ3rA8rvPfby1Ni1JEVYPpmK7azAQtg13hhPu1Z0UIuj6MGd7nCH1Sk2gTugVNlNAk1hjRbm8lConev+iJ5IeSHVyhk52BkDpty5pMyWI5MU1V2LWBz8phh2/3giJpYlO6QsjfF1qBAyiCsszKty2q04/u0w/49esPYwSv3VZdbPVVYHVNDAtjp0cYHeyUkYpdecYH8F4Bj3u31kcFDsdJUG/dWwfkCXshYl3JjlIIA5TBgfCsQVjl8gG8uCXGSYZQ+nm0OCLEEi9Zqwc+Pwk6QKr23pggUB8oCf9mcbi7ODvUbGf1pjgrvByApJpbwlIwXkAx6T0HoiN+GyqYBMva5ts6oEjDp8GKR1KxPffKH4NPYE14wPgPF8Hzsz1p8y81P6lT8j4fsWcqvw+UxnwGER1yvPKfOaT1gZ+cG5Wkpv3rau5yay4JD7RDjA67WMNbyfd9fqZ2ixLyJmyN1Ivzt/1MZuZzQf1hq7hkjgeHOAl1Aa5j3hLy0i9d+hpTFHHvCUIoNVCRgW+LOi1jpNdWysgsynztpUjbdRCg== X-Forefront-Antispam-Report: CIP:255.255.255.255; CTRY:; LANG:en; SCL:1; SRV:; IPV:NLI; SFV:NSPM; H:VI1PR0302MB3486.eurprd03.prod.outlook.com; PTR:; CAT:NONE; SFS:(13230022)(136003)(376002)(346002)(396003)(366004)(39830400003)(451199015)(36756003)(86362001)(26005)(38350700002)(38100700002)(2616005)(1076003)(186003)(6512007)(44832011)(83380400001)(6916009)(30864003)(2906002)(5660300002)(8936002)(6666004)(52116002)(6506007)(478600001)(6486002)(19627235002)(41300700001)(66476007)(316002)(66556008)(4326008)(8676002)(66946007)(21314003)(2004002)(559001)(579004); DIR:OUT; SFP:1102; X-MS-Exchange-AntiSpam-MessageData-ChunkCount: 1 X-MS-Exchange-AntiSpam-MessageData-0: KcAolZziuOf2P5i+hvOPEEaCg0B4UZ8Fh/yTU3pFycCsPIvrr9VoIQunTXEm5iwi6o/nA7nM4xN/AlDzEkxPXgWmJZvA/NY2XI2m90zPa62gHVytTa6FocFUeSrPREf5pNY5PGAYacrzIhP2w+448x4QexO/KK6k+0FUFqKDj6fp/1v/MZO3zTwRzdMGj2p2cOd8/a7ULiPXhYZ6XIef+D8ObKK25nPqf3dR9Up1+7MNIxEUAfHMadGcgb6Vx9i+KnjGAj1uuhkUOWKAe2RN9QSLyXZMx6H/sw0XT+fND9MDTgVg0Q+oQNTr2D4QGvX7RDUGNTSw6wQgRLJaBA9umOHmGVdslWefaKrLDga2Zel7SmQS2eAn/f6g6K2VZUJNNpFTAj2qOfTojYPmZOjDa5pza5jbh7j3Z9Bt8GKTHHQY1IzkbE6LdkugPC1W2kobGTSMlWnY7rkya9WVgasnv1tHzLNOr6aGaqr3FFWF/uuzwdKGtPohWygdaZ8d+oxvhvdOeABBgdpLW4hlX2KdBs0v5w/lJVMdIyfbAXezfxGPLkgXS5ZN9R5c/fj4QFBeAUS3X6mBFtWD8atpNnDD/r02CQAObV4OQK7HX5JwY/lbC82H65m9CJ4PfhJwPWlpo734g/B9X363JPl/w9crcEyj1TroC3bMNrOLxE1kecn7e8/fr5EgCIHKZvgGUi2FZ0mkW9YahkJPGgtV8yCAAbo5Dnf07vFG1AjjBMrm0ic/bCMjv9NpTkZcOUiNdErgQhe6Sm1wmdv5yQf/QKUliJQ3CmQlPWPY8aydl+a/DpBaFXvvTqhs+T1ygv/M8Hxygj5caArUrZufkjVM68f4rJ9YQYJi02O7/Ey0mFuoOi9e1IiE/hA4kR35Cjq/bGMzBoFsCr3Juo42VjKvqwTddDlq1urtG69byqpKSlVSFvU7m7K4PHb/pvKxM/q35B9rrcwB1Ld3+r0MQ7P3qsRRymP8AdXg/ZNW4uyXfNlvMYAWtXS7h0quNCh5/36FdWw5cmWXGdt68aQcOUX2AtvnIXLOhFV2l7PbqlLmVUZan808V6aaWKkZWNKaXBFO0icIOg0TIZnFAe7ihVVp1EIoZYHELXjtWGR9n37E6L36cfY75FQUByhP1BR9FcoqMjeJ5N4RPEkFAtQqC8PFE92i1z0eEJda87P9+upiu8s18GPHucaOtPjqjwUWRJx9EyXWTz21oyOCbaDse9ug3q9lSfbZmSW+cAcqhylXIuOQZC21tfyEBCdqD37kAzpDDR5F21WxLUEpfxYNMl0GWaymvvqsetpls3z9i8GtkzhNG7Kk1AwyA2T+sdeHGKsLQuoGVTx29kCDxHyWCCHx20tN8rlnePL+Hr+9CGYrsOJ3TeerrEMrKggVk5yy6Hhh6ufNYYdaWdQUYQVOe19IIE0VJHLUfLKCrc1LMmmvXj8IN82iZ8+WvowIosqlUjC3ddmPeINnTsXa8+moQ6GDRuvTAFDnnvMMWMLgYalcwfG1z7Dwu1G3H/pg/AY7EwSJHRnHtP5mIP0E5k+3AJc2F+9TzxHQfBMwNE/X3kv8RHJMdgqyjdv2VPuEl91kR9l+52+he3pTerROVjP35qwtrq67Sw== X-OriginatorOrg: syrmia.com X-MS-Exchange-CrossTenant-Network-Message-Id: 51906fde-1f60-428d-1daf-08dacbb064fd X-MS-Exchange-CrossTenant-AuthSource: VI1PR0302MB3486.eurprd03.prod.outlook.com X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-OriginalArrivalTime: 21 Nov 2022 11:06:09.8619 (UTC) X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 19214a73-c1ab-4e19-8f59-14bdcb09a66e X-MS-Exchange-CrossTenant-MailboxType: HOSTED X-MS-Exchange-CrossTenant-UserPrincipalName: 0ALsko/nmKlXqC5SIf7h+WE5fFEy2f5Q6E+UjgJ44tGAwnPXP4BSHV2+9BauGULzHSCQkkgvI6jSCQ3ISCs/I3c+qsOaDi9yuueHEbx1V+g= X-MS-Exchange-Transport-CrossTenantHeadersStamped: PAXPR03MB7806 X-Spam-Status: No, score=-13.5 required=5.0 tests=BAYES_00, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, GIT_PATCH_0, KAM_SHORT, RCVD_IN_DNSWL_NONE, RCVD_IN_MSPIKE_H2, SPF_HELO_PASS, SPF_PASS, TXREP autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org X-BeenThere: gdb-patches@sourceware.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Gdb-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: gdb-patches-bounces+patchwork=sourceware.org@sourceware.org Sender: "Gdb-patches" Co-Authored-By: Jaydeep Patil Co-Authored-By: Matthew Fortune Co-Authored-By: Maciej W. Rozycki Co-Authored-By: Stefan Markovic Co-Authored-By: Sara Graovac Co-Authored-By: Dragan Mladjenovic --- sim/common/sim-bits.h | 4 + sim/configure | 2 +- sim/configure.ac | 2 +- sim/mips/Makefile.in | 28 + sim/mips/configure | 28 + sim/mips/configure.ac | 28 + sim/mips/interp.c | 21 +- sim/mips/micromips16.dc | 3 + sim/mips/mips.igen | 193 ++- sim/mips/nanomipsdsp.igen | 1115 +++++++++++++++ sim/mips/nanomipsr6.igen | 2744 +++++++++++++++++++++++++++++++++++++ sim/mips/nanomipsrun.c | 109 ++ sim/mips/nms.c | 44 + sim/mips/sim-main.h | 61 +- 14 files changed, 4358 insertions(+), 24 deletions(-) create mode 100644 sim/mips/nanomipsdsp.igen create mode 100644 sim/mips/nanomipsr6.igen create mode 100644 sim/mips/nanomipsrun.c create mode 100644 sim/mips/nms.c diff --git a/sim/common/sim-bits.h b/sim/common/sim-bits.h index fab1dab478c..8799916de26 100644 --- a/sim/common/sim-bits.h +++ b/sim/common/sim-bits.h @@ -499,15 +499,19 @@ INLINE_SIM_BITS(unsigned_word) MSINSERTED (unsigned_word val, int start, int sto #define EXTEND4(X) (LSSEXT ((X), 3)) #define EXTEND5(X) (LSSEXT ((X), 4)) #define EXTEND6(X) (LSSEXT ((X), 5)) +#define EXTEND7(X) (LSSEXT ((X), 6)) #define EXTEND8(X) ((signed_word)(int8_t)(X)) #define EXTEND9(X) (LSSEXT ((X), 8)) +#define EXTEND10(X) (LSSEXT ((X), 9)) #define EXTEND11(X) (LSSEXT ((X), 10)) #define EXTEND12(X) (LSSEXT ((X), 11)) +#define EXTEND14(X) (LSSEXT ((X), 13)) #define EXTEND15(X) (LSSEXT ((X), 14)) #define EXTEND16(X) ((signed_word)(int16_t)(X)) #define EXTEND18(X) (LSSEXT ((X), 17)) #define EXTEND19(X) (LSSEXT ((X), 18)) #define EXTEND21(X) (LSSEXT ((X), 20)) +#define EXTEND22(X) (LSSEXT ((X), 21)) #define EXTEND24(X) (LSSEXT ((X), 23)) #define EXTEND25(X) (LSSEXT ((X), 24)) #define EXTEND26(X) (LSSEXT ((X), 25)) diff --git a/sim/configure b/sim/configure index 57c4fcf6972..aa9e21a2923 100755 --- a/sim/configure +++ b/sim/configure @@ -15157,7 +15157,7 @@ fi sim_enable_arch_mips=false case "${targ}" in - all|mips*-*-*) + all|mips*-*-*|nanomips*-*-*) if test "${targ}" = "${target}"; then SIM_PRIMARY_TARGET=mips fi diff --git a/sim/configure.ac b/sim/configure.ac index 675fa1bb44d..3f606ac5b64 100644 --- a/sim/configure.ac +++ b/sim/configure.ac @@ -143,7 +143,7 @@ if test "${enable_sim}" != no; then SIM_TARGET([m68hc11-*-*|m6811-*-*], [m68hc11]) SIM_TARGET([mcore-*-*], [mcore]) SIM_TARGET([microblaze*-*-*], [microblaze]) - SIM_TARGET([mips*-*-*], [mips], [true], [sim_igen=yes]) + SIM_TARGET([mips*-*-*|nanomips*-*-*], [mips], [true], [sim_igen=yes]) SIM_TARGET([mn10300*-*-*], [mn10300], [], [sim_igen=yes]) SIM_TARGET([moxie-*-*], [moxie]) SIM_TARGET([msp430*-*-*], [msp430]) diff --git a/sim/mips/Makefile.in b/sim/mips/Makefile.in index 75438be5a18..8637b46b186 100644 --- a/sim/mips/Makefile.in +++ b/sim/mips/Makefile.in @@ -61,6 +61,7 @@ SIM_OBJS = \ cp1.o \ mdmx.o \ dsp.o \ + nms.o \ sim-main.o \ sim-resume.o \ @@ -99,6 +100,8 @@ IGEN_INCLUDE=\ $(srcdir)/dsp2.igen \ $(srcdir)/mips3264r2.igen \ $(srcdir)/mips3264r6.igen \ + $(srcdir)/nanomipsdsp.igen \ + $(srcdir)/nanomipsr6.igen # NB: Since these can be built by a number of generators, care # must be taken to ensure that they are only dependant on @@ -463,8 +466,11 @@ tmp-mach-multi: $(IGEN_INSN) $(IGEN_DC) $(IGEN) $(IGEN_INCLUDE) f=`echo $${t} | sed -e 's/.*://'` ; \ case $${p} in \ micromips16*) e="-B 16 -H 15 -o $(MICROMIPS16_DC) -F 16" ;; \ + nanomips16*) e="-B 16 -H 15 -o $(MICROMIPS16_DC) -F 16" ;; \ micromips32* | micromips64*) \ e="-B 32 -H 31 -o $(MICROMIPS32_DC) -F $${f}" ;; \ + nanomips32* | nanomips64*) \ + e="-B 32 -H 31 -o $(MICROMIPS32_DC) -F $${f}" ;; \ micromips_m32*) \ e="-B 32 -H 31 -o $(IGEN_DC) -F $${f}"; \ m="mips32r2,mips3d,mdmx,dsp,dsp2,smartmips" ;; \ @@ -579,6 +585,28 @@ tmp-run-multi: $(srcdir)/m16run.c $(srcdir)/micromipsrun.c $(SHELL) $(srcdir)/../../move-if-change tmp-run \ micromips$${m}_run.c ; \ ;;\ + nanomips32*) \ + m=`echo $${t} | sed -e 's/^nanomips32//' -e 's/:.*//'`; \ + sed < $(srcdir)/nanomipsrun.c > tmp-run \ + -e "s/^sim_/nanomips32$${m}_/" \ + -e "s/nanomips_instruction_decode/nanomips32$${m}_instruction_decode/g" \ + -e "s/nanomips16_/nanomips16$${m}_/" \ + -e "s/nanomips32_/nanomips32$${m}_/" \ + -e "s/m32_/m32$${m}_/" ; \ + $(SHELL) $(srcdir)/../../move-if-change tmp-run \ + nanomips$${m}_run.c ; \ + ;;\ + nanomips64*) \ + m=`echo $${t} | sed -e 's/^nanomips64//' -e 's/:.*//'`; \ + sed < $(srcdir)/nanomipsrun.c > tmp-run \ + -e "s/^sim_/nanomips64$${m}_/" \ + -e "s/nanomips_instruction_decode/nanomips64$${m}_instruction_decode/g" \ + -e "s/nanomips16_/nanomips16$${m}_/" \ + -e "s/nanomips32_/nanomips64$${m}_/" \ + -e "s/m32_/m64$${m}_/" ; \ + $(SHELL) $(srcdir)/../../move-if-change tmp-run \ + nanomips$${m}_run.c ; \ + ;;\ esac \ done $(SILENCE) touch $@ diff --git a/sim/mips/configure b/sim/mips/configure index b0ba7ba7470..493547fc97b 100755 --- a/sim/mips/configure +++ b/sim/mips/configure @@ -2028,6 +2028,12 @@ case "${target}" in mipsisa64r6:mips64r6:32,64,f:mipsisa32r6,mipsisa64r6" sim_multi_default=mipsisa64r2 ;; + nanomips*-elf*) + sim_gen=MULTI + sim_multi_configs="\ + nanor6sim:nanomips64r6,nanomipsdsp:32,64,f:nanomipsisa64r6,nanomipsisa32r6" + sim_multi_default=nanomipsisa32r6 + ;; mips64*-*-*) sim_igen_filter="32,64,f" sim_gen=IGEN ;; @@ -2226,6 +2232,17 @@ __EOF__ sim_multi_obj="${sim_multi_obj} micromips${name}_run.o" sim_multi_flags="${sim_multi_flags} -F 16,32" ;; + *:*nanomips32*) + # Run igen twice, once for nanomips32 and once for nanomips16. + ws="nanomips16 nanomips32" + + # The top-level function for the micromips simulator is + # in a file micromips${name}_run.c, generated by the + # tmp-run-multi Makefile rule. + sim_multi_src="${sim_multi_src} nanomips${name}_run.c" + sim_multi_obj="${sim_multi_obj} nanomips${name}_run.o" + sim_multi_flags="${sim_multi_flags} -F 16,32" + ;; *:*micromips64*:*) # Run igen thrice, once for micromips64, once for micromips16, # and once for m64. @@ -2238,6 +2255,17 @@ __EOF__ sim_multi_obj="${sim_multi_obj} micromips${name}_run.o" sim_multi_flags="${sim_multi_flags} -F 16,32,64" ;; + *:*nanomips64*) + # Run igen twice, once for nanomips64 and once for nanomips16. + ws="nanomips16 nanomips64" + + # The top-level function for the micromips simulator is + # in a file micromips${name}_run.c, generated by the + # tmp-run-multi Makefile rule. + sim_multi_src="${sim_multi_src} nanomips${name}_run.c" + sim_multi_obj="${sim_multi_obj} nanomips${name}_run.o" + sim_multi_flags="${sim_multi_flags} -F 16,32,64" + ;; *) ws=m32 ;; diff --git a/sim/mips/configure.ac b/sim/mips/configure.ac index f1d9f3d2410..e8153b0c5ac 100644 --- a/sim/mips/configure.ac +++ b/sim/mips/configure.ac @@ -106,6 +106,12 @@ case "${target}" in mipsisa64r6:mips64r6:32,64,f:mipsisa32r6,mipsisa64r6" sim_multi_default=mipsisa64r2 ;; + nanomips*-*-elf*) + sim_gen=MULTI + sim_multi_configs="\ + nanor6sim:nanomips64r6,nanomipsdsp:32,64,f:nanomipsisa64r6,nanomipsisa32r6" + sim_multi_default=nanomipsisa64r6 + ;; mips64*-*-*) sim_igen_filter="32,64,f" sim_gen=IGEN ;; @@ -304,6 +310,17 @@ __EOF__ sim_multi_obj="${sim_multi_obj} micromips${name}_run.o" sim_multi_flags="${sim_multi_flags} -F 16,32" ;; + *:*nanomips32*) + # Run igen twice, once for nanomips32 and once for nanomips16. + ws="nanomips16 nanomips32" + + # The top-level function for the micromips simulator is + # in a file micromips${name}_run.c, generated by the + # tmp-run-multi Makefile rule. + sim_multi_src="${sim_multi_src} nanomips${name}_run.c" + sim_multi_obj="${sim_multi_obj} nanomips${name}_run.o" + sim_multi_flags="${sim_multi_flags} -F 16,32" + ;; *:*micromips64*:*) # Run igen thrice, once for micromips64, once for micromips16, # and once for m64. @@ -316,6 +333,17 @@ __EOF__ sim_multi_obj="${sim_multi_obj} micromips${name}_run.o" sim_multi_flags="${sim_multi_flags} -F 16,32,64" ;; + *:*nanomips64*) + # Run igen twice, once for nanomips64 and once for nanomips16. + ws="nanomips16 nanomips64" + + # The top-level function for the micromips simulator is + # in a file micromips${name}_run.c, generated by the + # tmp-run-multi Makefile rule. + sim_multi_src="${sim_multi_src} nanomips${name}_run.c" + sim_multi_obj="${sim_multi_obj} nanomips${name}_run.o" + sim_multi_flags="${sim_multi_flags} -F 16,32,64" + ;; *) ws=m32 ;; diff --git a/sim/mips/interp.c b/sim/mips/interp.c index ab20f079939..3612956bb2b 100644 --- a/sim/mips/interp.c +++ b/sim/mips/interp.c @@ -356,6 +356,8 @@ sim_open (SIM_OPEN_KIND kind, host_callback *cb, cpu = STATE_CPU (sd, 0); /* FIXME */ + IS_NANOMIPS = 0; + /* FIXME: watchpoints code shouldn't need this */ STATE_WATCHPOINTS (sd)->interrupt_handler = interrupt_event; @@ -672,10 +674,13 @@ sim_open (SIM_OPEN_KIND kind, host_callback *cb, cpu->register_widths[rn] = WITH_TARGET_FLOATING_POINT_BITSIZE; else if ((rn >= 33) && (rn <= 37)) cpu->register_widths[rn] = WITH_TARGET_WORD_BITSIZE; + else if ((rn >= 70) && (rn <= 78)) + cpu->register_widths[rn] = WITH_TARGET_WORD_BITSIZE; else if ((rn == SRIDX) || (rn == FCR0IDX) || (rn == FCR31IDX) - || ((rn >= 72) && (rn <= 89))) + || (rn == DSPCRIDX) + || ((rn >= 80) && (rn <= 89))) cpu->register_widths[rn] = 32; else cpu->register_widths[rn] = 0; @@ -1200,7 +1205,7 @@ sim_monitor (SIM_DESC sd, case 6: /* int open(char *path,int flags) */ { char *path = fetch_str (sd, A0); - V0 = sim_io_open (sd, path, (int)A1); + SET_RV0 (sim_io_open (sd, path, (int)A1)); free (path); break; } @@ -1210,7 +1215,7 @@ sim_monitor (SIM_DESC sd, int fd = A0; int nr = A2; char *buf = zalloc (nr); - V0 = sim_io_read (sd, fd, buf, nr); + SET_RV0 (sim_io_read (sd, fd, buf, nr)); sim_write (sd, A1, buf, nr); free (buf); } @@ -1222,7 +1227,7 @@ sim_monitor (SIM_DESC sd, int nr = A2; char *buf = zalloc (nr); sim_read (sd, A1, buf, nr); - V0 = sim_io_write (sd, fd, buf, nr); + SET_RV0 (sim_io_write (sd, fd, buf, nr)); if (fd == 1) sim_io_flush_stdout (sd); else if (fd == 2) @@ -1233,14 +1238,14 @@ sim_monitor (SIM_DESC sd, case 10: /* int close(int file) */ { - V0 = sim_io_close (sd, (int)A0); + SET_RV0 (sim_io_close (sd, (int)A0)); break; } case 2: /* Densan monitor: char inbyte(int waitflag) */ { if (A0 == 0) /* waitflag == NOWAIT */ - V0 = (unsigned_word)-1; + SET_RV0 ((unsigned_word)-1); } /* Drop through to case 11 */ @@ -1252,10 +1257,10 @@ sim_monitor (SIM_DESC sd, if (sim_io_read_stdin (sd, &tmp, sizeof(char)) != sizeof(char)) { sim_io_error(sd,"Invalid return from character read"); - V0 = (unsigned_word)-1; + SET_RV0 ((unsigned_word)-1); } else - V0 = (unsigned_word)tmp; + SET_RV0 ((unsigned_word)tmp); break; } diff --git a/sim/mips/micromips16.dc b/sim/mips/micromips16.dc index a1cd9a0ea89..ace9bb94fad 100644 --- a/sim/mips/micromips16.dc +++ b/sim/mips/micromips16.dc @@ -8,4 +8,7 @@ switch,combine : 9 : 6 : : : : : : switch,combine : 9 : 5 : : : : : : + switch,combine : 3 : 0 : : : : : : + switch,combine : 2 : 0 : : : : : : + switch,combine : 5 : 3 : : : : : : switch,combine : 0 : 0 : : : : : : diff --git a/sim/mips/mips.igen b/sim/mips/mips.igen index 0746a52d5ab..e9110c44f2f 100644 --- a/sim/mips/mips.igen +++ b/sim/mips/mips.igen @@ -79,6 +79,9 @@ :model:::micromips32:micromips64: // micromips.igen :model:::micromips64:micromips64: // micromips.igen :model:::micromipsdsp:micromipsdsp: // micromipsdsp.igen +:model:::nanomips32r6:nanomips32r6: // nanomipsr6.igen +:model:::nanomips64r6:nanomips64r6: // nanomipsr6.igen +:model:::nanomipsdsp:nanomipsdsp: // nanompsdsp.igen // Vendor Extensions // @@ -98,6 +101,33 @@ // For grep - RSVD_INSTRUCTION, RSVD_INSTRUCTION_MASK 000000,5.*,5.*,5.*,5.OP,111001:SPECIAL:32::RSVD "rsvd " +*mipsI: +*mipsII: +*mipsIII: +*mipsIV: +*mipsV: +*mips32: +*mips32r2: +*mips32r6: +*mips64: +*mips64r2: +*mips64r6: +*vr4100: +*vr4120: +*vr5000: +*vr5400: +*vr5500: +*r3900: +*mips16: +*mips16e: +*mips3d: +*mdmx: +*dsp: +*dsp2: +*smartmips: +*micromips32: +*micromips64: +*micromipsdsp: { SignalException (ReservedInstruction, instruction_0); } @@ -192,6 +222,7 @@ *vr5000: *r3900: *micromips32: +*nanomips32r6: { return base + offset; } @@ -201,6 +232,7 @@ *mips64r2: *micromips64: *mips64r6: +*nanomips64r6: { #if 0 /* XXX FIXME: enable this only after some additional testing. */ /* If in user mode and UX is not set, use 32-bit compatibility effective @@ -237,6 +269,8 @@ *micromips32: *micromips64: *mips64r6: +*nanomips32r6: +*nanomips64r6: { #if WITH_TARGET_WORD_BITSIZE == 64 return value != (((value & 0xffffffff) ^ 0x80000000) - 0x80000000); @@ -274,6 +308,8 @@ *micromips32: *micromips64: *mips64r6: +*nanomips32r6: +*nanomips64r6: { unpredictable_action (CPU, CIA); } @@ -369,6 +405,7 @@ *r3900: *micromips32: *micromips64: +*nanomipsdsp: { int64_t time = sim_events_time (SD); history->mt.timestamp = time; @@ -399,6 +436,7 @@ *r3900: *micromips32: *micromips64: +*nanomipsdsp: { int64_t time = sim_events_time (SD); int ok = 1; @@ -473,6 +511,7 @@ *r3900: *micromips32: *micromips64: +*nanomipsdsp: { /* FIXME: could record the fact that a stall occured if we want */ int64_t time = sim_events_time (SD); @@ -570,6 +609,8 @@ *micromips64: *micromips32: *mips64r6: +*nanomips32r6: +*nanomips64r6: { #if 0 /* XXX FIXME: enable this only after some additional testing. */ if (UserMode && (SR & (status_UX|status_PX)) == 0) @@ -781,12 +822,44 @@ } :function:::void:do_lb:int rt, int offset, int base +*mipsI: +*mipsII: +*mipsIII: +*mipsIV: +*mipsV: +*mips32: +*mips32r2: +*mips32r6: +*mips64: +*mips64r2: +*mips64r6: +*vr4100: +*vr5000: +*r3900: +*micromips32: +*micromips64: { GPR[rt] = EXTEND8 (do_load (SD_, AccessLength_BYTE, GPR[base], EXTEND16 (offset))); } :function:::void:do_lh:int rt, int offset, int base +*mipsI: +*mipsII: +*mipsIII: +*mipsIV: +*mipsV: +*mips32: +*mips32r2: +*mips32r6: +*mips64: +*mips64r2: +*mips64r6: +*vr4100: +*vr5000: +*r3900: +*micromips32: +*micromips64: { GPR[rt] = EXTEND16 (do_load (SD_, AccessLength_HALFWORD, GPR[base], EXTEND16 (offset))); @@ -811,6 +884,22 @@ } :function:::void:do_lw:int rt, int offset, int base +*mipsI: +*mipsII: +*mipsIII: +*mipsIV: +*mipsV: +*mips32: +*mips32r2: +*mips32r6: +*mips64: +*mips64r2: +*mips64r6: +*vr4100: +*vr5000: +*r3900: +*micromips32: +*micromips64: { GPR[rt] = EXTEND32 (do_load (SD_, AccessLength_WORD, GPR[base], EXTEND16 (offset))); @@ -823,6 +912,22 @@ } :function:::void:do_lhu:int rt, int offset, int base +*mipsI: +*mipsII: +*mipsIII: +*mipsIV: +*mipsV: +*mips32: +*mips32r2: +*mips32r6: +*mips64: +*mips64r2: +*mips64r6: +*vr4100: +*vr5000: +*r3900: +*micromips32: +*micromips64: { GPR[rt] = do_load (SD_, AccessLength_HALFWORD, GPR[base], EXTEND16 (offset)); } @@ -1861,7 +1966,23 @@ -:function:::void:do_addiu:int rs, int rt, uint16_t immediate +:function:::void:do_addiu:int rs, int rt, int immediate +*mipsI: +*mipsII: +*mipsIII: +*mipsIV: +*mipsV: +*mips32: +*mips32r2: +*mips32r6: +*mips64: +*mips64r2: +*mips64r6: +*vr4100: +*vr5000: +*r3900: +*micromips32: +*micromips64: { if (NotWordValue (GPR[rs])) Unpredictable (); @@ -2595,6 +2716,14 @@ :function:::void:do_ddiv:int rs, int rt +*mipsIII: +*mipsIV: +*mipsV: +*mips64: +*mips64r2: +*micromips64: +*vr4100: +*vr5000: { check_div_hilo (SD_, HIHISTORY, LOHISTORY); TRACE_ALU_INPUT2 (GPR[rs], GPR[rt]); @@ -2641,6 +2770,14 @@ :function:::void:do_ddivu:int rs, int rt +*mipsIII: +*mipsIV: +*mipsV: +*mips64: +*mips64r2: +*micromips64: +*vr4100: +*vr5000: { check_div_hilo (SD_, HIHISTORY, LOHISTORY); TRACE_ALU_INPUT2 (GPR[rs], GPR[rt]); @@ -2680,6 +2817,20 @@ } :function:::void:do_div:int rs, int rt +*mipsI: +*mipsII: +*mipsIII: +*mipsIV: +*mipsV: +*mips32: +*mips32r2: +*micromips32: +*mips64: +*mips64r2: +*micromips64: +*vr4100: +*vr5000: +*r3900: { check_div_hilo (SD_, HIHISTORY, LOHISTORY); TRACE_ALU_INPUT2 (GPR[rs], GPR[rt]); @@ -2726,6 +2877,20 @@ :function:::void:do_divu:int rs, int rt +*mipsI: +*mipsII: +*mipsIII: +*mipsIV: +*mipsV: +*mips32: +*mips32r2: +*micromips32: +*mips64: +*mips64r2: +*micromips64: +*vr4100: +*vr5000: +*r3900: { check_div_hilo (SD_, HIHISTORY, LOHISTORY); TRACE_ALU_INPUT2 (GPR[rs], GPR[rt]); @@ -3714,6 +3879,25 @@ :function:::void:do_mfhi:int rd +*mipsI: +*mipsII: +*mipsIII: +*mipsIV: +*mipsV: +*vr4100: +*vr5000: +*r3900: +*mips32: +*mips64: +*mips32r2: +*mips32r6: +*mips64r2: +*mips64r6: +*dsp: +*micromips32: +*micromips64: +*micromipsdsp: +*nanomipsdsp: { check_mf_hilo (SD_, HIHISTORY, LOHISTORY); TRACE_ALU_INPUT1 (HI); @@ -5225,6 +5409,8 @@ *vr4100: *vr5000: *r3900: +*nanomips32r6: +*nanomips64r6: { /* None of these ISAs support Paired Single, so just fall back to the single/double check. */ @@ -5273,6 +5459,8 @@ *r3900: *micromips32: *micromips64: +*nanomips32r6: +*nanomips64r6: { if (! COP_Usable (1)) SignalExceptionCoProcessorUnusable (1); @@ -6867,4 +7055,5 @@ :include:::smartmips.igen :include:::micromips.igen :include:::micromipsdsp.igen - +:include:::nanomipsr6.igen +:include:::nanomipsdsp.igen diff --git a/sim/mips/nanomipsdsp.igen b/sim/mips/nanomipsdsp.igen new file mode 100644 index 00000000000..07fd26b6ad0 --- /dev/null +++ b/sim/mips/nanomipsdsp.igen @@ -0,0 +1,1115 @@ +// Simulator definition for the micromips ASE. +// Copyright (C) 2018-2022 Free Software Foundation, Inc. +// Contributed by Imagination Technologies, Ltd. +// Written by Ali Lown +// +// This file is part of GDB, the GNU debugger. +// +// This program is free software; you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation; either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +001000,5.RT,5.RS,0001000100111111:POOL32A:32::ABSQ_S.PH +"absq_s.ph r, r" +*nanomipsdsp: +{ + do_ph_s_absq (SD_, RT, RS); +} + +001000,5.RT,5.RS,0000000100111111:POOL32A:32::ABSQ_S.QB +"absq_s.qb r, r" +*nanomipsdsp: +{ + do_qb_s_absq (SD_, RT, RS); +} + +001000,5.RT,5.RS,0010000100111111:POOL32A:32::ABSQ_S.W +"absq_s.w r, r" +*nanomipsdsp: +{ + do_w_s_absq (SD_, RT, RS); +} + +001000,5.RT,5.RS,5.RD,00000001101:POOL32A:32::ADDQ.PH +"addq.ph r, r, r" +*nanomipsdsp: +{ + do_ph_op (SD_, RD, RS, RT, 0, 0); +} + +001000,5.RT,5.RS,5.RD,10000001101:POOL32A:32::ADDQ_S.PH +"addq_s.ph r, r, r" +*nanomipsdsp: +{ + do_ph_op (SD_, RD, RS, RT, 0, 1); +} + +001000,5.RT,5.RS,5.RD,1.X,1100000101:POOL32A:32::ADDQ_S.W +"addq_s.w r, r, r" +*nanomipsdsp: +{ + do_w_op (SD_, RD, RS, RT, 0); +} + +001000,5.RT,5.RS,5.RD,00001001101:POOL32A:32::ADDQH.PH +"addqh.ph r, r, r" +*nanomipsdsp: +{ + do_qh_ph_op (SD_, RD, RS, RT, 0, 0); +} + +001000,5.RT,5.RS,5.RD,10001001101:POOL32A:32::ADDQH_R.PH +"addqh_r.ph r, r, r" +*nanomipsdsp: +{ + do_qh_ph_op (SD_, RD, RS, RT, 0, 1); +} + +001000,5.RT,5.RS,5.RD,00010001101:POOL32A:32::ADDQH.W +"addqh.w r, r, r" +*nanomipsdsp: +{ + do_qh_w_op (SD_, RD, RS, RT, 0, 0); +} + +001000,5.RT,5.RS,5.RD,10010001101:POOL32A:32::ADDQH_R.W +"addqh_r.w r, r, r" +*nanomipsdsp: +{ + do_qh_w_op (SD_, RD, RS, RT, 0, 1); +} + +001000,5.RT,5.RS,5.RD,1.X,1110000101:POOL32A:32::ADDSC +"addsc r, r, r" +*nanomipsdsp: +{ + do_addsc (SD_, RD, RS, RT); +} + +001000,5.RT,5.RS,5.RD,00100001101:POOL32A:32::ADDU.PH +"addu.ph r, r, r" +*nanomipsdsp: +{ + do_u_ph_op (SD_, RD, RS, RT, 0, 0); +} + +001000,5.RT,5.RS,5.RD,10100001101:POOL32A:32::ADDU_S.PH +"addu_s.ph r, r, r" +*nanomipsdsp: +{ + do_u_ph_op (SD_, RD, RS, RT, 0, 1); +} + +001000,5.RT,5.RS,5.RD,00011001101:POOL32A:32::ADDU.QB +"addu.qb r, r, r" +*nanomipsdsp: +{ + do_qb_op (SD_, RD, RS, RT, 0, 0); +} + +001000,5.RT,5.RS,5.RD,10011001101:POOL32A:32::ADDU_S.QB +"addu_s.qb r, r, r" +*nanomipsdsp: +{ + do_qb_op (SD_, RD, RS, RT, 0, 1); +} + +001000,5.RT,5.RS,5.RD,1.X,1111000101:POOL32A:32::ADDWC +"addwc r, r, r" +*nanomipsdsp: +{ + do_addwc (SD_, RD, RS, RT); +} + +001000,5.RT,5.RS,5.RD,00101001101:POOL32A:32::ADDUH.QB +"adduh.qb r, r, r" +*nanomipsdsp: +{ + do_uh_qb_op (SD_, RD, RS, RT, 0, 0); +} + +001000,5.RT,5.RS,5.RD,10101001101:POOL32A:32::ADDUH_R.QB +"adduh_r.qb r, r, r" +*nanomipsdsp: +{ + do_uh_qb_op (SD_, RD, RS, RT, 0, 1); +} + +001000,5.RT,5.RS,5.SA,1.X,1000010101:POOL32A:32::APPEND +"append r, r, " +*nanomipsdsp: +{ + do_append (SD_, RT, RS, SA); +} + +001000,5.RT,5.RS,2.BP,00100010111111:POOL32A:32::BALIGN +"balign r, r, " +*nanomipsdsp: +{ + do_balign (SD_, RT, RS, BP); +} + +001000,5.RT,5.RS,0011000100111111:POOL32A:32::BITREV +"bitrev r, r" +*nanomipsdsp: +{ + do_bitrev (SD_, RT, RS); +} + +100010,5.X,0010001,13.S1,1.S2:POOL32I:32::BPOSGE32C +"bposge32c " +*nanomipsdsp: +{ + uint32_t pos = (DSPCR >> DSPCR_POS_SHIFT) & DSPCR_POS_MASK; + if (pos >= 32) + NIA = ADDRESS15; +} + +001000,5.RT,5.RS,6.X,0000000101:POOL32A:32::CMP.EQ.PH +"cmp.eq.ph r, r" +*nanomipsdsp: +{ + do_ph_cmpu (SD_, RS, RT, 0); +} + +001000,5.RT,5.RS,0000000001,000101:POOL32A:32::CMP.LT.PH +"cmp.lt.ph r, r" +*nanomipsdsp: +{ + do_ph_cmpu (SD_, RS, RT, 1); +} + +001000,5.RT,5.RS,0000000010,000101:POOL32A:32::CMP.LE.PH +"cmp.le.ph r, r" +*nanomipsdsp: +{ + do_ph_cmpu (SD_, RS, RT, 2); +} + +001000,5.RT,5.RS,5.RD,1.X,0110000101:POOL32A:32::CMPGDU.EQ.QB +"cmpgdu.eq.qb r, r, r" +*nanomipsdsp: +{ + do_qb_cmpgdu (SD_, RD, RS, RT, 0); +} + +001000,5.RT,5.RS,5.RD,1.X,0111000101:POOL32A:32::CMPGDU.LT.QB +"cmpgdu.lt.qb r, r, r" +*nanomipsdsp: +{ + do_qb_cmpgdu (SD_, RD, RS, RT, 1); +} + +001000,5.RT,5.RS,5.RD,1.X,1000000101:POOL32A:32::CMPGDU.LE.QB +"cmpgdu.le.qb r, r, r" +*nanomipsdsp: +{ + do_qb_cmpgdu (SD_, RD, RS, RT, 2); +} + +001000,5.RT,5.RS,5.RD,1.X,0011000101:POOL32A:32::CMPGU.EQ.QB +"cmpgu.eq.qb r, r, r" +*nanomipsdsp: +{ + do_qb_cmpgu (SD_, RD, RS, RT, 0); +} + +001000,5.RT,5.RS,5.RD,1.X,0100000101:POOL32A:32::CMPGU.LT.QB +"cmpgu.lt.qb r, r, r" +*nanomipsdsp: +{ + do_qb_cmpgu (SD_, RD, RS, RT, 1); +} + +001000,5.RT,5.RS,5.RD,1.X,0101000101:POOL32A:32::CMPGU.LE.QB +"cmpgu.le.qb r, r, r" +*nanomipsdsp: +{ + do_qb_cmpgu (SD_, RD, RS, RT, 2); +} + +001000,5.RT,5.RS,5.X1,1.X2,1001000101:POOL32A:32::CMPU.EQ.QB +"cmpu.eq.qb r, r" +*nanomipsdsp: +{ + do_qb_cmpu (SD_, RS, RT, 0); +} + +001000,5.RT,5.RS,5.X1,1.X2,1010000101:POOL32A:32::CMPU.LT.QB +"cmpu.lt.qb r, r" +*nanomipsdsp: +{ + do_qb_cmpu (SD_, RS, RT, 1); +} + +001000,5.RT,5.RS,5.X1,1.X2,1011000101:POOL32A:32::CMPU.LE.QB +"cmpu.le.qb r, r" +*nanomipsdsp: +{ + do_qb_cmpu (SD_, RS, RT, 2); +} + +001000,5.RT,5.RS,2.AC,00000010111111:POOL32A:32::DPA.W.PH +"dpa.w.ph ac, r, r" +*nanomipsdsp: +{ + do_w_ph_dot_product (SD_, AC, RS, RT, 0); +} + +001000,5.RT,5.RS,2.AC,00001010111111:POOL32A:32::DPAQ_S.W.PH +"dpaq_s.w.ph ac, r, r" +*nanomipsdsp: +{ + do_ph_dot_product (SD_, AC, RS, RT, 0); +} + +001000,5.RT,5.RS,2.AC,01001010111111:POOL32A:32::DPAQ_SA.L.W +"dpaq_sa.l.w ac, r, r" +*nanomipsdsp: +{ + do_w_dot_product (SD_, AC, RS, RT, 0); +} + +001000,5.RT,5.RS,2.AC,10001010111111:POOL32A:32::DPAQX_S.W.PH +"dpaqx_s.w.ph ac, r, r" +*nanomipsdsp: +{ + do_qx_w_ph_dot_product (SD_, AC, RS, RT, 0, 0); +} + +001000,5.RT,5.RS,2.AC,11001010111111:POOL32A:32::DPAQX_SA.W.PH +"dpaqx_sa.w.ph ac, r, r" +*nanomipsdsp: +{ + do_qx_w_ph_dot_product (SD_, AC, RS, RT, 0, 1); +} + +001000,5.RT,5.RS,2.AC,10000010111111:POOL32A:32::DPAU.H.QBL +"dpau.h.qbl ac, r, r" +*nanomipsdsp: +{ + do_qb_dot_product (SD_, AC, RS, RT, 0, 0); +} + +001000,5.RT,5.RS,2.AC,11000010111111:POOL32A:32::DPAU.H.QBR +"dpau.h.qbr ac, r, r" +*nanomipsdsp: +{ + do_qb_dot_product (SD_, AC, RS, RT, 0, 1); +} + +001000,5.RT,5.RS,2.AC,01000010111111:POOL32A:32::DPAX.W.PH +"dpax.w.ph ac, r, r" +*nanomipsdsp: +{ + do_x_w_ph_dot_product (SD_, AC, RS, RT, 0); +} + +001000,5.RT,5.RS,2.AC,00010010111111:POOL32A:32::DPS.W.PH +"dps.w.ph ac, r, r" +*nanomipsdsp: +{ + do_w_ph_dot_product (SD_, AC, RS, RT, 1); +} + +001000,5.RT,5.RS,2.AC,00011010111111:POOL32A:32::DPSQ_S.W.PH +"dpsq_s.w.ph ac, r, r" +*nanomipsdsp: +{ + do_ph_dot_product (SD_, AC, RS, RT, 1); +} + +001000,5.RT,5.RS,2.AC,01011010111111:POOL32A:32::DPSQ_SA.L.W +"dpsq_sa.l.w ac, r, r" +*nanomipsdsp: +{ + do_w_dot_product (SD_, AC, RS, RT, 1); +} + +001000,5.RT,5.RS,2.AC,10011010111111:POOL32A:32::DPSQX_S.W.PH +"dpsqx_s.w.ph ac, r, r" +*nanomipsdsp: +{ + do_qx_w_ph_dot_product (SD_, AC, RS, RT, 1, 0); +} + +001000,5.RT,5.RS,2.AC,11011010111111:POOL32A:32::DPSQX_SA.W.PH +"dpsqx_sa.w.ph ac, r, r" +*nanomipsdsp: +{ + do_qx_w_ph_dot_product (SD_, AC, RS, RT, 1, 1); +} + +001000,5.RT,5.RS,2.AC,10010010111111:POOL32A:32::DPSU.H.QBL +"dpsu.h.qbl ac, r, r" +*nanomipsdsp: +{ + do_qb_dot_product (SD_, AC, RS, RT, 1, 0); +} + +001000,5.RT,5.RS,2.AC,11010010111111:POOL32A:32::DPSU.H.QBR +"dpsu.h.qbr ac, r, r" +*nanomipsdsp: +{ + do_qb_dot_product (SD_, AC, RS, RT, 1, 1); +} + +001000,5.RT,5.RS,2.AC,01010010111111:POOL32A:32::DPSX.W.PH +"dpsx.w.ph ac, r, r" +*nanomipsdsp: +{ + do_x_w_ph_dot_product (SD_, AC, RS, RT, 1); +} + +001000,5.RT,5.SIZE,2.AC,10011001111111:POOL32A:32::EXTP +"extp r, ac, " +*nanomipsdsp: +{ + do_extp (SD_, RT, AC, SIZE, 0); +} + +001000,5.RT,5.SIZE,2.AC,11011001111111:POOL32A:32::EXTPDP +"extpdp r, ac, " +*nanomipsdsp: +{ + do_extp (SD_, RT, AC, SIZE, 1); +} + +001000,5.RT,5.RS,2.AC,11100010111111:POOL32A:32::EXTPDPV +"extpdpv r, ac, r" +*nanomipsdsp: +{ + do_extpv (SD_, RT, AC, RS, 1); +} + +001000,5.RT,5.RS,2.AC,10100010111111:POOL32A:32::EXTPV +"extpv r, ac, r" +*nanomipsdsp: +{ + do_extpv (SD_, RT, AC, RS, 0); +} + +001000,5.RT,5.SHIFT,2.AC,00111001111111:POOL32A:32::EXTR.W +"extr.w r, ac, " +*nanomipsdsp: +{ + do_w_extr (SD_, RT, AC, SHIFT, 0); +} + +001000,5.RT,5.SHIFT,2.AC,01111001111111:POOL32A:32::EXTR_R.W +"extr_r.w r, ac, " +*nanomipsdsp: +{ + do_w_extr (SD_, RT, AC, SHIFT, 1); +} + +001000,5.RT,5.SHIFT,2.AC,10111001111111:POOL32A:32::EXTR_RS.W +"extr_rs.w r, ac, " +*nanomipsdsp: +{ + do_w_extr (SD_, RT, AC, SHIFT, 2); +} + +001000,5.RT,5.SHIFT,2.AC,11111001111111:POOL32A:32::EXTR_S.H +"extr_s.h r, ac, " +*nanomipsdsp: +{ + do_h_extr (SD_, RT, AC, SHIFT); +} + +001000,5.RT,5.RS,2.AC,00111010111111:POOL32A:32::EXTRV.W +"extrv.w r, ac, r" +*nanomipsdsp: +{ + do_extrv (SD_, RT, AC, RS, 0); +} + +001000,5.RT,5.RS,2.AC,01111010111111:POOL32A:32::EXTRV_R.W +"extrv_r.w r, ac, r" +*nanomipsdsp: +{ + do_extrv (SD_, RT, AC, RS, 1); +} + +001000,5.RT,5.RS,2.AC,10111010111111:POOL32A:32::EXTRV_RS.W +"extrv_rs.w r, ac, r" +*nanomipsdsp: +{ + do_extrv (SD_, RT, AC, RS, 2); +} + +001000,5.RT,5.RS,2.AC,11111010111111:POOL32A:32::EXTRV_S.H +"extrv_s.h r, ac, r" +*nanomipsdsp: +{ + do_extrv_s_h (SD_, RT, AC, RS); +} + +001000,5.RT,5.RS,0100000100111111:POOL32A:32::INSV +"insv r, r" +*nanomipsdsp: +{ + do_insv (SD_, RT, RS); +} + +001000,5.RT,5.RS,2.AC,00101010111111:POOL32A:32::MADD_DSP +"madd ac, r, r" +*nanomipsdsp: +{ + do_dsp_madd (SD_, AC, RS, RT); +} + +001000,5.RT,5.RS,2.AC,01101010111111:POOL32A:32::MADDU_DSP +"maddu ac, r, r" +*nanomipsdsp: +{ + do_dsp_maddu (SD_, AC, RS, RT); +} + +001000,5.RT,5.RS,2.AC,01101001111111:POOL32A:32::MAQ_S.W.PHL +"maq_s.w.phl ac, r, r" +*nanomipsdsp: +{ + do_ph_maq (SD_, AC, RS, RT, 0, 0); +} + +001000,5.RT,5.RS,2.AC,11101001111111:POOL32A:32::MAQ_SA.W.PHL +"maq_sa.w.phl ac, r, r" +*nanomipsdsp: +{ + do_ph_maq (SD_, AC, RS, RT, 1, 0); +} + +001000,5.RT,5.RS,2.AC,00101001111111:POOL32A:32::MAQ_S.W.PHR +"maq_s.w.phr ac, r, r" +*nanomipsdsp: +{ + do_ph_maq (SD_, AC, RS, RT, 0, 1); +} + +001000,5.RT,5.RS,2.AC,10101001111111:POOL32A:32::MAQ_SA.W.PHR +"maq_sa.w.phr ac, r, r" +*nanomipsdsp: +{ + do_ph_maq (SD_, AC, RS, RT, 1, 1); +} + +001000,5.RS,5.X,2.AC,00000001111111:POOL32A:32::MFHI_DSP +"mfhi r, ac" +*nanomipsdsp: +{ + do_dsp_mfhi (SD_, AC, RS); +} + +001000,5.RS,5.X,2.AC,01000001111111:POOL32A:32::MFLO_DSP +"mflo r, ac" +*nanomipsdsp: +{ + do_dsp_mflo (SD_, AC, RS); +} + +001000,5.RT,5.RS,5.RD,1.X,1010010101:POOL32A:32::MODSUB +"modsub r, r, r" +*nanomipsdsp: +{ + do_modsub (SD_, RD, RS, RT); +} + +001000,5.RT,5.RS,2.AC,10101010111111:POOL32A:32::MSUB_DSP +"msub ac, r, r" +*nanomipsdsp: +{ + do_dsp_msub (SD_, AC, RS, RT); +} + +001000,5.RT,5.RS,2.AC,11101010111111:POOL32A:32::MSUBU_DSP +"msubu ac, r, r" +*nanomipsdsp: +{ + do_dsp_msubu (SD_, AC, RS, RT); +} + +001000,00000,5.RS,2.AC,10000001111111:POOL32A:32::MTHI_DSP +"mthi r, ac" +*nanomipsdsp: +{ + do_dsp_mthi (SD_, AC, RS); +} + +001000,00000,5.RS,2.AC,00001001111111:POOL32A:32::MTHLIP +"mthlip r, ac" +*nanomipsdsp: +{ + do_mthlip (SD_, RS, AC); +} + +001000,00000,5.RS,2.AC,11000001111111:POOL32A:32::MTLO_DSP +"mtlo r, ac" +*nanomipsdsp: +{ + do_dsp_mtlo (SD_, AC, RS); +} + +001000,5.RT,5.RS,5.RD,00000101101:POOL32A:32::MUL.PH +"mul.ph r, r, r" +*nanomipsdsp: +{ + do_ph_op (SD_, RD, RS, RT, 2, 0); +} + +001000,5.RT,5.RS,5.RD,10000101101:POOL32A:32::MUL_S.PH +"mul_s.ph r, r, r" +*nanomipsdsp: +{ + do_ph_op (SD_, RD, RS, RT, 2, 1); +} + +001000,5.RT,5.RS,5.RD,1.X,0000100101:POOL32A:32::MULEQ_S.W.PHL +"muleq_s.w.phl r, r, r" +*nanomipsdsp: +{ + do_ph_muleq (SD_, RD, RS, RT, 0); +} + +001000,5.RT,5.RS,5.RD,1.X,0001100101:POOL32A:32::MULEQ_S.W.PHR +"muleq_s.w.phr r, r, r" +*nanomipsdsp: +{ + do_ph_muleq (SD_, RD, RS, RT, 1); +} + +001000,5.RT,5.RS,5.RD,1.X,0010010101:POOL32A:32::MULEU_S.PH.QBL +"muleu_s.ph.qbl r, r, r" +*nanomipsdsp: +{ + do_qb_muleu (SD_, RD, RS, RT, 0); +} + +001000,5.RT,5.RS,5.RD,1.X,0011010101:POOL32A:32::MULEU_S.PH.QBR +"muleu_s.ph.qbr r, r, r" +*nanomipsdsp: +{ + do_qb_muleu (SD_, RD, RS, RT, 1); +} + +001000,5.RT,5.RS,5.RD,1.X,0100010101:POOL32A:32::MULQ_RS.PH +"mulq_rs.ph r, r, r" +*nanomipsdsp: +{ + do_ph_mulq (SD_, RD, RS, RT, 1); +} + +001000,5.RT,5.RS,5.RD,1.X,0110010101:POOL32A:32::MULQ_RS.W +"mulq_rs.w r, r, r" +*nanomipsdsp: +{ + do_w_mulq (SD_, RD, RS, RT, 1); +} + +001000,5.RT,5.RS,5.RD,1.X,0101010101:POOL32A:32::MULQ_S.PH +"mulq_s.ph r, r, r" +*nanomipsdsp: +{ + do_ph_mulq (SD_, RD, RS, RT, 0); +} + +001000,5.RT,5.RS,5.RD,1.X,0111010101:POOL32A:32::MULQ_S.W +"mulq_s.w r, r, r" +*nanomipsdsp: +{ + do_w_mulq (SD_, RD, RS, RT, 0); +} + +001000,5.RT,5.RS,2.AC,10110010111111:POOL32A:32::MULSA.W.PH +"mulsa.w.ph ac, r, r" +*nanomipsdsp: +{ + do_ph_w_mulsa (SD_, AC, RS, RT); +} + +001000,5.RT,5.RS,2.AC,11110010111111:POOL32A:32::MULSAQ_S.W.PH +"mulsaq_s.w.ph ac, r, r" +*nanomipsdsp: +{ + do_mulsaq_s_w_ph (SD_, AC, RS, RT); +} + +001000,5.RT,5.RS,2.AC,00110010111111:POOL32A:32::MULT_DSP +"mult ac, r, r" +*nanomipsdsp: +{ + do_dsp_mult (SD_, AC, RS, RT); +} + +001000,5.RT,5.RS,2.AC,01110010111111:POOL32A:32::MULTU_DSP +"multu ac, r, r" +*nanomipsdsp: +{ + do_dsp_multu (SD_, AC, RS, RT); +} + +001000,5.RT,5.RS,5.RD,1.X,0110101101:POOL32A:32::PACKRL.PH +"packrl.ph r, r, r" +*nanomipsdsp: +{ + do_ph_packrl (SD_, RD, RS, RT); +} + +001000,5.RT,5.RS,5.RD,1.X,1000101101:POOL32A:32::PICK.PH +"pick.ph r, r, r" +*nanomipsdsp: +{ + do_ph_pick (SD_, RD, RS, RT); +} + +001000,5.RT,5.RS,5.RD,1.X,0111101101:POOL32A:32::PICK.QB +"pick.qb r, r, r" +*nanomipsdsp: +{ + do_qb_pick (SD_, RD, RS, RT); +} + +001000,5.RT,5.RS,0101000100111111:POOL32A:32::PRECEQ.W.PHL +"preceq.w.phl r, r" +*nanomipsdsp: +{ + do_w_preceq (SD_, RT, RS, 0); +} + +001000,5.RT,5.RS,0110000100111111:POOL32A:32::PRECEQ.W.PHR +"preceq.w.phr r, r" +*nanomipsdsp: +{ + do_w_preceq (SD_, RT, RS, 1); +} + +001000,5.RT,5.RS,0111000100111111:POOL32A:32::PRECEQU.PH.QBL +"precequ.ph.qbl r, r" +*nanomipsdsp: +{ + do_qb_ph_precequ (SD_, RT, RS, 2); +} + +001000,5.RT,5.RS,0111001100111111:POOL32A:32::PRECEQU.PH.QBLA +"precequ.ph.qbla r, r" +*nanomipsdsp: +{ + do_qb_ph_precequ (SD_, RT, RS, 3); +} + +001000,5.RT,5.RS,1001000100111111:POOL32A:32::PRECEQU.PH.QBR +"precequ.ph.qbr r, r" +*nanomipsdsp: +{ + do_qb_ph_precequ (SD_, RT, RS, 0); +} + +001000,5.RT,5.RS,1001001100111111:POOL32A:32::PRECEQU.PH.QBRA +"precequ.ph.qbra r, r" +*nanomipsdsp: +{ + do_qb_ph_precequ (SD_, RT, RS, 1); +} + +001000,5.RT,5.RS,1011000100111111:POOL32A:32::PRECEU.PH.QBL +"preceu.ph.qbl r, r" +*nanomipsdsp: +{ + do_qb_ph_preceu (SD_, RT, RS, 2); +} + +001000,5.RT,5.RS,1011001100111111:POOL32A:32::PRECEU.PH.QBLA +"preceu.ph.qbla r, r" +*nanomipsdsp: +{ + do_qb_ph_preceu (SD_, RT, RS, 3); +} + +001000,5.RT,5.RS,1101000100111111:POOL32A:32::PRECEU.PH.QBR +"preceu.ph.qbr r, r" +*nanomipsdsp: +{ + do_qb_ph_preceu (SD_, RT, RS, 0); +} + +001000,5.RT,5.RS,1101001100111111:POOL32A:32::PRECEU.PH.QBRA +"preceu.ph.qbra r, r" +*nanomipsdsp: +{ + do_qb_ph_preceu (SD_, RT, RS, 1); +} + +001000,5.RT,5.RS,5.RD,1.X,0001101101:POOL32A:32::PRECR.QB.PH +"precr.qb.ph r, r, r" +*nanomipsdsp: +{ + do_ph_qb_precr (SD_, RD, RS, RT); +} + +001000,5.RT,5.RS,5.SA,01111001101:POOL32A:32::PRECR_SRA.PH.W +"precr_sra.ph.w r, r, " +*nanomipsdsp: +{ + do_precr_sra (SD_, RT, RS, SA, 0); +} + +001000,5.RT,5.RS,5.SA,11111001101:POOL32A:32::PRECR_SRA_R.PH.W +"precr_sra_r.ph.w r, r, " +*nanomipsdsp: +{ + do_precr_sra (SD_, RT, RS, SA, 1); +} + +001000,5.RT,5.RS,5.RD,1.X,0011101101:POOL32A:32::PRECRQ.PH.W +"precrq.ph.w r, r, r" +*nanomipsdsp: +{ + do_w_ph_precrq (SD_, RD, RS, RT); +} + +001000,5.RT,5.RS,5.RD,1.X,0010101101:POOL32A:32::PRECRQ.QB.PH +"precrq.qb.ph r, r, r" +*nanomipsdsp: +{ + do_ph_qb_precrq (SD_, RD, RS, RT, 0); +} + +001000,5.RT,5.RS,5.RD,1.X,0101101101:POOL32A:32::PRECRQU_S.QB.PH +"precrqu_s.qb.ph r, r, r" +*nanomipsdsp: +{ + do_ph_qb_precrq (SD_, RD, RS, RT, 1); +} + +001000,5.RT,5.RS,5.RD,1.X,0100101101:POOL32A:32::PRECRQ_RS.PH.W +"precrq_rs.ph.w r, r, r" +*nanomipsdsp: +{ + do_w_ph_rs_precrq (SD_, RD, RS, RT); +} + +001000,5.RT,5.RS,5.SA,1.X,1001010101:POOL32A:32::PREPEND +"prepend r, r, " +*nanomipsdsp: +{ + do_prepend (SD_, RT, RS, SA); +} + +001000,5.RT,5.RS,1111000100111111:POOL32A:32::RADDU.W.QB +"raddu.w.qb r, r" +*nanomipsdsp: +{ + do_qb_w_raddu (SD_, RT, RS); +} + +001000,5.RT,7.CONTROL_MASK,00011001111111:POOL32A:32::RDDSP +"rddsp r":CONTROL_MASK == 1111111111 +"rddsp r, " +*nanomipsdsp: +{ + do_rddsp (SD_, RT, CONTROL_MASK); +} + +001000,5.RT,10.IMMEDIATE,1.X,0000111101:POOL32A:32::REPL.PH +"repl.ph r, " +*nanomipsdsp: +{ + do_repl (SD_, RT, IMMEDIATE, 2); +} + +001000,5.RT,8.IMMEDIATE,1.X,010111111111:POOL32A:32::REPL.QB +"repl.qb r, " +*nanomipsdsp: +{ + do_repl (SD_, RT, IMMEDIATE, 0); +} + +001000,5.RT,5.RS,0000001100111111:POOL32A:32::REPLV.PH +"replv.ph r, r" +*nanomipsdsp: +{ + do_repl (SD_, RT, RS, 3); +} + +001000,5.RT,5.RS,0001001100111111:POOL32A:32::REPLV.QB +"replv.qb r, r" +*nanomipsdsp: +{ + do_repl (SD_, RT, RS, 1); +} + +001000,0000,6.IMMEDIATE,2.AC,00000000011101:POOL32A:32::SHILO +"shilo ac, " +*nanomipsdsp: +{ + do_shilo (SD_, AC, IMMEDIATE); +} + +001000,00000,5.RS,2.AC,01001001111111:POOL32A:32::SHILOV +"shilov ac, r" +*nanomipsdsp: +{ + do_shilov (SD_, AC, RS); +} + +001000,5.RT,5.RS,4.SHIFT,001110110101:POOL32A:32::SHLL.PH +"shll.ph r, r, " +*nanomipsdsp: +{ + do_ph_shift (SD_, RT, RS, SHIFT, 0, 0); +} + +001000,5.RT,5.RS,4.SHIFT,101110110101:POOL32A:32::SHLL_S.PH +"shll_s.ph r, r, " +*nanomipsdsp: +{ + do_ph_shift (SD_, RT, RS, SHIFT, 0, 1); +} + +001000,5.RT,5.RS,3.SHIFT,0100001111111:POOL32A:32::SHLL.QB +"shll.qb r, r, " +*nanomipsdsp: +{ + do_qb_shift (SD_, RT, RS, SHIFT, 0); +} + +001000,5.RT,5.RS,5.RD,01110001101:POOL32A:32::SHLLV.PH +"shllv.ph r, r, r" +*nanomipsdsp: +{ + do_ph_shl (SD_, RD, RT, RS, 0, 0); +} + +001000,5.RT,5.RS,5.RD,11110001101:POOL32A:32::SHLLV_S.PH +"shllv_s.ph r, r, r" +*nanomipsdsp: +{ + do_ph_shl (SD_, RD, RT, RS, 0, 1); +} + +001000,5.RT,5.RS,5.RD,1.X,1110010101:POOL32A:32::SHLLV.QB +"shllv.qb r, r, r" +*nanomipsdsp: +{ + do_qb_shl (SD_, RD, RT, RS, 0); +} + +001000,5.RT,5.RS,5.RD,1.X,1111010101:POOL32A:32::SHLLV_S.W +"shllv_s.w r, r, r" +*nanomipsdsp: +{ + do_w_s_shllv (SD_, RD, RT, RS); +} + +001000,5.RT,5.RS,5.SHIFT,1.X,1111110101:POOL32A:32::SHLL_S.W +"shll_s.w r, r, " +*nanomipsdsp: +{ + do_w_shll (SD_, RT, RS, SHIFT); +} + +001000,5.RT,5.RS,3.SHIFT,0000111111111:POOL32A:32::SHRA.QB +"shra.qb r, r, " +*nanomipsdsp: +{ + do_qb_shra (SD_, RT, RS, SHIFT, 0); +} + +001000,5.RT,5.RS,3.SHIFT,1000111111111:POOL32A:32::SHRA_R.QB +"shra_r.qb r, r, " +*nanomipsdsp: +{ + do_qb_shra (SD_, RT, RS, SHIFT, 1); +} + +001000,5.RT,5.RS,4.SHIFT,1.X,01100110101:POOL32A:32::SHRA.PH +"shra.ph r, r, " +*nanomipsdsp: +{ + do_ph_shift (SD_, RT, RS, SHIFT, 1, 0); +} + +001000,5.RT,5.RS,4.SHIFT,1.X,11100110101:POOL32A:32::SHRA_R.PH +"shra_r.ph r, r, " +*nanomipsdsp: +{ + do_ph_shift (SD_, RT, RS, SHIFT, 1, 1); +} + +001000,5.RT,5.RS,5.RD,00110001101:POOL32A:32::SHRAV.PH +"shrav.ph r, r, r" +*nanomipsdsp: +{ + do_ph_shl (SD_, RD, RT, RS, 1, 0); +} + +001000,5.RT,5.RS,5.RD,10110001101:POOL32A:32::SHRAV_R.PH +"shrav_r.ph r, r, r" +*nanomipsdsp: +{ + do_ph_shl (SD_, RD, RT, RS, 1, 1); +} + +001000,5.RT,5.RS,5.RD,00111001101:POOL32A:32::SHRAV.QB +"shrav.qb r, r, r" +*nanomipsdsp: +{ + do_qb_shrav (SD_, RD, RT, RS, 0); +} + +001000,5.RT,5.RS,5.RD,10111001101:POOL32A:32::SHRAV_R.QB +"shrav_r.qb r, r, r" +*nanomipsdsp: +{ + do_qb_shrav (SD_, RD, RT, RS, 1); +} + +001000,5.RT,5.RS,5.RD,1.X,1011010101:POOL32A:32::SHRAV_R.W +"shrav_r.w r, r, r" +*nanomipsdsp: +{ + do_w_r_shrav (SD_, RD, RT, RS); +} + +001000,5.RT,5.RS,5.SHIFT,1.X,1011110101:POOL32A:32::SHRA_R.W +"shra_r.w r, r, " +*nanomipsdsp: +{ + do_w_shra (SD_, RT, RS, SHIFT); +} + +001000,5.RT,5.RS,4.SHIFT,001111111111:POOL32A:32::SHRL.PH +"shrl.ph r, r, " +*nanomipsdsp: +{ + do_ph_shrl (SD_, RT, RS, SHIFT); +} + +001000,5.RT,5.RS,3.SHIFT,1100001111111:POOL32A:32::SHRL.QB +"shrl.qb r, r, " +*nanomipsdsp: +{ + do_qb_shift (SD_, RT, RS, SHIFT, 1); +} + +001000,5.RT,5.RS,5.RD,1.X,1100010101:POOL32A:32::SHRLV.PH +"shrlv.ph r, r, r" +*nanomipsdsp: +{ + do_ph_shrlv (SD_, RD, RT, RS); +} + +001000,5.RT,5.RS,5.RD,1.X,1101010101:POOL32A:32::SHRLV.QB +"shrlv.qb r, r, r" +*nanomipsdsp: +{ + do_qb_shl (SD_, RD, RT, RS, 1); +} + +001000,5.RT,5.RS,5.RD,01000001101:POOL32A:32::SUBQ.PH +"subq.ph r, r, r" +*nanomipsdsp: +{ + do_ph_op (SD_, RD, RS, RT, 1, 0); +} + +001000,5.RT,5.RS,5.RD,11000001101:POOL32A:32::SUBQ_S.PH +"subq_s.ph r, r, r" +*nanomipsdsp: +{ + do_ph_op (SD_, RD, RS, RT, 1, 1); +} + +001000,5.RT,5.RS,5.RD,1.X,1101000101:POOL32A:32::SUBQ_S.W +"subq_s.w r, r, r" +*nanomipsdsp: +{ + do_w_op (SD_, RD, RS, RT, 1); +} + +001000,5.RT,5.RS,5.RD,01001001101:POOL32A:32::SUBQH.PH +"subqh.ph r, r, r" +*nanomipsdsp: +{ + do_qh_ph_op (SD_, RD, RS, RT, 1, 0); +} + +001000,5.RT,5.RS,5.RD,11001001101:POOL32A:32::SUBQH_R.PH +"subqh_r.ph r, r, r" +*nanomipsdsp: +{ + do_qh_ph_op (SD_, RD, RS, RT, 1, 1); +} + +001000,5.RT,5.RS,5.RD,01010001101:POOL32A:32::SUBQH.W +"subqh.w r, r, r" +*nanomipsdsp: +{ + do_qh_w_op (SD_, RD, RS, RT, 1, 0); +} + +001000,5.RT,5.RS,5.RD,11010001101:POOL32A:32::SUBQH_R.W +"subqh_r.w r, r, r" +*nanomipsdsp: +{ + do_qh_w_op (SD_, RD, RS, RT, 1, 1); +} + +001000,5.RT,5.RS,5.RD,01100001101:POOL32A:32::SUBU.PH +"subu.ph r, r, r" +*nanomipsdsp: +{ + do_u_ph_op (SD_, RD, RS, RT, 1, 0); +} + +001000,5.RT,5.RS,5.RD,11100001101:POOL32A:32::SUBU_S.PH +"subu_s.ph r, r, r" +*nanomipsdsp: +{ + do_u_ph_op (SD_, RD, RS, RT, 1, 1); +} + +001000,5.RT,5.RS,5.RD,01011001101:POOL32A:32::SUBU.QB +"subu.qb r, r, r" +*nanomipsdsp: +{ + do_qb_op (SD_, RD, RS, RT, 1, 0); +} + +001000,5.RT,5.RS,5.RD,11011001101:POOL32A:32::SUBU_S.QB +"subu_s.qb r, r, r" +*nanomipsdsp: +{ + do_qb_op (SD_, RD, RS, RT, 1, 1); +} + +001000,5.RT,5.RS,5.RD,01101001101:POOL32A:32::SUBUH.QB +"subuh.qb r, r, r" +*nanomipsdsp: +{ + do_uh_qb_op (SD_, RD, RS, RT, 1, 0); +} + +001000,5.RT,5.RS,5.RD,11101001101:POOL32A:32::SUBUH_R.QB +"subuh_r.qb r, r, r" +*nanomipsdsp: +{ + do_uh_qb_op (SD_, RD, RS, RT, 1, 1); +} + +001000,5.RT,7.CONTROL_MASK,01011001111111:POOL32A:32::WRDSP +"wrdsp r":CONTROL_MASK == 1111111111 +"wrdsp r, " +*nanomipsdsp: +{ + do_wrdsp (SD_, RT, CONTROL_MASK); +} diff --git a/sim/mips/nanomipsr6.igen b/sim/mips/nanomipsr6.igen new file mode 100644 index 00000000000..bef5c04c3b3 --- /dev/null +++ b/sim/mips/nanomipsr6.igen @@ -0,0 +1,2744 @@ +// Simulator definition for the nanoMIPS. +// Copyright (C) 2018-2022 Free Software Foundation, Inc. +// Contributed by Imagination Technologies, Ltd. +// Written by Ali Lown +// +// This file is part of GDB, the GNU debugger. +// +// This program is free software; you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation; either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +:compute:::int:U_SHIFT_1BIT:U:(U << 1) +:compute:::int:U_SHIFT_2BIT:U:(U << 2) +:compute:::int:U_SHIFT_3BIT:U:(U << 3) +:compute:::int:U_SHIFT_4BIT:U:(U << 4) +:compute:::int:EU_127:EU:((EU == 127) ? -1 \: EU) +:compute:::int:U_LW4X4:U2,U3:((U3 << 3) | (U2 << 2)) +:compute:::int:AXUIPC_S_LO:S1,S2,S3:((EXTEND32((S3 << 31) | (S2 << 21) | (S1 << 12))) & 0x0000ffff) +:compute:::int:AXUIPC_S_HI:S1,S2,S3:((EXTEND32((S3 << 31) | (S2 << 21) | (S1 << 12))) & 0xffff0000) +:compute:::int:AXUIPC_S:S1,S2,S3:(EXTEND32((S3 << 31) | (S2 << 21) | (S1 << 12))) +:compute:::int:TRD2:RD20,RD21:(compute_gpr2_dest1_reg (SD_, (RD21 << 1 | RD20))) +:compute:::int:TRE2:RD20,RD21:(compute_gpr2_dest2_reg (SD_, (RD21 << 1 | RD20))) +:compute:::int:TRS2:RS4,RS2_0:(compute_gpr4_zero (SD_, (RS4 << 3 | RS2_0))) +:compute:::int:TRT2:RT4,RT2_0:(compute_gpr4_zero (SD_, (RT4 << 3 | RT2_0))) +:compute:::int:TRD2_REV:RD4,RD2_0:(compute_gpr4 (SD_, (RD4 << 3) | RD2_0)) +:compute:::int:TRE2_REV:RE4,RE2_0:(compute_gpr4 (SD_, (RE4 << 3) | RE2_0)) +:compute:::int:TRS2_REV:RS20,RS21:(compute_gpr2_dest1_reg (SD_, (RS21 << 1 | RS20))) +:compute:::int:TRT2_REV:RS20,RS21:(compute_gpr2_dest2_reg (SD_, (RS21 << 1 | RS20))) +:compute:::address_word:ADDRESS8:S1,S2:(nia + EXTEND8((S2 << 7) | (S1 << 1))) +:compute:::address_word:ADDRESS11:S1,S2:(nia + EXTEND11((S2 << 10) | (S1 << 1))) +:compute:::address_word:ADDRESS15:S1,S2:(nia + EXTEND15((S2 << 14) | (S1 << 1))) +:compute:::address_word:ADDRESS21:S1,S2:(nia + EXTEND21((S2 << 20) | (S1 << 1))) +:compute:::address_word:ADDRESS22:S1,S2:(nia + EXTEND22((S2 << 21) | (S1 << 1))) +:compute:::address_word:ADDRESS26:S1,S2:(nia + EXTEND26((S2 << 25) | (S1 << 1))) +:compute:::int:INS_POS:LSB:(LSB) +:compute:::int:INS_SIZE:LSB,MSBD:(1 + MSBD - LSB) +:compute:::address_word:ADDRESS12:S1,S2:(nia + EXTEND12(S2 << 11 | S1 << 1)) +:compute:::int:S_14_BIT:S1,S2:(EXTEND14 ((S1 << 13) | S2)) +:compute:::int:S_4_BIT:S1,S2:(EXTEND4((S1 << 3) | S2)) +:compute:::int:S_9_BIT:S1,S2:(EXTEND9((S1 << 8) | S2)) +:compute:::int:S_9_BIT_LLSC:S1,S2:(EXTEND9((S1 << 8) | (S2 << 2))) +:compute:::int:RD1:RD:(compute_gpr1_dest_reg (SD_, RD)) +:compute:::int:RT_5_BIT_NM_Z:RT1,RT2:(compute_gpr4_zero (SD_, (RT1 << 3) | RT2)) +:compute:::int:RT_5_BIT_NM:RT1,RT2:(compute_gpr4 (SD_, (RT1 << 3) | RT2)) +:compute:::int:RS_5_BIT_NM:RS1,RS2:(compute_gpr4 (SD_, (RS1 << 3) | RS2)) +:compute:::int:TRTZ:RTZ:((RTZ >= 1 && RTZ <= 3) ? (16 + RTZ) \: RTZ) +:compute:::int:EU_12_13:EU:((EU == 12) ? 255 \: ((EU == 13) ? 65535 \: EU)) +:compute:::int:RS_MOVE:RS1,RS_CODE_1,RS_CODE_2:((RS1 << 3) | (RS_CODE_1 << 2) | RS_CODE_2) +:compute:::int:CODE_BREAK:RS_CODE_1,RS_CODE_2:((RS_CODE_1 << 2) | RS_CODE_2) +:compute:::int:TRD_NM:RD:((RD < 4) ? (16 + RD) \: RD) +:compute:::int:TRS_NM:RS:((RS < 4) ? (16 + RS) \: RS) +:compute:::int:TRT_NM:RT:((RT < 4) ? (16 + RT) \: RT) +:compute:::int:COUNT:COUNT3:(COUNT3 == 0 ? 8 \: COUNT3) +:compute:::int:SHIFTX_1BIT:SHIFTX:(SHIFTX << 1) + +:function:::void:do_msubf:int fd, int fs, int ft, int fmt, instruction_word instruction_0 +{ + check_fpu (SD_); + check_u64 (SD_, instruction_0); + check_fmt_p (SD_, fmt, instruction_0); + TRACE_ALU_INPUT3 (FGR[fd], FGR[fs], FGR[ft]); + StoreFPR (fd, fmt, FusedMultiplySub (ValueFPR (fs, fmt), + ValueFPR (ft, fmt), + ValueFPR (fd, fmt), fmt)); + TRACE_ALU_RESULT (FGR[fd]); +} + +:function:::void:do_maddf:int fd, int fs, int ft, int fmt, instruction_word instruction_0 +{ + check_fpu (SD_); + check_u64 (SD_, instruction_0); + check_fmt_p (SD_, fmt, instruction_0); + TRACE_ALU_INPUT3 (FGR[fd], FGR[fs], FGR[ft]); + StoreFPR (fd, fmt, FusedMultiplyAdd (ValueFPR (fs, fmt), + ValueFPR (ft, fmt), + ValueFPR (fd, fmt), fmt)); + TRACE_ALU_RESULT (FGR[fd]); +} + +:function:::void:do_rint:int fd, int fs, int fmt, instruction_word instruction_0 +{ + uint64_t result = 0; + check_fpu (SD_); + check_u64 (SD_, instruction_0); + check_fmt_p (SD_, fmt, instruction_0); + TRACE_ALU_INPUT1 (FGR[fs]); + RoundToIntegralExact (ValueFPR (fs, fmt), &result, fmt); + StoreFPR (fd, fmt, result); + TRACE_ALU_RESULT (FGR[fd]); +} + +:function:::void:do_class:int fd, int fs, int fmt, instruction_word instruction_0 +{ + check_fpu (SD_); + check_u64 (SD_, instruction_0); + check_fmt_p (SD_, fmt, instruction_0); + StoreFPR (fd, fmt, Classify (ValueFPR (fs, fmt), fmt)); +} + +:function:::void:do_seleqzf:int fd, int fs, int ft, int fmt, instruction_word instruction_0 +{ + check_fpu (SD_); + check_fmt_p (SD_, fmt, instruction_0); + TRACE_ALU_INPUT2 (ValueFPR(fs, fmt), FGR[ft]); + if ((FGR[ft] & 0x01) == 0) + StoreFPR (fd, fmt, ValueFPR (fs, fmt)); + else + StoreFPR (fd, fmt, 0); + TRACE_ALU_RESULT (ValueFPR(fd, fmt)); +} + +:function:::void:do_selnezf:int fd, int fs, int ft, int fmt, instruction_word instruction_0 +{ + check_fpu (SD_); + check_fmt_p (SD_, fmt, instruction_0); + TRACE_ALU_INPUT2 (ValueFPR(fs, fmt), FGR[ft]); + if ((FGR[ft] & 0x01) == 0x1) + StoreFPR (fd, fmt, ValueFPR (fs, fmt)); + else + StoreFPR (fd, fmt, 0); + TRACE_ALU_RESULT (ValueFPR(fd, fmt)); +} + +:function:::void:do_self:int fd, int fs, int ft, int fmt, instruction_word instruction_0 +{ + check_fpu (SD_); + check_fmt_p (SD_, fmt, instruction_0); + TRACE_ALU_INPUT3 (FGR[fd], ValueFPR(fs, fmt), ValueFPR(ft, fmt)); + if ((FGR[fd] & 0x01) != 0) + StoreFPR (fd, fmt, ValueFPR (ft, fmt)); + else + StoreFPR (fd, fmt, ValueFPR (fs, fmt)); + TRACE_ALU_RESULT (ValueFPR(fd, fmt)); +} + +:function:::void:do_mina:int fd, int fs, int ft, int fmt, instruction_word instruction_0 +{ + check_fpu (SD_); + check_u64 (SD_, instruction_0); + check_fmt_p (SD_, fmt, instruction_0); + TRACE_ALU_INPUT2 (FGR[fs], FGR[ft]); + StoreFPR (fd, fmt, MinA (ValueFPR (fs, fmt), ValueFPR (ft, fmt), fmt)); + TRACE_ALU_RESULT (FGR[fd]); +} + +:function:::void:do_maxa:int fd, int fs, int ft, int fmt, instruction_word instruction_0 +{ + check_fpu (SD_); + check_u64 (SD_, instruction_0); + check_fmt_p (SD_, fmt, instruction_0); + TRACE_ALU_INPUT2 (FGR[fs], FGR[ft]); + StoreFPR (fd, fmt, MaxA (ValueFPR (fs, fmt), ValueFPR (ft, fmt), fmt)); + TRACE_ALU_RESULT (FGR[fd]); +} + +:function:::void:do_max:int fd, int fs, int ft, int fmt, instruction_word instruction_0 +{ + check_fpu (SD_); + check_u64 (SD_, instruction_0); + check_fmt_p (SD_, fmt, instruction_0); + TRACE_ALU_INPUT2 (FGR[fs], FGR[ft]); + StoreFPR (fd, fmt, Max (ValueFPR (fs, fmt), ValueFPR (ft, fmt), fmt)); + TRACE_ALU_RESULT (FGR[fd]); +} + +:function:::void:do_min:int fd, int fs, int ft, int fmt, instruction_word instruction_0 +{ + check_fpu (SD_); + check_u64 (SD_, instruction_0); + check_fmt_p (SD_, fmt, instruction_0); + TRACE_ALU_INPUT2 (FGR[fs], FGR[ft]); + StoreFPR (fd, fmt, Min (ValueFPR (fs, fmt), ValueFPR (ft, fmt), fmt)); + TRACE_ALU_RESULT (FGR[fd]); +} + +:function:::void:do_cmp:int fd, int fs, int ft, int fmt, int condition +{ + uint64_t result; + check_fpu (SD_); + TRACE_ALU_INPUT2 (ValueFPR (fs, fmt), ValueFPR (ft, fmt)); + result = R6Compare (ValueFPR (fs, fmt), ValueFPR (ft, fmt), fmt, condition); + StoreFPR (fd, fmt, result); + TRACE_ALU_RESULT (result); +} + +:function:::void:do_modu:int rd, int rs, int rt +{ + uint32_t n = GPR[rs]; + uint32_t d = GPR[rt]; + TRACE_ALU_INPUT2 (n,d); + if (d == 0) + GPR[rd] = EXTEND32 (0); + else + GPR[rd] = EXTEND32 (n % d); + + TRACE_ALU_RESULT (GPR[rd]); +} + +:function:::void:do_mod:int rd, int rs, int rt +{ + int32_t n = GPR[rs]; + int32_t d = GPR[rt]; + TRACE_ALU_INPUT2 (n,d); + if (d == 0 || (n == SIGNED32 (0x80000000) && d == -1)) + GPR[rd] = EXTEND32 (0); + else + GPR[rd] = EXTEND32 (n % d); + + TRACE_ALU_RESULT (GPR[rd]); +} + +:function:::void:do_muhu:int rd, int rs, int rt +{ + uint64_t prod; + if (NotWordValue (GPR[rs]) || NotWordValue (GPR[rt])) + Unpredictable (); + TRACE_ALU_INPUT2 (GPR[rs], GPR[rt]); + prod = ((uint64_t)(uint32_t) GPR[rs]) + * ((uint64_t)(uint32_t) GPR[rt]); + GPR[rd] = EXTEND32 (VH4_8 (prod)); + TRACE_ALU_RESULT (GPR[rd]); +} + +:function:::void:do_mulu:int rd, int rs, int rt +{ + uint64_t prod; + if (NotWordValue (GPR[rs]) || NotWordValue (GPR[rt])) + Unpredictable (); + TRACE_ALU_INPUT2 (GPR[rs], GPR[rt]); + prod = ((uint64_t)(uint32_t) GPR[rs]) + * ((uint64_t)(uint32_t) GPR[rt]); + GPR[rd] = EXTEND32 (VL4_8 (prod)); + TRACE_ALU_RESULT (GPR[rd]); +} + +:function:::void:do_muh:int rd, int rs, int rt +{ + int64_t prod; + if (NotWordValue (GPR[rs]) || NotWordValue (GPR[rt])) + Unpredictable (); + TRACE_ALU_INPUT2 (GPR[rs], GPR[rt]); + prod = ((int64_t)(int32_t) GPR[rs]) + * ((int64_t)(int32_t) GPR[rt]); + GPR[rd] = EXTEND32 (VH4_8 (prod)); + TRACE_ALU_RESULT (GPR[rd]); +} + +:function:::void:do_lsa:int rd, int rs, int rt, unsigned immediate +{ + uint32_t t = GPR[rs] << immediate; + GPR[rd] = EXTEND32(GPR[rt] + t); + TRACE_ALU_RESULT (GPR[rd]); +} + +:function:::void:do_divu:int rd, int rs, int rt +*nanomips32r6: +*nanomips64r6: +{ + uint32_t n = GPR[rs]; + uint32_t d = GPR[rt]; + TRACE_ALU_INPUT2 (n,d); + if (d == 0) + GPR[rd] = EXTEND32 (0x80000000); + else + GPR[rd] = EXTEND32 (n / d); + + TRACE_ALU_RESULT (GPR[rd]); +} + +:function:::void:do_div:int rd, int rs, int rt +*nanomips32r6: +*nanomips64r6: +{ + int32_t n = GPR[rs]; + int32_t d = GPR[rt]; + TRACE_ALU_INPUT2 (n,d); + if (d == 0) + GPR[rd] = EXTEND32 (0x80000000); + else if (n == SIGNED32 (0x80000000) && d == -1) + GPR[rd] = EXTEND32 (0x80000000); + else + GPR[rd] = EXTEND32 (n / d); + + TRACE_ALU_RESULT (GPR[rd]); +} + +:function:::void:do_llwp:int rt, int ru, int roffset, int rbase +{ + address_word base = GPR[rbase]; + address_word offset = EXTEND16 (roffset); + { + address_word vaddr = loadstore_ea (SD_, base, offset); + address_word paddr = vaddr; + int uncached; + if ((vaddr & 7) != 0) + { + SIM_CORE_SIGNAL (SD, CPU, cia, read_map, 8, vaddr, read_transfer, + sim_core_unaligned_signal); + } + else + { + uint64_t memval = 0; + uint64_t memval1 = 0; + uint64_t data = memval; + + LoadMemory (&memval, &memval1, AccessLength_DOUBLEWORD, paddr, + vaddr, isDATA, isREAL); + + GPR[rt] = EXTEND32 (data & 0xFFFFFFFF); + GPR[ru] = EXTEND32 (data >> 32); + + LLBIT = 1; + COP0_COUNT++; + } + } +} + +:function:::void:do_rotx:int rt, int rs, int shift, int shiftx, int stripe +{ + int i; + uint64_t tmp0 = ((uint64_t)GPR[rs] << 32) | (GPR[rs] & 0xFFFFFFFF); + uint64_t tmp1, tmp2, tmp3, tmp4, tmp5; + + tmp1 = tmp0; + for (i = 0; i <=46; i++) { + int s; + + if (i & 0x8) + s = shift; + else + s = shiftx; + + if (stripe != 0 && !(i & 0x4)) + s = ~s; + + if (s & 0x10) { + if (tmp0 & (1LL << (i + 16))) + tmp1 |= 1LL << i; + else + tmp1 &= ~(1LL << i); + } + } + + tmp2 = tmp1; + for (i = 0; i <=38; i++) { + int s; + + if (i & 0x4) + s = shift; + else + s = shiftx; + + if (s & 0x8) { + if (tmp1 & (1LL << (i + 8))) + tmp2 |= 1LL << i; + else + tmp2 &= ~(1LL << i); + } + } + + tmp3 = tmp2; + for (i = 0; i <=34; i++) { + int s; + + if (i & 0x2) + s = shift; + else + s = shiftx; + + if (s & 0x4) { + if (tmp2 & (1LL << (i + 4))) + tmp3 |= 1LL << i; + else + tmp3 &= ~(1LL << i); + } + } + + tmp4 = tmp3; + for (i = 0; i <=32; i++) { + int s; + + if (i & 0x1) + s = shift; + else + s = shiftx; + + if (s & 0x2) { + if (tmp3 & (1LL << (i + 2))) + tmp4 |= 1LL << i; + else + tmp4 &= ~(1LL << i); + } + } + + tmp5 = tmp4; + for (i = 0; i <=31; i++) { + int s; + + s = shift; + + if (s & 0x1) { + if (tmp4 & (1LL << (i + 1))) + tmp5 |= 1LL << i; + else + tmp5 &= ~(1LL << i); + } + } + + GPR[rt] = EXTEND32 (tmp5); +} + +:function:::void:do_lwc1xs:int ft, int rbase, int roffset +*nanomips32r6: +*nanomips64r6: +{ + check_fpu (SD_); + COP_LW (1, ft, do_load (SD_, AccessLength_WORD, GPR[rbase] << 2, + GPR[roffset])); +} + +:function:::void:do_lwpc_nanomips:int rt, uint32_t offset, address_word nia +*nanomips32r6: +*nanomips64r6: +{ + check_fpu (SD_); + GPR[rt] = EXTEND32 (do_load (SD_, AccessLength_WORD, nia, offset)); +} + +:function:::void:check_nms_flag: +*nanomips32r6: +*nanomips64r6: +{ + if(nms_flag == 0) + sim_engine_abort (SD, CPU, CIA, "Error: NMS instruction generated\ + (nanoMIPS Subset is disabled - use -march=32r6s option)\n"); +} + +:function:::uint32_t:compute_gpr2_dest1_reg:int reg +*nanomips32r6: +*nanomips64r6: +{ + switch(reg) + { + case 0: return 4; + case 1: return 5; + case 2: return 6; + case 3: return 7; + default: return 4; + } +} + +:function:::uint32_t:compute_gpr4_zero:int reg +*nanomips32r6: +*nanomips64r6: +{ + if (reg == 3) return 0; + else if (reg >=4 && reg <= 7) return reg; + else return reg + 8; +} + +:function:::uint32_t:compute_gpr4:int reg +*nanomips32r6: +*nanomips64r6: +{ + if (reg >=4 && reg <= 7) return reg; + else return reg + 8; +} + +:function:::uint32_t:compute_gpr2_dest2_reg:int reg +*nanomips32r6: +*nanomips64r6: +{ + switch(reg) + { + case 0: return 5; + case 1: return 6; + case 2: return 7; + case 3: return 8; + default: return 5; + } +} + +:function:::uint32_t:compute_gpr1_dest_reg:int reg +*nanomips32r6: +*nanomips64r6: +{ + switch(reg) + { + case 0: return 4; + case 1: return 5; + default: return 4; + } +} + +:function:::unsigned:zero_extend:signed_word value, uint32_t from_nbits +{ + uint32_t low_bits_mask = (1 << from_nbits) - 1; + return value & low_bits_mask; +} + +:function:::void:do_save_gprs_to_stack_and_adjust_sp: int first_gpr, int count, int gp, int u +*nanomips32r6: +*nanomips64r6: +{ + int counter = 0; + + while (counter != count) { + int gpr = (first_gpr & 0x10) | ((first_gpr + counter) & 0x1F); + int offset = - ( (counter + 1) << 2 ); + + if ( gp && (counter == count - 1)) + gpr = 28; + + do_store (SD_, AccessLength_WORD, GPR[SPIDX], offset, GPR[gpr]); + + counter++; + COP0_COUNT++; + } + + GPR[SPIDX] -= u; +} + +:function:::void:do_restore_gprs_from_stack_and_adjust_sp: int first_gpr, int count, int gp, int u +*nanomips32r6: +*nanomips64r6: +{ + int counter = 0; + + while (counter != count) { + int gpr = (first_gpr & 0x10) | ((first_gpr + counter) & 0x1F); + int offset; + + if (gpr == 29) + Unpredictable(); + + offset = u - ((counter + 1) << 2); + + if ( gp && (counter == count - 1)) + gpr = 28; + + GPR[gpr] = EXTEND32 (do_load(SD_, AccessLength_WORD, GPR[SPIDX], offset)); + + counter++; + COP0_COUNT++; + } + + GPR[SPIDX] += u; +} + +:function:::address_word:do_eret:int nc, address_word nia +*nanomips32r6: +*nanomips64r6: +{ + if (SR & status_ERL) + { + /* Oops, not yet available */ + sim_io_printf (SD, "Warning: ERET when SR[ERL] set not supported"); + nia = EPC; + SR &= ~status_ERL; + } + else + { + nia = EPC; + SR &= ~status_EXL; + //if ( SRSCtl.HSS > 0 && Status.BEV == 0) + // SRSCtl.CSS = SRSCtl.PSS + } + + if (!nc) + LLBIT = 0; + + //TODO: ClearHazards() + return nia; +} + +:%s::::GPR_LIST_SAVE:int count +*nanomips32r6: +*nanomips64r6: +{ + int i; + static char gpr_list[100]; + + gpr_list[0] = '\0'; + + i = 0; + + while (i 1) + strcat (gpr_list,"-"); + } + i++; + } + return (gpr_list); +} + +:function:::void:do_break_nanomips:address_word instruction_0 +{ + /* Check for some break instruction which are reserved for use by the + simulator. */ + unsigned int break_code = instruction_0 & HALT_INSTRUCTION_MASK_NANOMIPS; + if (break_code == (HALT_INSTRUCTION_NANOMIPS & HALT_INSTRUCTION_MASK_NANOMIPS)) + { + sim_engine_halt (SD, CPU, NULL, cia, + sim_exited, (unsigned int)(A0 & 0xFFFFFFFF)); + } + else if (break_code == (BREAKPOINT_INSTRUCTION_NANOMIPS & HALT_INSTRUCTION_MASK_NANOMIPS)) + { + PC = cia; + SignalException (BreakPoint, instruction_0); + } + + else + { + /* If we get this far, we're not an instruction reserved by the sim. Raise + the exception. */ + SignalException (BreakPoint, instruction_0); + } +} + +:%s::::GP_SAVE:int gp +*nanomips32r6: +*nanomips64r6: +{ + return (gp > 0) ? "gp" : ""; +} + +:%s::::FP_SAVE:int fp +*nanomips32r6: +*nanomips64r6: +{ + return (fp > 0) ? "fp" : ""; +} + +11111111111111111111111111111111:R6DUMMY:32,f::DUMMY0.fmt +"dummy 0" +*nanomips32r6: +*nanomips64r6: +{ + /* Just needed so GNUSIM builds */ +} + +011100,3.RT,1,6.U:R6P16A1:16::ADDIUR1SP +"addiu r, SP, " +*nanomips32r6: +*nanomips64r6: +{ + do_addiu (SD_, SPIDX, TRT_NM, U_SHIFT_2BIT); +} + +100100,3.RT,3.RS,0,3.U:R6P16A2:16::ADDIUR2 +"addiu r, r, " +*nanomips32r6: +*nanomips64r6: +{ + do_addiu (SD_, TRS_NM, TRT_NM, U_SHIFT_2BIT); +} + +100100,5.RT,1.S1,1,3.S2:R6P16ADDIURS5:16::ADDIURS5 +"nop":RT==0 +"addiu r, " +*nanomips32r6: +*nanomips64r6: +{ + if (RT != 0) + do_addiu (SD_, RT, RT, S_4_BIT); +} + +000001,5.RT,20.S1,1.S2:R6P32:32::ADDIUPC +"addiu r, " +*nanomips32r6: +*nanomips64r6: +{ + GPR[RT] = ADDRESS22; +} + +011000,5.RT,00011,16.IMM48:R6POOL48I:32::ADDIUPC48 +"addiu r, " +*nanomips32r6: +*nanomips64r6: +{ + uint16_t U2; + uint32_t total; + check_nms_flag (SD_); + U2 = do_load (SD_, AccessLength_HALFWORD, CIA + 4, 0); + total = U2 << 16 | IMM48; + TRACE_ALU_INPUT2(GPR[RT], total); + GPR[RT] = CIA + 6 + EXTEND32(total); + TRACE_ALU_RESULT(GPR[RT]); + NIA = CIA + 6; +} + +101100,3.RT,3.RS,3.RD,0:R6P16ADDU:16::ADDU16 +"addu r, r, r" +*nanomips32r6: +*nanomips64r6: +{ + do_addu (SD_, TRS_NM, TRT_NM, TRD_NM); +} + +001111,1.RT1,0,3.RT2,1.RS1,0,3.RS2:R6P164X4:16::ADDU4X4 +"addu r, r, r" +*nanomips32r6: +*nanomips64r6: +{ + check_nms_flag (SD_); + do_addu (SD_, RS_5_BIT_NM, RT_5_BIT_NM, RT_5_BIT_NM); +} + +010100,3.RT,3.RS,10,0,0:R6POOL16C00:16::AND16 +"and r, r" +*nanomips32r6: +*nanomips64r6: +{ + do_and (SD_, TRS_NM, TRT_NM, TRT_NM); +} + +111100,3.RT,3.RS,4.EU:R6P16:16::ANDI16 +"andi r, r, " +*nanomips32r6: +*nanomips64r6: +{ + do_andi (SD_, TRS_NM, TRT_NM, EU_12_13); +} + +001110,9.S1,1.S2:R6P16:16::BALC16 +"balc " +*nanomips32r6: +*nanomips64r6: +{ + TRACE_ALU_INPUT1(RA); + RA = NIA; + NIA = ADDRESS11; + TRACE_ALU_RESULT(RA); + + // For cycle counting + COP0_COUNT++; +} + +000110,9.S1,1.S2:R6P16:16::BC16 +"bc " +*nanomips32r6: +*nanomips64r6: +{ + NIA = ADDRESS11; +} + +110110,3.RT,3.RS,4.U!0:R6P16BR1:16::BxxC16 +"beqc r, r, ":RS, r, " +*nanomips32r6: +*nanomips64r6: +{ + check_nms_flag (SD_); + TRACE_ALU_INPUT2(GPR[TRS_NM], GPR[TRT_NM]); + if (RS < RT && GPR[TRS_NM] == GPR[TRT_NM]) + NIA = NIA + U_SHIFT_1BIT; //BEQC + else if (RS >= RT && GPR[TRS_NM] != GPR[TRT_NM]) + NIA = NIA + U_SHIFT_1BIT; //BNEC +} + +100110,3.RT,6.S1,1.S2:R6P16:16::BEQZC16 +"beqzc r, " +*nanomips32r6: +*nanomips64r6: +{ + TRACE_ALU_INPUT1(GPR[TRT_NM]); + if(GPR[TRT_NM] == 0) + NIA = ADDRESS8; +} + +101110,3.RT,6.S1,1.S2:R6P16:16::BNEZC16 +"bnezc r, " +*nanomips32r6: +*nanomips64r6: +{ + TRACE_ALU_INPUT1(GPR[TRT_NM]); + if(GPR[TRT_NM] != 0) + NIA = ADDRESS8; +} + +110110,5.RT,1,0000:R6P16JRC:16::JALRC16 +"jalrc r" +*nanomips32r6: +*nanomips64r6: +{ + TRACE_ALU_INPUT2(GPR[RT], RA); + RA = NIA; + NIA = GPR[RT]; + TRACE_ALU_RESULT(RA); + + // For cycle counting + COP0_COUNT++; +} + +110110,5.RT,0,0000:R6P16JRC:16::JRC16 +"jrc r" +*nanomips32r6: +*nanomips64r6: +{ + TRACE_ALU_INPUT1(GPR[RT]); + NIA = GPR[RT]; +} + +010111,3.RT,3.RS,00,2.U:R6P16LB:16::LB16 +"lb r, (r)" +*nanomips32r6: +*nanomips64r6: +{ + do_lb (SD_, TRT_NM, U, TRS_NM); +} + +010111,3.RT,3.RS,10,2.U:R6P16LB:16::LBU16 +"lbu r, (r)" +*nanomips32r6: +*nanomips64r6: +{ + TRACE_ALU_INPUT2 (U, GPR[TRS_NM]); + do_lbu (SD_, TRT_NM, U, TRS_NM); + TRACE_ALU_RESULT (GPR[TRT_NM]); +} + +011111,3.RT,3.RS,0,2.U,0:R6P16LH:16::LH16 +"lh r, (r)" +*nanomips32r6: +*nanomips64r6: +{ + do_lh (SD_, TRT_NM, U_SHIFT_1BIT, TRS_NM); +} + +011111,3.RT,3.RS,1,2.U,0:R6P16LH:16::LHU16 +"lhu r, (r)" +*nanomips32r6: +*nanomips64r6: +{ + do_lhu (SD_, TRT_NM, U_SHIFT_1BIT, TRS_NM); +} + +110100,3.RT,7.EU:R6P16:16::LI16 +"li r, " +*nanomips32r6: +*nanomips64r6: +{ + TRACE_ALU_INPUT1(GPR[TRT_NM]); + GPR[TRT_NM] = EU_127; + TRACE_ALU_RESULT(GPR[TRT_NM]); +} + +011101,1.RT1,1.U2,3.RT2,1.RS1,1.U3,3.RS2:R6P16:16::LW4X4 +"lw r, (r)" +*nanomips32r6: +*nanomips64r6: +{ + check_nms_flag (SD_); + do_lw (SD_, RT_5_BIT_NM, U_LW4X4, RS_5_BIT_NM); +} + +000101,3.RT,3.RS,4.U:R6P16:16::LW16 +"lw r, (r)" +*nanomips32r6: +*nanomips64r6: +{ + do_lw (SD_, TRT_NM, U_SHIFT_2BIT, TRS_NM); +} + +010101,3.RT,7.U:R6P16:16::LWGP16 +"lw r, (gp)" +*nanomips32r6: +*nanomips64r6: +{ + do_lw (SD_, TRT_NM, U_SHIFT_2BIT, GPIDX); +} + +001101,5.RT,5.U:R6P16:16::LWSP +"lw r, (sp)" +*nanomips32r6: +*nanomips64r6: +{ + do_lw (SD_, RT, U_SHIFT_2BIT, SPIDX); +} + +010100,3.RT,3.RS,3.RD,1:R6P16C:16::LWXS16 +"lwxs r, r(r)" +*nanomips32r6: +*nanomips64r6: +{ + do_lw (SD_, TRD_NM, GPR[TRS_NM] << 2, TRT_NM); +} + +// These four instructions are grouped together because of a bug in GNUSIM +// pattern recognition +000100,5.RT,2.RS1,1.RS_CODE_1,2.RS_CODE_2:R6P16MOVE:16::P16MOVE_P16RI +"move r, r": RT != 0 +"syscall ": RS1 == 1 +"sdbbp ": RS1 == 3 +"break " +*nanomips32r6: +*nanomips64r6: +{ + if (RT == 0) { + if (RS1 == 1) + SignalException (SystemCall, instruction_0); + else if (RS1 == 3) + SignalException (DebugBreakPoint, instruction_0); + else + do_break_nanomips (SD_, instruction_0); + } + else { + TRACE_ALU_INPUT2 (GPR[RT], GPR[RS_MOVE]); + GPR[RT] = GPR[RS_MOVE]; + TRACE_ALU_RESULT2 (GPR[RT], GPR[RS_MOVE]); + } +} + +101111,1.RT4,1.RD20,3.RT2_0,1.RS4,1.RD21,3.RS2_0:R6P16:16::MOVEP +"movep r, r, r, r" +*nanomips32r6: +*nanomips64r6: +{ + check_nms_flag (SD_); + TRACE_ALU_INPUT4 (GPR[TRD2], GPR[TRE2], GPR[TRS2], GPR[TRT2]); + GPR[TRD2] = GPR[TRS2]; + GPR[TRE2] = GPR[TRT2]; + TRACE_ALU_RESULT2 (GPR[TRD2], GPR[TRE2]); + + // For cycle counting + COP0_COUNT++; +} + +111111,1.RE4,1.RS20,3.RE2_0,1.RD4,1.RS21,3.RD2_0:R6P16:16::MOVEPREV +"movep r, r, r, r" +*nanomips32r6: +*nanomips64r6: +{ + check_nms_flag (SD_); + TRACE_ALU_INPUT4 (GPR[TRD2_REV], GPR[TRE2_REV], GPR[TRS2_REV], GPR[TRT2_REV]); + GPR[TRD2_REV] = GPR[TRS2_REV]; + GPR[TRE2_REV] = GPR[TRT2_REV]; + TRACE_ALU_RESULT2 (GPR[TRD2_REV], GPR[TRE2_REV]); + + // For cycle counting + COP0_COUNT++; +} + +010100,3.RT,3.RS,00,0,0:R6POOL16C00:16::NOT16 +"not r, r" +*nanomips32r6: +*nanomips64r6: +{ + do_nor (SD_, 0, TRS_NM, TRT_NM); +} + +010100,3.RT,3.RS,11,0,0:R6POOL16C00:16::OR16 +"or r, r" +*nanomips32r6: +*nanomips64r6: +{ + do_or (SD_, TRS_NM, TRT_NM, TRT_NM); +} + +000111,1.RT1,1,4.U,4.GPR_LIST_SAVE:R6P16SR:16::RESTORE.JRC16 +"restore.jrc ":GPR_LIST_SAVE==15 +"restore.jrc , ra, %s" +*nanomips32r6: +*nanomips64r6: +{ + if (RT1 == 0) + do_restore_gprs_from_stack_and_adjust_sp(SD_, 30, GPR_LIST_SAVE, 0, + U_SHIFT_4BIT); + else + do_restore_gprs_from_stack_and_adjust_sp(SD_, 31, GPR_LIST_SAVE, 0, + U_SHIFT_4BIT); + NIA = RA; +} + +000111,1.RT1,0,4.U,4.GPR_LIST_SAVE:R6P16SR:16::SAVE16 +"save , ra": GPR_LIST_SAVE == 0 +"save , ra, %s" +*nanomips32r6: +*nanomips64r6: +{ + if (RT1 == 0) + do_save_gprs_to_stack_and_adjust_sp(SD_, 30, GPR_LIST_SAVE, 0, U_SHIFT_4BIT); + else + do_save_gprs_to_stack_and_adjust_sp(SD_, 31, GPR_LIST_SAVE, 0, U_SHIFT_4BIT); + +} + +010111,3.RTZ,3.RS,01,2.U:R6P16LB:16::SB16 +"sb r, (r)" +*nanomips32r6: +*nanomips64r6: +{ + do_store (SD_, AccessLength_BYTE, GPR[TRS_NM], U, GPR[TRTZ]); +} + +011111,3.RTZ,3.RS,0,2.U,1:R6P16LH:16::SH16 +"sh r, (r)" +*nanomips32r6: +*nanomips64r6: +{ + do_store (SD_, AccessLength_HALFWORD, GPR[TRS_NM], U_SHIFT_1BIT, GPR[TRTZ]); +} + +001100,3.RT,3.RS,0,3.SHIFT:R6P16SHIFT:16::SLL16 +"sll r, r, " +*nanomips32r6: +*nanomips64r6: +{ + do_sll (SD_, TRS_NM, TRT_NM, SHIFT_DEC); +} + +001100,3.RT,3.RS,1,3.SHIFT:R6P16SHIFT:16::SRL16 +"srl r, r, " +*nanomips32r6: +*nanomips64r6: +{ + do_srl (SD_, TRS_NM, TRT_NM, SHIFT_DEC); +} + +101100,3.RT,3.RS,3.RD,1:R6P16ADDU:16::SUBU16 +"subu r, r, r" +*nanomips32r6: +*nanomips64r6: +{ + do_subu (SD_, TRS_NM, TRT_NM, TRD_NM); +} + +100101,3.RTZ,3.RS,4.U:R6P16:16::SW16 +"sw r, (r)" +*nanomips32r6: +*nanomips64r6: +{ + do_store (SD_, AccessLength_WORD, GPR[TRS_NM], U_SHIFT_2BIT, GPR[TRTZ]); +} + +101101,5.RT,5.U:R6P16:16::SWSP +"sw r, (sp)" +*nanomips32r6: +*nanomips64r6: +{ + do_store (SD_, AccessLength_WORD, SP, U_SHIFT_2BIT, GPR[RT]); +} + +010100,3.RT,3.RS,01,0,0:R6POOL16C00:16::XOR16 +"xor r, r" +*nanomips32r6: +*nanomips64r6: +{ + do_xor (SD_, TRT_NM, TRS_NM, TRT_NM); +} + +// 32-bit instructions + +001000,5.RT,5.RS,5.RD,1.X,0100010,000:R6POOL32A0:32::ADD +"add r, r, r" +*nanomips32r6: +*nanomips64r6: +{ + check_nms_flag (SD_); + do_add (SD_, RS, RT, RD); +} + +000000,5.RT!0,5.RS,16.U:R6PPADDIU:32::ADDIU +"addiu r, r, " +*nanomips32r6: +*nanomips64r6: +{ + do_addiu (SD_, RS, RT, U); +} + +010001,5.RT,011,18.U:R6PGPBH:32::ADDIUGPB +"addiu r, GP, " +*nanomips32r6: +*nanomips64r6: +{ + do_addiu (SD_, GPIDX, RT, U); +} + +010000,5.RT,19.U,00:R6PGPW:32::ADDIUGPW +"addiu r, GP, " +*nanomips32r6: +*nanomips64r6: +{ + do_addiu (SD_, GPIDX, RT, U_SHIFT_2BIT); +} + +111000,5.RT,9.S1,10.S2,1,1.S3:R6PLUI:32::ALUIPC +"aluipc r, " +*nanomips32r6: +*nanomips64r6: +{ + address_word address = NIA + AXUIPC_S; + + TRACE_ALU_INPUT2(GPR[RT], address); + GPR[RT] = address & ~0xfff; + TRACE_ALU_RESULT(GPR[RT]); +} + +001000,5.RT,5.RS,5.RD,1.X,0101010,000:R6POOL32A0:32::ADDU +"addu r, r, r" +*nanomips32r6: +*nanomips64r6: +{ + do_addu (SD_, RS, RT, RD); +} + +001000,5.RT,5.RS,5.RD,5.IMMEDIATE,011,111:R6POOL32A0:32::EXTW +"prepend r, r, ": RD == RS +"align r, r, r, ": IMMEDIATE != 0 +"extw r, r, r, " +*nanomips32r6: +*nanomips64r6: +{ + if (IMMEDIATE != 0) { + uint64_t tmp = ((uint64_t)GPR[RT] << 32) | (0xffffffff & GPR[RS]); + TRACE_ALU_INPUT4 (GPR[RD], GPR[RS], GPR[RT], tmp); + GPR[RD] = EXTEND32 (tmp >> IMMEDIATE); + TRACE_ALU_RESULT (GPR[RD]); + } else { + TRACE_ALU_INPUT2 (GPR[RD], GPR[RT]); + GPR[RD] = GPR[RT]; + TRACE_ALU_RESULT (GPR[RD]); + } +} + +001000,5.RT,5.RS,5.RD,1.X,1001010,000:R6POOL32A0:32::AND +"and r, r, r" +*nanomips32r6: +*nanomips64r6: +{ + do_and (SD_, RS, RT, RD); +} + +100000,5.RT,5.RS,0010,12.U:R6PU12:32::ANDI +"andi r, r, " +*nanomips32r6: +*nanomips64r6: +{ + do_andi (SD_, RS, RT, U); +} + +001010,1,24.S1,1.S2:R6PBAL:32::BALC +"balc " +*nanomips32r6: +*nanomips64r6: +{ + TRACE_ALU_INPUT1(RA); + RA = NIA; + NIA = ADDRESS26; + TRACE_ALU_RESULT(RA); + + // For cycle counting + COP0_COUNT++; +} + +001010,0,24.S1,1.S2:R6PBAL:32::BC +"bc " +*nanomips32r6: +*nanomips64r6: +{ + NIA = ADDRESS26; +} + +100010,5.RT,5.RS,00,13.S1,1.S2:R6PBR1:32::BEQC +"beqc r, r, " +*nanomips32r6: +*nanomips64r6: +{ + TRACE_ALU_INPUT2(GPR[RS], GPR[RT]); + if (GPR[RS] == GPR[RT]) + NIA = ADDRESS15; +} + +110010,5.RT,000,7.U,10.S1,1.S2:P7PBRI:32::BEQIC +"beqic r, , " +*nanomips32r6: +*nanomips64r6: +{ + TRACE_ALU_INPUT2(GPR[RT], U); + if (GPR[RT] == U) { + NIA = ADDRESS12; + } +} + +100010,5.RT,5.RS,10,13.S1,1.S2:P7PBR1:32::BGEC +"bgec r, r, " +*nanomips32r6: +*nanomips64r6: +{ + TRACE_ALU_INPUT2(GPR[RS], GPR[RT]); + if ((signed_word) GPR[RS] >= (signed_word) GPR[RT]) + NIA = ADDRESS15; +} + +110010,5.RT,010,7.U,10.S1,1.S2:P7PBRI:32::BGEIC +"bgeic r, , " +*nanomips32r6: +*nanomips64r6: +{ + TRACE_ALU_INPUT2(GPR[RT], U); + if ((signed_word) GPR[RT] >= U) { + NIA = ADDRESS12; + } +} + +100010,5.RT,5.RS,11,13.S1,1.S2:P7PBR2:32::BGEUC +"bgeuc r, r, " +*nanomips32r6: +*nanomips64r6: +{ + TRACE_ALU_INPUT2(GPR[RS], GPR[RT]); + if ((unsigned_word) (GPR[RS]) >= (unsigned_word)(GPR[RT])) { + NIA = ADDRESS15; + } +} + +110010,5.RT,011,7.U,10.S1,1.S2:P7PBRI:32::BGEUIC +"bgeuic r, , " +*nanomips32r6: +*nanomips64r6: +{ + TRACE_ALU_INPUT2(GPR[RT], U); + if ((unsigned_word) GPR[RT] >= U) { + NIA = ADDRESS12; + } +} + +101010,5.RT,5.RS,10,13.S1,1.S2:P7PBR2:32::BLTC +"bltc r, r, " +*nanomips32r6: +*nanomips64r6: +{ + TRACE_ALU_INPUT2(GPR[RS], GPR[RT]); + if ((signed_word) GPR[RS] < (signed_word) GPR[RT]) + NIA = ADDRESS15; +} + +110010,5.RT,110,7.U,10.S1,1.S2:P7PBRI:32::BLTIC +"bltic r, , " +*nanomips32r6: +*nanomips64r6: +{ + TRACE_ALU_INPUT2(GPR[RT], U); + if ((signed_word) GPR[RT] < U) { + NIA = ADDRESS12; + } +} + +101010,5.RT,5.RS,11,13.S1,1.S2:P7PBR2:32::BLTUC +"bltuc r, r, " +*nanomips32r6: +*nanomips64r6: +{ + TRACE_ALU_INPUT2(GPR[RS], GPR[RT]); + if ((unsigned_word) GPR[RS] < (unsigned_word) GPR[RT]) { + NIA = ADDRESS15; + } +} + +110010,5.RT,111,7.U,10.S1,1.S2:P7PBRI:32::BLTIUC +"bltiuc , , " +*nanomips32r6: +*nanomips64r6: +{ + TRACE_ALU_INPUT2(GPR[RT], U); + if ((unsigned_word) GPR[RT] < U) { + NIA = ADDRESS12; + } +} + +101010,5.RT,5.RS,00,13.S1,1.S2:R6PBR2:32::BNEC +"bnec r, r, " +*nanomips32r6: +*nanomips64r6: +{ + TRACE_ALU_INPUT2(GPR[RS], GPR[RT]); + if (GPR[RS] != GPR[RT]) + NIA = ADDRESS15; +} + +110010,5.RT,100,7.U,10.S1,1.S2:R6PBRI:32::BNEIC +"bneic r, , " +*nanomips32r6: +*nanomips64r6: +{ + TRACE_ALU_INPUT2(GPR[RT], U); + if (GPR[RT] != U) { + NIA = ADDRESS12; + } +} + +000000,00000,10,19.CODE:R6PRI:32::BREAK +"break %#lx" +*nanomips32r6: +*nanomips64r6: +{ + do_break_nanomips (SD_, instruction_0); +} + +101001,5.OP,5.RS,1.S1,0111,0,01,8.S2:R6PLSS1:32::CACHE +"cache , (r)" +*nanomips32r6: +*nanomips64r6: +{ + do_cache (SD_, OP, RS, S_9_BIT, instruction_0); +} + +001000,5.RT,5.RS,0100101,100,111,111:R6POOL32AXF4:32::CLO +"clo r, r" +*nanomips32r6: +*nanomips64r6: +{ + check_nms_flag (SD_); + do_clo (SD_, RT, RS); +} + +001000,5.RT,5.RS,0101101,100,111,111:R6POOL32AXF4:32::CLZ +"clz r, r" +*nanomips32r6: +*nanomips64r6: +{ + check_nms_flag (SD_); + do_clz (SD_, RT, RS); +} + +001000,5.RT,5.X,01,00011,101,111,111:R6POOL32AXF5GROUP1:32::DI +"di":RT == 0 +"di r" +*nanomips32r6: +*nanomips64r6: +{ + do_di (SD_, RT); +} + +001000,5.RT,5.RS,5.RD,1.X,0100011,000:R6POOL32A0:32::DIV +"div r, r, r" +*nanomips32r6: +*nanomips64r6: +{ + do_div (SD_, RD, RS, RT); +} + +001000,5.RT,5.RS,5.RD,1.X,0110011,000:R6POOL32A0:32::DIVU +"divu r, r, r" +*nanomips32r6: +*nanomips64r6: +{ + do_divu (SD_, RD, RS, RT); +} + +001000,5.RT,5.X,01,01011,101,111,111:R6POOL32AXF5GROUP1:32::EI +"ei":RT == 0 +"ei r" +*nanomips32r6: +*nanomips64r6: +{ + do_ei (SD_, RT); +} + +001000,9.X,0,11,11001,101,111,111:R6ERETX:32::ERET +"eret" +*nanomips32r6: +*nanomips64r6: +{ + NIA = do_eret(SD_, 0, NIA); +} + +001000,9.X,1,11,11001,101,111,111:R6ERETX:32::ERETNC +"eretnc" +*nanomips32r6: +*nanomips64r6: +{ + check_nms_flag (SD_); + SignalException (ReservedInstruction, instruction_0); + NIA = do_eret(SD_, 1, NIA); +} + +100000,5.RT,5.RS,1111,0,5.MSBD,0,5.LSB:R6PEXT:32::EXT +"ext r, r, , " +*nanomips32r6: +*nanomips64r6: +{ + check_nms_flag (SD_); + if (LSB + MSBD + 1 > 32) + Unpredictable (); + + do_ext (SD_, RT, RS, LSB, MSBD); +} + +100000,5.RT,5.RS,1110,0,5.MSBD,0,5.LSB:R6PINS:32::INS +"ins r, r, , " +*nanomips32r6: +*nanomips64r6: +{ + check_nms_flag (SD_); + if ((1 + MSBD - LSB) < 1) + Unpredictable (); + do_ins (SD_, RT, RS, LSB, MSBD); +} + +100000,5.RT,5.RS,1101,0,4.SHIFTX,1.STRIPE,0,5.SHIFT:R6PROTX:32::ROTX +"bitrev r, r": SHIFT == 31 && SHIFTX_1BIT == 0 +"bitswap r, r": SHIFT == 7 && SHIFTX_1BIT == 8 && STRIPE == 1 +"bitswap.h r, r": SHIFT == 15 && SHIFTX_1BIT == 16 +"byteswap r, r": SHIFT == 24 && SHIFTX_1BIT == 8 +"wsbh r, r": SHIFT == 8 && SHIFTX_1BIT == 24 +"rotx r, r, , ": STRIPE == 0 +"rotx r, r, , , " +*nanomips32r6: +*nanomips64r6: +{ + check_nms_flag (SD_); + + TRACE_ALU_INPUT4 (GPR[RT], GPR[RS], SHIFT, SHIFTX_1BIT); + do_rotx (SD_, RT, RS, SHIFT, SHIFTX_1BIT, STRIPE); + TRACE_ALU_RESULT (GPR[RT]); +} + +010010,5.RT,5.RS,0000,12.X:R6PJ:32::JALRC +"jalrc r, r" +*nanomips32r6: +*nanomips64r6: +{ + unsigned_word address; + TRACE_ALU_INPUT3(GPR[RT], GPR[RS], RA); + GPR[RT] = NIA; + address = GPR[RS]; + NIA = address; + + // For cycle counting + COP0_COUNT++; + TRACE_ALU_RESULT(NIA); + +} + +010010,5.RT,5.RS,0001,12.X:R6PJ:32::JALRC.HB +"jalrc.hb r, r" +*nanomips32r6: +*nanomips64r6: +{ + unsigned_word address; + GPR[RT] = NIA; + address = GPR[RS]; + NIA = address; + + // For cycle counting + COP0_COUNT++; +} + +100001,5.RT,5.RS,0000,12.U:R6PLSU12:32::LB +"lb r, (r)" +*nanomips32r6: +*nanomips64r6: +{ + do_lb (SD_, RT, U, RS); +} + +010001,5.RT,000,18.U:R6PLSGP:32::LBGP +"lb r, (GP)" +*nanomips32r6: +*nanomips64r6: +{ + do_lb (SD_, RT, U, GPIDX); +} + +101001,5.RT,5.RS,1.S1,0000,0,00,8.S2:R6PLSS0:32::LBS9 +"lb r, (r)" +*nanomips32r6: +*nanomips64r6: +{ + do_lb (SD_, RT, S_9_BIT, RS); +} + +100001,5.RT,5.RS,0010,12.U:R6PLSU12:32::LBU +"lbu r, (r)" +*nanomips32r6: +*nanomips64r6: +{ + do_lbu (SD_, RT, U, RS); +} + +010001,5.RT,010,18.U:R6GPBH:32::LBUGP +"lbu r, (GP)" +*nanomips32r6: +*nanomips64r6: +{ + TRACE_ALU_INPUT2 (U, GP); + do_lbu (SD_, RT, U, GPIDX); + TRACE_ALU_RESULT (GPR[RT]); +} + +101001,5.RT,5.RS,1.S1,0010,0,00,8.S2:R6PLSS0:32::LBUS9 +"lbu r, (r)" +*nanomips32r6: +*nanomips64r6: +{ + do_lbu (SD_, RT, S_9_BIT, RS); +} + +001000,5.RT,5.RS,5.RD,0010,0,000,111:R6PPLSX:32::LBUX +"lbux r, r(r)" +*nanomips32r6: +*nanomips64r6: +{ + do_lbu (SD_, RD, GPR[RS], RT); +} + +001000,5.RT,5.RS,5.RD,0000,0,000,111:R6PPLSX:32::LBX +"lbx r, r(r)" +*nanomips32r6: +*nanomips64r6: +{ + do_lb (SD_, RD, GPR[RS], RT); +} + +100001,5.RT,5.RS,0100,12.U:R6PLSU12:32::LH +"lh r, (r)" +*nanomips32r6: +*nanomips64r6: +{ + do_lh (SD_, RT, U, RS); +} + +010001,5.RT,100,17.U,0:R6PGPLH:32::LHGP +"lh r, (GP)" +*nanomips32r6: +*nanomips64r6: +{ + do_lh (SD_, RT, U_SHIFT_1BIT, GPIDX); +} + +101001,5.RT,5.RS,1.S1,0100,0,00,8.S2:R6PLSS0:32::LHS9 +"lh r, (r)" +*nanomips32r6: +*nanomips64r6: +{ + do_lh (SD_, RT, S_9_BIT, RS); +} + +100001,5.RT,5.RS,0110,12.U:R6PLSU12:32::LHU +"lhu r, (r)" +*nanomips32r6: +*nanomips64r6: +{ + do_lhu (SD_, RT, U, RS); +} + +010001,5.RT,100,17.U,1:R6PLSGP:32::LHUGP +"lhu r, (gp)" +*nanomips32r6: +*nanomips64r6: +{ + do_lhu (SD_, RT, U_SHIFT_1BIT, GPIDX); +} + +101001,5.RT,5.RS,1.S1,0110,0,00,8.S2:R6PLSS0:32::LHUS9 +"lhu r, (r)" +*nanomips32r6: +*nanomips64r6: +{ + do_lhu (SD_, RT, S_9_BIT, RS); +} + +001000,5.RT,5.RS,5.RD,0110,0,000,111:R6PPLSX:32::LHUX +"lhux r, r(r)" +*nanomips32r6: +*nanomips64r6: +{ + do_lhu (SD_, RD, GPR[RS], RT); +} + +001000,5.RT,5.RS,5.RD,0110,1,000,111:R6PPLSXS:32::LHUXS +"lhux r, r(r)" +*nanomips32r6: +*nanomips64r6: +{ + do_lhu (SD_, RD, GPR[RS] << 1, RT); +} + +001000,5.RT,5.RS,5.RD,0100,0,000,111:R6PPLSX:32::LHX +"lhx r, r(r)" +*nanomips32r6: +*nanomips64r6: +{ + do_lh (SD_, RD, GPR[RS], RT); +} + +001000,5.RT,5.RS,5.RD,0100,1,000,111:R6PPLSXS:32::LHXS +"lhxs r, r(r)" +*nanomips32r6: +*nanomips64r6: +{ + do_lh (SD_, RD, GPR[RS] << 1, RT); +} + +101001,5.RT,5.RS,1.S1,1010,0,01,6.S2,00:R6PLL:32::LL +"ll r, (r)" +*nanomips32r6: +*nanomips64r6: +{ + TRACE_ALU_INPUT3(GPR[RT], S_9_BIT_LLSC, GPR[RS]); + do_ll (SD_, RT, S_9_BIT_LLSC, RS); + TRACE_ALU_RESULT(GPR[RT]); +} + +101001,5.RT,5.RS,1.X1,1010,0,01,5.RU,1.X2,01:R6PLL:32::LLWP +"llwp r, r, (r)" +*nanomips32r6: +*nanomips64r6: +{ + do_llwp (SD_, RT, RU, 0, RS); +} + +001000,5.RT,5.RS,5.RD,2.U,3.X,001,111:R6POOL32A7:32::LSA +"lsa r, r, r, " +*nanomips32r6: +*nanomips64r6: +{ + do_lsa (SD_, RD, RS, RT, U); +} + +111000,5.RT,9.S1,10.S2,0,1.S3:R6PLUI:32::LUI +"lui r, , ":AXUIPC_S_LO != 0 +"lui r, " +*nanomips32r6: +*nanomips64r6: +{ + TRACE_ALU_INPUT2 (GPR[RT], AXUIPC_S); + GPR[RT] = AXUIPC_S; + TRACE_ALU_RESULT (GPR[RT]); +} + +100001,5.RT,5.RS,1000,12.U:R6PLSU12:32::LW +"lw r, (r)" +*nanomips32r6: +*nanomips64r6: +{ + TRACE_ALU_INPUT3 (GPR[RT], U, GPR[RS]); + do_lw (SD_, RT, U, RS); + TRACE_ALU_RESULT (GPR[RT]); +} + +101001,5.RT,5.RS,1.S1,1000000,8.S2:R6PLSS0:32::LWS9 +"lw r, (r)" +*nanomips32r6: +*nanomips64r6: +{ + do_lw (SD_, RT, S_9_BIT, RS); +} + +101001,5.RT,5.RS,1.S1,3.COUNT3,0,1,00,8.S2:R6PLSWM:32::LWM +"lwm r, (r), " +*nanomips32r6: +*nanomips64r6: +{ + int counter = 0; + int dest; + int this_offset; + + check_nms_flag (SD_); + + while (counter != COUNT) + { + dest = (RT & 0x10) | ((RT + counter) & 0x1F); + + if ((dest == RS) && (counter != (COUNT - 1))) + Unpredictable (); + + this_offset = S_9_BIT + (counter << 2); + + do_lw (SD_, dest, this_offset, RS); + + counter++; + if (counter != 0) + COP0_COUNT++; + } +} + +010000,5.RT,19.U,10:R6PGPW:32::LWGP +"lw r, (GP)" +*nanomips32r6: +*nanomips64r6: +{ + TRACE_ALU_INPUT2(GPR[RT], GPR[RT]); + do_lw (SD_, RT, U_SHIFT_2BIT, GPIDX); + TRACE_ALU_RESULT(GPR[RT]); +} + +011000,5.RT,01011,16.IMM48:R6POOL48I:32::LWPC48 +"lwpc r, " +*nanomips32r6: +*nanomips64r6: +{ + uint16_t S2; + uint32_t total; + check_nms_flag (SD_); + S2 = do_load(SD_, AccessLength_HALFWORD, CIA + 4, 0); + total = S2 << 16 | IMM48; + + do_lwpc_nanomips (SD_, RT, total, CIA + 6); + NIA = CIA + 6; +} + +001000,5.RT,5.RS,5.RD,1000,0,000,111:R6PPLSX:32::LWX +"lwx r, r(r)" +*nanomips32r6: +*nanomips64r6: +{ + do_lw (SD_, RD, GPR[RS], RT); +} + +001000,5.RT,5.RS,5.RD,1000,1,000,111:R6PPLSXS:32::LWXS +"lwxs r, r(r)" +*nanomips32r6: +*nanomips64r6: +{ + do_lw (SD_, RD, GPR[RS] << 2, RT); +} + +001000,5.RT,5.C0S,5.SEL,1.X,0000110,000:R6POOL32A0:32::MFC0 +"mfc0 r, r, " +*nanomips32r6: +*nanomips64r6: +{ + DecodeCoproc (instruction_0, 0, cp0_mfc0, RT, C0S, SEL); +} + +001000,5.RT,5.RS,5.RD,1.X,0101011,000:R6POOL32A0:32::MOD +"mod r, r, r" +*nanomips32r6: +*nanomips64r6: +{ + do_mod (SD_, RD, RS, RT); +} + +001000,5.RT,5.RS,5.RD,1.X,0111011,000:R6POOL32A0:32::MODU +"modu r, r, r" +*nanomips32r6: +*nanomips64r6: +{ + do_modu (SD_, RD, RS, RT); +} + +000010,1.RT1,1.RD,3.RT2,20.S1,1.S2:R6MOVEBALC:32::MOVE.BALC +"move.balc r, r, " +*nanomips32r6: +*nanomips64r6: +{ + check_nms_flag (SD_); + TRACE_ALU_INPUT2(GPR[RD1], GPR[RT_5_BIT_NM_Z]); + GPR[RD1] = GPR[RT_5_BIT_NM_Z]; + RA = NIA; + NIA = ADDRESS22; + TRACE_ALU_RESULT(GPR[RD1]); + + // For cycle counting + COP0_COUNT += 2; +} + +001000,5.RT,5.RS,5.RD,1,1000010,000:R6PCMOVE:32::MOVN +"movn r, r, r" +*nanomips32r6: +*nanomips64r6: +{ + TRACE_ALU_INPUT2(GPR[RS], GPR[RT]); + do_movn (SD_, RD, RS, RT); + TRACE_ALU_RESULT(GPR[RD]); +} + +001000,5.RT,5.RS,5.RD,0,1000010,000:R6PCMOVE:32::MOVZ +"movz r, r, r" +*nanomips32r6: +*nanomips64r6: +{ + do_movz (SD_, RD, RS, RT); +} + +001000,5.RT,5.C0S,5.SEL,1.X,0001110,000:R6POOL32A0:32::MTC0 +"mtc0 r, r, " +*nanomips32r6: +*nanomips64r6: +{ + DecodeCoproc (instruction_0, 0, cp0_mtc0, RT, C0S, SEL); +} + +001000,5.RT,5.RS,5.RD,1.X,0001011,000:R6POOL32A0:32::MUH +"muh r, r, r" +*nanomips32r6: +*nanomips64r6: +{ + do_muh (SD_, RD, RS, RT); +} + +001000,5.RT,5.RS,5.RD,1.X,0011011,000:R6POOL32A0:32::MUHU +"muhu r, r, r" +*nanomips32r6: +*nanomips64r6: +{ + do_muhu (SD_, RD, RS, RT); +} + +001000,5.RT,5.RS,5.RD,1.X,0000011,000:R6POOL32A0:32::MUL32 +"mul r, r, r" +*nanomips32r6: +*nanomips64r6: +{ + do_mul (SD_, RD, RS, RT); +} + +001111,1.RT1,0,3.RT2,1.RS1,1,3.RS2:R6P164X4:16::MUL4X4 +"mul r, r, r" +*nanomips32r6: +*nanomips64r6: +{ + check_nms_flag (SD_); + do_mul (SD_, RT_5_BIT_NM, RS_5_BIT_NM, RT_5_BIT_NM); +} + +001000,5.RT,5.RS,5.RD,1.X,0010011,000:R6POOL32A0:32::MULU +"mulu r, r, r" +*nanomips32r6: +*nanomips64r6: +{ + do_mulu (SD_, RD, RS, RT); +} + +100000,00000,5.X1,1100,3.X2,0000,00000:R6PSLL:32::NOP32 +"nop" +*nanomips32r6: +*nanomips64r6: +{ +} + +001000,5.RT,5.RS,5.RD,1.X,1011010,000:R6POOL32A0:32::NOR +"nor r, r, r" +*nanomips32r6: +*nanomips64r6: +{ + do_nor (SD_, RS, RT, RD); +} + +001000,5.RT,5.RS,5.RD,1.X,1010010,000:R6POOL32A0:32::OR32 +"or r, r, r" +*nanomips32r6: +*nanomips64r6: +{ + do_or (SD_, RS, RT, RD); +} + +100000,5.RT,5.RS,0000,12.U:R6PU12:32::ORI +"ori r, r, " +*nanomips32r6: +*nanomips64r6: +{ + do_ori (SD_, RS, RT, U); +} + +100000,00000,5.X1,1100,3.X2,0000,00101:R6PSLL:32::PAUSE +"pause" +*nanomips32r6: +*nanomips64r6: +{ + sim_io_printf (SD, "Not implemented"); +} + +101001,5.HINT!31,5.RS,1.S1,0011,0,00,8.S2:R6PPREFS9:32::PREFS9 +"pref , (r)" +*nanomips32r6: +*nanomips64r6: +{ + do_pref (SD_, HINT, S_9_BIT, RS); +} + +100001,5.HINT,5.RS,0011,12.U:R6PLSU12:32::PREFU12 +"pref , (r)": HINT != 31 +"synci (r)" +*nanomips32r6: +*nanomips64r6: +{ + if (HINT != 31) + do_pref (SD_, HINT, U, RS); + else + { + // synci - nothing to do currently + sim_io_printf (SD, "Not implemented"); + } +} + +100000,5.RT,0,4.GPR_LIST_SAVE,0011,9.U,1.GP_SAVE,10:R6PPSR:32::RESTORE +"restore , r": GPR_LIST_SAVE == 0 +"restore , r, %s": !GP_SAVE && GPR_LIST_SAVE != 0 +"restore , r": !GP_SAVE && GPR_LIST_SAVE < 2 +"restore , r, %s" : !GP_SAVE && GPR_LIST_SAVE >=2 +"restore , r, %s": GP_SAVE && GPR_LIST_SAVE < 2 +"restore , r, %s, %s" : GP_SAVE && GPR_LIST_SAVE >=2 +"restore , r, %s": GP_SAVE && GPR_LIST_SAVE < 3 +"restore , r, %s, %s" +*nanomips32r6: +*nanomips64r6: +{ + do_restore_gprs_from_stack_and_adjust_sp(SD_, RT, GPR_LIST_SAVE, + GP_SAVE, U_SHIFT_3BIT); +} + +100000,5.RT,0,4.GPR_LIST_SAVE,0011,9.U,1.GP_SAVE,11:R6PPSR:32::RESTORE.JRC +"restore.jrc , r": GPR_LIST_SAVE == 0 +"restore.jrc , r, %s": !GP_SAVE && GPR_LIST_SAVE != 0 +"restore.jrc , r": !GP_SAVE && GPR_LIST_SAVE < 2 +"restore.jrc , r, %s" : !GP_SAVE && GPR_LIST_SAVE >=2 +"restore.jrc , r, %s": GP_SAVE && GPR_LIST_SAVE < 2 +"restore.jrc , r, %s, %s" : GP_SAVE && GPR_LIST_SAVE >=2 +"restore.jrc , r, %s": GP_SAVE && GPR_LIST_SAVE < 3 +"restore.jrc , r, %s, %s" +*nanomips32r6: +*nanomips64r6: +{ + do_restore_gprs_from_stack_and_adjust_sp(SD_, RT, GPR_LIST_SAVE, + GP_SAVE, U_SHIFT_3BIT); + + NIA = GPR[RAIDX]; +} + +100000,5.RT,5.RS,1100,3.X,0110,5.SHIFT:R6PSHIFT:32::ROTR +"rotr r, r, " +*nanomips32r6: +*nanomips64r6: +{ + GPR[RT] = do_ror (SD_, GPR[RS], SHIFT); +} + +001000,5.RT,5.RS,5.RD,1.X,0011010,000:R6POOL32A0:32::ROTRV +"rotrv r, r, r" +*nanomips32r6: +*nanomips64r6: +{ + uint32_t shift = GPR[RT] & 0x1f; + GPR[RD] = do_ror (SD_, GPR[RS], shift); +} + +001000,5.RT,5.RS,5.RD,0,1100010,000:R6POOL32A0:32::XOR +"xor r, r, r" +*nanomips32r6: +*nanomips64r6: +{ + do_xor (SD_, RS, RT, RD); +} + +100000,5.RT,5.RS,0001,12.U:R6PU12:32::XORI +"xori r, r, " +*nanomips32r6: +*nanomips64r6: +{ + do_xori (SD_, RS, RT, U); +} + +100000,5.RT,0,4.GPR_LIST_SAVE,0011,9.U,1.GP_SAVE,00:R6PPSR:32::SAVE +"save , r": GPR_LIST_SAVE == 0 +"save , r, %s": !GP_SAVE && GPR_LIST_SAVE != 0 +"save , r": !GP_SAVE && GPR_LIST_SAVE < 2 +"save , r %s" : !GP_SAVE && GPR_LIST_SAVE >=2 +"save , r, %s": GP_SAVE && GPR_LIST_SAVE < 2 +"save , r, %s, %s" : GP_SAVE && GPR_LIST_SAVE >=2 +"save , r, %s": GP_SAVE && GPR_LIST_SAVE < 3 +"save , r, %s, %s" +*nanomips32r6: +*nanomips64r6: +{ + do_save_gprs_to_stack_and_adjust_sp(SD_, RT, GPR_LIST_SAVE, + GP_SAVE, U_SHIFT_3BIT); +} + +100001,5.RT,5.RS,0001,12.U:R6PLSU12:32::SBU12 +"sb r, (r)" +*nanomips32r6: +*nanomips64r6: +{ + do_store (SD_, AccessLength_BYTE, GPR[RS], U, GPR[RT]); +} + +010001,5.RT,001,18.U:R6PGPBH:32::SBGP +"sb r, (gp)" +*nanomips32r6: +*nanomips64r6: +{ + do_store (SD_, AccessLength_BYTE, GP, U, GPR[RT]); +} + +101001,5.RT,5.RS,1.S1,0001,0,00,8.S2:R6PLSS0:32::SBS9 +"sb r, (r)" +*nanomips32r6: +*nanomips64r6: +{ + do_store (SD_, AccessLength_BYTE, GPR[RS], S_9_BIT, GPR[RT]); +} + +001000,5.RT,5.RS,5.RD,0001,0,000,111:R6PPLSX:32::SBX +"sbx r, r(r)" +*nanomips32r6: +*nanomips64r6: +{ + check_nms_flag (SD_); + do_store (SD_, AccessLength_BYTE, GPR[RT], GPR[RS], GPR[RD]); +} + +101001,5.RT,5.RS,1.S1,1011,0,01,6.S2,00:R6PSC:32::SC +"sc r, (r)" +*nanomips32r6: +*nanomips64r6: +{ + do_sc (SD_, RT, S_9_BIT_LLSC, RS, instruction_0, 1); +} + +101001,5.RT,5.RS,1.X1,1011,0,01,5.RU,1.X,01:R6PSC:32::SCWP +"scwp r, r, (r)" +*nanomips32r6: +*nanomips64r6: +{ + int offset = BigEndianCPU ? 0 : 4; + + do_sc (SD_, RU, offset, RS, instruction_0, 0); + do_sc (SD_, RT, offset ^ 4, RS, instruction_0, 1); +} + +001000,5.RT,5.RS,6.X,0000001,000:R6POOL32A0:32::SEB +"seb r, r" +*nanomips32r6: +*nanomips64r6: +{ + check_nms_flag (SD_); + do_seb (SD_, RT, RS); +} + +001000,5.RT,5.RS,6.X,0001001,000:R6POOL32A0:32::SEH +"seh r, r" +*nanomips32r6: +*nanomips64r6: +{ + do_seh (SD_, RT, RS); +} + +100000,5.RT,5.RS,0110,12.IMMEDIATE:R6PU12:32::SEQI +"seqi r, r, " +*nanomips32r6: +*nanomips64r6: +{ + TRACE_ALU_INPUT3(GPR[RT], GPR[RS], IMMEDIATE); + GPR[RT] = (GPR[RS] == IMMEDIATE) ? 1 : 0; + TRACE_ALU_RESULT(GPR[RT]); +} + +100001,5.RT,5.RS,0101,12.U:R6PLSU12:32::SHU12 +"sh r, (r)" +*nanomips32r6: +*nanomips64r6: +{ + do_store (SD_, AccessLength_HALFWORD, GPR[RS], U, GPR[RT]); +} + +010001,5.RT,101,17.U,0:R6PGPSH:32::SHGP +"sh r, (GP)" +*nanomips32r6: +*nanomips64r6: +{ + do_store (SD_, AccessLength_HALFWORD, GP, U_SHIFT_1BIT, GPR[RT]); +} + +101001,5.RT,5.RS,1.S1,0101,0,00,8.S2:R6PLSS0:32::SHS9 +"sh r, (r)" +*nanomips32r6: +*nanomips64r6: +{ + do_store (SD_, AccessLength_HALFWORD, GPR[RS], S_9_BIT, GPR[RT]); +} + +001000,5.RT,5.RS,5.RD,0101,0,000,111:R6PPLSX:32::SHX +"shx r, r(r)" +*nanomips32r6: +*nanomips64r6: +{ + check_nms_flag (SD_); + do_store (SD_, AccessLength_HALFWORD, GPR[RT], GPR[RS], GPR[RD]); +} + +001000,5.RT,5.RS,5.RD,0101,1,000,111:R6PPLSXS:32::SHXS +"shxs r, r(r)" +*nanomips32r6: +*nanomips64r6: +{ + check_nms_flag (SD_); + do_store (SD_, AccessLength_HALFWORD, GPR[RT], GPR[RS] << 1, GPR[RD]); +} + +000000,00000,00,19.CODE:R6PRI:32::SIGRIE +"sigrie %#lx" +*nanomips32r6: +*nanomips64r6: +{ + SignalException (ReservedInstruction, instruction_0); +} + +100000,5.RT!0,5.RS,1100,3.X,0000,5.SHIFT:R6PSLL:32::SLL32 +"sll r, r, " +*nanomips32r6: +*nanomips64r6: +{ + do_sll (SD_, RS, RT, SHIFT); +} + +001000,5.RT,5.RS,5.RD,1.X,0000010,000:R6POOL32A0:32::SLLV +"sllv r, r, r" +*nanomips32r6: +*nanomips64r6: +{ + do_sllv (SD_, RT, RS, RD); +} + +001000,5.RT,5.RS,5.RD,1.X,1101010,000:R6POOL32A0:32::SLT +"slt r, r, r" +*nanomips32r6: +*nanomips64r6: +{ + do_slt (SD_, RS, RT, RD); +} + +100000,5.RT,5.RS,0100,12.IMMEDIATE:R6PU12:32::SLTI +"slti r, r, " +*nanomips32r6: +*nanomips64r6: +{ + do_slti (SD_, RS, RT, EXTEND12(IMMEDIATE)); +} + +100000,5.RT,5.RS,0101,12.U:R6PU12:32::SLTIU +"sltiu r, r, " +*nanomips32r6: +*nanomips64r6: +{ + do_sltiu (SD_, RS, RT, EXTEND12(U)); +} + +001000,5.RT,5.RS,5.RD!0,1.X,1110010,000:R6PSLTU:32::SLTU +"sltu r, r, r" +*nanomips32r6: +*nanomips64r6: +{ + do_sltu (SD_, RS, RT, RD); +} + +100000,5.RT,5.RS,1100,3.X,0100,5.SHIFT:R6PSHIFT:32::SRA +"sra r, r, " +*nanomips32r6: +*nanomips64r6: +{ + do_sra (SD_, RS, RT, SHIFT); +} + +001000,5.RT,5.RS,5.RD,1.X,0010010,000:R6POOL32A0:32::SRAV +"srav r, r, r" +*nanomips32r6: +*nanomips64r6: +{ + do_srav (SD_, RT, RS, RD); +} + +100000,5.RT,5.RS,1100,3.X,0010,5.SHIFT:R6PSHIFT:32::SRL32 +"srl r, r, " +*nanomips32r6: +*nanomips64r6: +{ + do_srl (SD_, RS, RT, SHIFT); +} + +001000,5.RT,5.RS,5.RD,1.X,0001010,000:R6POOL32A0:32::SRLV +"srlv r, r, r" +*nanomips32r6: +*nanomips64r6: +{ + do_srlv (SD_, RT, RS, RD); +} + +001000,5.RT,5.RS,5.RD,1.X,0110010,000:R6POOL32A0:32::SUB +"sub r, r, r" +*nanomips32r6: +*nanomips64r6: +{ + check_nms_flag (SD_); + do_sub (SD_, RS, RT, RD); +} + +001000,5.RT,5.RS,5.RD,1.X,0111010,000:R6POOL32A0:32::SUBU32 +"subu r, r, r" +*nanomips32r6: +*nanomips64r6: +{ + do_subu (SD_, RS, RT, RD); +} + +100001,5.RT,5.RS,1001,12.U:R6PLSU12:32::SWU12 +"sw r, (r)" +*nanomips32r6: +*nanomips64r6: +{ + do_store (SD_, AccessLength_WORD, GPR[RS], U, GPR[RT]); +} + +101001,5.RT,5.RS,1.S1,1001,0,00,8.S2:R6PLS0:32::SWS9 +"sw r, (r)" +*nanomips32r6: +*nanomips64r6: +{ + do_store (SD_, AccessLength_WORD, GPR[RS], S_9_BIT, GPR[RT]); +} + +010000,5.RT,19.U,11:R6PGPW:32::SWGP +"sw r, (GP)" +*nanomips32r6: +*nanomips64r6: +{ + do_store (SD_, AccessLength_WORD, GP, U_SHIFT_2BIT, GPR[RT]); +} + +011000,5.RT,01111,16.IMM48:R6POOL48I:32::SWPC48 +"swpc r, " +*nanomips32r6: +*nanomips64r6: +{ + uint16_t U2; + uint32_t total; + check_nms_flag (SD_); + U2 = do_load (SD_, AccessLength_HALFWORD, CIA + 4, 0); + total = U2 << 16 | IMM48; + TRACE_ALU_INPUT2(GPR[RT], total); + do_store(SD_, AccessLength_WORD, CIA + 6, total, GPR[RT]); + TRACE_ALU_RESULT(GPR[RT]); + NIA = CIA + 6; +} + + +110101,3.RTZ,7.U:R6P16:16::SWGP16 +"sw r, (GP)" +*nanomips32r6: +*nanomips64r6: +{ + do_store (SD_, AccessLength_WORD, GP, U_SHIFT_2BIT, GPR[TRTZ]); +} + +001000,5.RT,5.RS,5.RD,1001,0,000,111:R6PPLSX:32::SWX +"swx r, r(r)" +*nanomips32r6: +*nanomips64r6: +{ + check_nms_flag (SD_); + do_store (SD_, AccessLength_WORD, GPR[RT], GPR[RS], GPR[RD]); +} + +001000,5.RT,5.RS,5.RD,1001,1,000,111:R6PPLSXS:32::SWXS +"swxs r, r(r)" +*nanomips32r6: +*nanomips64r6: +{ + check_nms_flag (SD_); + do_store (SD_, AccessLength_WORD, GPR[RT], GPR[RS] << 2, GPR[RD]); +} + +111101,1.RT1,1.U2,3.RT2,1.RS1,1.U3,3.RS2:R6P16:16::SW4X4 +"sw r, (r)" +*nanomips32r6: +*nanomips64r6: +{ + check_nms_flag (SD_); + do_store (SD_, AccessLength_WORD, GPR[RS_5_BIT_NM], U_LW4X4, GPR[RT_5_BIT_NM_Z]); +} + +101001,5.RT,5.RS,1.S1,3.COUNT3,1,1,00,8.S2:R6PLSWM:32::SWM +"swm r, (r), " +*nanomips32r6: +*nanomips64r6: +{ + int counter = 0; + int source; + int offsetm; + + check_nms_flag (SD_); + + while (counter != COUNT) + { + if (RT == 0) + source = 0; + else + source = (RT & 0x10) | ((RT + counter) & 0x1F); + + offsetm = S_9_BIT + (counter << 2); + + do_sw (SD_, source, offsetm, RS); + + counter++; + + if (counter != 0) + COP0_COUNT++; + } +} + +100000,00000,5.STYPE,1100,3.X,0000,00110:R6PHB:32::SYNC +"sync":STYPE==0 +"sync " +*nanomips32r6: +*nanomips64r6: +{ + SyncOperation (STYPE); +} + +101001,11111,5.RS,1.S1,0011,0,00,8.S2:R6PPREFS:32::SYNCI +"synci (r)" +*nanomips32r6: +*nanomips64r6: +{ + // sync i-cache - nothing to do currently + sim_io_printf (SD, "Not implemented"); +} + +000000,00000,11,19.CODE:R6PRI:32::SDBBP32 +"sdbbp %#lx" +*nanomips32r6: +*nanomips64r6: +{ + SignalException (DebugBreakPoint, instruction_0); +} + +001000,10.X,00,00001,101,111,111:R6POOL32AXF5GROUP0:32::TLBP +"tlbp" +*nanomips32r6: +*nanomips64r6: +{ + // nothing to do currently + sim_io_printf (SD, "Not implemented"); +} + +001000,10.X,00,10001,101,111,111:R6POOL32AXF5GROUP0:32::TLBWI +"tlbwi" +*nanomips32r6: +*nanomips64r6: +{ + // nothing to do currently + sim_io_printf (SD, "Not implemented"); +} + +001000,10.X,00,11001,101,111,111:R6POOL32AXF5GROUP0:32::TLBWR +"tlbwr" +*nanomips32r6: +*nanomips64r6: +{ + // nothing to do currently + sim_io_printf (SD, "Not implemented"); +} + + +001000,0000000000,01,00001,101,111,111:R6POOL32AXF5GROUP1:32::TLBINV +"tlbinv" +*nanomips32r6: +*nanomips64r6: +{ + // invalidate a set of TLB entries based on ASID and Index match - nothing to do currently + sim_io_printf (SD, "Not implemented"); +} + +001000,0000000000,01,01001,101,111,111:R6POOL32AXF5GROUP1:32::TLBINVF +"tlbinvf" +*nanomips32r6: +*nanomips64r6: +{ + // invalidate a set of TLB entries based on Index match - nothing to do currently + sim_io_printf (SD, "Not implemented"); +} + +001000,10.CODE,10,00101,101,111,111:R6PSYSCALL:32::SYSCALL +"syscall %#lx" +*nanomips32r6: +*nanomips64r6: +{ + SignalException (SystemCall, instruction_0); +} + +100000,00000,5.X1,1100,3.X2,0000,00011:R6PHB:32::EHB +"ehb" +*nanomips32r6: +*nanomips64r6: +{ + // Do nothing, there are no hazards to clear +} + +001000,5.RT,5.RS,5.X,0,0000000,000:R6PTRAP:32::TEQ +"teq r, r" +*nanomips32r6: +*nanomips64r6: +{ + check_nms_flag (SD_); + + if (GPR[RS] == GPR[RT]) + SignalException(Trap, instruction_0); +} + +001000,5.RT,5.RS,5.X,1,0000000,000:R6PTRAP:32::TNE +"tne r, r" +*nanomips32r6: +*nanomips64r6: +{ + check_nms_flag (SD_); + + if (GPR[RS] != GPR[RT]) + SignalException(Trap, instruction_0); +} + +101001,5.RT,5.RS,1.S1,0100,0,01,8.S2:R6PLSS1:32::UALH +"ualh r, (r)" +*nanomips32r6: +*nanomips64r6: +{ + check_nms_flag (SD_); + + TRACE_ALU_INPUT3(GPR[RT], S_9_BIT, GPR[RS]); + do_lh (SD_, RT, S_9_BIT, RS); + TRACE_ALU_RESULT(GPR[RT]); +} + +101001,5.RT,5.RS,1.S1,3.COUNT3,0,1,01,8.S2:R6PLSUAWM:32::UALWM +"ualwm r, (r), ":COUNT != 1 +"ualw r, (r)" +*nanomips32r6: +*nanomips64r6: +{ + int i; + int dest; + int this_offset; + + address_word base = GPR[RS]; + for(i = 0; i< COUNT; i++) + { + dest = (RT & 0x10) | ((RT + i) & 0x1F); + + if (dest == RS && i != COUNT - 1) + Unpredictable (); + + this_offset = S_9_BIT + (i << 2); + + if(BigEndianCPU) { + GPR[dest] = EXTEND32 (do_load_left (SD_, AccessLength_WORD, base, + EXTEND16 (this_offset), GPR[dest])); + GPR[dest] = EXTEND32 (do_load_right (SD_, AccessLength_WORD, base, + EXTEND16 (this_offset + AccessLength_WORD), GPR[dest])); + } else { + GPR[dest] = EXTEND32 (do_load_right (SD_, AccessLength_WORD, base, + EXTEND16 (this_offset), GPR[dest])); + GPR[dest] = EXTEND32 (do_load_left (SD_, AccessLength_WORD, base, + EXTEND16 (this_offset + AccessLength_WORD), GPR[dest])); + } + + if (i != 0) + COP0_COUNT++; + } +} + +101001,5.RT,5.RS,1.S1,0101,0,01,8.S2:R6PLSS1:32::UASH +"uash r, (r)" +*nanomips32r6: +*nanomips64r6: +{ + check_nms_flag (SD_); + + do_store (SD_, AccessLength_HALFWORD, GPR[RS], S_9_BIT, GPR[RT]); +} + +101001,5.RT,5.RS,1.S1,3.COUNT3,1,1,01,8.S2:R6PLSUAWM:32::UASWM +"uaswm r, (r), ":COUNT != 1 +"uasw r, (r)" +*nanomips32r6: +*nanomips64r6: +{ + + int i; + int source; + int offsetm; + + for(i = 0; i< COUNT; i++) + { + if (RT == 0) + source = 0; + else + source = (RT & 0x10) | ((RT + i) & 0x1F); + + offsetm = S_9_BIT + (i << 2); + + if(BigEndianCPU) { + do_store_left (SD_, AccessLength_WORD, GPR[RS], EXTEND16 (offsetm), GPR[source]); + do_store_right (SD_, AccessLength_WORD, GPR[RS], + EXTEND16 (offsetm + AccessLength_WORD), GPR[source]); + } else { + do_store_right (SD_, AccessLength_WORD, GPR[RS], EXTEND16 (offsetm), GPR[source]); + do_store_left (SD_, AccessLength_WORD, GPR[RS], + EXTEND16 (offsetm + AccessLength_WORD), GPR[source]); + } + + if (i != 0) + COP0_COUNT++; + } +} + +001000,5.RT,5.X,00000,0,1110010,000:R6PDVP:32::DVP +"dvp r" +*nanomips32r6: +*nanomips64r6: +{ + // nothing to do currently + sim_io_printf (SD, "Not implemented"); +} + + +001000,5.RT,5.HS,2.X1,3.SEL,1.X2,0111000,000:R6POOL32A0:32::RDHWR +"rdhwr r, r, " +*nanomips32r6: +*nanomips64r6: +{ + check_nms_flag (SD_); + do_rdhwr (SD_, RT, HS); +} + +001000,5.RT,5.RS,11,10000,101,111,111:R6POOL32AXF5GROUP3:32::RDPGPR +"rdpgpr r, r" +*nanomips32r6: +*nanomips64r6: +{ + // nothing to do currently + sim_io_printf (SD, "Not implemented"); +} + +001000,5.RT,5.RS,11,11000,101,111,111:R6POOL32AXF5GROUP3:32::WRPGPR +"wrpgpr r, r" +*nanomips32r6: +*nanomips64r6: +{ + // nothing to do currently + sim_io_printf (SD, "Not implemented"); +} + +001000,5.RT,5.RS,5.RD,1.X,1111010,000:R6POOL32A0:32::SOV +"SOV r, r, r" +*nanomips32r6: +*nanomips64r6: +{ + if (NotWordValue (GPR[RS]) || NotWordValue (GPR[RT])) + Unpredictable (); + TRACE_ALU_INPUT2 (GPR[RS], GPR[RT]); + { + ALU32_BEGIN (GPR[RS]); + ALU32_ADD (GPR[RT]); + if (ALU32_HAD_OVERFLOW) + GPR[RD] = 1; + else + GPR[RD] = 0; + } + TRACE_ALU_RESULT (GPR[RD]); +} + +001000,10.X,11,10001,101,111,111:R6POOL32A0:32::DERET +"deret" +*nanomips32r6: +*nanomips64r6: +{ + // nothing to do currently + sim_io_printf (SD, "Not implemented"); +} + +001000,5.RT,5.X,00000,1,1110010,000:R6PDVP:32::EVP +"evp r" : RT!=0 +"evp" +*nanomips32r6: +*nanomips64r6: +{ + // nothing to do currently + sim_io_printf (SD, "Not implemented"); +} + +001000,10.CODE,110000110,1111111:R6POOL32AXF5GROUP2:32::WAIT +"wait" +*nanomips32r6: +*nanomips64r6: +{ + // nothing to do currently + sim_io_printf (SD, "Not implemented"); +} + +011000,5.RT,00000,16.IMM48:R6POOL48I:32::LI48 +"li r, " +*nanomips32r6: +*nanomips64r6: +{ + uint16_t U2; + uint32_t total; + check_nms_flag (SD_); + U2 = do_load (SD_, AccessLength_HALFWORD, CIA + 4, 0); + total = U2 << 16 | IMM48; + TRACE_ALU_INPUT2(GPR[RT], total); + GPR[RT] = EXTEND32(total); + TRACE_ALU_RESULT(GPR[RT]); + NIA = CIA + 6; +} + +011000,5.RT,00001,16.IMM48:R6POOL48I:32::ADDIU48 +"addiu r, " +*nanomips32r6: +*nanomips64r6: +{ + uint16_t S2; + uint32_t total; + check_nms_flag (SD_); + S2 = do_load(SD_, AccessLength_HALFWORD, CIA + 4, 0); + total = S2 << 16 | IMM48; + do_addiu(SD_, RT, RT, total); + NIA = CIA + 6; +} + +100000,5.RT,5.RS,1000,12.U:R6PU12:32::ADDIUNEG +"addiu r, r, -" +*nanomips32r6: +*nanomips64r6: +{ + do_addiu (SD_, RS, RT, -U); +} + +011000,5.RT,00010,16.IMM48:R6POOL48I:32::ADDIUGP48 +"addiu r, GP, " +*nanomips32r6: +*nanomips64r6: +{ + uint16_t S2; + uint32_t total; + check_nms_flag (SD_); + S2 = do_load(SD_, AccessLength_HALFWORD, CIA + 4, 0); + total = S2 << 16 | IMM48; + do_addiu (SD_, GPIDX, RT, total); + NIA = CIA + 6; +} + +010010,00000,5.RS,1000,12.X:R6BALRSC:32::BRSC +"brsc r" +*nanomips32r6: +*nanomips64r6: +{ + unsigned_word address = NIA + (GPR[RS] << 1); + NIA = address; +} + +010010,5.RT!0,5.RS,1000,12.X:R6PBALRSC:32::BALRSC +"balrsc r, r" +*nanomips32r6: +*nanomips64r6: +{ + unsigned_word address = NIA + (GPR[RS] << 1); + + GPR[RT] = NIA; + NIA = address; + + // For cycle counting + COP0_COUNT++; +} + +110010,5.RT,001,1.X,6.BIT,10.S1,1.S2:R6PBRI:32::BBEQZC +"bbeqzc r, , " +*nanomips32r6: +*nanomips64r6: +{ + int testbit = (GPR[RT] >> BIT) & 1; + + check_nms_flag (SD_); + + if (testbit == 0) + NIA = ADDRESS12; +} + +110010,5.RT,101,1.X,6.BIT,10.S1,1.S2:R6PBRI:32::BBNEZC +"bbnezc r, , " +*nanomips32r6: +*nanomips64r6: +{ + int testbit = (GPR[RT] >> BIT) & 1; + + check_nms_flag (SD_); + + if (testbit == 1) + NIA = ADDRESS12; +} + +:function:::void:do_lb:int rt, int offset, int base +*nanomips32r6: +*nanomips64r6: +{ + GPR[rt] = EXTEND8 (do_load (SD_, AccessLength_BYTE, GPR[base], offset)); +} + +:function:::void:do_lh:int rt, int offset, int base +*nanomips32r6: +*nanomips64r6: +{ + GPR[rt] = EXTEND16 (do_load (SD_, AccessLength_HALFWORD, GPR[base], offset)); +} + +:function:::void:do_lw:int rt, int offset, int base +*nanomips32r6: +*nanomips64r6: +{ + GPR[rt] = EXTEND32 (do_load (SD_, AccessLength_WORD, GPR[base], offset)); +} + +:function:::void:do_lhu:int rt, int offset, int base +*nanomips32r6: +*nanomips64r6: +{ + GPR[rt] = do_load (SD_, AccessLength_HALFWORD, GPR[base], offset); +} + +:function:::void:do_addiu:int rs, int rt, int immediate +*nanomips32r6: +*nanomips64r6: +{ + if (NotWordValue (GPR[rs])) + Unpredictable (); + TRACE_ALU_INPUT2 (GPR[rs], immediate); + GPR[rt] = EXTEND32 (GPR[rs] + immediate); + TRACE_ALU_RESULT (GPR[rt]); +} diff --git a/sim/mips/nanomipsrun.c b/sim/mips/nanomipsrun.c new file mode 100644 index 00000000000..8698726a9fa --- /dev/null +++ b/sim/mips/nanomipsrun.c @@ -0,0 +1,109 @@ +/* Run function for the nanomips simulator + + Copyright (C) 2018-2022 Free Software Foundation, Inc. + + Written by Andrew Bennett . + + This file is part of GDB, the GNU debugger. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . */ + +#include "sim-main.h" +#include "nanomips16_idecode.h" +#include "nanomips32_idecode.h" +#include "bfd.h" + + +#define SD sd +#define CPU cpu +#define SIM_MONITOR_ADDRESS 0xBFC00000 + +void +sim_engine_run (SIM_DESC sd, int next_cpu_nr, int nr_cpus, int signal); + +address_word +nanomips_instruction_decode (SIM_DESC sd, sim_cpu * cpu, + address_word cia, + int instruction_size); + +address_word +nanomips_instruction_decode (SIM_DESC sd, sim_cpu * cpu, + address_word cia, + int instruction_size) +{ + + nanomips16_instruction_word instruction_0 = IMEM16_NANOMIPS (cia); + + if((cia & 0xFFF00000) == SIM_MONITOR_ADDRESS) { + nanomips32_instruction_word instruction_0 = IMEM32 (cia); + return nanomips32_idecode_issue (sd, instruction_0, cia); + } else if ((STATE_ARCHITECTURE (sd)->mach == bfd_mach_nanomipsisa32r6 + || STATE_ARCHITECTURE (sd)->mach == bfd_mach_nanomipsisa64r6) + && (NANOMIPS_MAJOR_OPCODE_3_5 (instruction_0) & 0x4) == 4) + return nanomips16_idecode_issue (sd, instruction_0, cia); + else + { + nanomips32_instruction_word instruction_0 = IMEM32_NANOMIPS (cia); + return nanomips32_idecode_issue (sd, instruction_0, cia); + } +} + +void +sim_engine_run (SIM_DESC sd, int next_cpu_nr, int nr_cpus, + int signal) +{ + nanomips32_instruction_word instruction_0; + sim_cpu *cpu = STATE_CPU (sd, next_cpu_nr); + nanomips32_instruction_address cia = CPU_PC_GET (cpu); + unsigned long bfdmach; + IS_NANOMIPS = 1; + + bfdmach = STATE_ARCHITECTURE(SD)->mach; + + if (is_nms_flag_set == 0 && (bfdmach == bfd_mach_nanomipsisa64r6 + || bfdmach == bfd_mach_nanomipsisa32r6)) + set_nms_flag (sd); + + while (1) + { + nanomips32_instruction_address nia; + + cia = cia & ~0x1; + +#if defined (ENGINE_ISSUE_PREFIX_HOOK) + ENGINE_ISSUE_PREFIX_HOOK (); +#endif + + nia = + nanomips_instruction_decode (sd, cpu, cia, + MICROMIPS_DELAYSLOT_SIZE_ANY); + +#if defined (ENGINE_ISSUE_POSTFIX_HOOK) + ENGINE_ISSUE_POSTFIX_HOOK (); +#endif + // Cycle counting + COP0_COUNT++; + + /* Update the instruction address */ + cia = nia; + + /* process any events */ + if (sim_events_tick (sd)) + { + CPU_PC_SET (CPU, cia); + sim_events_process (sd); + cia = CPU_PC_GET (CPU); + } + } +} diff --git a/sim/mips/nms.c b/sim/mips/nms.c new file mode 100644 index 00000000000..fd957d69e8b --- /dev/null +++ b/sim/mips/nms.c @@ -0,0 +1,44 @@ +/* Run function for the nanomips simulator + + Copyright (C) 2018-2022 Free Software Foundation, Inc. + + Written by Andrew Bennett . + + This file is part of GDB, the GNU debugger. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . */ + +#include "sim-main.h" +#include "elf/mips-common.h" +#include "elf/nanomips.h" + +/* NMS Flag */ +int nms_flag = -1; + +int is_nms_flag_set = 0; + +void +set_nms_flag (SIM_DESC sd) +{ + Elf_Internal_ABIFlags_v0 *abiflags; + abiflags = bfd_nanomips_elf_get_abiflags (STATE_PROG_BFD(sd)); + + nms_flag = 0; + + if (abiflags != NULL + && ((abiflags->ases & NANOMIPS_ASE_xNMS) != 0)) + nms_flag = 1; + + is_nms_flag_set = 1; +} diff --git a/sim/mips/sim-main.h b/sim/mips/sim-main.h index 418c6599118..e6b2b47ede7 100644 --- a/sim/mips/sim-main.h +++ b/sim/mips/sim-main.h @@ -318,9 +318,9 @@ struct _sim_cpu { #define LAST_EMBED_REGNUM (96) #define NUM_REGS (LAST_EMBED_REGNUM + 1) -#define FP0_REGNUM 38 /* Floating point register 0 (single float) */ -#define FCRCS_REGNUM 70 /* FP control/status */ -#define FCRIR_REGNUM 71 /* FP implementation/revision */ +#define FP0_REGNUM ((CPU)->is_nanomips ? 36 : 38) /* Floating point register 0 (single float) */ +#define FCRCS_REGNUM ((CPU)->is_nanomips ? 68 : 70) /* FP control/status */ +#define FCRIR_REGNUM ((CPU)->is_nanomips ? 69 : 71) /* FP implementation/revision */ #endif @@ -336,16 +336,19 @@ struct _sim_cpu { #define GPR (®ISTERS[0]) #define GPR_SET(N,VAL) (REGISTERS[(N)] = (VAL)) -#define LO (REGISTERS[33]) -#define HI (REGISTERS[34]) -#define PCIDX 37 +#define HIIDX ((CPU)->is_nanomips ? 70 : 33) +#define LOIDX ((CPU)->is_nanomips ? 71 : 34) +#define HI (REGISTERS[HIIDX]) +#define LO (REGISTERS[LOIDX]) +#define PCIDX ((CPU)->is_nanomips ? 32 : 37) #define PC (REGISTERS[PCIDX]) -#define CAUSE (REGISTERS[36]) +#define COUSEIDX ((CPU)->is_nanomips ? 34 : 36) +#define CAUSE (REGISTERS[COUSEIDX]) #define SRIDX (32) #define SR (REGISTERS[SRIDX]) /* CPU status register */ -#define FCR0IDX (71) +#define FCR0IDX ((CPU)->is_nanomips ? 69 : 71) #define FCR0 (REGISTERS[FCR0IDX]) /* really a 32bit register */ -#define FCR31IDX (70) +#define FCR31IDX ((CPU)->is_nanomips ? 68 : 70) #define FCR31 (REGISTERS[FCR31IDX]) /* really a 32bit register */ #define FCSR (FCR31) #define Debug (REGISTERS[86]) @@ -362,10 +365,10 @@ struct _sim_cpu { #define AC3LOIDX (94) #define AC3HIIDX (95) -#define DSPLO(N) (REGISTERS[DSPLO_REGNUM[N]]) -#define DSPHI(N) (REGISTERS[DSPHI_REGNUM[N]]) +#define DSPLO(N) (REGISTERS[((CPU)->is_nanomips ? (LOIDX + 2 * N) : DSPLO_REGNUM[N])]) +#define DSPHI(N) (REGISTERS[((CPU)->is_nanomips ? (HIIDX + 2 * N) : DSPHI_REGNUM[N])]) -#define DSPCRIDX (96) /* DSP control register */ +#define DSPCRIDX ((CPU)->is_nanomips ? 79 : 96) /* DSP control register */ #define DSPCR (REGISTERS[DSPCRIDX]) #define DSPCR_POS_SHIFT (0) @@ -420,6 +423,8 @@ struct _sim_cpu { #define A3 (REGISTERS[7]) #define T8IDX 24 #define T8 (REGISTERS[T8IDX]) +#define GPIDX 28 +#define GP (REGISTERS[GPIDX]) #define SPIDX 29 #define SP (REGISTERS[SPIDX]) #define RAIDX 31 @@ -433,6 +438,7 @@ struct _sim_cpu { unsigned_word cop0_gpr[NR_COP0_GPR]; #define COP0_GPR ((CPU)->cop0_gpr) #define COP0_BADVADDR (COP0_GPR[8]) +#define COP0_COUNT (COP0_GPR[9]) /* While space is allocated for the floating point registers in the main registers array, they are stored separatly. This is because @@ -472,10 +478,21 @@ struct _sim_cpu { hilo_history lo_history; #define LOHISTORY (&(CPU)->lo_history) + int is_nanomips; +#define IS_NANOMIPS ((CPU)->is_nanomips) sim_cpu_base base; }; +#define SET_RV0(VAL) \ + do { \ + if ((CPU)->is_nanomips) \ + A0 = VAL; \ + else \ + V0 = VAL; \ + } while (0) + + extern void mips_sim_close (SIM_DESC sd, int quitting); #define SIM_CLOSE_HOOK(...) mips_sim_close (__VA_ARGS__) @@ -643,13 +660,16 @@ enum ExceptionCause { is used by gdb for break-points. NOTE: Care must be taken, since this value may be used in later revisions of the MIPS ISA. */ #define HALT_INSTRUCTION_MASK (0x03FFFFC0) +#define HALT_INSTRUCTION_MASK_NANOMIPS (0x0007FFFF) #define HALT_INSTRUCTION (0x03ff000d) #define HALT_INSTRUCTION2 (0x0000ffcd) +#define HALT_INSTRUCTION_NANOMIPS (0x001003FF) #define BREAKPOINT_INSTRUCTION (0x0005000d) #define BREAKPOINT_INSTRUCTION2 (0x0000014d) +#define BREAKPOINT_INSTRUCTION_NANOMIPS (0x00101400) @@ -1022,6 +1042,16 @@ INLINE_SIM_MAIN (uint16_t) ifetch16 (SIM_DESC sd, sim_cpu *cpu, address_word cia #define MICROMIPS_DELAYSLOT_SIZE_16 2 #define MICROMIPS_DELAYSLOT_SIZE_32 4 +#define IMEM32_NANOMIPS(CIA) \ + (ifetch16 (SD, CPU, (CIA), (CIA)) << 16 | ifetch16 (SD, CPU, (CIA + 2), \ + (CIA + 2))) +#define IMEM16_NANOMIPS(CIA) ifetch16 (SD, CPU, (CIA), ((CIA))) + + +#define NANOMIPS_MAJOR_OPCODE_3_5(INSN) ((INSN & 0x1c00) >> 10) + +#define NANOMIPS_DELAYSLOT_SIZE_ANY 0 + extern int isa_mode; #define ISA_MODE_MIPS32 0 @@ -1041,6 +1071,13 @@ extern FILE *tracefh; extern int DSPLO_REGNUM[4]; extern int DSPHI_REGNUM[4]; +/* NMS Flag */ +extern int nms_flag; +extern int is_nms_flag_set; + +void +set_nms_flag (SIM_DESC sd); + INLINE_SIM_MAIN (void) pending_tick (SIM_DESC sd, sim_cpu *cpu, address_word cia); extern SIM_CORE_SIGNAL_FN mips_core_signal;