Finish separation of testing from sel_ldr validation. Also, automate

src/trusted/validator_arm/gen/arm32_decode_named.h

Index: src/trusted/validator_arm/gen/arm32_decode_named.h
===================================================================
--- src/trusted/validator_arm/gen/arm32_decode_named.h	(revision 8201)
+++ src/trusted/validator_arm/gen/arm32_decode_named.h	(working copy)
@@ -8,262 +8,473 @@
  * DO NOT EDIT: GENERATED CODE
  */
 
+#ifndef NACL_TRUSTED_BUT_NOT_TCB
+#error("This file is not meant for use in the TCB")
+#endif
+
 #ifndef NATIVE_CLIENT_SRC_TRUSTED_VALIDATOR_ARM_GEN_ARM32_DECODE_NAMED_H_
 #define NATIVE_CLIENT_SRC_TRUSTED_VALIDATOR_ARM_GEN_ARM32_DECODE_NAMED_H_
 
 #include "native_client/src/trusted/validator_arm/decode.h"
+#include "native_client/src/trusted/validator_arm/named_class_decoder.h"
 
+/*
+ * Define rule decoder classes
+ */
 namespace nacl_arm_dec {
 
-struct NamedCoprocessorOp : public CoprocessorOp {
+class Add_Rule_7_A1_P26 : public Binary4RegisterShiftedOp {
+ public:
+  virtual ~Add_Rule_7_A1_P26() {}
+};
+
+}  // namespace nacl_arm_dec
+
+namespace nacl_arm_test {
+
+/*
+ * Define name class decoders for each class decoder
+ */
+
+class NamedCoprocessorOp : public NamedClassDecoder {

[robertm, 2012/04/11 01:28:43]

can you add a comment about the purpose of these classes.
They do not appear to do much.

[Karl, 2012/04/16 23:18:10]

Added comment in dgen_test_output.py that generates these.

+ public:
+  NamedCoprocessorOp();
   virtual ~NamedCoprocessorOp() {}
-  virtual const char* name() const;
+ private:
+  nacl_arm_dec::CoprocessorOp named_decoder_;
 };
 
-struct NamedImmediateBic : public ImmediateBic {
+class NamedMoveToStatusRegister : public NamedClassDecoder {
+ public:
+  NamedMoveToStatusRegister();
+  virtual ~NamedMoveToStatusRegister() {}
+ private:
+  nacl_arm_dec::MoveToStatusRegister named_decoder_;
+};
+
+class NamedImmediateBic : public NamedClassDecoder {
+ public:
+  NamedImmediateBic();
   virtual ~NamedImmediateBic() {}
-  virtual const char* name() const;
+ private:
+  nacl_arm_dec::ImmediateBic named_decoder_;
 };
 
-struct NamedLoadMultiple : public LoadMultiple {
+class NamedLoadMultiple : public NamedClassDecoder {
+ public:
+  NamedLoadMultiple();
   virtual ~NamedLoadMultiple() {}
-  virtual const char* name() const;
+ private:
+  nacl_arm_dec::LoadMultiple named_decoder_;
 };
 
-struct NamedLoadCoprocessor : public LoadCoprocessor {
+class NamedLoadCoprocessor : public NamedClassDecoder {
+ public:
+  NamedLoadCoprocessor();
   virtual ~NamedLoadCoprocessor() {}
-  virtual const char* name() const;
+ private:
+  nacl_arm_dec::LoadCoprocessor named_decoder_;
 };
 
-struct NamedLoadDoubleExclusive : public LoadDoubleExclusive {
-  virtual ~NamedLoadDoubleExclusive() {}
-  virtual const char* name() const;
+class NamedLongMultiply : public NamedClassDecoder {
+ public:
+  NamedLongMultiply();
+  virtual ~NamedLongMultiply() {}
+ private:
+  nacl_arm_dec::LongMultiply named_decoder_;
 };
 
-struct NamedBranch : public Branch {
+class NamedBranch : public NamedClassDecoder {
+ public:
+  NamedBranch();
   virtual ~NamedBranch() {}
-  virtual const char* name() const;
+ private:
+  nacl_arm_dec::Branch named_decoder_;
 };
 
-struct NamedTest : public Test {
+class NamedTest : public NamedClassDecoder {
+ public:
+  NamedTest();
   virtual ~NamedTest() {}
-  virtual const char* name() const;
+ private:
+  nacl_arm_dec::Test named_decoder_;
 };
 
-struct NamedStoreRegister : public StoreRegister {
+class NamedStoreRegister : public NamedClassDecoder {
+ public:
+  NamedStoreRegister();
   virtual ~NamedStoreRegister() {}
-  virtual const char* name() const;
+ private:
+  nacl_arm_dec::StoreRegister named_decoder_;
 };
 
-struct NamedMoveDoubleFromCoprocessor : public MoveDoubleFromCoprocessor {
-  virtual ~NamedMoveDoubleFromCoprocessor() {}
-  virtual const char* name() const;
+class NamedLoadRegister : public NamedClassDecoder {
+ public:
+  NamedLoadRegister();
+  virtual ~NamedLoadRegister() {}
+ private:
+  nacl_arm_dec::LoadRegister named_decoder_;
 };
 
-struct NamedTestImmediate : public TestImmediate {
+class NamedTestImmediate : public NamedClassDecoder {
+ public:
+  NamedTestImmediate();
   virtual ~NamedTestImmediate() {}
-  virtual const char* name() const;
+ private:
+  nacl_arm_dec::TestImmediate named_decoder_;
 };
 
-struct NamedBxBlx : public BxBlx {
-  virtual ~NamedBxBlx() {}
-  virtual const char* name() const;
+class NamedVectorLoad : public NamedClassDecoder {
+ public:
+  NamedVectorLoad();
+  virtual ~NamedVectorLoad() {}
+ private:
+  nacl_arm_dec::VectorLoad named_decoder_;
 };
 
-struct NamedEffectiveNoOp : public EffectiveNoOp {
+class NamedEffectiveNoOp : public NamedClassDecoder {
+ public:
+  NamedEffectiveNoOp();
   virtual ~NamedEffectiveNoOp() {}
-  virtual const char* name() const;
+ private:
+  nacl_arm_dec::EffectiveNoOp named_decoder_;
 };
 
-struct NamedLongMultiply : public LongMultiply {
-  virtual ~NamedLongMultiply() {}
-  virtual const char* name() const;
+class NamedLoadDoubleExclusive : public NamedClassDecoder {
+ public:
+  NamedLoadDoubleExclusive();
+  virtual ~NamedLoadDoubleExclusive() {}
+ private:
+  nacl_arm_dec::LoadDoubleExclusive named_decoder_;
 };
 
-struct NamedBinary4RegisterShiftedOp : public Binary4RegisterShiftedOp {
+class NamedBinary4RegisterShiftedOp : public NamedClassDecoder {
+ public:
+  NamedBinary4RegisterShiftedOp();
   virtual ~NamedBinary4RegisterShiftedOp() {}
-  virtual const char* name() const;
+ private:
+  nacl_arm_dec::Binary4RegisterShiftedOp named_decoder_;
 };
 
-struct NamedBreakpoint : public Breakpoint {
+class NamedBreakpoint : public NamedClassDecoder {
+ public:
+  NamedBreakpoint();
   virtual ~NamedBreakpoint() {}
-  virtual const char* name() const;
+ private:
+  nacl_arm_dec::Breakpoint named_decoder_;
 };
 
-struct NamedMultiply : public Multiply {
+class NamedMultiply : public NamedClassDecoder {
+ public:
+  NamedMultiply();
   virtual ~NamedMultiply() {}
-  virtual const char* name() const;
+ private:
+  nacl_arm_dec::Multiply named_decoder_;
 };
 
-struct NamedPackSatRev : public PackSatRev {
+class NamedAdd_Rule_7_A1_P26 : public NamedClassDecoder {
+ public:
+  NamedAdd_Rule_7_A1_P26();
+  virtual ~NamedAdd_Rule_7_A1_P26() {}
+ private:
+  nacl_arm_dec::Add_Rule_7_A1_P26 named_decoder_;
+};
+
+class NamedPackSatRev : public NamedClassDecoder {
+ public:
+  NamedPackSatRev();
   virtual ~NamedPackSatRev() {}
-  virtual const char* name() const;
+ private:
+  nacl_arm_dec::PackSatRev named_decoder_;
 };
 
-struct NamedLoadExclusive : public LoadExclusive {
+class NamedLoadExclusive : public NamedClassDecoder {
+ public:
+  NamedLoadExclusive();
   virtual ~NamedLoadExclusive() {}
-  virtual const char* name() const;
+ private:
+  nacl_arm_dec::LoadExclusive named_decoder_;
 };
 
-struct NamedVectorStore : public VectorStore {
+class NamedVectorStore : public NamedClassDecoder {
+ public:
+  NamedVectorStore();
   virtual ~NamedVectorStore() {}
-  virtual const char* name() const;
+ private:
+  nacl_arm_dec::VectorStore named_decoder_;
 };
 
-struct NamedUnary3RegisterShiftedOp : public Unary3RegisterShiftedOp {
+class NamedUnary3RegisterShiftedOp : public NamedClassDecoder {
+ public:
+  NamedUnary3RegisterShiftedOp();
   virtual ~NamedUnary3RegisterShiftedOp() {}
-  virtual const char* name() const;
+ private:
+  nacl_arm_dec::Unary3RegisterShiftedOp named_decoder_;
 };
 
-struct NamedUndefined : public Undefined {
+class NamedUndefined : public NamedClassDecoder {
+ public:
+  NamedUndefined();
   virtual ~NamedUndefined() {}
-  virtual const char* name() const;
+ private:
+  nacl_arm_dec::Undefined named_decoder_;
 };
 
-struct NamedDataProc : public DataProc {
+class NamedDataProc : public NamedClassDecoder {
+ public:
+  NamedDataProc();
   virtual ~NamedDataProc() {}
-  virtual const char* name() const;
+ private:
+  nacl_arm_dec::DataProc named_decoder_;
 };
 
-struct NamedDeprecated : public Deprecated {
+class NamedDeprecated : public NamedClassDecoder {
+ public:
+  NamedDeprecated();
   virtual ~NamedDeprecated() {}
-  virtual const char* name() const;
+ private:
+  nacl_arm_dec::Deprecated named_decoder_;
 };
 
-struct NamedLoadImmediate : public LoadImmediate {
+class NamedLoadImmediate : public NamedClassDecoder {
+ public:
+  NamedLoadImmediate();
   virtual ~NamedLoadImmediate() {}
-  virtual const char* name() const;
+ private:
+  nacl_arm_dec::LoadImmediate named_decoder_;
 };
 
-struct NamedStoreCoprocessor : public StoreCoprocessor {
+class NamedStoreCoprocessor : public NamedClassDecoder {
+ public:
+  NamedStoreCoprocessor();
   virtual ~NamedStoreCoprocessor() {}
-  virtual const char* name() const;
+ private:
+  nacl_arm_dec::StoreCoprocessor named_decoder_;
 };
 
-struct NamedRoadblock : public Roadblock {
+class NamedRoadblock : public NamedClassDecoder {
+ public:
+  NamedRoadblock();
   virtual ~NamedRoadblock() {}
-  virtual const char* name() const;
+ private:
+  nacl_arm_dec::Roadblock named_decoder_;
 };
 
-struct NamedLoadDoubleR : public LoadDoubleR {
-  virtual ~NamedLoadDoubleR() {}
-  virtual const char* name() const;
+class NamedMoveFromCoprocessor : public NamedClassDecoder {
+ public:
+  NamedMoveFromCoprocessor();
+  virtual ~NamedMoveFromCoprocessor() {}
+ private:
+  nacl_arm_dec::MoveFromCoprocessor named_decoder_;
 };
 
-struct NamedStoreExclusive : public StoreExclusive {
+class NamedStoreExclusive : public NamedClassDecoder {
+ public:
+  NamedStoreExclusive();
   virtual ~NamedStoreExclusive() {}
-  virtual const char* name() const;
+ private:
+  nacl_arm_dec::StoreExclusive named_decoder_;
 };
 
-struct NamedStoreImmediate : public StoreImmediate {
+class NamedStoreImmediate : public NamedClassDecoder {
+ public:
+  NamedStoreImmediate();
   virtual ~NamedStoreImmediate() {}
-  virtual const char* name() const;
+ private:
+  nacl_arm_dec::StoreImmediate named_decoder_;
 };
 
-struct NamedMoveFromCoprocessor : public MoveFromCoprocessor {
-  virtual ~NamedMoveFromCoprocessor() {}
-  virtual const char* name() const;
+class NamedMoveDoubleFromCoprocessor : public NamedClassDecoder {
+ public:
+  NamedMoveDoubleFromCoprocessor();
+  virtual ~NamedMoveDoubleFromCoprocessor() {}
+ private:
+  nacl_arm_dec::MoveDoubleFromCoprocessor named_decoder_;
 };
 
-struct NamedLoadRegister : public LoadRegister {
-  virtual ~NamedLoadRegister() {}
-  virtual const char* name() const;
+class NamedSatAddSub : public NamedClassDecoder {
+ public:
+  NamedSatAddSub();
+  virtual ~NamedSatAddSub() {}
+ private:
+  nacl_arm_dec::SatAddSub named_decoder_;
 };
 
-struct NamedLoadDoubleI : public LoadDoubleI {
+class NamedLoadDoubleI : public NamedClassDecoder {
+ public:
+  NamedLoadDoubleI();
   virtual ~NamedLoadDoubleI() {}
-  virtual const char* name() const;
+ private:
+  nacl_arm_dec::LoadDoubleI named_decoder_;
 };
 
-struct NamedBinary3RegisterShiftedTest : public Binary3RegisterShiftedTest {
+class NamedBinary3RegisterShiftedTest : public NamedClassDecoder {
+ public:
+  NamedBinary3RegisterShiftedTest();
   virtual ~NamedBinary3RegisterShiftedTest() {}
-  virtual const char* name() const;
+ private:
+  nacl_arm_dec::Binary3RegisterShiftedTest named_decoder_;
 };
 
-struct NamedUnpredictable : public Unpredictable {
+class NamedUnpredictable : public NamedClassDecoder {
+ public:
+  NamedUnpredictable();
   virtual ~NamedUnpredictable() {}
-  virtual const char* name() const;
+ private:
+  nacl_arm_dec::Unpredictable named_decoder_;
 };
 
-struct NamedForbidden : public Forbidden {
+class NamedForbidden : public NamedClassDecoder {
+ public:
+  NamedForbidden();
   virtual ~NamedForbidden() {}
-  virtual const char* name() const;
+ private:
+  nacl_arm_dec::Forbidden named_decoder_;
 };
 
-struct NamedVectorLoad : public VectorLoad {
-  virtual ~NamedVectorLoad() {}
-  virtual const char* name() const;
+class NamedBxBlx : public NamedClassDecoder {
+ public:
+  NamedBxBlx();
+  virtual ~NamedBxBlx() {}
+ private:
+  nacl_arm_dec::BxBlx named_decoder_;
 };
 
-struct NamedMoveToStatusRegister : public MoveToStatusRegister {
-  virtual ~NamedMoveToStatusRegister() {}
-  virtual const char* name() const;
+class NamedLoadDoubleR : public NamedClassDecoder {
+ public:
+  NamedLoadDoubleR();
+  virtual ~NamedLoadDoubleR() {}
+ private:
+  nacl_arm_dec::LoadDoubleR named_decoder_;
 };
 
-struct NamedSatAddSub : public SatAddSub {
-  virtual ~NamedSatAddSub() {}
-  virtual const char* name() const;
-};
-
 /*
  * Defines a stateless decoder class selector for instructions
  */
-/*
- * Define the class decoders used by this decoder state.
- */
-class NamedArm32DecoderState : DecoderState {
+class NamedArm32DecoderState : nacl_arm_dec::DecoderState {
  public:
-  // Generates an instance of a decoder state.
+  /*
+   * Generates an instance of a decoder state.
+   */
   explicit NamedArm32DecoderState();
   virtual ~NamedArm32DecoderState();
   
-  // Parses the given instruction, returning the decoder to use.
-  virtual const class ClassDecoder &decode(const Instruction) const;
+  /*
+   * Parses the given instruction, returning the decoder to use.
+   */
+  const NamedClassDecoder &decode_named(     const nacl_arm_dec::Instruction) const;
+  virtual const class nacl_arm_dec::ClassDecoder
+        &decode(const nacl_arm_dec::Instruction) const;
+  /*
+   * Define the class decoders used by this decoder state.
+   */
+  const NamedCoprocessorOp CoprocessorOp_instance_;
+  const NamedMoveToStatusRegister MoveToStatusRegister_instance_;
+  const NamedImmediateBic ImmediateBic_instance_;
+  const NamedLoadMultiple LoadMultiple_instance_;
+  const NamedLoadCoprocessor LoadCoprocessor_instance_;
+  const NamedLongMultiply LongMultiply_instance_;
+  const NamedBranch Branch_instance_;
+  const NamedTest Test_instance_;
+  const NamedStoreRegister StoreRegister_instance_;
+  const NamedLoadRegister LoadRegister_instance_;
+  const NamedTestImmediate TestImmediate_instance_;
+  const NamedVectorLoad VectorLoad_instance_;
+  const NamedEffectiveNoOp EffectiveNoOp_instance_;
+  const NamedLoadDoubleExclusive LoadDoubleExclusive_instance_;
+  const NamedBinary4RegisterShiftedOp Binary4RegisterShiftedOp_instance_;
+  const NamedBreakpoint Breakpoint_instance_;
+  const NamedMultiply Multiply_instance_;
+  const NamedAdd_Rule_7_A1_P26 Add_Rule_7_A1_P26_instance_;
+  const NamedPackSatRev PackSatRev_instance_;
+  const NamedLoadExclusive LoadExclusive_instance_;
+  const NamedVectorStore VectorStore_instance_;
+  const NamedUnary3RegisterShiftedOp Unary3RegisterShiftedOp_instance_;
+  const NamedUndefined Undefined_instance_;
+  const NamedDataProc DataProc_instance_;
+  const NamedDeprecated Deprecated_instance_;
+  const NamedLoadImmediate LoadImmediate_instance_;
+  const NamedStoreCoprocessor StoreCoprocessor_instance_;
+  const NamedRoadblock Roadblock_instance_;
+  const NamedMoveFromCoprocessor MoveFromCoprocessor_instance_;
+  const NamedStoreExclusive StoreExclusive_instance_;
+  const NamedStoreImmediate StoreImmediate_instance_;
+  const NamedMoveDoubleFromCoprocessor MoveDoubleFromCoprocessor_instance_;
+  const NamedSatAddSub SatAddSub_instance_;
+  const NamedLoadDoubleI LoadDoubleI_instance_;
+  const NamedBinary3RegisterShiftedTest Binary3RegisterShiftedTest_instance_;
+  const NamedUnpredictable Unpredictable_instance_;
+  const NamedForbidden Forbidden_instance_;
+  const NamedBxBlx BxBlx_instance_;
+  const NamedLoadDoubleR LoadDoubleR_instance_;
   
-  // Define the decoders to use in this decoder state
-  NamedCoprocessorOp CoprocessorOp_instance_;
-  NamedImmediateBic ImmediateBic_instance_;
-  NamedLoadMultiple LoadMultiple_instance_;
-  NamedLoadCoprocessor LoadCoprocessor_instance_;
-  NamedLoadDoubleExclusive LoadDoubleExclusive_instance_;
-  NamedBranch Branch_instance_;
-  NamedTest Test_instance_;
-  NamedStoreRegister StoreRegister_instance_;
-  NamedMoveDoubleFromCoprocessor MoveDoubleFromCoprocessor_instance_;
-  NamedTestImmediate TestImmediate_instance_;
-  NamedBxBlx BxBlx_instance_;
-  NamedEffectiveNoOp EffectiveNoOp_instance_;
-  NamedLongMultiply LongMultiply_instance_;
-  NamedBinary4RegisterShiftedOp Binary4RegisterShiftedOp_instance_;
-  NamedBreakpoint Breakpoint_instance_;
-  NamedMultiply Multiply_instance_;
-  NamedPackSatRev PackSatRev_instance_;
-  NamedLoadExclusive LoadExclusive_instance_;
-  NamedVectorStore VectorStore_instance_;
-  NamedUnary3RegisterShiftedOp Unary3RegisterShiftedOp_instance_;
-  NamedUndefined Undefined_instance_;
-  NamedDataProc DataProc_instance_;
-  NamedDeprecated Deprecated_instance_;
-  NamedLoadImmediate LoadImmediate_instance_;
-  NamedStoreCoprocessor StoreCoprocessor_instance_;
-  NamedRoadblock Roadblock_instance_;
-  NamedLoadDoubleR LoadDoubleR_instance_;
-  NamedStoreExclusive StoreExclusive_instance_;
-  NamedStoreImmediate StoreImmediate_instance_;
-  NamedMoveFromCoprocessor MoveFromCoprocessor_instance_;
-  NamedLoadRegister LoadRegister_instance_;
-  NamedLoadDoubleI LoadDoubleI_instance_;
-  NamedBinary3RegisterShiftedTest Binary3RegisterShiftedTest_instance_;
-  NamedUnpredictable Unpredictable_instance_;
-  NamedForbidden Forbidden_instance_;
-  NamedVectorLoad VectorLoad_instance_;
-  NamedMoveToStatusRegister MoveToStatusRegister_instance_;
-  NamedSatAddSub SatAddSub_instance_;
   
  private:
-  // Don't allow the following!
-  explicit NamedArm32DecoderState(const NamedArm32DecoderState&);
-  void operator=(const NamedArm32DecoderState&);
+  /*
+   * Prototypes for static table-matching functions.
+   */
+  inline const NamedClassDecoder &decode_ARMv7(     const nacl_arm_dec::Instruction insn) const;
+  
+  inline const NamedClassDecoder &decode_dp_misc(     const nacl_arm_dec::Instruction insn) const;
+  
+  inline const NamedClassDecoder &decode_dp_reg(     const nacl_arm_dec::Instruction insn) const;
+  
+  inline const NamedClassDecoder &decode_dp_reg_shifted(     const nacl_arm_dec::Instruction insn) const;
+  
+  inline const NamedClassDecoder &decode_dp_immed(     const nacl_arm_dec::Instruction insn) const;
+  
+  inline const NamedClassDecoder &decode_mult(     const nacl_arm_dec::Instruction insn) const;
+  
+  inline const NamedClassDecoder &decode_sat_add_sub(     const nacl_arm_dec::Instruction insn) const;
+  
+  inline const NamedClassDecoder &decode_half_mult(     const nacl_arm_dec::Instruction insn) const;
+  
+  inline const NamedClassDecoder &decode_extra_load_store(     const nacl_arm_dec::Instruction insn) const;
+  
+  inline const NamedClassDecoder &decode_sync(     const nacl_arm_dec::Instruction insn) const;
+  
+  inline const NamedClassDecoder &decode_msr_and_hints(     const nacl_arm_dec::Instruction insn) const;
+  
+  inline const NamedClassDecoder &decode_misc(     const nacl_arm_dec::Instruction insn) const;
+  
+  inline const NamedClassDecoder &decode_load_store_word_byte(     const nacl_arm_dec::Instruction insn) const;
+  
+  inline const NamedClassDecoder &decode_media(     const nacl_arm_dec::Instruction insn) const;
+  
+  inline const NamedClassDecoder &decode_parallel_add_sub(     const nacl_arm_dec::Instruction insn) const;
+  
+  inline const NamedClassDecoder &decode_pack_sat_rev(     const nacl_arm_dec::Instruction insn) const;
+  
+  inline const NamedClassDecoder &decode_signed_mult(     const nacl_arm_dec::Instruction insn) const;
+  
+  inline const NamedClassDecoder &decode_branch_block_xfer(     const nacl_arm_dec::Instruction insn) const;
+  
+  inline const NamedClassDecoder &decode_super_cop(     const nacl_arm_dec::Instruction insn) const;
+  
+  inline const NamedClassDecoder &decode_unconditional(     const nacl_arm_dec::Instruction insn) const;
+  
+  inline const NamedClassDecoder &decode_misc_hints_simd(     const nacl_arm_dec::Instruction insn) const;
+  
+  inline const NamedClassDecoder &decode_simd_dp(     const nacl_arm_dec::Instruction insn) const;
+  
+  inline const NamedClassDecoder &decode_simd_dp_3same(     const nacl_arm_dec::Instruction insn) const;
+  
+  inline const NamedClassDecoder &decode_simd_dp_3diff(     const nacl_arm_dec::Instruction insn) const;
+  
+  inline const NamedClassDecoder &decode_simd_dp_2scalar(     const nacl_arm_dec::Instruction insn) const;
+  
+  inline const NamedClassDecoder &decode_simd_dp_2shift(     const nacl_arm_dec::Instruction insn) const;
+  
+  inline const NamedClassDecoder &decode_simd_dp_2misc(     const nacl_arm_dec::Instruction insn) const;
+  
+  inline const NamedClassDecoder &decode_simd_dp_1imm(     const nacl_arm_dec::Instruction insn) const;
+  
+  inline const NamedClassDecoder &decode_simd_load_store(     const nacl_arm_dec::Instruction insn) const;
+  
+  inline const NamedClassDecoder &decode_simd_load_store_l0(     const nacl_arm_dec::Instruction insn) const;
+  
+  inline const NamedClassDecoder &decode_simd_load_store_l1(     const nacl_arm_dec::Instruction insn) const;
+  
 };
 
 }  // namespace