1 /* Simulator instruction decoder for bpfbf_ebpfle. 2 3 THIS FILE IS MACHINE GENERATED WITH CGEN. 4 5 Copyright (C) 1996-2023 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 #include "cgen-mem.h" 31 #include "cgen-ops.h" 32 33 /* The instruction descriptor array. 34 This is computed at runtime. Space for it is not malloc'd to save a 35 teensy bit of cpu in the decoder. Moving it to malloc space is trivial 36 but won't be done until necessary (we don't currently support the runtime 37 addition of instructions nor an SMP machine with different cpus). */ 38 static IDESC bpfbf_ebpfle_insn_data[BPFBF_EBPFLE_INSN__MAX]; 39 40 /* Commas between elements are contained in the macros. 41 Some of these are conditionally compiled out. */ 42 43 static const struct insn_sem bpfbf_ebpfle_insn_sem[] = 44 { 45 { VIRTUAL_INSN_X_INVALID, BPFBF_EBPFLE_INSN_X_INVALID, BPFBF_EBPFLE_SFMT_EMPTY }, 46 { VIRTUAL_INSN_X_AFTER, BPFBF_EBPFLE_INSN_X_AFTER, BPFBF_EBPFLE_SFMT_EMPTY }, 47 { VIRTUAL_INSN_X_BEFORE, BPFBF_EBPFLE_INSN_X_BEFORE, BPFBF_EBPFLE_SFMT_EMPTY }, 48 { VIRTUAL_INSN_X_CTI_CHAIN, BPFBF_EBPFLE_INSN_X_CTI_CHAIN, BPFBF_EBPFLE_SFMT_EMPTY }, 49 { VIRTUAL_INSN_X_CHAIN, BPFBF_EBPFLE_INSN_X_CHAIN, BPFBF_EBPFLE_SFMT_EMPTY }, 50 { VIRTUAL_INSN_X_BEGIN, BPFBF_EBPFLE_INSN_X_BEGIN, BPFBF_EBPFLE_SFMT_EMPTY }, 51 { BPF_INSN_ADDILE, BPFBF_EBPFLE_INSN_ADDILE, BPFBF_EBPFLE_SFMT_ADDILE }, 52 { BPF_INSN_ADDRLE, BPFBF_EBPFLE_INSN_ADDRLE, BPFBF_EBPFLE_SFMT_ADDRLE }, 53 { BPF_INSN_ADD32ILE, BPFBF_EBPFLE_INSN_ADD32ILE, BPFBF_EBPFLE_SFMT_ADDILE }, 54 { BPF_INSN_ADD32RLE, BPFBF_EBPFLE_INSN_ADD32RLE, BPFBF_EBPFLE_SFMT_ADDRLE }, 55 { BPF_INSN_SUBILE, BPFBF_EBPFLE_INSN_SUBILE, BPFBF_EBPFLE_SFMT_ADDILE }, 56 { BPF_INSN_SUBRLE, BPFBF_EBPFLE_INSN_SUBRLE, BPFBF_EBPFLE_SFMT_ADDRLE }, 57 { BPF_INSN_SUB32ILE, BPFBF_EBPFLE_INSN_SUB32ILE, BPFBF_EBPFLE_SFMT_ADDILE }, 58 { BPF_INSN_SUB32RLE, BPFBF_EBPFLE_INSN_SUB32RLE, BPFBF_EBPFLE_SFMT_ADDRLE }, 59 { BPF_INSN_MULILE, BPFBF_EBPFLE_INSN_MULILE, BPFBF_EBPFLE_SFMT_ADDILE }, 60 { BPF_INSN_MULRLE, BPFBF_EBPFLE_INSN_MULRLE, BPFBF_EBPFLE_SFMT_ADDRLE }, 61 { BPF_INSN_MUL32ILE, BPFBF_EBPFLE_INSN_MUL32ILE, BPFBF_EBPFLE_SFMT_ADDILE }, 62 { BPF_INSN_MUL32RLE, BPFBF_EBPFLE_INSN_MUL32RLE, BPFBF_EBPFLE_SFMT_ADDRLE }, 63 { BPF_INSN_DIVILE, BPFBF_EBPFLE_INSN_DIVILE, BPFBF_EBPFLE_SFMT_ADDILE }, 64 { BPF_INSN_DIVRLE, BPFBF_EBPFLE_INSN_DIVRLE, BPFBF_EBPFLE_SFMT_ADDRLE }, 65 { BPF_INSN_DIV32ILE, BPFBF_EBPFLE_INSN_DIV32ILE, BPFBF_EBPFLE_SFMT_ADDILE }, 66 { BPF_INSN_DIV32RLE, BPFBF_EBPFLE_INSN_DIV32RLE, BPFBF_EBPFLE_SFMT_ADDRLE }, 67 { BPF_INSN_ORILE, BPFBF_EBPFLE_INSN_ORILE, BPFBF_EBPFLE_SFMT_ADDILE }, 68 { BPF_INSN_ORRLE, BPFBF_EBPFLE_INSN_ORRLE, BPFBF_EBPFLE_SFMT_ADDRLE }, 69 { BPF_INSN_OR32ILE, BPFBF_EBPFLE_INSN_OR32ILE, BPFBF_EBPFLE_SFMT_ADDILE }, 70 { BPF_INSN_OR32RLE, BPFBF_EBPFLE_INSN_OR32RLE, BPFBF_EBPFLE_SFMT_ADDRLE }, 71 { BPF_INSN_ANDILE, BPFBF_EBPFLE_INSN_ANDILE, BPFBF_EBPFLE_SFMT_ADDILE }, 72 { BPF_INSN_ANDRLE, BPFBF_EBPFLE_INSN_ANDRLE, BPFBF_EBPFLE_SFMT_ADDRLE }, 73 { BPF_INSN_AND32ILE, BPFBF_EBPFLE_INSN_AND32ILE, BPFBF_EBPFLE_SFMT_ADDILE }, 74 { BPF_INSN_AND32RLE, BPFBF_EBPFLE_INSN_AND32RLE, BPFBF_EBPFLE_SFMT_ADDRLE }, 75 { BPF_INSN_LSHILE, BPFBF_EBPFLE_INSN_LSHILE, BPFBF_EBPFLE_SFMT_ADDILE }, 76 { BPF_INSN_LSHRLE, BPFBF_EBPFLE_INSN_LSHRLE, BPFBF_EBPFLE_SFMT_ADDRLE }, 77 { BPF_INSN_LSH32ILE, BPFBF_EBPFLE_INSN_LSH32ILE, BPFBF_EBPFLE_SFMT_ADDILE }, 78 { BPF_INSN_LSH32RLE, BPFBF_EBPFLE_INSN_LSH32RLE, BPFBF_EBPFLE_SFMT_ADDRLE }, 79 { BPF_INSN_RSHILE, BPFBF_EBPFLE_INSN_RSHILE, BPFBF_EBPFLE_SFMT_ADDILE }, 80 { BPF_INSN_RSHRLE, BPFBF_EBPFLE_INSN_RSHRLE, BPFBF_EBPFLE_SFMT_ADDRLE }, 81 { BPF_INSN_RSH32ILE, BPFBF_EBPFLE_INSN_RSH32ILE, BPFBF_EBPFLE_SFMT_ADDILE }, 82 { BPF_INSN_RSH32RLE, BPFBF_EBPFLE_INSN_RSH32RLE, BPFBF_EBPFLE_SFMT_ADDRLE }, 83 { BPF_INSN_MODILE, BPFBF_EBPFLE_INSN_MODILE, BPFBF_EBPFLE_SFMT_ADDILE }, 84 { BPF_INSN_MODRLE, BPFBF_EBPFLE_INSN_MODRLE, BPFBF_EBPFLE_SFMT_ADDRLE }, 85 { BPF_INSN_MOD32ILE, BPFBF_EBPFLE_INSN_MOD32ILE, BPFBF_EBPFLE_SFMT_ADDILE }, 86 { BPF_INSN_MOD32RLE, BPFBF_EBPFLE_INSN_MOD32RLE, BPFBF_EBPFLE_SFMT_ADDRLE }, 87 { BPF_INSN_XORILE, BPFBF_EBPFLE_INSN_XORILE, BPFBF_EBPFLE_SFMT_ADDILE }, 88 { BPF_INSN_XORRLE, BPFBF_EBPFLE_INSN_XORRLE, BPFBF_EBPFLE_SFMT_ADDRLE }, 89 { BPF_INSN_XOR32ILE, BPFBF_EBPFLE_INSN_XOR32ILE, BPFBF_EBPFLE_SFMT_ADDILE }, 90 { BPF_INSN_XOR32RLE, BPFBF_EBPFLE_INSN_XOR32RLE, BPFBF_EBPFLE_SFMT_ADDRLE }, 91 { BPF_INSN_ARSHILE, BPFBF_EBPFLE_INSN_ARSHILE, BPFBF_EBPFLE_SFMT_ADDILE }, 92 { BPF_INSN_ARSHRLE, BPFBF_EBPFLE_INSN_ARSHRLE, BPFBF_EBPFLE_SFMT_ADDRLE }, 93 { BPF_INSN_ARSH32ILE, BPFBF_EBPFLE_INSN_ARSH32ILE, BPFBF_EBPFLE_SFMT_ADDILE }, 94 { BPF_INSN_ARSH32RLE, BPFBF_EBPFLE_INSN_ARSH32RLE, BPFBF_EBPFLE_SFMT_ADDRLE }, 95 { BPF_INSN_NEGLE, BPFBF_EBPFLE_INSN_NEGLE, BPFBF_EBPFLE_SFMT_NEGLE }, 96 { BPF_INSN_NEG32LE, BPFBF_EBPFLE_INSN_NEG32LE, BPFBF_EBPFLE_SFMT_NEGLE }, 97 { BPF_INSN_MOVILE, BPFBF_EBPFLE_INSN_MOVILE, BPFBF_EBPFLE_SFMT_MOVILE }, 98 { BPF_INSN_MOVRLE, BPFBF_EBPFLE_INSN_MOVRLE, BPFBF_EBPFLE_SFMT_MOVRLE }, 99 { BPF_INSN_MOV32ILE, BPFBF_EBPFLE_INSN_MOV32ILE, BPFBF_EBPFLE_SFMT_MOVILE }, 100 { BPF_INSN_MOV32RLE, BPFBF_EBPFLE_INSN_MOV32RLE, BPFBF_EBPFLE_SFMT_MOVRLE }, 101 { BPF_INSN_ENDLELE, BPFBF_EBPFLE_INSN_ENDLELE, BPFBF_EBPFLE_SFMT_ENDLELE }, 102 { BPF_INSN_ENDBELE, BPFBF_EBPFLE_INSN_ENDBELE, BPFBF_EBPFLE_SFMT_ENDLELE }, 103 { BPF_INSN_LDDWLE, BPFBF_EBPFLE_INSN_LDDWLE, BPFBF_EBPFLE_SFMT_LDDWLE }, 104 { BPF_INSN_LDABSW, BPFBF_EBPFLE_INSN_LDABSW, BPFBF_EBPFLE_SFMT_LDABSW }, 105 { BPF_INSN_LDABSH, BPFBF_EBPFLE_INSN_LDABSH, BPFBF_EBPFLE_SFMT_LDABSH }, 106 { BPF_INSN_LDABSB, BPFBF_EBPFLE_INSN_LDABSB, BPFBF_EBPFLE_SFMT_LDABSB }, 107 { BPF_INSN_LDABSDW, BPFBF_EBPFLE_INSN_LDABSDW, BPFBF_EBPFLE_SFMT_LDABSDW }, 108 { BPF_INSN_LDINDWLE, BPFBF_EBPFLE_INSN_LDINDWLE, BPFBF_EBPFLE_SFMT_LDINDWLE }, 109 { BPF_INSN_LDINDHLE, BPFBF_EBPFLE_INSN_LDINDHLE, BPFBF_EBPFLE_SFMT_LDINDHLE }, 110 { BPF_INSN_LDINDBLE, BPFBF_EBPFLE_INSN_LDINDBLE, BPFBF_EBPFLE_SFMT_LDINDBLE }, 111 { BPF_INSN_LDINDDWLE, BPFBF_EBPFLE_INSN_LDINDDWLE, BPFBF_EBPFLE_SFMT_LDINDDWLE }, 112 { BPF_INSN_LDXWLE, BPFBF_EBPFLE_INSN_LDXWLE, BPFBF_EBPFLE_SFMT_LDXWLE }, 113 { BPF_INSN_LDXHLE, BPFBF_EBPFLE_INSN_LDXHLE, BPFBF_EBPFLE_SFMT_LDXHLE }, 114 { BPF_INSN_LDXBLE, BPFBF_EBPFLE_INSN_LDXBLE, BPFBF_EBPFLE_SFMT_LDXBLE }, 115 { BPF_INSN_LDXDWLE, BPFBF_EBPFLE_INSN_LDXDWLE, BPFBF_EBPFLE_SFMT_LDXDWLE }, 116 { BPF_INSN_STXWLE, BPFBF_EBPFLE_INSN_STXWLE, BPFBF_EBPFLE_SFMT_STXWLE }, 117 { BPF_INSN_STXHLE, BPFBF_EBPFLE_INSN_STXHLE, BPFBF_EBPFLE_SFMT_STXHLE }, 118 { BPF_INSN_STXBLE, BPFBF_EBPFLE_INSN_STXBLE, BPFBF_EBPFLE_SFMT_STXBLE }, 119 { BPF_INSN_STXDWLE, BPFBF_EBPFLE_INSN_STXDWLE, BPFBF_EBPFLE_SFMT_STXDWLE }, 120 { BPF_INSN_STBLE, BPFBF_EBPFLE_INSN_STBLE, BPFBF_EBPFLE_SFMT_STBLE }, 121 { BPF_INSN_STHLE, BPFBF_EBPFLE_INSN_STHLE, BPFBF_EBPFLE_SFMT_STHLE }, 122 { BPF_INSN_STWLE, BPFBF_EBPFLE_INSN_STWLE, BPFBF_EBPFLE_SFMT_STWLE }, 123 { BPF_INSN_STDWLE, BPFBF_EBPFLE_INSN_STDWLE, BPFBF_EBPFLE_SFMT_STDWLE }, 124 { BPF_INSN_JEQILE, BPFBF_EBPFLE_INSN_JEQILE, BPFBF_EBPFLE_SFMT_JEQILE }, 125 { BPF_INSN_JEQRLE, BPFBF_EBPFLE_INSN_JEQRLE, BPFBF_EBPFLE_SFMT_JEQRLE }, 126 { BPF_INSN_JEQ32ILE, BPFBF_EBPFLE_INSN_JEQ32ILE, BPFBF_EBPFLE_SFMT_JEQILE }, 127 { BPF_INSN_JEQ32RLE, BPFBF_EBPFLE_INSN_JEQ32RLE, BPFBF_EBPFLE_SFMT_JEQRLE }, 128 { BPF_INSN_JGTILE, BPFBF_EBPFLE_INSN_JGTILE, BPFBF_EBPFLE_SFMT_JEQILE }, 129 { BPF_INSN_JGTRLE, BPFBF_EBPFLE_INSN_JGTRLE, BPFBF_EBPFLE_SFMT_JEQRLE }, 130 { BPF_INSN_JGT32ILE, BPFBF_EBPFLE_INSN_JGT32ILE, BPFBF_EBPFLE_SFMT_JEQILE }, 131 { BPF_INSN_JGT32RLE, BPFBF_EBPFLE_INSN_JGT32RLE, BPFBF_EBPFLE_SFMT_JEQRLE }, 132 { BPF_INSN_JGEILE, BPFBF_EBPFLE_INSN_JGEILE, BPFBF_EBPFLE_SFMT_JEQILE }, 133 { BPF_INSN_JGERLE, BPFBF_EBPFLE_INSN_JGERLE, BPFBF_EBPFLE_SFMT_JEQRLE }, 134 { BPF_INSN_JGE32ILE, BPFBF_EBPFLE_INSN_JGE32ILE, BPFBF_EBPFLE_SFMT_JEQILE }, 135 { BPF_INSN_JGE32RLE, BPFBF_EBPFLE_INSN_JGE32RLE, BPFBF_EBPFLE_SFMT_JEQRLE }, 136 { BPF_INSN_JLTILE, BPFBF_EBPFLE_INSN_JLTILE, BPFBF_EBPFLE_SFMT_JEQILE }, 137 { BPF_INSN_JLTRLE, BPFBF_EBPFLE_INSN_JLTRLE, BPFBF_EBPFLE_SFMT_JEQRLE }, 138 { BPF_INSN_JLT32ILE, BPFBF_EBPFLE_INSN_JLT32ILE, BPFBF_EBPFLE_SFMT_JEQILE }, 139 { BPF_INSN_JLT32RLE, BPFBF_EBPFLE_INSN_JLT32RLE, BPFBF_EBPFLE_SFMT_JEQRLE }, 140 { BPF_INSN_JLEILE, BPFBF_EBPFLE_INSN_JLEILE, BPFBF_EBPFLE_SFMT_JEQILE }, 141 { BPF_INSN_JLERLE, BPFBF_EBPFLE_INSN_JLERLE, BPFBF_EBPFLE_SFMT_JEQRLE }, 142 { BPF_INSN_JLE32ILE, BPFBF_EBPFLE_INSN_JLE32ILE, BPFBF_EBPFLE_SFMT_JEQILE }, 143 { BPF_INSN_JLE32RLE, BPFBF_EBPFLE_INSN_JLE32RLE, BPFBF_EBPFLE_SFMT_JEQRLE }, 144 { BPF_INSN_JSETILE, BPFBF_EBPFLE_INSN_JSETILE, BPFBF_EBPFLE_SFMT_JEQILE }, 145 { BPF_INSN_JSETRLE, BPFBF_EBPFLE_INSN_JSETRLE, BPFBF_EBPFLE_SFMT_JEQRLE }, 146 { BPF_INSN_JSET32ILE, BPFBF_EBPFLE_INSN_JSET32ILE, BPFBF_EBPFLE_SFMT_JEQILE }, 147 { BPF_INSN_JSET32RLE, BPFBF_EBPFLE_INSN_JSET32RLE, BPFBF_EBPFLE_SFMT_JEQRLE }, 148 { BPF_INSN_JNEILE, BPFBF_EBPFLE_INSN_JNEILE, BPFBF_EBPFLE_SFMT_JEQILE }, 149 { BPF_INSN_JNERLE, BPFBF_EBPFLE_INSN_JNERLE, BPFBF_EBPFLE_SFMT_JEQRLE }, 150 { BPF_INSN_JNE32ILE, BPFBF_EBPFLE_INSN_JNE32ILE, BPFBF_EBPFLE_SFMT_JEQILE }, 151 { BPF_INSN_JNE32RLE, BPFBF_EBPFLE_INSN_JNE32RLE, BPFBF_EBPFLE_SFMT_JEQRLE }, 152 { BPF_INSN_JSGTILE, BPFBF_EBPFLE_INSN_JSGTILE, BPFBF_EBPFLE_SFMT_JEQILE }, 153 { BPF_INSN_JSGTRLE, BPFBF_EBPFLE_INSN_JSGTRLE, BPFBF_EBPFLE_SFMT_JEQRLE }, 154 { BPF_INSN_JSGT32ILE, BPFBF_EBPFLE_INSN_JSGT32ILE, BPFBF_EBPFLE_SFMT_JEQILE }, 155 { BPF_INSN_JSGT32RLE, BPFBF_EBPFLE_INSN_JSGT32RLE, BPFBF_EBPFLE_SFMT_JEQRLE }, 156 { BPF_INSN_JSGEILE, BPFBF_EBPFLE_INSN_JSGEILE, BPFBF_EBPFLE_SFMT_JEQILE }, 157 { BPF_INSN_JSGERLE, BPFBF_EBPFLE_INSN_JSGERLE, BPFBF_EBPFLE_SFMT_JEQRLE }, 158 { BPF_INSN_JSGE32ILE, BPFBF_EBPFLE_INSN_JSGE32ILE, BPFBF_EBPFLE_SFMT_JEQILE }, 159 { BPF_INSN_JSGE32RLE, BPFBF_EBPFLE_INSN_JSGE32RLE, BPFBF_EBPFLE_SFMT_JEQRLE }, 160 { BPF_INSN_JSLTILE, BPFBF_EBPFLE_INSN_JSLTILE, BPFBF_EBPFLE_SFMT_JEQILE }, 161 { BPF_INSN_JSLTRLE, BPFBF_EBPFLE_INSN_JSLTRLE, BPFBF_EBPFLE_SFMT_JEQRLE }, 162 { BPF_INSN_JSLT32ILE, BPFBF_EBPFLE_INSN_JSLT32ILE, BPFBF_EBPFLE_SFMT_JEQILE }, 163 { BPF_INSN_JSLT32RLE, BPFBF_EBPFLE_INSN_JSLT32RLE, BPFBF_EBPFLE_SFMT_JEQRLE }, 164 { BPF_INSN_JSLEILE, BPFBF_EBPFLE_INSN_JSLEILE, BPFBF_EBPFLE_SFMT_JEQILE }, 165 { BPF_INSN_JSLERLE, BPFBF_EBPFLE_INSN_JSLERLE, BPFBF_EBPFLE_SFMT_JEQRLE }, 166 { BPF_INSN_JSLE32ILE, BPFBF_EBPFLE_INSN_JSLE32ILE, BPFBF_EBPFLE_SFMT_JEQILE }, 167 { BPF_INSN_JSLE32RLE, BPFBF_EBPFLE_INSN_JSLE32RLE, BPFBF_EBPFLE_SFMT_JEQRLE }, 168 { BPF_INSN_CALLLE, BPFBF_EBPFLE_INSN_CALLLE, BPFBF_EBPFLE_SFMT_CALLLE }, 169 { BPF_INSN_JA, BPFBF_EBPFLE_INSN_JA, BPFBF_EBPFLE_SFMT_JA }, 170 { BPF_INSN_EXIT, BPFBF_EBPFLE_INSN_EXIT, BPFBF_EBPFLE_SFMT_EXIT }, 171 { BPF_INSN_XADDDWLE, BPFBF_EBPFLE_INSN_XADDDWLE, BPFBF_EBPFLE_SFMT_XADDDWLE }, 172 { BPF_INSN_XADDWLE, BPFBF_EBPFLE_INSN_XADDWLE, BPFBF_EBPFLE_SFMT_XADDWLE }, 173 { BPF_INSN_BRKPT, BPFBF_EBPFLE_INSN_BRKPT, BPFBF_EBPFLE_SFMT_EXIT }, 174 }; 175 176 static const struct insn_sem bpfbf_ebpfle_insn_sem_invalid = 177 { 178 VIRTUAL_INSN_X_INVALID, BPFBF_EBPFLE_INSN_X_INVALID, BPFBF_EBPFLE_SFMT_EMPTY 179 }; 180 181 /* Initialize an IDESC from the compile-time computable parts. */ 182 183 static INLINE void 184 init_idesc (SIM_CPU *cpu, IDESC *id, const struct insn_sem *t) 185 { 186 const CGEN_INSN *insn_table = CGEN_CPU_INSN_TABLE (CPU_CPU_DESC (cpu))->init_entries; 187 188 id->num = t->index; 189 id->sfmt = t->sfmt; 190 if ((int) t->type <= 0) 191 id->idata = & cgen_virtual_insn_table[- (int) t->type]; 192 else 193 id->idata = & insn_table[t->type]; 194 id->attrs = CGEN_INSN_ATTRS (id->idata); 195 /* Oh my god, a magic number. */ 196 id->length = CGEN_INSN_BITSIZE (id->idata) / 8; 197 198 #if WITH_PROFILE_MODEL_P 199 id->timing = & MODEL_TIMING (CPU_MODEL (cpu)) [t->index]; 200 { 201 SIM_DESC sd = CPU_STATE (cpu); 202 SIM_ASSERT (t->index == id->timing->num); 203 } 204 #endif 205 206 /* Semantic pointers are initialized elsewhere. */ 207 } 208 209 /* Initialize the instruction descriptor table. */ 210 211 void 212 bpfbf_ebpfle_init_idesc_table (SIM_CPU *cpu) 213 { 214 IDESC *id,*tabend; 215 const struct insn_sem *t,*tend; 216 int tabsize = BPFBF_EBPFLE_INSN__MAX; 217 IDESC *table = bpfbf_ebpfle_insn_data; 218 219 memset (table, 0, tabsize * sizeof (IDESC)); 220 221 /* First set all entries to the `invalid insn'. */ 222 t = & bpfbf_ebpfle_insn_sem_invalid; 223 for (id = table, tabend = table + tabsize; id < tabend; ++id) 224 init_idesc (cpu, id, t); 225 226 /* Now fill in the values for the chosen cpu. */ 227 for (t = bpfbf_ebpfle_insn_sem, tend = t + sizeof (bpfbf_ebpfle_insn_sem) / sizeof (*t); 228 t != tend; ++t) 229 { 230 init_idesc (cpu, & table[t->index], t); 231 } 232 233 /* Link the IDESC table into the cpu. */ 234 CPU_IDESC (cpu) = table; 235 } 236 237 /* Given an instruction, return a pointer to its IDESC entry. */ 238 239 const IDESC * 240 bpfbf_ebpfle_decode (SIM_CPU *current_cpu, IADDR pc, 241 CGEN_INSN_WORD base_insn, 242 ARGBUF *abuf) 243 { 244 /* Result of decoder. */ 245 BPFBF_EBPFLE_INSN_TYPE itype; 246 247 { 248 CGEN_INSN_WORD insn = base_insn; 249 250 { 251 unsigned int val = (((insn >> 0) & (255 << 0))); 252 switch (val) 253 { 254 case 4 : itype = BPFBF_EBPFLE_INSN_ADD32ILE; goto extract_sfmt_addile; 255 case 5 : itype = BPFBF_EBPFLE_INSN_JA; goto extract_sfmt_ja; 256 case 7 : itype = BPFBF_EBPFLE_INSN_ADDILE; goto extract_sfmt_addile; 257 case 12 : itype = BPFBF_EBPFLE_INSN_ADD32RLE; goto extract_sfmt_addrle; 258 case 15 : itype = BPFBF_EBPFLE_INSN_ADDRLE; goto extract_sfmt_addrle; 259 case 20 : itype = BPFBF_EBPFLE_INSN_SUB32ILE; goto extract_sfmt_addile; 260 case 21 : itype = BPFBF_EBPFLE_INSN_JEQILE; goto extract_sfmt_jeqile; 261 case 22 : itype = BPFBF_EBPFLE_INSN_JEQ32ILE; goto extract_sfmt_jeqile; 262 case 23 : itype = BPFBF_EBPFLE_INSN_SUBILE; goto extract_sfmt_addile; 263 case 24 : itype = BPFBF_EBPFLE_INSN_LDDWLE; goto extract_sfmt_lddwle; 264 case 28 : itype = BPFBF_EBPFLE_INSN_SUB32RLE; goto extract_sfmt_addrle; 265 case 29 : itype = BPFBF_EBPFLE_INSN_JEQRLE; goto extract_sfmt_jeqrle; 266 case 30 : itype = BPFBF_EBPFLE_INSN_JEQ32RLE; goto extract_sfmt_jeqrle; 267 case 31 : itype = BPFBF_EBPFLE_INSN_SUBRLE; goto extract_sfmt_addrle; 268 case 32 : itype = BPFBF_EBPFLE_INSN_LDABSW; goto extract_sfmt_ldabsw; 269 case 36 : itype = BPFBF_EBPFLE_INSN_MUL32ILE; goto extract_sfmt_addile; 270 case 37 : itype = BPFBF_EBPFLE_INSN_JGTILE; goto extract_sfmt_jeqile; 271 case 38 : itype = BPFBF_EBPFLE_INSN_JGT32ILE; goto extract_sfmt_jeqile; 272 case 39 : itype = BPFBF_EBPFLE_INSN_MULILE; goto extract_sfmt_addile; 273 case 40 : itype = BPFBF_EBPFLE_INSN_LDABSH; goto extract_sfmt_ldabsh; 274 case 44 : itype = BPFBF_EBPFLE_INSN_MUL32RLE; goto extract_sfmt_addrle; 275 case 45 : itype = BPFBF_EBPFLE_INSN_JGTRLE; goto extract_sfmt_jeqrle; 276 case 46 : itype = BPFBF_EBPFLE_INSN_JGT32RLE; goto extract_sfmt_jeqrle; 277 case 47 : itype = BPFBF_EBPFLE_INSN_MULRLE; goto extract_sfmt_addrle; 278 case 48 : itype = BPFBF_EBPFLE_INSN_LDABSB; goto extract_sfmt_ldabsb; 279 case 52 : itype = BPFBF_EBPFLE_INSN_DIV32ILE; goto extract_sfmt_addile; 280 case 53 : itype = BPFBF_EBPFLE_INSN_JGEILE; goto extract_sfmt_jeqile; 281 case 54 : itype = BPFBF_EBPFLE_INSN_JGE32ILE; goto extract_sfmt_jeqile; 282 case 55 : itype = BPFBF_EBPFLE_INSN_DIVILE; goto extract_sfmt_addile; 283 case 56 : itype = BPFBF_EBPFLE_INSN_LDABSDW; goto extract_sfmt_ldabsdw; 284 case 60 : itype = BPFBF_EBPFLE_INSN_DIV32RLE; goto extract_sfmt_addrle; 285 case 61 : itype = BPFBF_EBPFLE_INSN_JGERLE; goto extract_sfmt_jeqrle; 286 case 62 : itype = BPFBF_EBPFLE_INSN_JGE32RLE; goto extract_sfmt_jeqrle; 287 case 63 : itype = BPFBF_EBPFLE_INSN_DIVRLE; goto extract_sfmt_addrle; 288 case 64 : itype = BPFBF_EBPFLE_INSN_LDINDWLE; goto extract_sfmt_ldindwle; 289 case 68 : itype = BPFBF_EBPFLE_INSN_OR32ILE; goto extract_sfmt_addile; 290 case 69 : itype = BPFBF_EBPFLE_INSN_JSETILE; goto extract_sfmt_jeqile; 291 case 70 : itype = BPFBF_EBPFLE_INSN_JSET32ILE; goto extract_sfmt_jeqile; 292 case 71 : itype = BPFBF_EBPFLE_INSN_ORILE; goto extract_sfmt_addile; 293 case 72 : itype = BPFBF_EBPFLE_INSN_LDINDHLE; goto extract_sfmt_ldindhle; 294 case 76 : itype = BPFBF_EBPFLE_INSN_OR32RLE; goto extract_sfmt_addrle; 295 case 77 : itype = BPFBF_EBPFLE_INSN_JSETRLE; goto extract_sfmt_jeqrle; 296 case 78 : itype = BPFBF_EBPFLE_INSN_JSET32RLE; goto extract_sfmt_jeqrle; 297 case 79 : itype = BPFBF_EBPFLE_INSN_ORRLE; goto extract_sfmt_addrle; 298 case 80 : itype = BPFBF_EBPFLE_INSN_LDINDBLE; goto extract_sfmt_ldindble; 299 case 84 : itype = BPFBF_EBPFLE_INSN_AND32ILE; goto extract_sfmt_addile; 300 case 85 : itype = BPFBF_EBPFLE_INSN_JNEILE; goto extract_sfmt_jeqile; 301 case 86 : itype = BPFBF_EBPFLE_INSN_JNE32ILE; goto extract_sfmt_jeqile; 302 case 87 : itype = BPFBF_EBPFLE_INSN_ANDILE; goto extract_sfmt_addile; 303 case 88 : itype = BPFBF_EBPFLE_INSN_LDINDDWLE; goto extract_sfmt_ldinddwle; 304 case 92 : itype = BPFBF_EBPFLE_INSN_AND32RLE; goto extract_sfmt_addrle; 305 case 93 : itype = BPFBF_EBPFLE_INSN_JNERLE; goto extract_sfmt_jeqrle; 306 case 94 : itype = BPFBF_EBPFLE_INSN_JNE32RLE; goto extract_sfmt_jeqrle; 307 case 95 : itype = BPFBF_EBPFLE_INSN_ANDRLE; goto extract_sfmt_addrle; 308 case 97 : itype = BPFBF_EBPFLE_INSN_LDXWLE; goto extract_sfmt_ldxwle; 309 case 98 : itype = BPFBF_EBPFLE_INSN_STWLE; goto extract_sfmt_stwle; 310 case 99 : itype = BPFBF_EBPFLE_INSN_STXWLE; goto extract_sfmt_stxwle; 311 case 100 : itype = BPFBF_EBPFLE_INSN_LSH32ILE; goto extract_sfmt_addile; 312 case 101 : itype = BPFBF_EBPFLE_INSN_JSGTILE; goto extract_sfmt_jeqile; 313 case 102 : itype = BPFBF_EBPFLE_INSN_JSGT32ILE; goto extract_sfmt_jeqile; 314 case 103 : itype = BPFBF_EBPFLE_INSN_LSHILE; goto extract_sfmt_addile; 315 case 105 : itype = BPFBF_EBPFLE_INSN_LDXHLE; goto extract_sfmt_ldxhle; 316 case 106 : itype = BPFBF_EBPFLE_INSN_STHLE; goto extract_sfmt_sthle; 317 case 107 : itype = BPFBF_EBPFLE_INSN_STXHLE; goto extract_sfmt_stxhle; 318 case 108 : itype = BPFBF_EBPFLE_INSN_LSH32RLE; goto extract_sfmt_addrle; 319 case 109 : itype = BPFBF_EBPFLE_INSN_JSGTRLE; goto extract_sfmt_jeqrle; 320 case 110 : itype = BPFBF_EBPFLE_INSN_JSGT32RLE; goto extract_sfmt_jeqrle; 321 case 111 : itype = BPFBF_EBPFLE_INSN_LSHRLE; goto extract_sfmt_addrle; 322 case 113 : itype = BPFBF_EBPFLE_INSN_LDXBLE; goto extract_sfmt_ldxble; 323 case 114 : itype = BPFBF_EBPFLE_INSN_STBLE; goto extract_sfmt_stble; 324 case 115 : itype = BPFBF_EBPFLE_INSN_STXBLE; goto extract_sfmt_stxble; 325 case 116 : itype = BPFBF_EBPFLE_INSN_RSH32ILE; goto extract_sfmt_addile; 326 case 117 : itype = BPFBF_EBPFLE_INSN_JSGEILE; goto extract_sfmt_jeqile; 327 case 118 : itype = BPFBF_EBPFLE_INSN_JSGE32ILE; goto extract_sfmt_jeqile; 328 case 119 : itype = BPFBF_EBPFLE_INSN_RSHILE; goto extract_sfmt_addile; 329 case 121 : itype = BPFBF_EBPFLE_INSN_LDXDWLE; goto extract_sfmt_ldxdwle; 330 case 122 : itype = BPFBF_EBPFLE_INSN_STDWLE; goto extract_sfmt_stdwle; 331 case 123 : itype = BPFBF_EBPFLE_INSN_STXDWLE; goto extract_sfmt_stxdwle; 332 case 124 : itype = BPFBF_EBPFLE_INSN_RSH32RLE; goto extract_sfmt_addrle; 333 case 125 : itype = BPFBF_EBPFLE_INSN_JSGERLE; goto extract_sfmt_jeqrle; 334 case 126 : itype = BPFBF_EBPFLE_INSN_JSGE32RLE; goto extract_sfmt_jeqrle; 335 case 127 : itype = BPFBF_EBPFLE_INSN_RSHRLE; goto extract_sfmt_addrle; 336 case 132 : itype = BPFBF_EBPFLE_INSN_NEG32LE; goto extract_sfmt_negle; 337 case 133 : itype = BPFBF_EBPFLE_INSN_CALLLE; goto extract_sfmt_callle; 338 case 135 : itype = BPFBF_EBPFLE_INSN_NEGLE; goto extract_sfmt_negle; 339 case 140 : itype = BPFBF_EBPFLE_INSN_BRKPT; goto extract_sfmt_exit; 340 case 148 : itype = BPFBF_EBPFLE_INSN_MOD32ILE; goto extract_sfmt_addile; 341 case 149 : itype = BPFBF_EBPFLE_INSN_EXIT; goto extract_sfmt_exit; 342 case 151 : itype = BPFBF_EBPFLE_INSN_MODILE; goto extract_sfmt_addile; 343 case 156 : itype = BPFBF_EBPFLE_INSN_MOD32RLE; goto extract_sfmt_addrle; 344 case 159 : itype = BPFBF_EBPFLE_INSN_MODRLE; goto extract_sfmt_addrle; 345 case 164 : itype = BPFBF_EBPFLE_INSN_XOR32ILE; goto extract_sfmt_addile; 346 case 165 : itype = BPFBF_EBPFLE_INSN_JLTILE; goto extract_sfmt_jeqile; 347 case 166 : itype = BPFBF_EBPFLE_INSN_JLT32ILE; goto extract_sfmt_jeqile; 348 case 167 : itype = BPFBF_EBPFLE_INSN_XORILE; goto extract_sfmt_addile; 349 case 172 : itype = BPFBF_EBPFLE_INSN_XOR32RLE; goto extract_sfmt_addrle; 350 case 173 : itype = BPFBF_EBPFLE_INSN_JLTRLE; goto extract_sfmt_jeqrle; 351 case 174 : itype = BPFBF_EBPFLE_INSN_JLT32RLE; goto extract_sfmt_jeqrle; 352 case 175 : itype = BPFBF_EBPFLE_INSN_XORRLE; goto extract_sfmt_addrle; 353 case 180 : itype = BPFBF_EBPFLE_INSN_MOV32ILE; goto extract_sfmt_movile; 354 case 181 : itype = BPFBF_EBPFLE_INSN_JLEILE; goto extract_sfmt_jeqile; 355 case 182 : itype = BPFBF_EBPFLE_INSN_JLE32ILE; goto extract_sfmt_jeqile; 356 case 183 : itype = BPFBF_EBPFLE_INSN_MOVILE; goto extract_sfmt_movile; 357 case 188 : itype = BPFBF_EBPFLE_INSN_MOV32RLE; goto extract_sfmt_movrle; 358 case 189 : itype = BPFBF_EBPFLE_INSN_JLERLE; goto extract_sfmt_jeqrle; 359 case 190 : itype = BPFBF_EBPFLE_INSN_JLE32RLE; goto extract_sfmt_jeqrle; 360 case 191 : itype = BPFBF_EBPFLE_INSN_MOVRLE; goto extract_sfmt_movrle; 361 case 195 : itype = BPFBF_EBPFLE_INSN_XADDWLE; goto extract_sfmt_xaddwle; 362 case 196 : itype = BPFBF_EBPFLE_INSN_ARSH32ILE; goto extract_sfmt_addile; 363 case 197 : itype = BPFBF_EBPFLE_INSN_JSLTILE; goto extract_sfmt_jeqile; 364 case 198 : itype = BPFBF_EBPFLE_INSN_JSLT32ILE; goto extract_sfmt_jeqile; 365 case 199 : itype = BPFBF_EBPFLE_INSN_ARSHILE; goto extract_sfmt_addile; 366 case 204 : itype = BPFBF_EBPFLE_INSN_ARSH32RLE; goto extract_sfmt_addrle; 367 case 205 : itype = BPFBF_EBPFLE_INSN_JSLTRLE; goto extract_sfmt_jeqrle; 368 case 206 : itype = BPFBF_EBPFLE_INSN_JSLT32RLE; goto extract_sfmt_jeqrle; 369 case 207 : itype = BPFBF_EBPFLE_INSN_ARSHRLE; goto extract_sfmt_addrle; 370 case 212 : itype = BPFBF_EBPFLE_INSN_ENDLELE; goto extract_sfmt_endlele; 371 case 213 : itype = BPFBF_EBPFLE_INSN_JSLEILE; goto extract_sfmt_jeqile; 372 case 214 : itype = BPFBF_EBPFLE_INSN_JSLE32ILE; goto extract_sfmt_jeqile; 373 case 219 : itype = BPFBF_EBPFLE_INSN_XADDDWLE; goto extract_sfmt_xadddwle; 374 case 220 : itype = BPFBF_EBPFLE_INSN_ENDBELE; goto extract_sfmt_endlele; 375 case 221 : itype = BPFBF_EBPFLE_INSN_JSLERLE; goto extract_sfmt_jeqrle; 376 case 222 : itype = BPFBF_EBPFLE_INSN_JSLE32RLE; goto extract_sfmt_jeqrle; 377 default : itype = BPFBF_EBPFLE_INSN_X_INVALID; goto extract_sfmt_empty; 378 } 379 } 380 } 381 382 /* The instruction has been decoded, now extract the fields. */ 383 384 extract_sfmt_empty: 385 { 386 const IDESC *idesc = &bpfbf_ebpfle_insn_data[itype]; 387 #define FLD(f) abuf->fields.sfmt_empty.f 388 389 390 /* Record the fields for the semantic handler. */ 391 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_empty", (char *) 0)); 392 393 #undef FLD 394 return idesc; 395 } 396 397 extract_sfmt_addile: 398 { 399 const IDESC *idesc = &bpfbf_ebpfle_insn_data[itype]; 400 CGEN_INSN_WORD insn = base_insn; 401 #define FLD(f) abuf->fields.sfmt_stble.f 402 INT f_imm32; 403 UINT f_dstle; 404 405 f_imm32 = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 63, 32) << 0)); 406 f_dstle = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 11, 4) << 0)); 407 408 /* Record the fields for the semantic handler. */ 409 FLD (f_dstle) = f_dstle; 410 FLD (f_imm32) = f_imm32; 411 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_addile", "f_dstle 0x%x", 'x', f_dstle, "f_imm32 0x%x", 'x', f_imm32, (char *) 0)); 412 413 #undef FLD 414 return idesc; 415 } 416 417 extract_sfmt_addrle: 418 { 419 const IDESC *idesc = &bpfbf_ebpfle_insn_data[itype]; 420 CGEN_INSN_WORD insn = base_insn; 421 #define FLD(f) abuf->fields.sfmt_ldxwle.f 422 UINT f_srcle; 423 UINT f_dstle; 424 425 f_srcle = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 15, 4) << 0)); 426 f_dstle = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 11, 4) << 0)); 427 428 /* Record the fields for the semantic handler. */ 429 FLD (f_dstle) = f_dstle; 430 FLD (f_srcle) = f_srcle; 431 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_addrle", "f_dstle 0x%x", 'x', f_dstle, "f_srcle 0x%x", 'x', f_srcle, (char *) 0)); 432 433 #undef FLD 434 return idesc; 435 } 436 437 extract_sfmt_negle: 438 { 439 const IDESC *idesc = &bpfbf_ebpfle_insn_data[itype]; 440 CGEN_INSN_WORD insn = base_insn; 441 #define FLD(f) abuf->fields.sfmt_lddwle.f 442 UINT f_dstle; 443 444 f_dstle = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 11, 4) << 0)); 445 446 /* Record the fields for the semantic handler. */ 447 FLD (f_dstle) = f_dstle; 448 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_negle", "f_dstle 0x%x", 'x', f_dstle, (char *) 0)); 449 450 #undef FLD 451 return idesc; 452 } 453 454 extract_sfmt_movile: 455 { 456 const IDESC *idesc = &bpfbf_ebpfle_insn_data[itype]; 457 CGEN_INSN_WORD insn = base_insn; 458 #define FLD(f) abuf->fields.sfmt_stble.f 459 INT f_imm32; 460 UINT f_dstle; 461 462 f_imm32 = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 63, 32) << 0)); 463 f_dstle = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 11, 4) << 0)); 464 465 /* Record the fields for the semantic handler. */ 466 FLD (f_imm32) = f_imm32; 467 FLD (f_dstle) = f_dstle; 468 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_movile", "f_imm32 0x%x", 'x', f_imm32, "f_dstle 0x%x", 'x', f_dstle, (char *) 0)); 469 470 #undef FLD 471 return idesc; 472 } 473 474 extract_sfmt_movrle: 475 { 476 const IDESC *idesc = &bpfbf_ebpfle_insn_data[itype]; 477 CGEN_INSN_WORD insn = base_insn; 478 #define FLD(f) abuf->fields.sfmt_ldxwle.f 479 UINT f_srcle; 480 UINT f_dstle; 481 482 f_srcle = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 15, 4) << 0)); 483 f_dstle = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 11, 4) << 0)); 484 485 /* Record the fields for the semantic handler. */ 486 FLD (f_srcle) = f_srcle; 487 FLD (f_dstle) = f_dstle; 488 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_movrle", "f_srcle 0x%x", 'x', f_srcle, "f_dstle 0x%x", 'x', f_dstle, (char *) 0)); 489 490 #undef FLD 491 return idesc; 492 } 493 494 extract_sfmt_endlele: 495 { 496 const IDESC *idesc = &bpfbf_ebpfle_insn_data[itype]; 497 CGEN_INSN_WORD insn = base_insn; 498 #define FLD(f) abuf->fields.sfmt_stble.f 499 INT f_imm32; 500 UINT f_dstle; 501 502 f_imm32 = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 63, 32) << 0)); 503 f_dstle = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 11, 4) << 0)); 504 505 /* Record the fields for the semantic handler. */ 506 FLD (f_dstle) = f_dstle; 507 FLD (f_imm32) = f_imm32; 508 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_endlele", "f_dstle 0x%x", 'x', f_dstle, "f_imm32 0x%x", 'x', f_imm32, (char *) 0)); 509 510 #undef FLD 511 return idesc; 512 } 513 514 extract_sfmt_lddwle: 515 { 516 const IDESC *idesc = &bpfbf_ebpfle_insn_data[itype]; 517 CGEN_INSN_WORD insn = base_insn; 518 #define FLD(f) abuf->fields.sfmt_lddwle.f 519 UINT f_imm64_c; 520 UINT f_imm64_b; 521 UINT f_imm64_a; 522 UINT f_dstle; 523 DI f_imm64; 524 /* Contents of trailing part of insn. */ 525 UINT word_1; 526 UINT word_2; 527 528 word_1 = GETIMEMUSI (current_cpu, pc + 8); 529 word_2 = GETIMEMUSI (current_cpu, pc + 12); 530 f_imm64_c = (0|(EXTRACT_LSB0_UINT (word_2, 32, 31, 32) << 0)); 531 f_imm64_b = (0|(EXTRACT_LSB0_UINT (word_1, 32, 31, 32) << 0)); 532 f_imm64_a = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 63, 32) << 0)); 533 f_dstle = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 11, 4) << 0)); 534 { 535 f_imm64 = ((((((UDI) (UINT) (f_imm64_c))) << (32))) | (((UDI) (UINT) (f_imm64_a)))); 536 } 537 538 /* Record the fields for the semantic handler. */ 539 FLD (f_imm64) = f_imm64; 540 FLD (f_dstle) = f_dstle; 541 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_lddwle", "f_imm64 0x%x", 'x', f_imm64, "f_dstle 0x%x", 'x', f_dstle, (char *) 0)); 542 543 #undef FLD 544 return idesc; 545 } 546 547 extract_sfmt_ldabsw: 548 { 549 const IDESC *idesc = &bpfbf_ebpfle_insn_data[itype]; 550 CGEN_INSN_WORD insn = base_insn; 551 #define FLD(f) abuf->fields.sfmt_ldindwle.f 552 INT f_imm32; 553 554 f_imm32 = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 63, 32) << 0)); 555 556 /* Record the fields for the semantic handler. */ 557 FLD (f_imm32) = f_imm32; 558 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_ldabsw", "f_imm32 0x%x", 'x', f_imm32, (char *) 0)); 559 560 #undef FLD 561 return idesc; 562 } 563 564 extract_sfmt_ldabsh: 565 { 566 const IDESC *idesc = &bpfbf_ebpfle_insn_data[itype]; 567 CGEN_INSN_WORD insn = base_insn; 568 #define FLD(f) abuf->fields.sfmt_ldindwle.f 569 INT f_imm32; 570 571 f_imm32 = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 63, 32) << 0)); 572 573 /* Record the fields for the semantic handler. */ 574 FLD (f_imm32) = f_imm32; 575 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_ldabsh", "f_imm32 0x%x", 'x', f_imm32, (char *) 0)); 576 577 #undef FLD 578 return idesc; 579 } 580 581 extract_sfmt_ldabsb: 582 { 583 const IDESC *idesc = &bpfbf_ebpfle_insn_data[itype]; 584 CGEN_INSN_WORD insn = base_insn; 585 #define FLD(f) abuf->fields.sfmt_ldindwle.f 586 INT f_imm32; 587 588 f_imm32 = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 63, 32) << 0)); 589 590 /* Record the fields for the semantic handler. */ 591 FLD (f_imm32) = f_imm32; 592 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_ldabsb", "f_imm32 0x%x", 'x', f_imm32, (char *) 0)); 593 594 #undef FLD 595 return idesc; 596 } 597 598 extract_sfmt_ldabsdw: 599 { 600 const IDESC *idesc = &bpfbf_ebpfle_insn_data[itype]; 601 CGEN_INSN_WORD insn = base_insn; 602 #define FLD(f) abuf->fields.sfmt_ldindwle.f 603 INT f_imm32; 604 605 f_imm32 = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 63, 32) << 0)); 606 607 /* Record the fields for the semantic handler. */ 608 FLD (f_imm32) = f_imm32; 609 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_ldabsdw", "f_imm32 0x%x", 'x', f_imm32, (char *) 0)); 610 611 #undef FLD 612 return idesc; 613 } 614 615 extract_sfmt_ldindwle: 616 { 617 const IDESC *idesc = &bpfbf_ebpfle_insn_data[itype]; 618 CGEN_INSN_WORD insn = base_insn; 619 #define FLD(f) abuf->fields.sfmt_ldindwle.f 620 INT f_imm32; 621 UINT f_srcle; 622 623 f_imm32 = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 63, 32) << 0)); 624 f_srcle = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 15, 4) << 0)); 625 626 /* Record the fields for the semantic handler. */ 627 FLD (f_imm32) = f_imm32; 628 FLD (f_srcle) = f_srcle; 629 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_ldindwle", "f_imm32 0x%x", 'x', f_imm32, "f_srcle 0x%x", 'x', f_srcle, (char *) 0)); 630 631 #undef FLD 632 return idesc; 633 } 634 635 extract_sfmt_ldindhle: 636 { 637 const IDESC *idesc = &bpfbf_ebpfle_insn_data[itype]; 638 CGEN_INSN_WORD insn = base_insn; 639 #define FLD(f) abuf->fields.sfmt_ldindwle.f 640 INT f_imm32; 641 UINT f_srcle; 642 643 f_imm32 = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 63, 32) << 0)); 644 f_srcle = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 15, 4) << 0)); 645 646 /* Record the fields for the semantic handler. */ 647 FLD (f_imm32) = f_imm32; 648 FLD (f_srcle) = f_srcle; 649 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_ldindhle", "f_imm32 0x%x", 'x', f_imm32, "f_srcle 0x%x", 'x', f_srcle, (char *) 0)); 650 651 #undef FLD 652 return idesc; 653 } 654 655 extract_sfmt_ldindble: 656 { 657 const IDESC *idesc = &bpfbf_ebpfle_insn_data[itype]; 658 CGEN_INSN_WORD insn = base_insn; 659 #define FLD(f) abuf->fields.sfmt_ldindwle.f 660 INT f_imm32; 661 UINT f_srcle; 662 663 f_imm32 = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 63, 32) << 0)); 664 f_srcle = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 15, 4) << 0)); 665 666 /* Record the fields for the semantic handler. */ 667 FLD (f_imm32) = f_imm32; 668 FLD (f_srcle) = f_srcle; 669 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_ldindble", "f_imm32 0x%x", 'x', f_imm32, "f_srcle 0x%x", 'x', f_srcle, (char *) 0)); 670 671 #undef FLD 672 return idesc; 673 } 674 675 extract_sfmt_ldinddwle: 676 { 677 const IDESC *idesc = &bpfbf_ebpfle_insn_data[itype]; 678 CGEN_INSN_WORD insn = base_insn; 679 #define FLD(f) abuf->fields.sfmt_ldindwle.f 680 INT f_imm32; 681 UINT f_srcle; 682 683 f_imm32 = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 63, 32) << 0)); 684 f_srcle = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 15, 4) << 0)); 685 686 /* Record the fields for the semantic handler. */ 687 FLD (f_imm32) = f_imm32; 688 FLD (f_srcle) = f_srcle; 689 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_ldinddwle", "f_imm32 0x%x", 'x', f_imm32, "f_srcle 0x%x", 'x', f_srcle, (char *) 0)); 690 691 #undef FLD 692 return idesc; 693 } 694 695 extract_sfmt_ldxwle: 696 { 697 const IDESC *idesc = &bpfbf_ebpfle_insn_data[itype]; 698 CGEN_INSN_WORD insn = base_insn; 699 #define FLD(f) abuf->fields.sfmt_ldxwle.f 700 HI f_offset16; 701 UINT f_srcle; 702 UINT f_dstle; 703 704 f_offset16 = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 31, 16) << 0)); 705 f_srcle = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 15, 4) << 0)); 706 f_dstle = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 11, 4) << 0)); 707 708 /* Record the fields for the semantic handler. */ 709 FLD (f_offset16) = f_offset16; 710 FLD (f_srcle) = f_srcle; 711 FLD (f_dstle) = f_dstle; 712 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_ldxwle", "f_offset16 0x%x", 'x', f_offset16, "f_srcle 0x%x", 'x', f_srcle, "f_dstle 0x%x", 'x', f_dstle, (char *) 0)); 713 714 #undef FLD 715 return idesc; 716 } 717 718 extract_sfmt_ldxhle: 719 { 720 const IDESC *idesc = &bpfbf_ebpfle_insn_data[itype]; 721 CGEN_INSN_WORD insn = base_insn; 722 #define FLD(f) abuf->fields.sfmt_ldxwle.f 723 HI f_offset16; 724 UINT f_srcle; 725 UINT f_dstle; 726 727 f_offset16 = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 31, 16) << 0)); 728 f_srcle = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 15, 4) << 0)); 729 f_dstle = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 11, 4) << 0)); 730 731 /* Record the fields for the semantic handler. */ 732 FLD (f_offset16) = f_offset16; 733 FLD (f_srcle) = f_srcle; 734 FLD (f_dstle) = f_dstle; 735 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_ldxhle", "f_offset16 0x%x", 'x', f_offset16, "f_srcle 0x%x", 'x', f_srcle, "f_dstle 0x%x", 'x', f_dstle, (char *) 0)); 736 737 #undef FLD 738 return idesc; 739 } 740 741 extract_sfmt_ldxble: 742 { 743 const IDESC *idesc = &bpfbf_ebpfle_insn_data[itype]; 744 CGEN_INSN_WORD insn = base_insn; 745 #define FLD(f) abuf->fields.sfmt_ldxwle.f 746 HI f_offset16; 747 UINT f_srcle; 748 UINT f_dstle; 749 750 f_offset16 = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 31, 16) << 0)); 751 f_srcle = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 15, 4) << 0)); 752 f_dstle = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 11, 4) << 0)); 753 754 /* Record the fields for the semantic handler. */ 755 FLD (f_offset16) = f_offset16; 756 FLD (f_srcle) = f_srcle; 757 FLD (f_dstle) = f_dstle; 758 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_ldxble", "f_offset16 0x%x", 'x', f_offset16, "f_srcle 0x%x", 'x', f_srcle, "f_dstle 0x%x", 'x', f_dstle, (char *) 0)); 759 760 #undef FLD 761 return idesc; 762 } 763 764 extract_sfmt_ldxdwle: 765 { 766 const IDESC *idesc = &bpfbf_ebpfle_insn_data[itype]; 767 CGEN_INSN_WORD insn = base_insn; 768 #define FLD(f) abuf->fields.sfmt_ldxwle.f 769 HI f_offset16; 770 UINT f_srcle; 771 UINT f_dstle; 772 773 f_offset16 = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 31, 16) << 0)); 774 f_srcle = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 15, 4) << 0)); 775 f_dstle = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 11, 4) << 0)); 776 777 /* Record the fields for the semantic handler. */ 778 FLD (f_offset16) = f_offset16; 779 FLD (f_srcle) = f_srcle; 780 FLD (f_dstle) = f_dstle; 781 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_ldxdwle", "f_offset16 0x%x", 'x', f_offset16, "f_srcle 0x%x", 'x', f_srcle, "f_dstle 0x%x", 'x', f_dstle, (char *) 0)); 782 783 #undef FLD 784 return idesc; 785 } 786 787 extract_sfmt_stxwle: 788 { 789 const IDESC *idesc = &bpfbf_ebpfle_insn_data[itype]; 790 CGEN_INSN_WORD insn = base_insn; 791 #define FLD(f) abuf->fields.sfmt_ldxwle.f 792 HI f_offset16; 793 UINT f_srcle; 794 UINT f_dstle; 795 796 f_offset16 = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 31, 16) << 0)); 797 f_srcle = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 15, 4) << 0)); 798 f_dstle = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 11, 4) << 0)); 799 800 /* Record the fields for the semantic handler. */ 801 FLD (f_dstle) = f_dstle; 802 FLD (f_offset16) = f_offset16; 803 FLD (f_srcle) = f_srcle; 804 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_stxwle", "f_dstle 0x%x", 'x', f_dstle, "f_offset16 0x%x", 'x', f_offset16, "f_srcle 0x%x", 'x', f_srcle, (char *) 0)); 805 806 #undef FLD 807 return idesc; 808 } 809 810 extract_sfmt_stxhle: 811 { 812 const IDESC *idesc = &bpfbf_ebpfle_insn_data[itype]; 813 CGEN_INSN_WORD insn = base_insn; 814 #define FLD(f) abuf->fields.sfmt_ldxwle.f 815 HI f_offset16; 816 UINT f_srcle; 817 UINT f_dstle; 818 819 f_offset16 = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 31, 16) << 0)); 820 f_srcle = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 15, 4) << 0)); 821 f_dstle = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 11, 4) << 0)); 822 823 /* Record the fields for the semantic handler. */ 824 FLD (f_dstle) = f_dstle; 825 FLD (f_offset16) = f_offset16; 826 FLD (f_srcle) = f_srcle; 827 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_stxhle", "f_dstle 0x%x", 'x', f_dstle, "f_offset16 0x%x", 'x', f_offset16, "f_srcle 0x%x", 'x', f_srcle, (char *) 0)); 828 829 #undef FLD 830 return idesc; 831 } 832 833 extract_sfmt_stxble: 834 { 835 const IDESC *idesc = &bpfbf_ebpfle_insn_data[itype]; 836 CGEN_INSN_WORD insn = base_insn; 837 #define FLD(f) abuf->fields.sfmt_ldxwle.f 838 HI f_offset16; 839 UINT f_srcle; 840 UINT f_dstle; 841 842 f_offset16 = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 31, 16) << 0)); 843 f_srcle = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 15, 4) << 0)); 844 f_dstle = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 11, 4) << 0)); 845 846 /* Record the fields for the semantic handler. */ 847 FLD (f_dstle) = f_dstle; 848 FLD (f_offset16) = f_offset16; 849 FLD (f_srcle) = f_srcle; 850 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_stxble", "f_dstle 0x%x", 'x', f_dstle, "f_offset16 0x%x", 'x', f_offset16, "f_srcle 0x%x", 'x', f_srcle, (char *) 0)); 851 852 #undef FLD 853 return idesc; 854 } 855 856 extract_sfmt_stxdwle: 857 { 858 const IDESC *idesc = &bpfbf_ebpfle_insn_data[itype]; 859 CGEN_INSN_WORD insn = base_insn; 860 #define FLD(f) abuf->fields.sfmt_ldxwle.f 861 HI f_offset16; 862 UINT f_srcle; 863 UINT f_dstle; 864 865 f_offset16 = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 31, 16) << 0)); 866 f_srcle = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 15, 4) << 0)); 867 f_dstle = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 11, 4) << 0)); 868 869 /* Record the fields for the semantic handler. */ 870 FLD (f_dstle) = f_dstle; 871 FLD (f_offset16) = f_offset16; 872 FLD (f_srcle) = f_srcle; 873 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_stxdwle", "f_dstle 0x%x", 'x', f_dstle, "f_offset16 0x%x", 'x', f_offset16, "f_srcle 0x%x", 'x', f_srcle, (char *) 0)); 874 875 #undef FLD 876 return idesc; 877 } 878 879 extract_sfmt_stble: 880 { 881 const IDESC *idesc = &bpfbf_ebpfle_insn_data[itype]; 882 CGEN_INSN_WORD insn = base_insn; 883 #define FLD(f) abuf->fields.sfmt_stble.f 884 INT f_imm32; 885 HI f_offset16; 886 UINT f_dstle; 887 888 f_imm32 = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 63, 32) << 0)); 889 f_offset16 = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 31, 16) << 0)); 890 f_dstle = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 11, 4) << 0)); 891 892 /* Record the fields for the semantic handler. */ 893 FLD (f_dstle) = f_dstle; 894 FLD (f_imm32) = f_imm32; 895 FLD (f_offset16) = f_offset16; 896 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_stble", "f_dstle 0x%x", 'x', f_dstle, "f_imm32 0x%x", 'x', f_imm32, "f_offset16 0x%x", 'x', f_offset16, (char *) 0)); 897 898 #undef FLD 899 return idesc; 900 } 901 902 extract_sfmt_sthle: 903 { 904 const IDESC *idesc = &bpfbf_ebpfle_insn_data[itype]; 905 CGEN_INSN_WORD insn = base_insn; 906 #define FLD(f) abuf->fields.sfmt_stble.f 907 INT f_imm32; 908 HI f_offset16; 909 UINT f_dstle; 910 911 f_imm32 = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 63, 32) << 0)); 912 f_offset16 = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 31, 16) << 0)); 913 f_dstle = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 11, 4) << 0)); 914 915 /* Record the fields for the semantic handler. */ 916 FLD (f_dstle) = f_dstle; 917 FLD (f_imm32) = f_imm32; 918 FLD (f_offset16) = f_offset16; 919 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_sthle", "f_dstle 0x%x", 'x', f_dstle, "f_imm32 0x%x", 'x', f_imm32, "f_offset16 0x%x", 'x', f_offset16, (char *) 0)); 920 921 #undef FLD 922 return idesc; 923 } 924 925 extract_sfmt_stwle: 926 { 927 const IDESC *idesc = &bpfbf_ebpfle_insn_data[itype]; 928 CGEN_INSN_WORD insn = base_insn; 929 #define FLD(f) abuf->fields.sfmt_stble.f 930 INT f_imm32; 931 HI f_offset16; 932 UINT f_dstle; 933 934 f_imm32 = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 63, 32) << 0)); 935 f_offset16 = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 31, 16) << 0)); 936 f_dstle = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 11, 4) << 0)); 937 938 /* Record the fields for the semantic handler. */ 939 FLD (f_dstle) = f_dstle; 940 FLD (f_imm32) = f_imm32; 941 FLD (f_offset16) = f_offset16; 942 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_stwle", "f_dstle 0x%x", 'x', f_dstle, "f_imm32 0x%x", 'x', f_imm32, "f_offset16 0x%x", 'x', f_offset16, (char *) 0)); 943 944 #undef FLD 945 return idesc; 946 } 947 948 extract_sfmt_stdwle: 949 { 950 const IDESC *idesc = &bpfbf_ebpfle_insn_data[itype]; 951 CGEN_INSN_WORD insn = base_insn; 952 #define FLD(f) abuf->fields.sfmt_stble.f 953 INT f_imm32; 954 HI f_offset16; 955 UINT f_dstle; 956 957 f_imm32 = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 63, 32) << 0)); 958 f_offset16 = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 31, 16) << 0)); 959 f_dstle = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 11, 4) << 0)); 960 961 /* Record the fields for the semantic handler. */ 962 FLD (f_dstle) = f_dstle; 963 FLD (f_imm32) = f_imm32; 964 FLD (f_offset16) = f_offset16; 965 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_stdwle", "f_dstle 0x%x", 'x', f_dstle, "f_imm32 0x%x", 'x', f_imm32, "f_offset16 0x%x", 'x', f_offset16, (char *) 0)); 966 967 #undef FLD 968 return idesc; 969 } 970 971 extract_sfmt_jeqile: 972 { 973 const IDESC *idesc = &bpfbf_ebpfle_insn_data[itype]; 974 CGEN_INSN_WORD insn = base_insn; 975 #define FLD(f) abuf->fields.sfmt_stble.f 976 INT f_imm32; 977 HI f_offset16; 978 UINT f_dstle; 979 980 f_imm32 = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 63, 32) << 0)); 981 f_offset16 = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 31, 16) << 0)); 982 f_dstle = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 11, 4) << 0)); 983 984 /* Record the fields for the semantic handler. */ 985 FLD (f_offset16) = f_offset16; 986 FLD (f_dstle) = f_dstle; 987 FLD (f_imm32) = f_imm32; 988 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_jeqile", "f_offset16 0x%x", 'x', f_offset16, "f_dstle 0x%x", 'x', f_dstle, "f_imm32 0x%x", 'x', f_imm32, (char *) 0)); 989 990 #if WITH_PROFILE_MODEL_P 991 /* Record the fields for profiling. */ 992 if (PROFILE_MODEL_P (current_cpu)) 993 { 994 } 995 #endif 996 #undef FLD 997 return idesc; 998 } 999 1000 extract_sfmt_jeqrle: 1001 { 1002 const IDESC *idesc = &bpfbf_ebpfle_insn_data[itype]; 1003 CGEN_INSN_WORD insn = base_insn; 1004 #define FLD(f) abuf->fields.sfmt_ldxwle.f 1005 HI f_offset16; 1006 UINT f_srcle; 1007 UINT f_dstle; 1008 1009 f_offset16 = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 31, 16) << 0)); 1010 f_srcle = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 15, 4) << 0)); 1011 f_dstle = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 11, 4) << 0)); 1012 1013 /* Record the fields for the semantic handler. */ 1014 FLD (f_offset16) = f_offset16; 1015 FLD (f_dstle) = f_dstle; 1016 FLD (f_srcle) = f_srcle; 1017 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_jeqrle", "f_offset16 0x%x", 'x', f_offset16, "f_dstle 0x%x", 'x', f_dstle, "f_srcle 0x%x", 'x', f_srcle, (char *) 0)); 1018 1019 #if WITH_PROFILE_MODEL_P 1020 /* Record the fields for profiling. */ 1021 if (PROFILE_MODEL_P (current_cpu)) 1022 { 1023 } 1024 #endif 1025 #undef FLD 1026 return idesc; 1027 } 1028 1029 extract_sfmt_callle: 1030 { 1031 const IDESC *idesc = &bpfbf_ebpfle_insn_data[itype]; 1032 CGEN_INSN_WORD insn = base_insn; 1033 #define FLD(f) abuf->fields.sfmt_ldindwle.f 1034 INT f_imm32; 1035 UINT f_srcle; 1036 1037 f_imm32 = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 63, 32) << 0)); 1038 f_srcle = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 15, 4) << 0)); 1039 1040 /* Record the fields for the semantic handler. */ 1041 FLD (f_imm32) = f_imm32; 1042 FLD (f_srcle) = f_srcle; 1043 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_callle", "f_imm32 0x%x", 'x', f_imm32, "f_srcle 0x%x", 'x', f_srcle, (char *) 0)); 1044 1045 #undef FLD 1046 return idesc; 1047 } 1048 1049 extract_sfmt_ja: 1050 { 1051 const IDESC *idesc = &bpfbf_ebpfle_insn_data[itype]; 1052 CGEN_INSN_WORD insn = base_insn; 1053 #define FLD(f) abuf->fields.sfmt_stble.f 1054 HI f_offset16; 1055 1056 f_offset16 = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 31, 16) << 0)); 1057 1058 /* Record the fields for the semantic handler. */ 1059 FLD (f_offset16) = f_offset16; 1060 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_ja", "f_offset16 0x%x", 'x', f_offset16, (char *) 0)); 1061 1062 #if WITH_PROFILE_MODEL_P 1063 /* Record the fields for profiling. */ 1064 if (PROFILE_MODEL_P (current_cpu)) 1065 { 1066 } 1067 #endif 1068 #undef FLD 1069 return idesc; 1070 } 1071 1072 extract_sfmt_exit: 1073 { 1074 const IDESC *idesc = &bpfbf_ebpfle_insn_data[itype]; 1075 #define FLD(f) abuf->fields.sfmt_empty.f 1076 1077 1078 /* Record the fields for the semantic handler. */ 1079 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_exit", (char *) 0)); 1080 1081 #undef FLD 1082 return idesc; 1083 } 1084 1085 extract_sfmt_xadddwle: 1086 { 1087 const IDESC *idesc = &bpfbf_ebpfle_insn_data[itype]; 1088 CGEN_INSN_WORD insn = base_insn; 1089 #define FLD(f) abuf->fields.sfmt_ldxwle.f 1090 HI f_offset16; 1091 UINT f_srcle; 1092 UINT f_dstle; 1093 1094 f_offset16 = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 31, 16) << 0)); 1095 f_srcle = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 15, 4) << 0)); 1096 f_dstle = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 11, 4) << 0)); 1097 1098 /* Record the fields for the semantic handler. */ 1099 FLD (f_dstle) = f_dstle; 1100 FLD (f_offset16) = f_offset16; 1101 FLD (f_srcle) = f_srcle; 1102 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_xadddwle", "f_dstle 0x%x", 'x', f_dstle, "f_offset16 0x%x", 'x', f_offset16, "f_srcle 0x%x", 'x', f_srcle, (char *) 0)); 1103 1104 #undef FLD 1105 return idesc; 1106 } 1107 1108 extract_sfmt_xaddwle: 1109 { 1110 const IDESC *idesc = &bpfbf_ebpfle_insn_data[itype]; 1111 CGEN_INSN_WORD insn = base_insn; 1112 #define FLD(f) abuf->fields.sfmt_ldxwle.f 1113 HI f_offset16; 1114 UINT f_srcle; 1115 UINT f_dstle; 1116 1117 f_offset16 = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 31, 16) << 0)); 1118 f_srcle = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 15, 4) << 0)); 1119 f_dstle = (0|(EXTRACT_LSB0_LGUINT (insn, 64, 11, 4) << 0)); 1120 1121 /* Record the fields for the semantic handler. */ 1122 FLD (f_dstle) = f_dstle; 1123 FLD (f_offset16) = f_offset16; 1124 FLD (f_srcle) = f_srcle; 1125 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_xaddwle", "f_dstle 0x%x", 'x', f_dstle, "f_offset16 0x%x", 'x', f_offset16, "f_srcle 0x%x", 'x', f_srcle, (char *) 0)); 1126 1127 #undef FLD 1128 return idesc; 1129 } 1130 1131 } 1132