sim/bpf/decode-le.c

   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 }