1 /* Simulator instruction decoder for bpfbf_ebpfbe. 2 3 THIS FILE IS MACHINE GENERATED WITH CGEN. 4 5 Copyright (C) 1996-2020 Free Software Foundation, Inc. 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 } 1130