Commit | Line | Data |
---|---|---|
8c4c1818 JM |
1 | /* Simulator instruction decoder for bpfbf_ebpfbe. |
2 | ||
3 | THIS FILE IS MACHINE GENERATED WITH CGEN. | |
4 | ||
3666a048 | 5 | Copyright (C) 1996-2021 Free Software Foundation, Inc. |
8c4c1818 JM |
6 | |
7 | This file is part of the GNU simulators. | |
8 | ||
9 | This file is free software; you can redistribute it and/or modify | |
10 | it under the terms of the GNU General Public License as published by | |
11 | the Free Software Foundation; either version 3, or (at your option) | |
12 | any later version. | |
13 | ||
14 | It is distributed in the hope that it will be useful, but WITHOUT | |
15 | ANY WARRANTY; without even the implied warranty of MERCHANTABILITY | |
16 | or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public | |
17 | License for more details. | |
18 | ||
19 | You should have received a copy of the GNU General Public License along | |
20 | with this program; if not, write to the Free Software Foundation, Inc., | |
21 | 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. | |
22 | ||
23 | */ | |
24 | ||
25 | #define WANT_CPU bpfbf | |
26 | #define WANT_CPU_BPFBF | |
27 | ||
28 | #include "sim-main.h" | |
29 | #include "sim-assert.h" | |
30 | ||
31 | /* The instruction descriptor array. | |
32 | This is computed at runtime. Space for it is not malloc'd to save a | |
33 | teensy bit of cpu in the decoder. Moving it to malloc space is trivial | |
34 | but won't be done until necessary (we don't currently support the runtime | |
35 | addition of instructions nor an SMP machine with different cpus). */ | |
36 | static IDESC bpfbf_ebpfbe_insn_data[BPFBF_EBPFBE_INSN__MAX]; | |
37 | ||
38 | /* Commas between elements are contained in the macros. | |
39 | Some of these are conditionally compiled out. */ | |
40 | ||
41 | static const struct insn_sem bpfbf_ebpfbe_insn_sem[] = | |
42 | { | |
43 | { VIRTUAL_INSN_X_INVALID, BPFBF_EBPFBE_INSN_X_INVALID, BPFBF_EBPFBE_SFMT_EMPTY }, | |
44 | { VIRTUAL_INSN_X_AFTER, BPFBF_EBPFBE_INSN_X_AFTER, BPFBF_EBPFBE_SFMT_EMPTY }, | |
45 | { VIRTUAL_INSN_X_BEFORE, BPFBF_EBPFBE_INSN_X_BEFORE, BPFBF_EBPFBE_SFMT_EMPTY }, | |
46 | { VIRTUAL_INSN_X_CTI_CHAIN, BPFBF_EBPFBE_INSN_X_CTI_CHAIN, BPFBF_EBPFBE_SFMT_EMPTY }, | |
47 | { VIRTUAL_INSN_X_CHAIN, BPFBF_EBPFBE_INSN_X_CHAIN, BPFBF_EBPFBE_SFMT_EMPTY }, | |
48 | { VIRTUAL_INSN_X_BEGIN, BPFBF_EBPFBE_INSN_X_BEGIN, BPFBF_EBPFBE_SFMT_EMPTY }, | |
49 | { BPF_INSN_ADDIBE, BPFBF_EBPFBE_INSN_ADDIBE, BPFBF_EBPFBE_SFMT_ADDIBE }, | |
50 | { BPF_INSN_ADDRBE, BPFBF_EBPFBE_INSN_ADDRBE, BPFBF_EBPFBE_SFMT_ADDRBE }, | |
51 | { BPF_INSN_ADD32IBE, BPFBF_EBPFBE_INSN_ADD32IBE, BPFBF_EBPFBE_SFMT_ADDIBE }, | |
52 | { BPF_INSN_ADD32RBE, BPFBF_EBPFBE_INSN_ADD32RBE, BPFBF_EBPFBE_SFMT_ADDRBE }, | |
53 | { BPF_INSN_SUBIBE, BPFBF_EBPFBE_INSN_SUBIBE, BPFBF_EBPFBE_SFMT_ADDIBE }, | |
54 | { BPF_INSN_SUBRBE, BPFBF_EBPFBE_INSN_SUBRBE, BPFBF_EBPFBE_SFMT_ADDRBE }, | |
55 | { BPF_INSN_SUB32IBE, BPFBF_EBPFBE_INSN_SUB32IBE, BPFBF_EBPFBE_SFMT_ADDIBE }, | |
56 | { BPF_INSN_SUB32RBE, BPFBF_EBPFBE_INSN_SUB32RBE, BPFBF_EBPFBE_SFMT_ADDRBE }, | |
57 | { BPF_INSN_MULIBE, BPFBF_EBPFBE_INSN_MULIBE, BPFBF_EBPFBE_SFMT_ADDIBE }, | |
58 | { BPF_INSN_MULRBE, BPFBF_EBPFBE_INSN_MULRBE, BPFBF_EBPFBE_SFMT_ADDRBE }, | |
59 | { BPF_INSN_MUL32IBE, BPFBF_EBPFBE_INSN_MUL32IBE, BPFBF_EBPFBE_SFMT_ADDIBE }, | |
60 | { BPF_INSN_MUL32RBE, BPFBF_EBPFBE_INSN_MUL32RBE, BPFBF_EBPFBE_SFMT_ADDRBE }, | |
61 | { BPF_INSN_DIVIBE, BPFBF_EBPFBE_INSN_DIVIBE, BPFBF_EBPFBE_SFMT_ADDIBE }, | |
62 | { BPF_INSN_DIVRBE, BPFBF_EBPFBE_INSN_DIVRBE, BPFBF_EBPFBE_SFMT_ADDRBE }, | |
63 | { BPF_INSN_DIV32IBE, BPFBF_EBPFBE_INSN_DIV32IBE, BPFBF_EBPFBE_SFMT_ADDIBE }, | |
64 | { BPF_INSN_DIV32RBE, BPFBF_EBPFBE_INSN_DIV32RBE, BPFBF_EBPFBE_SFMT_ADDRBE }, | |
65 | { BPF_INSN_ORIBE, BPFBF_EBPFBE_INSN_ORIBE, BPFBF_EBPFBE_SFMT_ADDIBE }, | |
66 | { BPF_INSN_ORRBE, BPFBF_EBPFBE_INSN_ORRBE, BPFBF_EBPFBE_SFMT_ADDRBE }, | |
67 | { BPF_INSN_OR32IBE, BPFBF_EBPFBE_INSN_OR32IBE, BPFBF_EBPFBE_SFMT_ADDIBE }, | |
68 | { BPF_INSN_OR32RBE, BPFBF_EBPFBE_INSN_OR32RBE, BPFBF_EBPFBE_SFMT_ADDRBE }, | |
69 | { BPF_INSN_ANDIBE, BPFBF_EBPFBE_INSN_ANDIBE, BPFBF_EBPFBE_SFMT_ADDIBE }, | |
70 | { BPF_INSN_ANDRBE, BPFBF_EBPFBE_INSN_ANDRBE, BPFBF_EBPFBE_SFMT_ADDRBE }, | |
71 | { BPF_INSN_AND32IBE, BPFBF_EBPFBE_INSN_AND32IBE, BPFBF_EBPFBE_SFMT_ADDIBE }, | |
72 | { BPF_INSN_AND32RBE, BPFBF_EBPFBE_INSN_AND32RBE, BPFBF_EBPFBE_SFMT_ADDRBE }, | |
73 | { BPF_INSN_LSHIBE, BPFBF_EBPFBE_INSN_LSHIBE, BPFBF_EBPFBE_SFMT_ADDIBE }, | |
74 | { BPF_INSN_LSHRBE, BPFBF_EBPFBE_INSN_LSHRBE, BPFBF_EBPFBE_SFMT_ADDRBE }, | |
75 | { BPF_INSN_LSH32IBE, BPFBF_EBPFBE_INSN_LSH32IBE, BPFBF_EBPFBE_SFMT_ADDIBE }, | |
76 | { BPF_INSN_LSH32RBE, BPFBF_EBPFBE_INSN_LSH32RBE, BPFBF_EBPFBE_SFMT_ADDRBE }, | |
77 | { BPF_INSN_RSHIBE, BPFBF_EBPFBE_INSN_RSHIBE, BPFBF_EBPFBE_SFMT_ADDIBE }, | |
78 | { BPF_INSN_RSHRBE, BPFBF_EBPFBE_INSN_RSHRBE, BPFBF_EBPFBE_SFMT_ADDRBE }, | |
79 | { BPF_INSN_RSH32IBE, BPFBF_EBPFBE_INSN_RSH32IBE, BPFBF_EBPFBE_SFMT_ADDIBE }, | |
80 | { BPF_INSN_RSH32RBE, BPFBF_EBPFBE_INSN_RSH32RBE, BPFBF_EBPFBE_SFMT_ADDRBE }, | |
81 | { BPF_INSN_MODIBE, BPFBF_EBPFBE_INSN_MODIBE, BPFBF_EBPFBE_SFMT_ADDIBE }, | |
82 | { BPF_INSN_MODRBE, BPFBF_EBPFBE_INSN_MODRBE, BPFBF_EBPFBE_SFMT_ADDRBE }, | |
83 | { BPF_INSN_MOD32IBE, BPFBF_EBPFBE_INSN_MOD32IBE, BPFBF_EBPFBE_SFMT_ADDIBE }, | |
84 | { BPF_INSN_MOD32RBE, BPFBF_EBPFBE_INSN_MOD32RBE, BPFBF_EBPFBE_SFMT_ADDRBE }, | |
85 | { BPF_INSN_XORIBE, BPFBF_EBPFBE_INSN_XORIBE, BPFBF_EBPFBE_SFMT_ADDIBE }, | |
86 | { BPF_INSN_XORRBE, BPFBF_EBPFBE_INSN_XORRBE, BPFBF_EBPFBE_SFMT_ADDRBE }, | |
87 | { BPF_INSN_XOR32IBE, BPFBF_EBPFBE_INSN_XOR32IBE, BPFBF_EBPFBE_SFMT_ADDIBE }, | |
88 | { BPF_INSN_XOR32RBE, BPFBF_EBPFBE_INSN_XOR32RBE, BPFBF_EBPFBE_SFMT_ADDRBE }, | |
89 | { BPF_INSN_ARSHIBE, BPFBF_EBPFBE_INSN_ARSHIBE, BPFBF_EBPFBE_SFMT_ADDIBE }, | |
90 | { BPF_INSN_ARSHRBE, BPFBF_EBPFBE_INSN_ARSHRBE, BPFBF_EBPFBE_SFMT_ADDRBE }, | |
91 | { BPF_INSN_ARSH32IBE, BPFBF_EBPFBE_INSN_ARSH32IBE, BPFBF_EBPFBE_SFMT_ADDIBE }, | |
92 | { BPF_INSN_ARSH32RBE, BPFBF_EBPFBE_INSN_ARSH32RBE, BPFBF_EBPFBE_SFMT_ADDRBE }, | |
93 | { BPF_INSN_NEGBE, BPFBF_EBPFBE_INSN_NEGBE, BPFBF_EBPFBE_SFMT_NEGBE }, | |
94 | { BPF_INSN_NEG32BE, BPFBF_EBPFBE_INSN_NEG32BE, BPFBF_EBPFBE_SFMT_NEGBE }, | |
95 | { BPF_INSN_MOVIBE, BPFBF_EBPFBE_INSN_MOVIBE, BPFBF_EBPFBE_SFMT_MOVIBE }, | |
96 | { BPF_INSN_MOVRBE, BPFBF_EBPFBE_INSN_MOVRBE, BPFBF_EBPFBE_SFMT_MOVRBE }, | |
97 | { BPF_INSN_MOV32IBE, BPFBF_EBPFBE_INSN_MOV32IBE, BPFBF_EBPFBE_SFMT_MOVIBE }, | |
98 | { BPF_INSN_MOV32RBE, BPFBF_EBPFBE_INSN_MOV32RBE, BPFBF_EBPFBE_SFMT_MOVRBE }, | |
99 | { BPF_INSN_ENDLEBE, BPFBF_EBPFBE_INSN_ENDLEBE, BPFBF_EBPFBE_SFMT_ENDLEBE }, | |
100 | { BPF_INSN_ENDBEBE, BPFBF_EBPFBE_INSN_ENDBEBE, BPFBF_EBPFBE_SFMT_ENDLEBE }, | |
101 | { BPF_INSN_LDDWBE, BPFBF_EBPFBE_INSN_LDDWBE, BPFBF_EBPFBE_SFMT_LDDWBE }, | |
102 | { BPF_INSN_LDABSW, BPFBF_EBPFBE_INSN_LDABSW, BPFBF_EBPFBE_SFMT_LDABSW }, | |
103 | { BPF_INSN_LDABSH, BPFBF_EBPFBE_INSN_LDABSH, BPFBF_EBPFBE_SFMT_LDABSH }, | |
104 | { BPF_INSN_LDABSB, BPFBF_EBPFBE_INSN_LDABSB, BPFBF_EBPFBE_SFMT_LDABSB }, | |
105 | { BPF_INSN_LDABSDW, BPFBF_EBPFBE_INSN_LDABSDW, BPFBF_EBPFBE_SFMT_LDABSDW }, | |
106 | { BPF_INSN_LDINDWBE, BPFBF_EBPFBE_INSN_LDINDWBE, BPFBF_EBPFBE_SFMT_LDINDWBE }, | |
107 | { BPF_INSN_LDINDHBE, BPFBF_EBPFBE_INSN_LDINDHBE, BPFBF_EBPFBE_SFMT_LDINDHBE }, | |
108 | { BPF_INSN_LDINDBBE, BPFBF_EBPFBE_INSN_LDINDBBE, BPFBF_EBPFBE_SFMT_LDINDBBE }, | |
109 | { BPF_INSN_LDINDDWBE, BPFBF_EBPFBE_INSN_LDINDDWBE, BPFBF_EBPFBE_SFMT_LDINDDWBE }, | |
110 | { BPF_INSN_LDXWBE, BPFBF_EBPFBE_INSN_LDXWBE, BPFBF_EBPFBE_SFMT_LDXWBE }, | |
111 | { BPF_INSN_LDXHBE, BPFBF_EBPFBE_INSN_LDXHBE, BPFBF_EBPFBE_SFMT_LDXHBE }, | |
112 | { BPF_INSN_LDXBBE, BPFBF_EBPFBE_INSN_LDXBBE, BPFBF_EBPFBE_SFMT_LDXBBE }, | |
113 | { BPF_INSN_LDXDWBE, BPFBF_EBPFBE_INSN_LDXDWBE, BPFBF_EBPFBE_SFMT_LDXDWBE }, | |
114 | { BPF_INSN_STXWBE, BPFBF_EBPFBE_INSN_STXWBE, BPFBF_EBPFBE_SFMT_STXWBE }, | |
115 | { BPF_INSN_STXHBE, BPFBF_EBPFBE_INSN_STXHBE, BPFBF_EBPFBE_SFMT_STXHBE }, | |
116 | { BPF_INSN_STXBBE, BPFBF_EBPFBE_INSN_STXBBE, BPFBF_EBPFBE_SFMT_STXBBE }, | |
117 | { BPF_INSN_STXDWBE, BPFBF_EBPFBE_INSN_STXDWBE, BPFBF_EBPFBE_SFMT_STXDWBE }, | |
118 | { BPF_INSN_STBBE, BPFBF_EBPFBE_INSN_STBBE, BPFBF_EBPFBE_SFMT_STBBE }, | |
119 | { BPF_INSN_STHBE, BPFBF_EBPFBE_INSN_STHBE, BPFBF_EBPFBE_SFMT_STHBE }, | |
120 | { BPF_INSN_STWBE, BPFBF_EBPFBE_INSN_STWBE, BPFBF_EBPFBE_SFMT_STWBE }, | |
121 | { BPF_INSN_STDWBE, BPFBF_EBPFBE_INSN_STDWBE, BPFBF_EBPFBE_SFMT_STDWBE }, | |
122 | { BPF_INSN_JEQIBE, BPFBF_EBPFBE_INSN_JEQIBE, BPFBF_EBPFBE_SFMT_JEQIBE }, | |
123 | { BPF_INSN_JEQRBE, BPFBF_EBPFBE_INSN_JEQRBE, BPFBF_EBPFBE_SFMT_JEQRBE }, | |
124 | { BPF_INSN_JEQ32IBE, BPFBF_EBPFBE_INSN_JEQ32IBE, BPFBF_EBPFBE_SFMT_JEQIBE }, | |
125 | { BPF_INSN_JEQ32RBE, BPFBF_EBPFBE_INSN_JEQ32RBE, BPFBF_EBPFBE_SFMT_JEQRBE }, | |
126 | { BPF_INSN_JGTIBE, BPFBF_EBPFBE_INSN_JGTIBE, BPFBF_EBPFBE_SFMT_JEQIBE }, | |
127 | { BPF_INSN_JGTRBE, BPFBF_EBPFBE_INSN_JGTRBE, BPFBF_EBPFBE_SFMT_JEQRBE }, | |
128 | { BPF_INSN_JGT32IBE, BPFBF_EBPFBE_INSN_JGT32IBE, BPFBF_EBPFBE_SFMT_JEQIBE }, | |
129 | { BPF_INSN_JGT32RBE, BPFBF_EBPFBE_INSN_JGT32RBE, BPFBF_EBPFBE_SFMT_JEQRBE }, | |
130 | { BPF_INSN_JGEIBE, BPFBF_EBPFBE_INSN_JGEIBE, BPFBF_EBPFBE_SFMT_JEQIBE }, | |
131 | { BPF_INSN_JGERBE, BPFBF_EBPFBE_INSN_JGERBE, BPFBF_EBPFBE_SFMT_JEQRBE }, | |
132 | { BPF_INSN_JGE32IBE, BPFBF_EBPFBE_INSN_JGE32IBE, BPFBF_EBPFBE_SFMT_JEQIBE }, | |
133 | { BPF_INSN_JGE32RBE, BPFBF_EBPFBE_INSN_JGE32RBE, BPFBF_EBPFBE_SFMT_JEQRBE }, | |
134 | { BPF_INSN_JLTIBE, BPFBF_EBPFBE_INSN_JLTIBE, BPFBF_EBPFBE_SFMT_JEQIBE }, | |
135 | { BPF_INSN_JLTRBE, BPFBF_EBPFBE_INSN_JLTRBE, BPFBF_EBPFBE_SFMT_JEQRBE }, | |
136 | { BPF_INSN_JLT32IBE, BPFBF_EBPFBE_INSN_JLT32IBE, BPFBF_EBPFBE_SFMT_JEQIBE }, | |
137 | { BPF_INSN_JLT32RBE, BPFBF_EBPFBE_INSN_JLT32RBE, BPFBF_EBPFBE_SFMT_JEQRBE }, | |
138 | { BPF_INSN_JLEIBE, BPFBF_EBPFBE_INSN_JLEIBE, BPFBF_EBPFBE_SFMT_JEQIBE }, | |
139 | { BPF_INSN_JLERBE, BPFBF_EBPFBE_INSN_JLERBE, BPFBF_EBPFBE_SFMT_JEQRBE }, | |
140 | { BPF_INSN_JLE32IBE, BPFBF_EBPFBE_INSN_JLE32IBE, BPFBF_EBPFBE_SFMT_JEQIBE }, | |
141 | { BPF_INSN_JLE32RBE, BPFBF_EBPFBE_INSN_JLE32RBE, BPFBF_EBPFBE_SFMT_JEQRBE }, | |
142 | { BPF_INSN_JSETIBE, BPFBF_EBPFBE_INSN_JSETIBE, BPFBF_EBPFBE_SFMT_JEQIBE }, | |
143 | { BPF_INSN_JSETRBE, BPFBF_EBPFBE_INSN_JSETRBE, BPFBF_EBPFBE_SFMT_JEQRBE }, | |
144 | { BPF_INSN_JSET32IBE, BPFBF_EBPFBE_INSN_JSET32IBE, BPFBF_EBPFBE_SFMT_JEQIBE }, | |
145 | { BPF_INSN_JSET32RBE, BPFBF_EBPFBE_INSN_JSET32RBE, BPFBF_EBPFBE_SFMT_JEQRBE }, | |
146 | { BPF_INSN_JNEIBE, BPFBF_EBPFBE_INSN_JNEIBE, BPFBF_EBPFBE_SFMT_JEQIBE }, | |
147 | { BPF_INSN_JNERBE, BPFBF_EBPFBE_INSN_JNERBE, BPFBF_EBPFBE_SFMT_JEQRBE }, | |
148 | { BPF_INSN_JNE32IBE, BPFBF_EBPFBE_INSN_JNE32IBE, BPFBF_EBPFBE_SFMT_JEQIBE }, | |
149 | { BPF_INSN_JNE32RBE, BPFBF_EBPFBE_INSN_JNE32RBE, BPFBF_EBPFBE_SFMT_JEQRBE }, | |
150 | { BPF_INSN_JSGTIBE, BPFBF_EBPFBE_INSN_JSGTIBE, BPFBF_EBPFBE_SFMT_JEQIBE }, | |
151 | { BPF_INSN_JSGTRBE, BPFBF_EBPFBE_INSN_JSGTRBE, BPFBF_EBPFBE_SFMT_JEQRBE }, | |
152 | { BPF_INSN_JSGT32IBE, BPFBF_EBPFBE_INSN_JSGT32IBE, BPFBF_EBPFBE_SFMT_JEQIBE }, | |
153 | { BPF_INSN_JSGT32RBE, BPFBF_EBPFBE_INSN_JSGT32RBE, BPFBF_EBPFBE_SFMT_JEQRBE }, | |
154 | { BPF_INSN_JSGEIBE, BPFBF_EBPFBE_INSN_JSGEIBE, BPFBF_EBPFBE_SFMT_JEQIBE }, | |
155 | { BPF_INSN_JSGERBE, BPFBF_EBPFBE_INSN_JSGERBE, BPFBF_EBPFBE_SFMT_JEQRBE }, | |
156 | { BPF_INSN_JSGE32IBE, BPFBF_EBPFBE_INSN_JSGE32IBE, BPFBF_EBPFBE_SFMT_JEQIBE }, | |
157 | { BPF_INSN_JSGE32RBE, BPFBF_EBPFBE_INSN_JSGE32RBE, BPFBF_EBPFBE_SFMT_JEQRBE }, | |
158 | { BPF_INSN_JSLTIBE, BPFBF_EBPFBE_INSN_JSLTIBE, BPFBF_EBPFBE_SFMT_JEQIBE }, | |
159 | { BPF_INSN_JSLTRBE, BPFBF_EBPFBE_INSN_JSLTRBE, BPFBF_EBPFBE_SFMT_JEQRBE }, | |
160 | { BPF_INSN_JSLT32IBE, BPFBF_EBPFBE_INSN_JSLT32IBE, BPFBF_EBPFBE_SFMT_JEQIBE }, | |
161 | { BPF_INSN_JSLT32RBE, BPFBF_EBPFBE_INSN_JSLT32RBE, BPFBF_EBPFBE_SFMT_JEQRBE }, | |
162 | { BPF_INSN_JSLEIBE, BPFBF_EBPFBE_INSN_JSLEIBE, BPFBF_EBPFBE_SFMT_JEQIBE }, | |
163 | { BPF_INSN_JSLERBE, BPFBF_EBPFBE_INSN_JSLERBE, BPFBF_EBPFBE_SFMT_JEQRBE }, | |
164 | { BPF_INSN_JSLE32IBE, BPFBF_EBPFBE_INSN_JSLE32IBE, BPFBF_EBPFBE_SFMT_JEQIBE }, | |
165 | { BPF_INSN_JSLE32RBE, BPFBF_EBPFBE_INSN_JSLE32RBE, BPFBF_EBPFBE_SFMT_JEQRBE }, | |
166 | { BPF_INSN_CALLBE, BPFBF_EBPFBE_INSN_CALLBE, BPFBF_EBPFBE_SFMT_CALLBE }, | |
167 | { BPF_INSN_JA, BPFBF_EBPFBE_INSN_JA, BPFBF_EBPFBE_SFMT_JA }, | |
168 | { BPF_INSN_EXIT, BPFBF_EBPFBE_INSN_EXIT, BPFBF_EBPFBE_SFMT_EXIT }, | |
169 | { BPF_INSN_XADDDWBE, BPFBF_EBPFBE_INSN_XADDDWBE, BPFBF_EBPFBE_SFMT_XADDDWBE }, | |
170 | { BPF_INSN_XADDWBE, BPFBF_EBPFBE_INSN_XADDWBE, BPFBF_EBPFBE_SFMT_XADDWBE }, | |
171 | { BPF_INSN_BRKPT, BPFBF_EBPFBE_INSN_BRKPT, BPFBF_EBPFBE_SFMT_EXIT }, | |
172 | }; | |
173 | ||
174 | static const struct insn_sem bpfbf_ebpfbe_insn_sem_invalid = | |
175 | { | |
176 | VIRTUAL_INSN_X_INVALID, BPFBF_EBPFBE_INSN_X_INVALID, BPFBF_EBPFBE_SFMT_EMPTY | |
177 | }; | |
178 | ||
179 | /* Initialize an IDESC from the compile-time computable parts. */ | |
180 | ||
181 | static INLINE void | |
182 | init_idesc (SIM_CPU *cpu, IDESC *id, const struct insn_sem *t) | |
183 | { | |
184 | const CGEN_INSN *insn_table = CGEN_CPU_INSN_TABLE (CPU_CPU_DESC (cpu))->init_entries; | |
185 | ||
186 | id->num = t->index; | |
187 | id->sfmt = t->sfmt; | |
188 | if ((int) t->type <= 0) | |
189 | id->idata = & cgen_virtual_insn_table[- (int) t->type]; | |
190 | else | |
191 | id->idata = & insn_table[t->type]; | |
192 | id->attrs = CGEN_INSN_ATTRS (id->idata); | |
193 | /* Oh my god, a magic number. */ | |
194 | id->length = CGEN_INSN_BITSIZE (id->idata) / 8; | |
195 | ||
196 | #if WITH_PROFILE_MODEL_P | |
197 | id->timing = & MODEL_TIMING (CPU_MODEL (cpu)) [t->index]; | |
198 | { | |
199 | SIM_DESC sd = CPU_STATE (cpu); | |
200 | SIM_ASSERT (t->index == id->timing->num); | |
201 | } | |
202 | #endif | |
203 | ||
204 | /* Semantic pointers are initialized elsewhere. */ | |
205 | } | |
206 | ||
207 | /* Initialize the instruction descriptor table. */ | |
208 | ||
209 | void | |
210 | bpfbf_ebpfbe_init_idesc_table (SIM_CPU *cpu) | |
211 | { | |
212 | IDESC *id,*tabend; | |
213 | const struct insn_sem *t,*tend; | |
214 | int tabsize = BPFBF_EBPFBE_INSN__MAX; | |
215 | IDESC *table = bpfbf_ebpfbe_insn_data; | |
216 | ||
217 | memset (table, 0, tabsize * sizeof (IDESC)); | |
218 | ||
219 | /* First set all entries to the `invalid insn'. */ | |
220 | t = & bpfbf_ebpfbe_insn_sem_invalid; | |
221 | for (id = table, tabend = table + tabsize; id < tabend; ++id) | |
222 | init_idesc (cpu, id, t); | |
223 | ||
224 | /* Now fill in the values for the chosen cpu. */ | |
225 | for (t = bpfbf_ebpfbe_insn_sem, tend = t + sizeof (bpfbf_ebpfbe_insn_sem) / sizeof (*t); | |
226 | t != tend; ++t) | |
227 | { | |
228 | init_idesc (cpu, & table[t->index], t); | |
229 | } | |
230 | ||
231 | /* Link the IDESC table into the cpu. */ | |
232 | CPU_IDESC (cpu) = table; | |
233 | } | |
234 | ||
235 | /* Given an instruction, return a pointer to its IDESC entry. */ | |
236 | ||
237 | const IDESC * | |
238 | bpfbf_ebpfbe_decode (SIM_CPU *current_cpu, IADDR pc, | |
239 | CGEN_INSN_WORD base_insn, | |
240 | ARGBUF *abuf) | |
241 | { | |
242 | /* Result of decoder. */ | |
243 | BPFBF_EBPFBE_INSN_TYPE itype; | |
244 | ||
245 | { | |
246 | CGEN_INSN_WORD insn = base_insn; | |
247 | ||
248 | { | |
249 | unsigned int val = (((insn >> 0) & (255 << 0))); | |
250 | switch (val) | |
251 | { | |
252 | case 4 : itype = BPFBF_EBPFBE_INSN_ADD32IBE; goto extract_sfmt_addibe; | |
253 | case 5 : itype = BPFBF_EBPFBE_INSN_JA; goto extract_sfmt_ja; | |
254 | case 7 : itype = BPFBF_EBPFBE_INSN_ADDIBE; goto extract_sfmt_addibe; | |
255 | case 12 : itype = BPFBF_EBPFBE_INSN_ADD32RBE; goto extract_sfmt_addrbe; | |
256 | case 15 : itype = BPFBF_EBPFBE_INSN_ADDRBE; goto extract_sfmt_addrbe; | |
257 | case 20 : itype = BPFBF_EBPFBE_INSN_SUB32IBE; goto extract_sfmt_addibe; | |
258 | case 21 : itype = BPFBF_EBPFBE_INSN_JEQIBE; goto extract_sfmt_jeqibe; | |
259 | case 22 : itype = BPFBF_EBPFBE_INSN_JEQ32IBE; goto extract_sfmt_jeqibe; | |
260 | case 23 : itype = BPFBF_EBPFBE_INSN_SUBIBE; goto extract_sfmt_addibe; | |
261 | case 24 : itype = BPFBF_EBPFBE_INSN_LDDWBE; goto extract_sfmt_lddwbe; | |
262 | case 28 : itype = BPFBF_EBPFBE_INSN_SUB32RBE; goto extract_sfmt_addrbe; | |
263 | case 29 : itype = BPFBF_EBPFBE_INSN_JEQRBE; goto extract_sfmt_jeqrbe; | |
264 | case 30 : itype = BPFBF_EBPFBE_INSN_JEQ32RBE; goto extract_sfmt_jeqrbe; | |
265 | case 31 : itype = BPFBF_EBPFBE_INSN_SUBRBE; goto extract_sfmt_addrbe; | |
266 | case 32 : itype = BPFBF_EBPFBE_INSN_LDABSW; goto extract_sfmt_ldabsw; | |
267 | case 36 : itype = BPFBF_EBPFBE_INSN_MUL32IBE; goto extract_sfmt_addibe; | |
268 | case 37 : itype = BPFBF_EBPFBE_INSN_JGTIBE; goto extract_sfmt_jeqibe; | |
269 | case 38 : itype = BPFBF_EBPFBE_INSN_JGT32IBE; goto extract_sfmt_jeqibe; | |
270 | case 39 : itype = BPFBF_EBPFBE_INSN_MULIBE; goto extract_sfmt_addibe; | |
271 | case 40 : itype = BPFBF_EBPFBE_INSN_LDABSH; goto extract_sfmt_ldabsh; | |
272 | case 44 : itype = BPFBF_EBPFBE_INSN_MUL32RBE; goto extract_sfmt_addrbe; | |
273 | case 45 : itype = BPFBF_EBPFBE_INSN_JGTRBE; goto extract_sfmt_jeqrbe; | |
274 | case 46 : itype = BPFBF_EBPFBE_INSN_JGT32RBE; goto extract_sfmt_jeqrbe; | |
275 | case 47 : itype = BPFBF_EBPFBE_INSN_MULRBE; goto extract_sfmt_addrbe; | |
276 | case 48 : itype = BPFBF_EBPFBE_INSN_LDABSB; goto extract_sfmt_ldabsb; | |
277 | case 52 : itype = BPFBF_EBPFBE_INSN_DIV32IBE; goto extract_sfmt_addibe; | |
278 | case 53 : itype = BPFBF_EBPFBE_INSN_JGEIBE; goto extract_sfmt_jeqibe; | |
279 | case 54 : itype = BPFBF_EBPFBE_INSN_JGE32IBE; goto extract_sfmt_jeqibe; | |
280 | case 55 : itype = BPFBF_EBPFBE_INSN_DIVIBE; goto extract_sfmt_addibe; | |
281 | case 56 : itype = BPFBF_EBPFBE_INSN_LDABSDW; goto extract_sfmt_ldabsdw; | |
282 | case 60 : itype = BPFBF_EBPFBE_INSN_DIV32RBE; goto extract_sfmt_addrbe; | |
283 | case 61 : itype = BPFBF_EBPFBE_INSN_JGERBE; goto extract_sfmt_jeqrbe; | |
284 | case 62 : itype = BPFBF_EBPFBE_INSN_JGE32RBE; goto extract_sfmt_jeqrbe; | |
285 | case 63 : itype = BPFBF_EBPFBE_INSN_DIVRBE; goto extract_sfmt_addrbe; | |
286 | case 64 : itype = BPFBF_EBPFBE_INSN_LDINDWBE; goto extract_sfmt_ldindwbe; | |
287 | case 68 : itype = BPFBF_EBPFBE_INSN_OR32IBE; goto extract_sfmt_addibe; | |
288 | case 69 : itype = BPFBF_EBPFBE_INSN_JSETIBE; goto extract_sfmt_jeqibe; | |
289 | case 70 : itype = BPFBF_EBPFBE_INSN_JSET32IBE; goto extract_sfmt_jeqibe; | |
290 | case 71 : itype = BPFBF_EBPFBE_INSN_ORIBE; goto extract_sfmt_addibe; | |
291 | case 72 : itype = BPFBF_EBPFBE_INSN_LDINDHBE; goto extract_sfmt_ldindhbe; | |
292 | case 76 : itype = BPFBF_EBPFBE_INSN_OR32RBE; goto extract_sfmt_addrbe; | |
293 | case 77 : itype = BPFBF_EBPFBE_INSN_JSETRBE; goto extract_sfmt_jeqrbe; | |
294 | case 78 : itype = BPFBF_EBPFBE_INSN_JSET32RBE; goto extract_sfmt_jeqrbe; | |
295 | case 79 : itype = BPFBF_EBPFBE_INSN_ORRBE; goto extract_sfmt_addrbe; | |
296 | case 80 : itype = BPFBF_EBPFBE_INSN_LDINDBBE; goto extract_sfmt_ldindbbe; | |
297 | case 84 : itype = BPFBF_EBPFBE_INSN_AND32IBE; goto extract_sfmt_addibe; | |
298 | case 85 : itype = BPFBF_EBPFBE_INSN_JNEIBE; goto extract_sfmt_jeqibe; | |
299 | case 86 : itype = BPFBF_EBPFBE_INSN_JNE32IBE; goto extract_sfmt_jeqibe; | |
300 | case 87 : itype = BPFBF_EBPFBE_INSN_ANDIBE; goto extract_sfmt_addibe; | |
301 | case 88 : itype = BPFBF_EBPFBE_INSN_LDINDDWBE; goto extract_sfmt_ldinddwbe; | |
302 | case 92 : itype = BPFBF_EBPFBE_INSN_AND32RBE; goto extract_sfmt_addrbe; | |
303 | case 93 : itype = BPFBF_EBPFBE_INSN_JNERBE; goto extract_sfmt_jeqrbe; | |
304 | case 94 : itype = BPFBF_EBPFBE_INSN_JNE32RBE; goto extract_sfmt_jeqrbe; | |
305 | case 95 : itype = BPFBF_EBPFBE_INSN_ANDRBE; goto extract_sfmt_addrbe; | |
306 | case 97 : itype = BPFBF_EBPFBE_INSN_LDXWBE; goto extract_sfmt_ldxwbe; | |
307 | case 98 : itype = BPFBF_EBPFBE_INSN_STWBE; goto extract_sfmt_stwbe; | |
308 | case 99 : itype = BPFBF_EBPFBE_INSN_STXWBE; goto extract_sfmt_stxwbe; | |
309 | case 100 : itype = BPFBF_EBPFBE_INSN_LSH32IBE; goto extract_sfmt_addibe; | |
310 | case 101 : itype = BPFBF_EBPFBE_INSN_JSGTIBE; goto extract_sfmt_jeqibe; | |
311 | case 102 : itype = BPFBF_EBPFBE_INSN_JSGT32IBE; goto extract_sfmt_jeqibe; | |
312 | case 103 : itype = BPFBF_EBPFBE_INSN_LSHIBE; goto extract_sfmt_addibe; | |
313 | case 105 : itype = BPFBF_EBPFBE_INSN_LDXHBE; goto extract_sfmt_ldxhbe; | |
314 | case 106 : itype = BPFBF_EBPFBE_INSN_STHBE; goto extract_sfmt_sthbe; | |
315 | case 107 : itype = BPFBF_EBPFBE_INSN_STXHBE; goto extract_sfmt_stxhbe; | |
316 | case 108 : itype = BPFBF_EBPFBE_INSN_LSH32RBE; goto extract_sfmt_addrbe; | |
317 | case 109 : itype = BPFBF_EBPFBE_INSN_JSGTRBE; goto extract_sfmt_jeqrbe; | |
318 | case 110 : itype = BPFBF_EBPFBE_INSN_JSGT32RBE; goto extract_sfmt_jeqrbe; | |
319 | case 111 : itype = BPFBF_EBPFBE_INSN_LSHRBE; goto extract_sfmt_addrbe; | |
320 | case 113 : itype = BPFBF_EBPFBE_INSN_LDXBBE; goto extract_sfmt_ldxbbe; | |
321 | case 114 : itype = BPFBF_EBPFBE_INSN_STBBE; goto extract_sfmt_stbbe; | |
322 | case 115 : itype = BPFBF_EBPFBE_INSN_STXBBE; goto extract_sfmt_stxbbe; | |
323 | case 116 : itype = BPFBF_EBPFBE_INSN_RSH32IBE; goto extract_sfmt_addibe; | |
324 | case 117 : itype = BPFBF_EBPFBE_INSN_JSGEIBE; goto extract_sfmt_jeqibe; | |
325 | case 118 : itype = BPFBF_EBPFBE_INSN_JSGE32IBE; goto extract_sfmt_jeqibe; | |
326 | case 119 : itype = BPFBF_EBPFBE_INSN_RSHIBE; goto extract_sfmt_addibe; | |
327 | case 121 : itype = BPFBF_EBPFBE_INSN_LDXDWBE; goto extract_sfmt_ldxdwbe; | |
328 | case 122 : itype = BPFBF_EBPFBE_INSN_STDWBE; goto extract_sfmt_stdwbe; | |
329 | case 123 : itype = BPFBF_EBPFBE_INSN_STXDWBE; goto extract_sfmt_stxdwbe; | |
330 | case 124 : itype = BPFBF_EBPFBE_INSN_RSH32RBE; goto extract_sfmt_addrbe; | |
331 | case 125 : itype = BPFBF_EBPFBE_INSN_JSGERBE; goto extract_sfmt_jeqrbe; | |
332 | case 126 : itype = BPFBF_EBPFBE_INSN_JSGE32RBE; goto extract_sfmt_jeqrbe; | |
333 | case 127 : itype = BPFBF_EBPFBE_INSN_RSHRBE; goto extract_sfmt_addrbe; | |
334 | case 132 : itype = BPFBF_EBPFBE_INSN_NEG32BE; goto extract_sfmt_negbe; | |
335 | case 133 : itype = BPFBF_EBPFBE_INSN_CALLBE; goto extract_sfmt_callbe; | |
336 | case 135 : itype = BPFBF_EBPFBE_INSN_NEGBE; goto extract_sfmt_negbe; | |
337 | case 140 : itype = BPFBF_EBPFBE_INSN_BRKPT; goto extract_sfmt_exit; | |
338 | case 148 : itype = BPFBF_EBPFBE_INSN_MOD32IBE; goto extract_sfmt_addibe; | |
339 | case 149 : itype = BPFBF_EBPFBE_INSN_EXIT; goto extract_sfmt_exit; | |
340 | case 151 : itype = BPFBF_EBPFBE_INSN_MODIBE; goto extract_sfmt_addibe; | |
341 | case 156 : itype = BPFBF_EBPFBE_INSN_MOD32RBE; goto extract_sfmt_addrbe; | |
342 | case 159 : itype = BPFBF_EBPFBE_INSN_MODRBE; goto extract_sfmt_addrbe; | |
343 | case 164 : itype = BPFBF_EBPFBE_INSN_XOR32IBE; goto extract_sfmt_addibe; | |
344 | case 165 : itype = BPFBF_EBPFBE_INSN_JLTIBE; goto extract_sfmt_jeqibe; | |
345 | case 166 : itype = BPFBF_EBPFBE_INSN_JLT32IBE; goto extract_sfmt_jeqibe; | |
346 | case 167 : itype = BPFBF_EBPFBE_INSN_XORIBE; goto extract_sfmt_addibe; | |
347 | case 172 : itype = BPFBF_EBPFBE_INSN_XOR32RBE; goto extract_sfmt_addrbe; | |
348 | case 173 : itype = BPFBF_EBPFBE_INSN_JLTRBE; goto extract_sfmt_jeqrbe; | |
349 | case 174 : itype = BPFBF_EBPFBE_INSN_JLT32RBE; goto extract_sfmt_jeqrbe; | |
350 | case 175 : itype = BPFBF_EBPFBE_INSN_XORRBE; goto extract_sfmt_addrbe; | |
351 | case 180 : itype = BPFBF_EBPFBE_INSN_MOV32IBE; goto extract_sfmt_movibe; | |
352 | case 181 : itype = BPFBF_EBPFBE_INSN_JLEIBE; goto extract_sfmt_jeqibe; | |
353 | case 182 : itype = BPFBF_EBPFBE_INSN_JLE32IBE; goto extract_sfmt_jeqibe; | |
354 | case 183 : itype = BPFBF_EBPFBE_INSN_MOVIBE; goto extract_sfmt_movibe; | |
355 | case 188 : itype = BPFBF_EBPFBE_INSN_MOV32RBE; goto extract_sfmt_movrbe; | |
356 | case 189 : itype = BPFBF_EBPFBE_INSN_JLERBE; goto extract_sfmt_jeqrbe; | |
357 | case 190 : itype = BPFBF_EBPFBE_INSN_JLE32RBE; goto extract_sfmt_jeqrbe; | |
358 | case 191 : itype = BPFBF_EBPFBE_INSN_MOVRBE; goto extract_sfmt_movrbe; | |
359 | case 195 : itype = BPFBF_EBPFBE_INSN_XADDWBE; goto extract_sfmt_xaddwbe; | |
360 | case 196 : itype = BPFBF_EBPFBE_INSN_ARSH32IBE; goto extract_sfmt_addibe; | |
361 | case 197 : itype = BPFBF_EBPFBE_INSN_JSLTIBE; goto extract_sfmt_jeqibe; | |
362 | case 198 : itype = BPFBF_EBPFBE_INSN_JSLT32IBE; goto extract_sfmt_jeqibe; | |
363 | case 199 : itype = BPFBF_EBPFBE_INSN_ARSHIBE; goto extract_sfmt_addibe; | |
364 | case 204 : itype = BPFBF_EBPFBE_INSN_ARSH32RBE; goto extract_sfmt_addrbe; | |
365 | case 205 : itype = BPFBF_EBPFBE_INSN_JSLTRBE; goto extract_sfmt_jeqrbe; | |
366 | case 206 : itype = BPFBF_EBPFBE_INSN_JSLT32RBE; goto extract_sfmt_jeqrbe; | |
367 | case 207 : itype = BPFBF_EBPFBE_INSN_ARSHRBE; goto extract_sfmt_addrbe; | |
368 | case 212 : itype = BPFBF_EBPFBE_INSN_ENDLEBE; goto extract_sfmt_endlebe; | |
369 | case 213 : itype = BPFBF_EBPFBE_INSN_JSLEIBE; goto extract_sfmt_jeqibe; | |
370 | case 214 : itype = BPFBF_EBPFBE_INSN_JSLE32IBE; goto extract_sfmt_jeqibe; | |
371 | case 219 : itype = BPFBF_EBPFBE_INSN_XADDDWBE; goto extract_sfmt_xadddwbe; | |
372 | case 220 : itype = BPFBF_EBPFBE_INSN_ENDBEBE; goto extract_sfmt_endlebe; | |
373 | case 221 : itype = BPFBF_EBPFBE_INSN_JSLERBE; goto extract_sfmt_jeqrbe; | |
374 | case 222 : itype = BPFBF_EBPFBE_INSN_JSLE32RBE; goto extract_sfmt_jeqrbe; | |
375 | default : itype = BPFBF_EBPFBE_INSN_X_INVALID; goto extract_sfmt_empty; | |
376 | } | |
377 | } | |
378 | } | |
379 | ||
380 | /* The instruction has been decoded, now extract the fields. */ | |
381 | ||
382 | extract_sfmt_empty: | |
383 | { | |
384 | const IDESC *idesc = &bpfbf_ebpfbe_insn_data[itype]; | |
385 | #define FLD(f) abuf->fields.sfmt_empty.f | |
386 | ||
387 | ||
388 | /* Record the fields for the semantic handler. */ | |
389 | TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_empty", (char *) 0)); | |
390 | ||
391 | #undef FLD | |
392 | return idesc; | |
393 | } | |
394 | ||
395 | extract_sfmt_addibe: | |
396 | { | |
397 | const IDESC *idesc = &bpfbf_ebpfbe_insn_data[itype]; | |
398 | CGEN_INSN_WORD insn = base_insn; | |
399 | #define FLD(f) abuf->fields.sfmt_stbbe.f | |
400 | INT f_imm32; | |
401 | UINT f_dstbe; | |
402 | ||
403 | f_imm32 = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 63, 32) << 0)); | |
404 | f_dstbe = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 15, 4) << 0)); | |
405 | ||
406 | /* Record the fields for the semantic handler. */ | |
407 | FLD (f_dstbe) = f_dstbe; | |
408 | FLD (f_imm32) = f_imm32; | |
409 | TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_addibe", "f_dstbe 0x%x", 'x', f_dstbe, "f_imm32 0x%x", 'x', f_imm32, (char *) 0)); | |
410 | ||
411 | #undef FLD | |
412 | return idesc; | |
413 | } | |
414 | ||
415 | extract_sfmt_addrbe: | |
416 | { | |
417 | const IDESC *idesc = &bpfbf_ebpfbe_insn_data[itype]; | |
418 | CGEN_INSN_WORD insn = base_insn; | |
419 | #define FLD(f) abuf->fields.sfmt_ldxwbe.f | |
420 | UINT f_dstbe; | |
421 | UINT f_srcbe; | |
422 | ||
423 | f_dstbe = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 15, 4) << 0)); | |
424 | f_srcbe = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 11, 4) << 0)); | |
425 | ||
426 | /* Record the fields for the semantic handler. */ | |
427 | FLD (f_dstbe) = f_dstbe; | |
428 | FLD (f_srcbe) = f_srcbe; | |
429 | TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_addrbe", "f_dstbe 0x%x", 'x', f_dstbe, "f_srcbe 0x%x", 'x', f_srcbe, (char *) 0)); | |
430 | ||
431 | #undef FLD | |
432 | return idesc; | |
433 | } | |
434 | ||
435 | extract_sfmt_negbe: | |
436 | { | |
437 | const IDESC *idesc = &bpfbf_ebpfbe_insn_data[itype]; | |
438 | CGEN_INSN_WORD insn = base_insn; | |
439 | #define FLD(f) abuf->fields.sfmt_lddwbe.f | |
440 | UINT f_dstbe; | |
441 | ||
442 | f_dstbe = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 15, 4) << 0)); | |
443 | ||
444 | /* Record the fields for the semantic handler. */ | |
445 | FLD (f_dstbe) = f_dstbe; | |
446 | TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_negbe", "f_dstbe 0x%x", 'x', f_dstbe, (char *) 0)); | |
447 | ||
448 | #undef FLD | |
449 | return idesc; | |
450 | } | |
451 | ||
452 | extract_sfmt_movibe: | |
453 | { | |
454 | const IDESC *idesc = &bpfbf_ebpfbe_insn_data[itype]; | |
455 | CGEN_INSN_WORD insn = base_insn; | |
456 | #define FLD(f) abuf->fields.sfmt_stbbe.f | |
457 | INT f_imm32; | |
458 | UINT f_dstbe; | |
459 | ||
460 | f_imm32 = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 63, 32) << 0)); | |
461 | f_dstbe = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 15, 4) << 0)); | |
462 | ||
463 | /* Record the fields for the semantic handler. */ | |
464 | FLD (f_imm32) = f_imm32; | |
465 | FLD (f_dstbe) = f_dstbe; | |
466 | TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_movibe", "f_imm32 0x%x", 'x', f_imm32, "f_dstbe 0x%x", 'x', f_dstbe, (char *) 0)); | |
467 | ||
468 | #undef FLD | |
469 | return idesc; | |
470 | } | |
471 | ||
472 | extract_sfmt_movrbe: | |
473 | { | |
474 | const IDESC *idesc = &bpfbf_ebpfbe_insn_data[itype]; | |
475 | CGEN_INSN_WORD insn = base_insn; | |
476 | #define FLD(f) abuf->fields.sfmt_ldxwbe.f | |
477 | UINT f_dstbe; | |
478 | UINT f_srcbe; | |
479 | ||
480 | f_dstbe = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 15, 4) << 0)); | |
481 | f_srcbe = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 11, 4) << 0)); | |
482 | ||
483 | /* Record the fields for the semantic handler. */ | |
484 | FLD (f_srcbe) = f_srcbe; | |
485 | FLD (f_dstbe) = f_dstbe; | |
486 | TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_movrbe", "f_srcbe 0x%x", 'x', f_srcbe, "f_dstbe 0x%x", 'x', f_dstbe, (char *) 0)); | |
487 | ||
488 | #undef FLD | |
489 | return idesc; | |
490 | } | |
491 | ||
492 | extract_sfmt_endlebe: | |
493 | { | |
494 | const IDESC *idesc = &bpfbf_ebpfbe_insn_data[itype]; | |
495 | CGEN_INSN_WORD insn = base_insn; | |
496 | #define FLD(f) abuf->fields.sfmt_stbbe.f | |
497 | INT f_imm32; | |
498 | UINT f_dstbe; | |
499 | ||
500 | f_imm32 = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 63, 32) << 0)); | |
501 | f_dstbe = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 15, 4) << 0)); | |
502 | ||
503 | /* Record the fields for the semantic handler. */ | |
504 | FLD (f_dstbe) = f_dstbe; | |
505 | FLD (f_imm32) = f_imm32; | |
506 | TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_endlebe", "f_dstbe 0x%x", 'x', f_dstbe, "f_imm32 0x%x", 'x', f_imm32, (char *) 0)); | |
507 | ||
508 | #undef FLD | |
509 | return idesc; | |
510 | } | |
511 | ||
512 | extract_sfmt_lddwbe: | |
513 | { | |
514 | const IDESC *idesc = &bpfbf_ebpfbe_insn_data[itype]; | |
515 | CGEN_INSN_WORD insn = base_insn; | |
516 | #define FLD(f) abuf->fields.sfmt_lddwbe.f | |
517 | UINT f_imm64_c; | |
518 | UINT f_imm64_b; | |
519 | UINT f_imm64_a; | |
520 | UINT f_dstbe; | |
521 | DI f_imm64; | |
522 | /* Contents of trailing part of insn. */ | |
523 | UINT word_1; | |
524 | UINT word_2; | |
525 | ||
526 | word_1 = GETIMEMUSI (current_cpu, pc + 8); | |
527 | word_2 = GETIMEMUSI (current_cpu, pc + 12); | |
528 | f_imm64_c = (0|(EXTRACT_LSB0_UINT (word_2, 32, 31, 32) << 0)); | |
529 | f_imm64_b = (0|(EXTRACT_LSB0_UINT (word_1, 32, 31, 32) << 0)); | |
530 | f_imm64_a = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 63, 32) << 0)); | |
531 | f_dstbe = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 15, 4) << 0)); | |
532 | { | |
533 | f_imm64 = ((((((UDI) (UINT) (f_imm64_c))) << (32))) | (((UDI) (UINT) (f_imm64_a)))); | |
534 | } | |
535 | ||
536 | /* Record the fields for the semantic handler. */ | |
537 | FLD (f_imm64) = f_imm64; | |
538 | FLD (f_dstbe) = f_dstbe; | |
539 | TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_lddwbe", "f_imm64 0x%x", 'x', f_imm64, "f_dstbe 0x%x", 'x', f_dstbe, (char *) 0)); | |
540 | ||
541 | #undef FLD | |
542 | return idesc; | |
543 | } | |
544 | ||
545 | extract_sfmt_ldabsw: | |
546 | { | |
547 | const IDESC *idesc = &bpfbf_ebpfbe_insn_data[itype]; | |
548 | CGEN_INSN_WORD insn = base_insn; | |
549 | #define FLD(f) abuf->fields.sfmt_ldindwbe.f | |
550 | INT f_imm32; | |
551 | ||
552 | f_imm32 = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 63, 32) << 0)); | |
553 | ||
554 | /* Record the fields for the semantic handler. */ | |
555 | FLD (f_imm32) = f_imm32; | |
556 | TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_ldabsw", "f_imm32 0x%x", 'x', f_imm32, (char *) 0)); | |
557 | ||
558 | #undef FLD | |
559 | return idesc; | |
560 | } | |
561 | ||
562 | extract_sfmt_ldabsh: | |
563 | { | |
564 | const IDESC *idesc = &bpfbf_ebpfbe_insn_data[itype]; | |
565 | CGEN_INSN_WORD insn = base_insn; | |
566 | #define FLD(f) abuf->fields.sfmt_ldindwbe.f | |
567 | INT f_imm32; | |
568 | ||
569 | f_imm32 = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 63, 32) << 0)); | |
570 | ||
571 | /* Record the fields for the semantic handler. */ | |
572 | FLD (f_imm32) = f_imm32; | |
573 | TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_ldabsh", "f_imm32 0x%x", 'x', f_imm32, (char *) 0)); | |
574 | ||
575 | #undef FLD | |
576 | return idesc; | |
577 | } | |
578 | ||
579 | extract_sfmt_ldabsb: | |
580 | { | |
581 | const IDESC *idesc = &bpfbf_ebpfbe_insn_data[itype]; | |
582 | CGEN_INSN_WORD insn = base_insn; | |
583 | #define FLD(f) abuf->fields.sfmt_ldindwbe.f | |
584 | INT f_imm32; | |
585 | ||
586 | f_imm32 = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 63, 32) << 0)); | |
587 | ||
588 | /* Record the fields for the semantic handler. */ | |
589 | FLD (f_imm32) = f_imm32; | |
590 | TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_ldabsb", "f_imm32 0x%x", 'x', f_imm32, (char *) 0)); | |
591 | ||
592 | #undef FLD | |
593 | return idesc; | |
594 | } | |
595 | ||
596 | extract_sfmt_ldabsdw: | |
597 | { | |
598 | const IDESC *idesc = &bpfbf_ebpfbe_insn_data[itype]; | |
599 | CGEN_INSN_WORD insn = base_insn; | |
600 | #define FLD(f) abuf->fields.sfmt_ldindwbe.f | |
601 | INT f_imm32; | |
602 | ||
603 | f_imm32 = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 63, 32) << 0)); | |
604 | ||
605 | /* Record the fields for the semantic handler. */ | |
606 | FLD (f_imm32) = f_imm32; | |
607 | TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_ldabsdw", "f_imm32 0x%x", 'x', f_imm32, (char *) 0)); | |
608 | ||
609 | #undef FLD | |
610 | return idesc; | |
611 | } | |
612 | ||
613 | extract_sfmt_ldindwbe: | |
614 | { | |
615 | const IDESC *idesc = &bpfbf_ebpfbe_insn_data[itype]; | |
616 | CGEN_INSN_WORD insn = base_insn; | |
617 | #define FLD(f) abuf->fields.sfmt_ldindwbe.f | |
618 | INT f_imm32; | |
619 | UINT f_srcbe; | |
620 | ||
621 | f_imm32 = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 63, 32) << 0)); | |
622 | f_srcbe = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 11, 4) << 0)); | |
623 | ||
624 | /* Record the fields for the semantic handler. */ | |
625 | FLD (f_imm32) = f_imm32; | |
626 | FLD (f_srcbe) = f_srcbe; | |
627 | TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_ldindwbe", "f_imm32 0x%x", 'x', f_imm32, "f_srcbe 0x%x", 'x', f_srcbe, (char *) 0)); | |
628 | ||
629 | #undef FLD | |
630 | return idesc; | |
631 | } | |
632 | ||
633 | extract_sfmt_ldindhbe: | |
634 | { | |
635 | const IDESC *idesc = &bpfbf_ebpfbe_insn_data[itype]; | |
636 | CGEN_INSN_WORD insn = base_insn; | |
637 | #define FLD(f) abuf->fields.sfmt_ldindwbe.f | |
638 | INT f_imm32; | |
639 | UINT f_srcbe; | |
640 | ||
641 | f_imm32 = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 63, 32) << 0)); | |
642 | f_srcbe = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 11, 4) << 0)); | |
643 | ||
644 | /* Record the fields for the semantic handler. */ | |
645 | FLD (f_imm32) = f_imm32; | |
646 | FLD (f_srcbe) = f_srcbe; | |
647 | TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_ldindhbe", "f_imm32 0x%x", 'x', f_imm32, "f_srcbe 0x%x", 'x', f_srcbe, (char *) 0)); | |
648 | ||
649 | #undef FLD | |
650 | return idesc; | |
651 | } | |
652 | ||
653 | extract_sfmt_ldindbbe: | |
654 | { | |
655 | const IDESC *idesc = &bpfbf_ebpfbe_insn_data[itype]; | |
656 | CGEN_INSN_WORD insn = base_insn; | |
657 | #define FLD(f) abuf->fields.sfmt_ldindwbe.f | |
658 | INT f_imm32; | |
659 | UINT f_srcbe; | |
660 | ||
661 | f_imm32 = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 63, 32) << 0)); | |
662 | f_srcbe = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 11, 4) << 0)); | |
663 | ||
664 | /* Record the fields for the semantic handler. */ | |
665 | FLD (f_imm32) = f_imm32; | |
666 | FLD (f_srcbe) = f_srcbe; | |
667 | TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_ldindbbe", "f_imm32 0x%x", 'x', f_imm32, "f_srcbe 0x%x", 'x', f_srcbe, (char *) 0)); | |
668 | ||
669 | #undef FLD | |
670 | return idesc; | |
671 | } | |
672 | ||
673 | extract_sfmt_ldinddwbe: | |
674 | { | |
675 | const IDESC *idesc = &bpfbf_ebpfbe_insn_data[itype]; | |
676 | CGEN_INSN_WORD insn = base_insn; | |
677 | #define FLD(f) abuf->fields.sfmt_ldindwbe.f | |
678 | INT f_imm32; | |
679 | UINT f_srcbe; | |
680 | ||
681 | f_imm32 = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 63, 32) << 0)); | |
682 | f_srcbe = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 11, 4) << 0)); | |
683 | ||
684 | /* Record the fields for the semantic handler. */ | |
685 | FLD (f_imm32) = f_imm32; | |
686 | FLD (f_srcbe) = f_srcbe; | |
687 | TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_ldinddwbe", "f_imm32 0x%x", 'x', f_imm32, "f_srcbe 0x%x", 'x', f_srcbe, (char *) 0)); | |
688 | ||
689 | #undef FLD | |
690 | return idesc; | |
691 | } | |
692 | ||
693 | extract_sfmt_ldxwbe: | |
694 | { | |
695 | const IDESC *idesc = &bpfbf_ebpfbe_insn_data[itype]; | |
696 | CGEN_INSN_WORD insn = base_insn; | |
697 | #define FLD(f) abuf->fields.sfmt_ldxwbe.f | |
698 | HI f_offset16; | |
699 | UINT f_dstbe; | |
700 | UINT f_srcbe; | |
701 | ||
702 | f_offset16 = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 31, 16) << 0)); | |
703 | f_dstbe = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 15, 4) << 0)); | |
704 | f_srcbe = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 11, 4) << 0)); | |
705 | ||
706 | /* Record the fields for the semantic handler. */ | |
707 | FLD (f_offset16) = f_offset16; | |
708 | FLD (f_srcbe) = f_srcbe; | |
709 | FLD (f_dstbe) = f_dstbe; | |
710 | TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_ldxwbe", "f_offset16 0x%x", 'x', f_offset16, "f_srcbe 0x%x", 'x', f_srcbe, "f_dstbe 0x%x", 'x', f_dstbe, (char *) 0)); | |
711 | ||
712 | #undef FLD | |
713 | return idesc; | |
714 | } | |
715 | ||
716 | extract_sfmt_ldxhbe: | |
717 | { | |
718 | const IDESC *idesc = &bpfbf_ebpfbe_insn_data[itype]; | |
719 | CGEN_INSN_WORD insn = base_insn; | |
720 | #define FLD(f) abuf->fields.sfmt_ldxwbe.f | |
721 | HI f_offset16; | |
722 | UINT f_dstbe; | |
723 | UINT f_srcbe; | |
724 | ||
725 | f_offset16 = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 31, 16) << 0)); | |
726 | f_dstbe = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 15, 4) << 0)); | |
727 | f_srcbe = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 11, 4) << 0)); | |
728 | ||
729 | /* Record the fields for the semantic handler. */ | |
730 | FLD (f_offset16) = f_offset16; | |
731 | FLD (f_srcbe) = f_srcbe; | |
732 | FLD (f_dstbe) = f_dstbe; | |
733 | TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_ldxhbe", "f_offset16 0x%x", 'x', f_offset16, "f_srcbe 0x%x", 'x', f_srcbe, "f_dstbe 0x%x", 'x', f_dstbe, (char *) 0)); | |
734 | ||
735 | #undef FLD | |
736 | return idesc; | |
737 | } | |
738 | ||
739 | extract_sfmt_ldxbbe: | |
740 | { | |
741 | const IDESC *idesc = &bpfbf_ebpfbe_insn_data[itype]; | |
742 | CGEN_INSN_WORD insn = base_insn; | |
743 | #define FLD(f) abuf->fields.sfmt_ldxwbe.f | |
744 | HI f_offset16; | |
745 | UINT f_dstbe; | |
746 | UINT f_srcbe; | |
747 | ||
748 | f_offset16 = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 31, 16) << 0)); | |
749 | f_dstbe = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 15, 4) << 0)); | |
750 | f_srcbe = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 11, 4) << 0)); | |
751 | ||
752 | /* Record the fields for the semantic handler. */ | |
753 | FLD (f_offset16) = f_offset16; | |
754 | FLD (f_srcbe) = f_srcbe; | |
755 | FLD (f_dstbe) = f_dstbe; | |
756 | TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_ldxbbe", "f_offset16 0x%x", 'x', f_offset16, "f_srcbe 0x%x", 'x', f_srcbe, "f_dstbe 0x%x", 'x', f_dstbe, (char *) 0)); | |
757 | ||
758 | #undef FLD | |
759 | return idesc; | |
760 | } | |
761 | ||
762 | extract_sfmt_ldxdwbe: | |
763 | { | |
764 | const IDESC *idesc = &bpfbf_ebpfbe_insn_data[itype]; | |
765 | CGEN_INSN_WORD insn = base_insn; | |
766 | #define FLD(f) abuf->fields.sfmt_ldxwbe.f | |
767 | HI f_offset16; | |
768 | UINT f_dstbe; | |
769 | UINT f_srcbe; | |
770 | ||
771 | f_offset16 = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 31, 16) << 0)); | |
772 | f_dstbe = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 15, 4) << 0)); | |
773 | f_srcbe = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 11, 4) << 0)); | |
774 | ||
775 | /* Record the fields for the semantic handler. */ | |
776 | FLD (f_offset16) = f_offset16; | |
777 | FLD (f_srcbe) = f_srcbe; | |
778 | FLD (f_dstbe) = f_dstbe; | |
779 | TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_ldxdwbe", "f_offset16 0x%x", 'x', f_offset16, "f_srcbe 0x%x", 'x', f_srcbe, "f_dstbe 0x%x", 'x', f_dstbe, (char *) 0)); | |
780 | ||
781 | #undef FLD | |
782 | return idesc; | |
783 | } | |
784 | ||
785 | extract_sfmt_stxwbe: | |
786 | { | |
787 | const IDESC *idesc = &bpfbf_ebpfbe_insn_data[itype]; | |
788 | CGEN_INSN_WORD insn = base_insn; | |
789 | #define FLD(f) abuf->fields.sfmt_ldxwbe.f | |
790 | HI f_offset16; | |
791 | UINT f_dstbe; | |
792 | UINT f_srcbe; | |
793 | ||
794 | f_offset16 = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 31, 16) << 0)); | |
795 | f_dstbe = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 15, 4) << 0)); | |
796 | f_srcbe = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 11, 4) << 0)); | |
797 | ||
798 | /* Record the fields for the semantic handler. */ | |
799 | FLD (f_dstbe) = f_dstbe; | |
800 | FLD (f_offset16) = f_offset16; | |
801 | FLD (f_srcbe) = f_srcbe; | |
802 | TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_stxwbe", "f_dstbe 0x%x", 'x', f_dstbe, "f_offset16 0x%x", 'x', f_offset16, "f_srcbe 0x%x", 'x', f_srcbe, (char *) 0)); | |
803 | ||
804 | #undef FLD | |
805 | return idesc; | |
806 | } | |
807 | ||
808 | extract_sfmt_stxhbe: | |
809 | { | |
810 | const IDESC *idesc = &bpfbf_ebpfbe_insn_data[itype]; | |
811 | CGEN_INSN_WORD insn = base_insn; | |
812 | #define FLD(f) abuf->fields.sfmt_ldxwbe.f | |
813 | HI f_offset16; | |
814 | UINT f_dstbe; | |
815 | UINT f_srcbe; | |
816 | ||
817 | f_offset16 = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 31, 16) << 0)); | |
818 | f_dstbe = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 15, 4) << 0)); | |
819 | f_srcbe = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 11, 4) << 0)); | |
820 | ||
821 | /* Record the fields for the semantic handler. */ | |
822 | FLD (f_dstbe) = f_dstbe; | |
823 | FLD (f_offset16) = f_offset16; | |
824 | FLD (f_srcbe) = f_srcbe; | |
825 | TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_stxhbe", "f_dstbe 0x%x", 'x', f_dstbe, "f_offset16 0x%x", 'x', f_offset16, "f_srcbe 0x%x", 'x', f_srcbe, (char *) 0)); | |
826 | ||
827 | #undef FLD | |
828 | return idesc; | |
829 | } | |
830 | ||
831 | extract_sfmt_stxbbe: | |
832 | { | |
833 | const IDESC *idesc = &bpfbf_ebpfbe_insn_data[itype]; | |
834 | CGEN_INSN_WORD insn = base_insn; | |
835 | #define FLD(f) abuf->fields.sfmt_ldxwbe.f | |
836 | HI f_offset16; | |
837 | UINT f_dstbe; | |
838 | UINT f_srcbe; | |
839 | ||
840 | f_offset16 = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 31, 16) << 0)); | |
841 | f_dstbe = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 15, 4) << 0)); | |
842 | f_srcbe = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 11, 4) << 0)); | |
843 | ||
844 | /* Record the fields for the semantic handler. */ | |
845 | FLD (f_dstbe) = f_dstbe; | |
846 | FLD (f_offset16) = f_offset16; | |
847 | FLD (f_srcbe) = f_srcbe; | |
848 | TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_stxbbe", "f_dstbe 0x%x", 'x', f_dstbe, "f_offset16 0x%x", 'x', f_offset16, "f_srcbe 0x%x", 'x', f_srcbe, (char *) 0)); | |
849 | ||
850 | #undef FLD | |
851 | return idesc; | |
852 | } | |
853 | ||
854 | extract_sfmt_stxdwbe: | |
855 | { | |
856 | const IDESC *idesc = &bpfbf_ebpfbe_insn_data[itype]; | |
857 | CGEN_INSN_WORD insn = base_insn; | |
858 | #define FLD(f) abuf->fields.sfmt_ldxwbe.f | |
859 | HI f_offset16; | |
860 | UINT f_dstbe; | |
861 | UINT f_srcbe; | |
862 | ||
863 | f_offset16 = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 31, 16) << 0)); | |
864 | f_dstbe = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 15, 4) << 0)); | |
865 | f_srcbe = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 11, 4) << 0)); | |
866 | ||
867 | /* Record the fields for the semantic handler. */ | |
868 | FLD (f_dstbe) = f_dstbe; | |
869 | FLD (f_offset16) = f_offset16; | |
870 | FLD (f_srcbe) = f_srcbe; | |
871 | TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_stxdwbe", "f_dstbe 0x%x", 'x', f_dstbe, "f_offset16 0x%x", 'x', f_offset16, "f_srcbe 0x%x", 'x', f_srcbe, (char *) 0)); | |
872 | ||
873 | #undef FLD | |
874 | return idesc; | |
875 | } | |
876 | ||
877 | extract_sfmt_stbbe: | |
878 | { | |
879 | const IDESC *idesc = &bpfbf_ebpfbe_insn_data[itype]; | |
880 | CGEN_INSN_WORD insn = base_insn; | |
881 | #define FLD(f) abuf->fields.sfmt_stbbe.f | |
882 | INT f_imm32; | |
883 | HI f_offset16; | |
884 | UINT f_dstbe; | |
885 | ||
886 | f_imm32 = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 63, 32) << 0)); | |
887 | f_offset16 = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 31, 16) << 0)); | |
888 | f_dstbe = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 15, 4) << 0)); | |
889 | ||
890 | /* Record the fields for the semantic handler. */ | |
891 | FLD (f_dstbe) = f_dstbe; | |
892 | FLD (f_imm32) = f_imm32; | |
893 | FLD (f_offset16) = f_offset16; | |
894 | TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_stbbe", "f_dstbe 0x%x", 'x', f_dstbe, "f_imm32 0x%x", 'x', f_imm32, "f_offset16 0x%x", 'x', f_offset16, (char *) 0)); | |
895 | ||
896 | #undef FLD | |
897 | return idesc; | |
898 | } | |
899 | ||
900 | extract_sfmt_sthbe: | |
901 | { | |
902 | const IDESC *idesc = &bpfbf_ebpfbe_insn_data[itype]; | |
903 | CGEN_INSN_WORD insn = base_insn; | |
904 | #define FLD(f) abuf->fields.sfmt_stbbe.f | |
905 | INT f_imm32; | |
906 | HI f_offset16; | |
907 | UINT f_dstbe; | |
908 | ||
909 | f_imm32 = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 63, 32) << 0)); | |
910 | f_offset16 = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 31, 16) << 0)); | |
911 | f_dstbe = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 15, 4) << 0)); | |
912 | ||
913 | /* Record the fields for the semantic handler. */ | |
914 | FLD (f_dstbe) = f_dstbe; | |
915 | FLD (f_imm32) = f_imm32; | |
916 | FLD (f_offset16) = f_offset16; | |
917 | TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_sthbe", "f_dstbe 0x%x", 'x', f_dstbe, "f_imm32 0x%x", 'x', f_imm32, "f_offset16 0x%x", 'x', f_offset16, (char *) 0)); | |
918 | ||
919 | #undef FLD | |
920 | return idesc; | |
921 | } | |
922 | ||
923 | extract_sfmt_stwbe: | |
924 | { | |
925 | const IDESC *idesc = &bpfbf_ebpfbe_insn_data[itype]; | |
926 | CGEN_INSN_WORD insn = base_insn; | |
927 | #define FLD(f) abuf->fields.sfmt_stbbe.f | |
928 | INT f_imm32; | |
929 | HI f_offset16; | |
930 | UINT f_dstbe; | |
931 | ||
932 | f_imm32 = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 63, 32) << 0)); | |
933 | f_offset16 = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 31, 16) << 0)); | |
934 | f_dstbe = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 15, 4) << 0)); | |
935 | ||
936 | /* Record the fields for the semantic handler. */ | |
937 | FLD (f_dstbe) = f_dstbe; | |
938 | FLD (f_imm32) = f_imm32; | |
939 | FLD (f_offset16) = f_offset16; | |
940 | TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_stwbe", "f_dstbe 0x%x", 'x', f_dstbe, "f_imm32 0x%x", 'x', f_imm32, "f_offset16 0x%x", 'x', f_offset16, (char *) 0)); | |
941 | ||
942 | #undef FLD | |
943 | return idesc; | |
944 | } | |
945 | ||
946 | extract_sfmt_stdwbe: | |
947 | { | |
948 | const IDESC *idesc = &bpfbf_ebpfbe_insn_data[itype]; | |
949 | CGEN_INSN_WORD insn = base_insn; | |
950 | #define FLD(f) abuf->fields.sfmt_stbbe.f | |
951 | INT f_imm32; | |
952 | HI f_offset16; | |
953 | UINT f_dstbe; | |
954 | ||
955 | f_imm32 = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 63, 32) << 0)); | |
956 | f_offset16 = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 31, 16) << 0)); | |
957 | f_dstbe = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 15, 4) << 0)); | |
958 | ||
959 | /* Record the fields for the semantic handler. */ | |
960 | FLD (f_dstbe) = f_dstbe; | |
961 | FLD (f_imm32) = f_imm32; | |
962 | FLD (f_offset16) = f_offset16; | |
963 | TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_stdwbe", "f_dstbe 0x%x", 'x', f_dstbe, "f_imm32 0x%x", 'x', f_imm32, "f_offset16 0x%x", 'x', f_offset16, (char *) 0)); | |
964 | ||
965 | #undef FLD | |
966 | return idesc; | |
967 | } | |
968 | ||
969 | extract_sfmt_jeqibe: | |
970 | { | |
971 | const IDESC *idesc = &bpfbf_ebpfbe_insn_data[itype]; | |
972 | CGEN_INSN_WORD insn = base_insn; | |
973 | #define FLD(f) abuf->fields.sfmt_stbbe.f | |
974 | INT f_imm32; | |
975 | HI f_offset16; | |
976 | UINT f_dstbe; | |
977 | ||
978 | f_imm32 = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 63, 32) << 0)); | |
979 | f_offset16 = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 31, 16) << 0)); | |
980 | f_dstbe = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 15, 4) << 0)); | |
981 | ||
982 | /* Record the fields for the semantic handler. */ | |
983 | FLD (f_offset16) = f_offset16; | |
984 | FLD (f_dstbe) = f_dstbe; | |
985 | FLD (f_imm32) = f_imm32; | |
986 | TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_jeqibe", "f_offset16 0x%x", 'x', f_offset16, "f_dstbe 0x%x", 'x', f_dstbe, "f_imm32 0x%x", 'x', f_imm32, (char *) 0)); | |
987 | ||
988 | #if WITH_PROFILE_MODEL_P | |
989 | /* Record the fields for profiling. */ | |
990 | if (PROFILE_MODEL_P (current_cpu)) | |
991 | { | |
992 | } | |
993 | #endif | |
994 | #undef FLD | |
995 | return idesc; | |
996 | } | |
997 | ||
998 | extract_sfmt_jeqrbe: | |
999 | { | |
1000 | const IDESC *idesc = &bpfbf_ebpfbe_insn_data[itype]; | |
1001 | CGEN_INSN_WORD insn = base_insn; | |
1002 | #define FLD(f) abuf->fields.sfmt_ldxwbe.f | |
1003 | HI f_offset16; | |
1004 | UINT f_dstbe; | |
1005 | UINT f_srcbe; | |
1006 | ||
1007 | f_offset16 = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 31, 16) << 0)); | |
1008 | f_dstbe = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 15, 4) << 0)); | |
1009 | f_srcbe = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 11, 4) << 0)); | |
1010 | ||
1011 | /* Record the fields for the semantic handler. */ | |
1012 | FLD (f_offset16) = f_offset16; | |
1013 | FLD (f_dstbe) = f_dstbe; | |
1014 | FLD (f_srcbe) = f_srcbe; | |
1015 | TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_jeqrbe", "f_offset16 0x%x", 'x', f_offset16, "f_dstbe 0x%x", 'x', f_dstbe, "f_srcbe 0x%x", 'x', f_srcbe, (char *) 0)); | |
1016 | ||
1017 | #if WITH_PROFILE_MODEL_P | |
1018 | /* Record the fields for profiling. */ | |
1019 | if (PROFILE_MODEL_P (current_cpu)) | |
1020 | { | |
1021 | } | |
1022 | #endif | |
1023 | #undef FLD | |
1024 | return idesc; | |
1025 | } | |
1026 | ||
1027 | extract_sfmt_callbe: | |
1028 | { | |
1029 | const IDESC *idesc = &bpfbf_ebpfbe_insn_data[itype]; | |
1030 | CGEN_INSN_WORD insn = base_insn; | |
1031 | #define FLD(f) abuf->fields.sfmt_ldindwbe.f | |
1032 | INT f_imm32; | |
1033 | UINT f_srcbe; | |
1034 | ||
1035 | f_imm32 = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 63, 32) << 0)); | |
1036 | f_srcbe = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 11, 4) << 0)); | |
1037 | ||
1038 | /* Record the fields for the semantic handler. */ | |
1039 | FLD (f_imm32) = f_imm32; | |
1040 | FLD (f_srcbe) = f_srcbe; | |
1041 | TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_callbe", "f_imm32 0x%x", 'x', f_imm32, "f_srcbe 0x%x", 'x', f_srcbe, (char *) 0)); | |
1042 | ||
1043 | #undef FLD | |
1044 | return idesc; | |
1045 | } | |
1046 | ||
1047 | extract_sfmt_ja: | |
1048 | { | |
1049 | const IDESC *idesc = &bpfbf_ebpfbe_insn_data[itype]; | |
1050 | CGEN_INSN_WORD insn = base_insn; | |
1051 | #define FLD(f) abuf->fields.sfmt_stbbe.f | |
1052 | HI f_offset16; | |
1053 | ||
1054 | f_offset16 = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 31, 16) << 0)); | |
1055 | ||
1056 | /* Record the fields for the semantic handler. */ | |
1057 | FLD (f_offset16) = f_offset16; | |
1058 | TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_ja", "f_offset16 0x%x", 'x', f_offset16, (char *) 0)); | |
1059 | ||
1060 | #if WITH_PROFILE_MODEL_P | |
1061 | /* Record the fields for profiling. */ | |
1062 | if (PROFILE_MODEL_P (current_cpu)) | |
1063 | { | |
1064 | } | |
1065 | #endif | |
1066 | #undef FLD | |
1067 | return idesc; | |
1068 | } | |
1069 | ||
1070 | extract_sfmt_exit: | |
1071 | { | |
1072 | const IDESC *idesc = &bpfbf_ebpfbe_insn_data[itype]; | |
1073 | #define FLD(f) abuf->fields.sfmt_empty.f | |
1074 | ||
1075 | ||
1076 | /* Record the fields for the semantic handler. */ | |
1077 | TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_exit", (char *) 0)); | |
1078 | ||
1079 | #undef FLD | |
1080 | return idesc; | |
1081 | } | |
1082 | ||
1083 | extract_sfmt_xadddwbe: | |
1084 | { | |
1085 | const IDESC *idesc = &bpfbf_ebpfbe_insn_data[itype]; | |
1086 | CGEN_INSN_WORD insn = base_insn; | |
1087 | #define FLD(f) abuf->fields.sfmt_ldxwbe.f | |
1088 | HI f_offset16; | |
1089 | UINT f_dstbe; | |
1090 | UINT f_srcbe; | |
1091 | ||
1092 | f_offset16 = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 31, 16) << 0)); | |
1093 | f_dstbe = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 15, 4) << 0)); | |
1094 | f_srcbe = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 11, 4) << 0)); | |
1095 | ||
1096 | /* Record the fields for the semantic handler. */ | |
1097 | FLD (f_dstbe) = f_dstbe; | |
1098 | FLD (f_offset16) = f_offset16; | |
1099 | FLD (f_srcbe) = f_srcbe; | |
1100 | TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_xadddwbe", "f_dstbe 0x%x", 'x', f_dstbe, "f_offset16 0x%x", 'x', f_offset16, "f_srcbe 0x%x", 'x', f_srcbe, (char *) 0)); | |
1101 | ||
1102 | #undef FLD | |
1103 | return idesc; | |
1104 | } | |
1105 | ||
1106 | extract_sfmt_xaddwbe: | |
1107 | { | |
1108 | const IDESC *idesc = &bpfbf_ebpfbe_insn_data[itype]; | |
1109 | CGEN_INSN_WORD insn = base_insn; | |
1110 | #define FLD(f) abuf->fields.sfmt_ldxwbe.f | |
1111 | HI f_offset16; | |
1112 | UINT f_dstbe; | |
1113 | UINT f_srcbe; | |
1114 | ||
1115 | f_offset16 = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 31, 16) << 0)); | |
1116 | f_dstbe = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 15, 4) << 0)); | |
1117 | f_srcbe = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 11, 4) << 0)); | |
1118 | ||
1119 | /* Record the fields for the semantic handler. */ | |
1120 | FLD (f_dstbe) = f_dstbe; | |
1121 | FLD (f_offset16) = f_offset16; | |
1122 | FLD (f_srcbe) = f_srcbe; | |
1123 | TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_xaddwbe", "f_dstbe 0x%x", 'x', f_dstbe, "f_offset16 0x%x", 'x', f_offset16, "f_srcbe 0x%x", 'x', f_srcbe, (char *) 0)); | |
1124 | ||
1125 | #undef FLD | |
1126 | return idesc; | |
1127 | } | |
1128 | ||
1129 | } |