binaryInstruction.C

 
//                                         THIS FILE IS MACHINE GENERATED  --  DO NOT MODIFY
//
// This file was generated with ROSE's "rosebud" tool by reading node definitions written in a
// C++-like language and emitting this ROSETTA input.
//
// DO NOT MODIFY THIS FILE MANUALLY!
 
 
#include <featureTests.h>
#if defined(ROSE_ENABLE_BINARY_ANALYSIS)
#include "ROSETTA_macros.h"
#include "grammar.h"
#include "AstNodeClass.h"
 
//#undef DOCUMENTATION -- commented out so IDEs can't figure it out
#ifdef DOCUMENTATION
DOCUMENTATION_should_never_be_defined;
#endif
 
#ifdef DOCUMENTATION
#define DECLARE_LEAF_CLASS(CLASS_WITHOUT_Sg) /*void*/
#define DECLARE_LEAF_CLASS2(CLASS_WITHOUT_Sg, TAG) /*void*/
#else
#define DECLARE_LEAF_CLASS(CLASS_WITHOUT_Sg) \
    NEW_TERMINAL_MACRO(CLASS_WITHOUT_Sg, #CLASS_WITHOUT_Sg, #CLASS_WITHOUT_Sg "Tag"); \
    CLASS_WITHOUT_Sg.setCppCondition("!defined(DOCUMENTATION)");\
    CLASS_WITHOUT_Sg.setAutomaticGenerationOfConstructor(false);\
    CLASS_WITHOUT_Sg.setAutomaticGenerationOfDestructor(false)
#define DECLARE_LEAF_CLASS2(CLASS_WITHOUT_Sg, TAG) \
    NEW_TERMINAL_MACRO(CLASS_WITHOUT_Sg, #CLASS_WITHOUT_Sg, #TAG); \
    CLASS_WITHOUT_Sg.setCppCondition("!defined(DOCUMENTATION)");\
    CLASS_WITHOUT_Sg.setAutomaticGenerationOfConstructor(false);\
    CLASS_WITHOUT_Sg.setAutomaticGenerationOfDestructor(false)
#endif
 
#ifdef DOCUMENTATION
#define DECLARE_HEADERS(CLASS_WITHOUT_Sg) /*void*/
#else
#define DECLARE_HEADERS(CLASS_WITHOUT_Sg) \
    CLASS_WITHOUT_Sg.setPredeclarationString("Sg" #CLASS_WITHOUT_Sg "_HEADERS", \
                          ROSE_AUTOMAKE_ABSOLUTE_PATH_TOP_SRCDIR + "//src/ROSETTA/src/binaryInstruction.C")
#endif
 
#ifdef DOCUMENTATION
#define DECLARE_OTHERS(CLASS_WITHOUT_Sg) /*void*/
#else
#define DECLARE_OTHERS(CLASS_WITHOUT_Sg) \
    CLASS_WITHOUT_Sg.setFunctionPrototype("Sg" #CLASS_WITHOUT_Sg "_OTHERS", \
                          ROSE_AUTOMAKE_ABSOLUTE_PATH_TOP_SRCDIR + "//src/ROSETTA/src/binaryInstruction.C")
#endif
 
#ifdef DOCUMENTATION
#define IS_SERIALIZABLE() /*void*/
#else
#define IS_SERIALIZABLE(CLASS_WITHOUT_Sg) \
    CLASS_WITHOUT_Sg.isBoostSerializable(true)
#endif
 
 
// Since ROSETTA builds classes from the leaves up to the base, and C++ builds classes from the
// base down to the leaves, we need to make sure that doxygen sees the base classes before the derived classes. So
// just list all the non-leaf classes here.
#ifdef DOCUMENTATION
class SgAsmBinaryExpression;
class SgAsmCilDataStream;
class SgAsmCilMetadata;
class SgAsmCilNode;
class SgAsmConstantExpression;
class SgAsmDwarfConstruct;
class SgAsmDwarfInformation;
class SgAsmElfSection;
class SgAsmExecutableFileFormat;
class SgAsmExpression;
class SgAsmGenericHeader;
class SgAsmGenericSection;
class SgAsmGenericString;
class SgAsmGenericStrtab;
class SgAsmGenericSymbol;
class SgAsmInstruction;
class SgAsmJvmAttribute;
class SgAsmJvmNode;
class SgAsmNode;
class SgAsmPESection;
class SgAsmRegisterReferenceExpression;
class SgAsmScalarType;
class SgAsmStatement;
class SgAsmSynthesizedDeclaration;
class SgAsmType;
class SgAsmUnaryExpression;
class SgAsmValueExpression;
class SgNode;
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
void Grammar::setUpBinaryInstructions() {
#endif // !DOCUMENTATION
 
 
// SgAsmX86Instruction           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmX86Instruction);
IS_SERIALIZABLE(AsmX86Instruction);
 
#ifndef DOCUMENTATION
AsmX86Instruction.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmX86Instruction);
#if defined(SgAsmX86Instruction_HEADERS) || defined(DOCUMENTATION)
#include <Rose/BinaryAnalysis/BasicTypes.h>
#include <Rose/BinaryAnalysis/InstructionEnumsX86.h>
#endif // SgAsmX86Instruction_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmX86Instruction: public SgAsmInstruction {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmX86Instruction.setDataPrototype(
        "Rose::BinaryAnalysis::X86InstructionKind", "kind", "= Rose::BinaryAnalysis::x86_unknown_instruction",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmX86Instruction.setDataPrototype(
        "Rose::BinaryAnalysis::X86InstructionSize", "baseSize", "= Rose::BinaryAnalysis::x86_insnsize_none",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmX86Instruction.setDataPrototype(
        "Rose::BinaryAnalysis::X86InstructionSize", "operandSize", "= Rose::BinaryAnalysis::x86_insnsize_none",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmX86Instruction.setDataPrototype(
        "Rose::BinaryAnalysis::X86InstructionSize", "addressSize", "= Rose::BinaryAnalysis::x86_insnsize_none",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmX86Instruction.setDataPrototype(
        "bool", "lockPrefix", "= false",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmX86Instruction.setDataPrototype(
        "Rose::BinaryAnalysis::X86RepeatPrefix", "repeatPrefix", "= Rose::BinaryAnalysis::x86_repeat_none",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmX86Instruction.setDataPrototype(
        "Rose::BinaryAnalysis::X86BranchPrediction", "branchPrediction", "= Rose::BinaryAnalysis::x86_branch_prediction_none",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmX86Instruction.setDataPrototype(
        "Rose::BinaryAnalysis::X86SegmentRegister", "segmentOverride", "= Rose::BinaryAnalysis::x86_segreg_none",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmX86Instruction);
#if defined(SgAsmX86Instruction_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmX86Instruction -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmX86Instruction");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmInstruction);
        s & BOOST_SERIALIZATION_NVP(p_kind);
        s & BOOST_SERIALIZATION_NVP(p_baseSize);
        s & BOOST_SERIALIZATION_NVP(p_operandSize);
        s & BOOST_SERIALIZATION_NVP(p_addressSize);
        s & BOOST_SERIALIZATION_NVP(p_lockPrefix);
        s & BOOST_SERIALIZATION_NVP(p_repeatPrefix);
        s & BOOST_SERIALIZATION_NVP(p_branchPrediction);
        s & BOOST_SERIALIZATION_NVP(p_segmentOverride);
        debugSerializationEnd("SgAsmX86Instruction");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    Rose::BinaryAnalysis::X86InstructionKind const& get_kind() const;
    void set_kind(Rose::BinaryAnalysis::X86InstructionKind const&);
public:
    Rose::BinaryAnalysis::X86InstructionSize const& get_baseSize() const;
    void set_baseSize(Rose::BinaryAnalysis::X86InstructionSize const&);
public:
    Rose::BinaryAnalysis::X86InstructionSize const& get_operandSize() const;
    void set_operandSize(Rose::BinaryAnalysis::X86InstructionSize const&);
public:
    Rose::BinaryAnalysis::X86InstructionSize const& get_addressSize() const;
    void set_addressSize(Rose::BinaryAnalysis::X86InstructionSize const&);
public:
    bool const& get_lockPrefix() const;
    void set_lockPrefix(bool const&);
public:
    Rose::BinaryAnalysis::X86RepeatPrefix const& get_repeatPrefix() const;
    void set_repeatPrefix(Rose::BinaryAnalysis::X86RepeatPrefix const&);
public:
    Rose::BinaryAnalysis::X86BranchPrediction const& get_branchPrediction() const;
    void set_branchPrediction(Rose::BinaryAnalysis::X86BranchPrediction const&);
public:
    Rose::BinaryAnalysis::X86SegmentRegister const& get_segmentOverride() const;
    void set_segmentOverride(Rose::BinaryAnalysis::X86SegmentRegister const&);
public:
    static Rose::BinaryAnalysis::X86InstructionSize instructionSizeForWidth(size_t);
 
    static size_t widthForInstructionSize(Rose::BinaryAnalysis::X86InstructionSize);
 
    static Rose::BinaryAnalysis::RegisterDictionaryPtr registersForInstructionSize(Rose::BinaryAnalysis::X86InstructionSize);
 
    static Rose::BinaryAnalysis::RegisterDictionaryPtr registersForWidth(size_t);
 
    // Overrides are documented in the base class
    virtual unsigned get_anyKind() const override;
public:
    virtual ~SgAsmX86Instruction();
 
public:
    SgAsmX86Instruction();
 
public:
    SgAsmX86Instruction(Rose::BinaryAnalysis::Address const& address,
                        uint8_t const& architectureId,
                        Rose::BinaryAnalysis::X86InstructionKind const& kind,
                        Rose::BinaryAnalysis::X86InstructionSize const& baseSize,
                        Rose::BinaryAnalysis::X86InstructionSize const& operandSize,
                        Rose::BinaryAnalysis::X86InstructionSize const& addressSize);
 
protected:
    void initializeProperties();
#endif // SgAsmX86Instruction_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmX86Instruction: public SgAsmInstruction {…};
#endif // DOCUMENTATION
 
 
// SgAsmVoidType           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmVoidType);
IS_SERIALIZABLE(AsmVoidType);
 
#ifndef DOCUMENTATION
AsmVoidType.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmVoidType: public SgAsmType {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmVoidType);
#if defined(SgAsmVoidType_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmVoidType -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmVoidType");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmType);
        debugSerializationEnd("SgAsmVoidType");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
    static SgAsmVoidType* instance();
 
    virtual std::string toString() const override;
    virtual size_t get_nBits() const override;
public:
    virtual ~SgAsmVoidType();
 
public:
    SgAsmVoidType();
 
protected:
    void initializeProperties();
#endif // SgAsmVoidType_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmVoidType: public SgAsmType {…};
#endif // DOCUMENTATION
 
 
// SgAsmVectorType           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmVectorType);
IS_SERIALIZABLE(AsmVectorType);
 
#ifndef DOCUMENTATION
AsmVectorType.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmVectorType: public SgAsmType {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmVectorType.setDataPrototype(
        "size_t", "nElmts", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmVectorType.setDataPrototype(
        "SgAsmType*", "elmtType", "= nullptr",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmVectorType);
#if defined(SgAsmVectorType_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmVectorType -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmVectorType");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmType);
        s & BOOST_SERIALIZATION_NVP(p_nElmts);
        s & BOOST_SERIALIZATION_NVP(p_elmtType);
        debugSerializationEnd("SgAsmVectorType");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
public:
public:
    SgAsmVectorType(size_t nElmts, SgAsmType *elmtType);
 
    size_t get_nElmts() const;
 
    SgAsmType* get_elmtType() const;
 
    // Overrides documented in base class
    virtual void check() const override;
    virtual std::string toString() const override;
    virtual size_t get_nBits() const override;
public:
    virtual ~SgAsmVectorType();
 
public:
    SgAsmVectorType();
 
protected:
    void initializeProperties();
#endif // SgAsmVectorType_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmVectorType: public SgAsmType {…};
#endif // DOCUMENTATION
 
 
// SgAsmUserInstruction           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmUserInstruction);
IS_SERIALIZABLE(AsmUserInstruction);
 
#ifndef DOCUMENTATION
AsmUserInstruction.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmUserInstruction: public SgAsmInstruction {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmUserInstruction.setDataPrototype(
        "unsigned", "kind", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmUserInstruction);
#if defined(SgAsmUserInstruction_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmUserInstruction -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmUserInstruction");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmInstruction);
        s & BOOST_SERIALIZATION_NVP(p_kind);
        debugSerializationEnd("SgAsmUserInstruction");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    unsigned const& get_kind() const;
    void set_kind(unsigned const&);
public:
    // Overrides are documented in the base class
    virtual unsigned get_anyKind() const override;
public:
    virtual ~SgAsmUserInstruction();
 
public:
    SgAsmUserInstruction();
 
public:
    SgAsmUserInstruction(Rose::BinaryAnalysis::Address const& address,
                         uint8_t const& architectureId,
                         unsigned const& kind);
 
protected:
    void initializeProperties();
#endif // SgAsmUserInstruction_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmUserInstruction: public SgAsmInstruction {…};
#endif // DOCUMENTATION
 
 
// SgAsmUnaryUnsignedExtend           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmUnaryUnsignedExtend);
IS_SERIALIZABLE(AsmUnaryUnsignedExtend);
 
#ifndef DOCUMENTATION
AsmUnaryUnsignedExtend.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmUnaryUnsignedExtend: public SgAsmUnaryExpression {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmUnaryUnsignedExtend);
#if defined(SgAsmUnaryUnsignedExtend_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmUnaryUnsignedExtend -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmUnaryUnsignedExtend");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmUnaryExpression);
        debugSerializationEnd("SgAsmUnaryUnsignedExtend");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    virtual ~SgAsmUnaryUnsignedExtend();
 
public:
    SgAsmUnaryUnsignedExtend();
 
public:
    explicit SgAsmUnaryUnsignedExtend(SgAsmExpression* const& operand);
 
protected:
    void initializeProperties();
#endif // SgAsmUnaryUnsignedExtend_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmUnaryUnsignedExtend: public SgAsmUnaryExpression {…};
#endif // DOCUMENTATION
 
 
// SgAsmUnaryTruncate           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmUnaryTruncate);
IS_SERIALIZABLE(AsmUnaryTruncate);
 
#ifndef DOCUMENTATION
AsmUnaryTruncate.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmUnaryTruncate: public SgAsmUnaryExpression {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmUnaryTruncate);
#if defined(SgAsmUnaryTruncate_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmUnaryTruncate -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmUnaryTruncate");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmUnaryExpression);
        debugSerializationEnd("SgAsmUnaryTruncate");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    virtual ~SgAsmUnaryTruncate();
 
public:
    SgAsmUnaryTruncate();
 
public:
    explicit SgAsmUnaryTruncate(SgAsmExpression* const& operand);
 
protected:
    void initializeProperties();
#endif // SgAsmUnaryTruncate_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmUnaryTruncate: public SgAsmUnaryExpression {…};
#endif // DOCUMENTATION
 
 
// SgAsmUnarySignedExtend           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmUnarySignedExtend);
IS_SERIALIZABLE(AsmUnarySignedExtend);
 
#ifndef DOCUMENTATION
AsmUnarySignedExtend.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmUnarySignedExtend: public SgAsmUnaryExpression {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmUnarySignedExtend);
#if defined(SgAsmUnarySignedExtend_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmUnarySignedExtend -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmUnarySignedExtend");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmUnaryExpression);
        debugSerializationEnd("SgAsmUnarySignedExtend");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    virtual ~SgAsmUnarySignedExtend();
 
public:
    SgAsmUnarySignedExtend();
 
public:
    explicit SgAsmUnarySignedExtend(SgAsmExpression* const& operand);
 
protected:
    void initializeProperties();
#endif // SgAsmUnarySignedExtend_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmUnarySignedExtend: public SgAsmUnaryExpression {…};
#endif // DOCUMENTATION
 
 
// SgAsmUnaryRrx           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmUnaryRrx);
IS_SERIALIZABLE(AsmUnaryRrx);
 
#ifndef DOCUMENTATION
AsmUnaryRrx.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmUnaryRrx);
#if defined(SgAsmUnaryRrx_HEADERS) || defined(DOCUMENTATION)
// FIXME[Robb P Matzke 2016-10-31]: no idea what this is
#endif // SgAsmUnaryRrx_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmUnaryRrx: public SgAsmUnaryExpression {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmUnaryRrx);
#if defined(SgAsmUnaryRrx_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmUnaryRrx -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmUnaryRrx");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmUnaryExpression);
        debugSerializationEnd("SgAsmUnaryRrx");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    virtual ~SgAsmUnaryRrx();
 
public:
    SgAsmUnaryRrx();
 
public:
    explicit SgAsmUnaryRrx(SgAsmExpression* const& operand);
 
protected:
    void initializeProperties();
#endif // SgAsmUnaryRrx_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmUnaryRrx: public SgAsmUnaryExpression {…};
#endif // DOCUMENTATION
 
 
// SgAsmUnaryPlus           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmUnaryPlus);
IS_SERIALIZABLE(AsmUnaryPlus);
 
#ifndef DOCUMENTATION
AsmUnaryPlus.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmUnaryPlus: public SgAsmUnaryExpression {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmUnaryPlus);
#if defined(SgAsmUnaryPlus_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmUnaryPlus -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmUnaryPlus");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmUnaryExpression);
        debugSerializationEnd("SgAsmUnaryPlus");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    virtual ~SgAsmUnaryPlus();
 
public:
    SgAsmUnaryPlus();
 
public:
    explicit SgAsmUnaryPlus(SgAsmExpression* const& operand);
 
protected:
    void initializeProperties();
#endif // SgAsmUnaryPlus_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmUnaryPlus: public SgAsmUnaryExpression {…};
#endif // DOCUMENTATION
 
 
// SgAsmUnaryMinus           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmUnaryMinus);
IS_SERIALIZABLE(AsmUnaryMinus);
 
#ifndef DOCUMENTATION
AsmUnaryMinus.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmUnaryMinus: public SgAsmUnaryExpression {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmUnaryMinus);
#if defined(SgAsmUnaryMinus_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmUnaryMinus -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmUnaryMinus");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmUnaryExpression);
        debugSerializationEnd("SgAsmUnaryMinus");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    virtual ~SgAsmUnaryMinus();
 
public:
    SgAsmUnaryMinus();
 
public:
    explicit SgAsmUnaryMinus(SgAsmExpression* const& operand);
 
protected:
    void initializeProperties();
#endif // SgAsmUnaryMinus_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmUnaryMinus: public SgAsmUnaryExpression {…};
#endif // DOCUMENTATION
 
 
// SgAsmUnaryExpression           -- MACHINE GENERATED; DO NOT MODIFY --
 
#ifndef DOCUMENTATION
AstNodeClass& AsmUnaryExpression = nonTerminalConstructor(
    "AsmUnaryExpression",
    *this,
    "AsmUnaryExpression",
    "AsmUnaryExpressionTag",
    SubclassListBuilder()
        | AsmUnaryMinus
        | AsmUnaryPlus
        | AsmUnaryRrx
        | AsmUnarySignedExtend
        | AsmUnaryTruncate
        | AsmUnaryUnsignedExtend
    , false);
assert(AsmUnaryExpression.associatedGrammar != nullptr);
AsmUnaryExpression.setCppCondition("!defined(DOCUMENTATION)");
AsmUnaryExpression.isBoostSerializable(true);
AsmUnaryExpression.setAutomaticGenerationOfConstructor(false);
AsmUnaryExpression.setAutomaticGenerationOfDestructor(false);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
AsmUnaryExpression.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmUnaryExpression: public SgAsmExpression {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmUnaryExpression.setDataPrototype(
        "SgAsmExpression*", "operand", "= nullptr",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmUnaryExpression);
#if defined(SgAsmUnaryExpression_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmUnaryExpression -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmUnaryExpression");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExpression);
        s & BOOST_SERIALIZATION_NVP(p_operand);
        debugSerializationEnd("SgAsmUnaryExpression");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgAsmExpression* const& get_operand() const;
    void set_operand(SgAsmExpression* const&);
public:
    virtual ~SgAsmUnaryExpression();
 
protected:
    SgAsmUnaryExpression();
 
protected:
    explicit SgAsmUnaryExpression(SgAsmExpression* const& operand);
 
protected:
    void initializeProperties();
#endif // SgAsmUnaryExpression_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmUnaryExpression: public SgAsmExpression {…};
#endif // DOCUMENTATION
 
 
// SgAsmSynthesizedFieldDeclaration           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmSynthesizedFieldDeclaration);
IS_SERIALIZABLE(AsmSynthesizedFieldDeclaration);
 
#ifndef DOCUMENTATION
AsmSynthesizedFieldDeclaration.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmSynthesizedFieldDeclaration);
#if defined(SgAsmSynthesizedFieldDeclaration_HEADERS) || defined(DOCUMENTATION)
// FIXME[Robb P Matzke 2017-02-13]: what is this?
#endif // SgAsmSynthesizedFieldDeclaration_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmSynthesizedFieldDeclaration: public SgAsmSynthesizedDeclaration {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmSynthesizedFieldDeclaration.setDataPrototype(
        "std::string", "name", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmSynthesizedFieldDeclaration.setDataPrototype(
        "uint64_t", "offset", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmSynthesizedFieldDeclaration);
#if defined(SgAsmSynthesizedFieldDeclaration_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmSynthesizedFieldDeclaration -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmSynthesizedFieldDeclaration");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmSynthesizedDeclaration);
        s & BOOST_SERIALIZATION_NVP(p_name);
        s & BOOST_SERIALIZATION_NVP(p_offset);
        debugSerializationEnd("SgAsmSynthesizedFieldDeclaration");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    std::string const& get_name() const;
    void set_name(std::string const&);
    // FIXME[Robb P Matzke 2017-02-13]: Is this bytes, bits, or what?
    // Not clear if we want to store the offset explicitly
public:
    uint64_t const& get_offset() const;
    void set_offset(uint64_t const&);
public:
    virtual ~SgAsmSynthesizedFieldDeclaration();
 
public:
    SgAsmSynthesizedFieldDeclaration();
 
public:
    explicit SgAsmSynthesizedFieldDeclaration(Rose::BinaryAnalysis::Address const& address);
 
protected:
    void initializeProperties();
#endif // SgAsmSynthesizedFieldDeclaration_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmSynthesizedFieldDeclaration: public SgAsmSynthesizedDeclaration {…};
#endif // DOCUMENTATION
 
 
// SgAsmSynthesizedDataStructureDeclaration           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmSynthesizedDataStructureDeclaration);
IS_SERIALIZABLE(AsmSynthesizedDataStructureDeclaration);
 
#ifndef DOCUMENTATION
AsmSynthesizedDataStructureDeclaration.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmSynthesizedDataStructureDeclaration);
#if defined(SgAsmSynthesizedDataStructureDeclaration_HEADERS) || defined(DOCUMENTATION)
#include <sageContainer.h>
#endif // SgAsmSynthesizedDataStructureDeclaration_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmSynthesizedDataStructureDeclaration: public SgAsmSynthesizedDeclaration {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmSynthesizedDataStructureDeclaration);
#if defined(SgAsmSynthesizedDataStructureDeclaration_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmSynthesizedDataStructureDeclaration -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmSynthesizedDataStructureDeclaration");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmSynthesizedDeclaration);
        debugSerializationEnd("SgAsmSynthesizedDataStructureDeclaration");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
protected:
      SgAsmSynthesizedDeclarationPtrList p_declarationList;
 
public:
    void appendDeclaration(SgAsmSynthesizedDeclaration *declaration) {
        p_declarationList.push_back(declaration);
    }
    void appendDeclaration(SgAsmSynthesizedDeclaration *declaration) {…}
 
    // Deprecated 2023-11
public:
    void append_declaration(SgAsmSynthesizedDeclaration*) ROSE_DEPRECATED("use appendDeclaration");
public:
    virtual ~SgAsmSynthesizedDataStructureDeclaration();
 
public:
    SgAsmSynthesizedDataStructureDeclaration();
 
public:
    explicit SgAsmSynthesizedDataStructureDeclaration(Rose::BinaryAnalysis::Address const& address);
 
protected:
    void initializeProperties();
#endif // SgAsmSynthesizedDataStructureDeclaration_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmSynthesizedDataStructureDeclaration: public SgAsmSynthesizedDeclaration {…};
#endif // DOCUMENTATION
 
 
// SgAsmStringStorage           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmStringStorage);
IS_SERIALIZABLE(AsmStringStorage);
 
#ifndef DOCUMENTATION
AsmStringStorage.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmStringStorage);
#if defined(SgAsmStringStorage_HEADERS) || defined(DOCUMENTATION)
#include <Rose/BinaryAnalysis/Address.h>
#endif // SgAsmStringStorage_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmStringStorage: public SgAsmExecutableFileFormat {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmStringStorage.setDataPrototype(
        "SgAsmGenericStrtab*", "strtab", "= nullptr",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmStringStorage.setDataPrototype(
        "std::string", "string", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmStringStorage.setDataPrototype(
        "Rose::BinaryAnalysis::Address", "offset", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmStringStorage);
#if defined(SgAsmStringStorage_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmStringStorage -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmStringStorage");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
        s & BOOST_SERIALIZATION_NVP(p_strtab);
        s & BOOST_SERIALIZATION_NVP(p_string);
        s & BOOST_SERIALIZATION_NVP(p_offset);
        debugSerializationEnd("SgAsmStringStorage");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgAsmGenericStrtab* const& get_strtab() const;
    void set_strtab(SgAsmGenericStrtab* const&);
public:
    std::string const& get_string() const;
    void set_string(std::string const&);
public:
    Rose::BinaryAnalysis::Address const& get_offset() const;
    void set_offset(Rose::BinaryAnalysis::Address const&);
public:
    SgAsmStringStorage(SgAsmGenericStrtab *strtab, const std::string &string, Rose::BinaryAnalysis::Address offset);
 
    void dump(FILE *s, const char *prefix, ssize_t idx) const;
 
    /* Accessors. The set_* accessors are private because we don't want anyone messing with them. These data members are
     * used to control string allocation in ELF string tables and must only be modified by allocators in closely related
     * classes.  For instance, to change the value of the string one should call SgAsmGenericString::set_string()
     * instead. */
 
 private:
      friend class SgAsmStoredString;                     /*allowed to set private data members*/
      friend class SgAsmStoredStrtab;                     /*allowed to set private data members*/
public:
    virtual ~SgAsmStringStorage();
 
public:
    SgAsmStringStorage();
 
protected:
    void initializeProperties();
#endif // SgAsmStringStorage_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmStringStorage: public SgAsmExecutableFileFormat {…};
#endif // DOCUMENTATION
 
 
// SgAsmStoredString           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmStoredString);
IS_SERIALIZABLE(AsmStoredString);
 
#ifndef DOCUMENTATION
AsmStoredString.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmStoredString);
#if defined(SgAsmStoredString_HEADERS) || defined(DOCUMENTATION)
#include <Rose/BinaryAnalysis/Address.h>
#endif // SgAsmStoredString_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmStoredString: public SgAsmGenericString {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmStoredString.setDataPrototype(
        "SgAsmStringStorage*", "storage", "= nullptr",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmStoredString);
#if defined(SgAsmStoredString_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmStoredString -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmStoredString");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmGenericString);
        s & BOOST_SERIALIZATION_NVP(p_storage);
        debugSerializationEnd("SgAsmStoredString");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgAsmStringStorage* const& get_storage() const;
    void set_storage(SgAsmStringStorage* const&);
public:
    SgAsmStoredString(SgAsmGenericStrtab*, Rose::BinaryAnalysis::Address offset);
 
    SgAsmStoredString(SgAsmGenericStrtab*, const std::string&);
 
    explicit SgAsmStoredString(class SgAsmStringStorage*);
 
    virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
 
    SgAsmGenericStrtab *get_strtab();
 
    virtual std::string get_string(bool escape=false) const override;
 
    virtual void set_string(const std::string&) override;
 
    virtual void set_string(Rose::BinaryAnalysis::Address) override;
 
    virtual Rose::BinaryAnalysis::Address get_offset() const override;
public:
    virtual ~SgAsmStoredString();
 
public:
    SgAsmStoredString();
 
protected:
    void initializeProperties();
#endif // SgAsmStoredString_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmStoredString: public SgAsmGenericString {…};
#endif // DOCUMENTATION
 
 
// SgAsmStaticData           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmStaticData);
IS_SERIALIZABLE(AsmStaticData);
 
#ifndef DOCUMENTATION
AsmStaticData.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmStaticData);
#if defined(SgAsmStaticData_HEADERS) || defined(DOCUMENTATION)
#include <sageContainer.h>
#endif // SgAsmStaticData_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmStaticData: public SgAsmStatement {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmStaticData.setDataPrototype(
        "SgUnsignedCharList", "rawBytes", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmStaticData);
#if defined(SgAsmStaticData_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmStaticData -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmStaticData");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmStatement);
        s & BOOST_SERIALIZATION_NVP(p_rawBytes);
        debugSerializationEnd("SgAsmStaticData");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgUnsignedCharList const& get_rawBytes() const;
    void set_rawBytes(SgUnsignedCharList const&);
public:
    size_t get_size() const;
 
    // Deprecated 2023-11
public:
    const SgUnsignedCharList& get_raw_bytes() const ROSE_DEPRECATED("use get_rawBytes");
    void set_raw_bytes(const SgUnsignedCharList&) ROSE_DEPRECATED("use set_rawBytes");
public:
    virtual ~SgAsmStaticData();
 
public:
    SgAsmStaticData();
 
public:
    explicit SgAsmStaticData(Rose::BinaryAnalysis::Address const& address);
 
protected:
    void initializeProperties();
#endif // SgAsmStaticData_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmStaticData: public SgAsmStatement {…};
#endif // DOCUMENTATION
 
 
// SgAsmStackExpression           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmStackExpression);
IS_SERIALIZABLE(AsmStackExpression);
 
#ifndef DOCUMENTATION
AsmStackExpression.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmStackExpression: public SgAsmExpression {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmStackExpression.setDataPrototype(
        "int", "stackPosition", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmStackExpression);
#if defined(SgAsmStackExpression_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmStackExpression -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmStackExpression");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExpression);
        s & BOOST_SERIALIZATION_NVP(p_stackPosition);
        debugSerializationEnd("SgAsmStackExpression");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    int const& get_stackPosition() const;
    void set_stackPosition(int const&);
    // Deprecated 2023-11
public:
    int get_stack_position() const ROSE_DEPRECATED("use get_stackPosition");
    void set_stack_position(int)  ROSE_DEPRECATED("use set_stackPosition");
public:
    virtual ~SgAsmStackExpression();
 
public:
    SgAsmStackExpression();
 
public:
    explicit SgAsmStackExpression(int const& stackPosition);
 
protected:
    void initializeProperties();
#endif // SgAsmStackExpression_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmStackExpression: public SgAsmExpression {…};
#endif // DOCUMENTATION
 
 
// SgAsmRiscOperation           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmRiscOperation);
IS_SERIALIZABLE(AsmRiscOperation);
 
#ifndef DOCUMENTATION
AsmRiscOperation.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmRiscOperation);
#if defined(SgAsmRiscOperation_HEADERS) || defined(DOCUMENTATION)
#ifdef ROSE_SgAsmRiscOperation_IMPL
#include <SgAsmExprListExp.h>
#endif
#endif // SgAsmRiscOperation_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmRiscOperation: public SgAsmExpression {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmRiscOperation.setDataPrototype(
        "SgAsmRiscOperation::RiscOperator", "riscOperator", "= OP_NONE",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmRiscOperation.setDataPrototype(
        "SgAsmExprListExp*", "operands", "= nullptr",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmRiscOperation);
#if defined(SgAsmRiscOperation_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmRiscOperation -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmRiscOperation");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExpression);
        s & BOOST_SERIALIZATION_NVP(p_riscOperator);
        s & BOOST_SERIALIZATION_NVP(p_operands);
        debugSerializationEnd("SgAsmRiscOperation");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
    // Local types
public:
    enum RiscOperator {
        OP_NONE,
        OP_bottom,
        OP_undefined,
        OP_unspecified,
        OP_filterCallTarget,
        OP_filterReturnTarget,
        OP_filterIndirectJumpTarget,
        OP_hlt,
        OP_cpuid,
        OP_rdtsc,
        OP_and_,
        OP_or_,
        OP_xor_,
        OP_invert,
        OP_extract,
        OP_concat,
        OP_leastSignificantSetBit,
        OP_mostSignificantSetBit,
        OP_rotateLeft,
        OP_rotateRight,
        OP_shiftLeft,
        OP_shiftRight,
        OP_shiftRightArithmetic,
        OP_equalToZero,
        OP_ite,
        OP_isEqual,
        OP_isNotEqual,
        OP_isUnsignedLessThan,
        OP_isUnsignedLessThanOrEqual,
        OP_isUnsignedGreaterThan,
        OP_isUnsignedGreaterThanOrEqual,
        OP_isSignedLessThan,
        OP_isSignedLessThanOrEqual,
        OP_isSignedGreaterThan,
        OP_isSignedGreaterThanOrEqual,
        OP_unsignedExtend,
        OP_signExtend,
        OP_add,                                     
        OP_addCarries,                              
        OP_subtract,
        OP_negate,
        OP_signedDivide,
        OP_signedModulo,
        OP_signedMultiply,
        OP_unsignedDivide,
        OP_unsignedModulo,
        OP_unsignedMultiply,
        OP_interrupt,
        OP_readRegister,
        OP_peekRegister,
        OP_writeRegister,
        OP_readMemory,                              
        OP_peekMemory,
        OP_writeMemory,                             
        OP_N_OPERATORS                               // MUST BE LAST!
    };
    enum RiscOperator {…};
 
    // Properties
public:
    // Note that the qualification for the type is necessary only for ROSETTA. Remove it when ROSETTA finally goes away.
public:
    SgAsmRiscOperation::RiscOperator const& get_riscOperator() const;
    void set_riscOperator(SgAsmRiscOperation::RiscOperator const&);
public:
    SgAsmExprListExp* const& get_operands() const;
    void set_operands(SgAsmExprListExp* const&);
public:
    virtual ~SgAsmRiscOperation();
 
public:
    SgAsmRiscOperation();
 
public:
    explicit SgAsmRiscOperation(SgAsmRiscOperation::RiscOperator const& riscOperator);
 
protected:
    void initializeProperties();
#endif // SgAsmRiscOperation_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmRiscOperation: public SgAsmExpression {…};
#endif // DOCUMENTATION
 
 
// SgAsmRegisterNames           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmRegisterNames);
IS_SERIALIZABLE(AsmRegisterNames);
 
#ifndef DOCUMENTATION
AsmRegisterNames.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmRegisterNames);
#if defined(SgAsmRegisterNames_HEADERS) || defined(DOCUMENTATION)
#include <sageContainer.h>
#endif // SgAsmRegisterNames_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmRegisterNames: public SgAsmExpression {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmRegisterNames.setDataPrototype(
        "SgAsmRegisterReferenceExpressionPtrList", "registers", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmRegisterNames.setDataPrototype(
        "unsigned", "mask", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmRegisterNames);
#if defined(SgAsmRegisterNames_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmRegisterNames -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmRegisterNames");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExpression);
        s & BOOST_SERIALIZATION_NVP(p_registers);
        s & BOOST_SERIALIZATION_NVP(p_mask);
        debugSerializationEnd("SgAsmRegisterNames");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgAsmRegisterReferenceExpressionPtrList const& get_registers() const;
    SgAsmRegisterReferenceExpressionPtrList& get_registers();
    void set_registers(SgAsmRegisterReferenceExpressionPtrList const&);
public:
    unsigned const& get_mask() const;
    void set_mask(unsigned const&);
public:
    virtual ~SgAsmRegisterNames();
 
public:
    SgAsmRegisterNames();
 
protected:
    void initializeProperties();
#endif // SgAsmRegisterNames_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmRegisterNames: public SgAsmExpression {…};
#endif // DOCUMENTATION
 
 
// SgAsmPowerpcInstruction           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmPowerpcInstruction);
IS_SERIALIZABLE(AsmPowerpcInstruction);
 
#ifndef DOCUMENTATION
AsmPowerpcInstruction.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmPowerpcInstruction);
#if defined(SgAsmPowerpcInstruction_HEADERS) || defined(DOCUMENTATION)
#include <Rose/BinaryAnalysis/InstructionEnumsPowerpc.h>
#endif // SgAsmPowerpcInstruction_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmPowerpcInstruction: public SgAsmInstruction {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPowerpcInstruction.setDataPrototype(
        "Rose::BinaryAnalysis::PowerpcInstructionKind", "kind", "= Rose::BinaryAnalysis::powerpc_unknown_instruction",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmPowerpcInstruction);
#if defined(SgAsmPowerpcInstruction_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmPowerpcInstruction -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmPowerpcInstruction");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmInstruction);
        s & BOOST_SERIALIZATION_NVP(p_kind);
        debugSerializationEnd("SgAsmPowerpcInstruction");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    Rose::BinaryAnalysis::PowerpcInstructionKind const& get_kind() const;
    void set_kind(Rose::BinaryAnalysis::PowerpcInstructionKind const&);
public:
    std::string conditionalBranchDescription() const;
 
    static Rose::BinaryAnalysis::RegisterDictionaryPtr registersForWidth(size_t);
 
    // Overrides are documented in the base class
    virtual unsigned get_anyKind() const override;
public:
    virtual ~SgAsmPowerpcInstruction();
 
public:
    SgAsmPowerpcInstruction();
 
public:
    SgAsmPowerpcInstruction(Rose::BinaryAnalysis::Address const& address,
                            uint8_t const& architectureId,
                            Rose::BinaryAnalysis::PowerpcInstructionKind const& kind);
 
protected:
    void initializeProperties();
#endif // SgAsmPowerpcInstruction_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmPowerpcInstruction: public SgAsmInstruction {…};
#endif // DOCUMENTATION
 
 
// SgAsmPointerType           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmPointerType);
IS_SERIALIZABLE(AsmPointerType);
 
#ifndef DOCUMENTATION
AsmPointerType.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmPointerType: public SgAsmScalarType {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPointerType.setDataPrototype(
        "SgAsmType *", "subtype", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmPointerType);
#if defined(SgAsmPointerType_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmPointerType -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmPointerType");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmScalarType);
        s & BOOST_SERIALIZATION_NVP(p_subtype);
        debugSerializationEnd("SgAsmPointerType");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgAsmType * const& get_subtype() const;
    void set_subtype(SgAsmType * const&);
public:
    SgAsmPointerType(Rose::BinaryAnalysis::ByteOrder::Endianness, size_t nBits, SgAsmType *subtype);
 
    static SgAsmPointerType* instance(Rose::BinaryAnalysis::ByteOrder::Endianness, size_t nBits, SgAsmType *subtype);
 
    virtual void check() const override;
    virtual std::string toString() const override;
public:
    virtual ~SgAsmPointerType();
 
public:
    SgAsmPointerType();
 
protected:
    void initializeProperties();
#endif // SgAsmPointerType_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmPointerType: public SgAsmScalarType {…};
#endif // DOCUMENTATION
 
 
// SgAsmPEStringSection           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmPEStringSection);
IS_SERIALIZABLE(AsmPEStringSection);
 
#ifndef DOCUMENTATION
AsmPEStringSection.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmPEStringSection);
#if defined(SgAsmPEStringSection_HEADERS) || defined(DOCUMENTATION)
#include <Rose/BinaryAnalysis/Address.h>
#endif // SgAsmPEStringSection_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmPEStringSection: public SgAsmPESection {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPEStringSection.setDataPrototype(
        "SgAsmCoffStrtab*", "strtab", "= nullptr",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmPEStringSection);
#if defined(SgAsmPEStringSection_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmPEStringSection -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmPEStringSection");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmPESection);
        s & BOOST_SERIALIZATION_NVP(p_strtab);
        debugSerializationEnd("SgAsmPEStringSection");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgAsmCoffStrtab* const& get_strtab() const;
    void set_strtab(SgAsmCoffStrtab* const&);
public:
    SgAsmPEStringSection(SgAsmPEFileHeader*);
    virtual SgAsmPEStringSection* parse() override;
    virtual bool reallocate() override;
    virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
    virtual void set_size(Rose::BinaryAnalysis::Address newsize) override;
    virtual void unparse(std::ostream&) const override;
public:
    virtual ~SgAsmPEStringSection();
 
public:
    SgAsmPEStringSection();
 
protected:
    void initializeProperties();
#endif // SgAsmPEStringSection_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmPEStringSection: public SgAsmPESection {…};
#endif // DOCUMENTATION
 
 
// SgAsmPESectionTable           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmPESectionTable);
IS_SERIALIZABLE(AsmPESectionTable);
 
#ifndef DOCUMENTATION
AsmPESectionTable.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmPESectionTable: public SgAsmGenericSection {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmPESectionTable);
#if defined(SgAsmPESectionTable_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmPESectionTable -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmPESectionTable");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmGenericSection);
        debugSerializationEnd("SgAsmPESectionTable");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
    explicit SgAsmPESectionTable(SgAsmPEFileHeader*);
    virtual SgAsmPESectionTable* parse() override;
 
    void addSection(SgAsmPESection *section);
    virtual bool reallocate() override;
    virtual void unparse(std::ostream&) const override;
    virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
 
    // Deprecated 2023-11
public:
    void add_section(SgAsmPESection*) ROSE_DEPRECATED("use addSection");
public:
    virtual ~SgAsmPESectionTable();
 
public:
    SgAsmPESectionTable();
 
protected:
    void initializeProperties();
#endif // SgAsmPESectionTable_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmPESectionTable: public SgAsmGenericSection {…};
#endif // DOCUMENTATION
 
 
// SgAsmPESectionTableEntry           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmPESectionTableEntry);
IS_SERIALIZABLE(AsmPESectionTableEntry);
 
#ifndef DOCUMENTATION
AsmPESectionTableEntry.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmPESectionTableEntry);
#if defined(SgAsmPESectionTableEntry_HEADERS) || defined(DOCUMENTATION)
#include <Rose/BinaryAnalysis/Address.h>
#endif // SgAsmPESectionTableEntry_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmPESectionTableEntry: public SgAsmExecutableFileFormat {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPESectionTableEntry.setDataPrototype(
        "std::string", "name", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPESectionTableEntry.setDataPrototype(
        "Rose::BinaryAnalysis::Address", "virtual_size", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPESectionTableEntry.setDataPrototype(
        "Rose::BinaryAnalysis::Address", "rva", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPESectionTableEntry.setDataPrototype(
        "Rose::BinaryAnalysis::Address", "physical_size", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPESectionTableEntry.setDataPrototype(
        "Rose::BinaryAnalysis::Address", "physical_offset", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPESectionTableEntry.setDataPrototype(
        "unsigned", "coff_line_nums", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPESectionTableEntry.setDataPrototype(
        "unsigned", "n_relocs", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPESectionTableEntry.setDataPrototype(
        "unsigned", "n_coff_line_nums", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPESectionTableEntry.setDataPrototype(
        "unsigned", "flags", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmPESectionTableEntry);
#if defined(SgAsmPESectionTableEntry_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmPESectionTableEntry -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmPESectionTableEntry");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
        s & BOOST_SERIALIZATION_NVP(p_name);
        s & BOOST_SERIALIZATION_NVP(p_virtual_size);
        s & BOOST_SERIALIZATION_NVP(p_rva);
        s & BOOST_SERIALIZATION_NVP(p_physical_size);
        s & BOOST_SERIALIZATION_NVP(p_physical_offset);
        s & BOOST_SERIALIZATION_NVP(p_coff_line_nums);
        s & BOOST_SERIALIZATION_NVP(p_n_relocs);
        s & BOOST_SERIALIZATION_NVP(p_n_coff_line_nums);
        s & BOOST_SERIALIZATION_NVP(p_flags);
        debugSerializationEnd("SgAsmPESectionTableEntry");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
    // Local types
public:
#ifdef _MSC_VER
# pragma pack (1)
#endif
    /* File format of a section table entry. All fields are little endian. Sections are ordered by RVA. */
    struct PESectionTableEntry_disk {
        char     name[8];          /* NUL-padded */
        uint32_t virtual_size;     /* virtual memory size, >= physical_size and difference is zero filled */
        uint32_t rva;              /* relative virt addr wrt Image Base; multiple of section_align; dense space */
        uint32_t physical_size;    /* bytes of initialized data on disk; multiple of file_align & <= virtual_size*/
        uint32_t physical_offset;  /* location of initialized data on disk; multiple of file_align */
        uint32_t coff_line_nums;   /* file offset of COFF line number info or zero */
        uint32_t n_relocs;         /* number of relocation entries; should be zero for executables */
        uint32_t n_coff_line_nums; /* number of COFF line number entries */
        uint32_t flags;            /* PESectionFlags bits: code, data, caching, paging, shared, permissions, etc.*/
    }
    struct PESectionTableEntry_disk {…};
#if !defined(SWIG) && !defined(_MSC_VER)
    __attribute__((packed))
#endif
    ;
#ifdef _MSC_VER
# pragma pack ()
#endif
 
    /* These come from the windows PE documentation and
     * http://en.wikibooks.org/wiki/X86_Disassembly/Windows_Executable_Files */
    enum PESectionFlags {
        OF_CODE             = 0x00000020,   /* section contains code */
        OF_IDATA            = 0x00000040,   /* initialized data */
        OF_UDATA            = 0x00000080,   /* uninitialized data */
        OF_INFO             = 0x00000200,   /* comments or some other type of info */
        OF_REMOVE           = 0x00000800,   /* section will not become part of image */
        OF_COMDAT           = 0x00001000,   /* section contains comdat */
        OF_NO_DEFER_SPEC_EXC= 0x00004000,   /* reset speculative exception handling bits in the TLB entires for
                                             * this section */
        OF_GPREL            = 0x00008000,   /* section content can be access relative to GP */
        OF_ALIGN_1          = 0x00100000,   /* no alignment */
        OF_ALIGN_2          = 0x00200000,   /* 2-byte alignment */
        OF_ALIGN_4          = 0x00300000,   /* 4-byte alignment */
        OF_ALIGN_8          = 0x00400000,   /* 8-byte alignment */
        OF_ALIGN_16         = 0x00500000,   /* 16-byte alignment (default if not other alignment specified) */
        OF_ALIGN_32         = 0x00600000,   /* 32-byte alignment */
        OF_ALIGN_64         = 0x00700000,   /* 64-byte alignment */
        OF_ALIGN_128        = 0x00800000,   /* 128-byte alignment */
        OF_ALIGN_256        = 0x00900000,   /* 256-byte alignment */
        OF_ALIGN_512        = 0x00a00000,   /* 512-byte alignment */
        OF_ALIGN_1k         = 0x00b00000,   /* 1024-byte alignment */
        OF_ALIGN_2k         = 0x00c00000,   /* 2048-byte alignment */
        OF_ALIGN_4k         = 0x00d00000,   /* 4096-byte alignment */
        OF_ALIGN_8k         = 0x00e00000,   /* 8192-byte alignment */
        OF_ALIGN_MASK       = 0x00f00000,   /* mask for alignment value */
        OF_NRELOC_OVFL      = 0x01000000,   /* section contains extended relocations */
        OF_DISCARDABLE      = 0x02000000,   /* can be discarded */
        OF_NO_CACHE         = 0x04000000,   /* section must not be cached */
        OF_NO_PAGING        = 0x08000000,   /* section is not pageable */
        OF_SHARED           = 0x10000000,   /* section is shared */
        OF_EXECUTABLE       = 0x20000000,   /* execute permission */
        OF_READABLE         = 0x40000000,   /* read permission */
        OF_WRITABLE         = 0x80000000    /* write permission */
    };
 
    // Properties
public:
public:
    std::string const& get_name() const;
    void set_name(std::string const&);
public:
    Rose::BinaryAnalysis::Address const& get_virtual_size() const;
    void set_virtual_size(Rose::BinaryAnalysis::Address const&);
public:
    Rose::BinaryAnalysis::Address const& get_rva() const;
    void set_rva(Rose::BinaryAnalysis::Address const&);
public:
    Rose::BinaryAnalysis::Address const& get_physical_size() const;
    void set_physical_size(Rose::BinaryAnalysis::Address const&);
public:
    Rose::BinaryAnalysis::Address const& get_physical_offset() const;
    void set_physical_offset(Rose::BinaryAnalysis::Address const&);
public:
    unsigned const& get_coff_line_nums() const;
    void set_coff_line_nums(unsigned const&);
public:
    unsigned const& get_n_relocs() const;
    void set_n_relocs(unsigned const&);
public:
    unsigned const& get_n_coff_line_nums() const;
    void set_n_coff_line_nums(unsigned const&);
public:
    unsigned const& get_flags() const;
    void set_flags(unsigned const&);
    // Functions
public:
    explicit SgAsmPESectionTableEntry(const SgAsmPESectionTableEntry::PESectionTableEntry_disk *disk);
 
    void updateFromSection(SgAsmPESection *section);
    void *encode(SgAsmPESectionTableEntry::PESectionTableEntry_disk*) const;
    virtual void dump(FILE*, const char *prefix, ssize_t idx) const;
 
    // Deprecated 2023-11
public:
    void update_from_section(SgAsmPESection*) ROSE_DEPRECATED("use updateFromSection");
public:
    virtual ~SgAsmPESectionTableEntry();
 
public:
    SgAsmPESectionTableEntry();
 
protected:
    void initializeProperties();
#endif // SgAsmPESectionTableEntry_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmPESectionTableEntry: public SgAsmExecutableFileFormat {…};
#endif // DOCUMENTATION
 
 
// SgAsmPERVASizePairList           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmPERVASizePairList);
IS_SERIALIZABLE(AsmPERVASizePairList);
 
#ifndef DOCUMENTATION
AsmPERVASizePairList.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmPERVASizePairList);
#if defined(SgAsmPERVASizePairList_HEADERS) || defined(DOCUMENTATION)
#include <sageContainer.h>
#endif // SgAsmPERVASizePairList_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmPERVASizePairList: public SgAsmExecutableFileFormat {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPERVASizePairList.setDataPrototype(
        "SgAsmPERVASizePairPtrList", "pairs", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmPERVASizePairList);
#if defined(SgAsmPERVASizePairList_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmPERVASizePairList -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmPERVASizePairList");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
        s & BOOST_SERIALIZATION_NVP(p_pairs);
        debugSerializationEnd("SgAsmPERVASizePairList");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgAsmPERVASizePairPtrList const& get_pairs() const;
    SgAsmPERVASizePairPtrList& get_pairs();
    void set_pairs(SgAsmPERVASizePairPtrList const&);
public:
    explicit SgAsmPERVASizePairList(SgAsmPEFileHeader *parent);
public:
    virtual ~SgAsmPERVASizePairList();
 
public:
    SgAsmPERVASizePairList();
 
protected:
    void initializeProperties();
#endif // SgAsmPERVASizePairList_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmPERVASizePairList: public SgAsmExecutableFileFormat {…};
#endif // DOCUMENTATION
 
 
// SgAsmPERVASizePair           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmPERVASizePair);
IS_SERIALIZABLE(AsmPERVASizePair);
 
#ifndef DOCUMENTATION
AsmPERVASizePair.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmPERVASizePair);
#if defined(SgAsmPERVASizePair_HEADERS) || defined(DOCUMENTATION)
#include <Rose/BinaryAnalysis/Address.h>
#include <Rose/BinaryAnalysis/RelativeVirtualAddress.h>
#endif // SgAsmPERVASizePair_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmPERVASizePair: public SgAsmExecutableFileFormat {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPERVASizePair.setDataPrototype(
        "Rose::BinaryAnalysis::RelativeVirtualAddress", "e_rva", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPERVASizePair.setDataPrototype(
        "Rose::BinaryAnalysis::Address", "e_size", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPERVASizePair.setDataPrototype(
        "SgAsmGenericSection*", "section", "= nullptr",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmPERVASizePair);
#if defined(SgAsmPERVASizePair_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmPERVASizePair -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmPERVASizePair");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
        s & BOOST_SERIALIZATION_NVP(p_e_rva);
        s & BOOST_SERIALIZATION_NVP(p_e_size);
        s & BOOST_SERIALIZATION_NVP(p_section);
        debugSerializationEnd("SgAsmPERVASizePair");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
    // Local types
public:
#ifdef _MSC_VER
# pragma pack (1)
#endif
    struct RVASizePair_disk {
        uint32_t    e_rva;
        uint32_t    e_size;
    }
    struct RVASizePair_disk {…};
#if !defined(SWIG) && !defined(_MSC_VER)
    __attribute__((packed))
#endif
    ;
#ifdef _MSC_VER
# pragma pack ()
#endif
 
    // Properties
public:
public:
    Rose::BinaryAnalysis::RelativeVirtualAddress const& get_e_rva() const;
    Rose::BinaryAnalysis::RelativeVirtualAddress& get_e_rva();
    void set_e_rva(Rose::BinaryAnalysis::RelativeVirtualAddress const&);
public:
    Rose::BinaryAnalysis::Address const& get_e_size() const;
    void set_e_size(Rose::BinaryAnalysis::Address const&);
public:
    // Functions
public:
    SgAsmPERVASizePair(SgAsmPERVASizePairList *parent, const SgAsmPERVASizePair::RVASizePair_disk*);
    SgAsmPERVASizePair(SgAsmPERVASizePairList *parent, Rose::BinaryAnalysis::Address rva, Rose::BinaryAnalysis::Address size);
 
    void set_section(SgAsmGenericSection *section);
 
    SgAsmGenericSection *get_section() const;
 
    void *encode(SgAsmPERVASizePair::RVASizePair_disk *disk) const;
public:
    virtual ~SgAsmPERVASizePair();
 
public:
    SgAsmPERVASizePair();
 
protected:
    void initializeProperties();
#endif // SgAsmPERVASizePair_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmPERVASizePair: public SgAsmExecutableFileFormat {…};
#endif // DOCUMENTATION
 
 
// SgAsmPEImportSection           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmPEImportSection);
IS_SERIALIZABLE(AsmPEImportSection);
 
#ifndef DOCUMENTATION
AsmPEImportSection.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmPEImportSection);
#if defined(SgAsmPEImportSection_HEADERS) || defined(DOCUMENTATION)
#include <Rose/BinaryAnalysis/Address.h>
#include <Rose/BinaryAnalysis/RelativeVirtualAddress.h>
 
#ifdef ROSE_SgAsmPEImportSection_IMPL
#include <SgAsmPEImportDirectoryList.h>
#endif
#endif // SgAsmPEImportSection_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmPEImportSection: public SgAsmPESection {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPEImportSection.setDataPrototype(
        "SgAsmPEImportDirectoryList*", "importDirectories", "= createAndParent<SgAsmPEImportDirectoryList>(this)",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmPEImportSection);
#if defined(SgAsmPEImportSection_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmPEImportSection -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmPEImportSection");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmPESection);
        s & BOOST_SERIALIZATION_NVP(p_importDirectories);
        debugSerializationEnd("SgAsmPEImportSection");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgAsmPEImportDirectoryList* const& get_importDirectories() const;
    void set_importDirectories(SgAsmPEImportDirectoryList* const&);
public:
    explicit SgAsmPEImportSection(SgAsmPEFileHeader*);
    virtual SgAsmPEImportSection *parse() override;
    virtual bool reallocate() override;
    virtual void unparse(std::ostream&) const override;
    virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
 
    void addImportDirectory(SgAsmPEImportDirectory*);
 
    void removeImportDirectory(SgAsmPEImportDirectory*);
    static bool showImportMessage();
    static void importMessageReset();
 
    size_t reallocateIats(Rose::BinaryAnalysis::RelativeVirtualAddress start_at);
 
private:
    static size_t mesg_nprinted; //counter for import_mesg()
 
    // Deprecated 2023-11
public:
    SgAsmPEImportDirectoryList* get_import_directories() const ROSE_DEPRECATED("use get_importDirectories");
    void set_import_directories(SgAsmPEImportDirectoryList*) ROSE_DEPRECATED("use set_importDirectories");
    void add_import_directory(SgAsmPEImportDirectory*) ROSE_DEPRECATED("use addImportDirectory");
    void remove_import_directory(SgAsmPEImportDirectory*) ROSE_DEPRECATED("use removeImportDirectory");
    static bool show_import_mesg() ROSE_DEPRECATED("use showImportMessage");
    static void import_mesg_reset() ROSE_DEPRECATED("use importMessageReset");
    size_t reallocate_iats(Rose::BinaryAnalysis::RelativeVirtualAddress) ROSE_DEPRECATED("use reallocateIats");
public:
    virtual ~SgAsmPEImportSection();
 
public:
    SgAsmPEImportSection();
 
protected:
    void initializeProperties();
#endif // SgAsmPEImportSection_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmPEImportSection: public SgAsmPESection {…};
#endif // DOCUMENTATION
 
 
// SgAsmPEImportItemList           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmPEImportItemList);
IS_SERIALIZABLE(AsmPEImportItemList);
 
#ifndef DOCUMENTATION
AsmPEImportItemList.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmPEImportItemList);
#if defined(SgAsmPEImportItemList_HEADERS) || defined(DOCUMENTATION)
#include <sageContainer.h>
#endif // SgAsmPEImportItemList_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmPEImportItemList: public SgAsmExecutableFileFormat {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPEImportItemList.setDataPrototype(
        "SgAsmPEImportItemPtrList", "vector", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmPEImportItemList);
#if defined(SgAsmPEImportItemList_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmPEImportItemList -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmPEImportItemList");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
        s & BOOST_SERIALIZATION_NVP(p_vector);
        debugSerializationEnd("SgAsmPEImportItemList");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgAsmPEImportItemPtrList const& get_vector() const;
    SgAsmPEImportItemPtrList& get_vector();
    void set_vector(SgAsmPEImportItemPtrList const&);
public:
    virtual ~SgAsmPEImportItemList();
 
public:
    SgAsmPEImportItemList();
 
protected:
    void initializeProperties();
#endif // SgAsmPEImportItemList_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmPEImportItemList: public SgAsmExecutableFileFormat {…};
#endif // DOCUMENTATION
 
 
// SgAsmPEImportItem           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmPEImportItem);
IS_SERIALIZABLE(AsmPEImportItem);
 
#ifndef DOCUMENTATION
AsmPEImportItem.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmPEImportItem);
#if defined(SgAsmPEImportItem_HEADERS) || defined(DOCUMENTATION)
#include <Rose/BinaryAnalysis/Address.h>
#include <Rose/BinaryAnalysis/RelativeVirtualAddress.h>
 
#ifdef ROSE_SgAsmPEImportItem_IMPL
#include <SgAsmBasicString.h>
#endif
#endif // SgAsmPEImportItem_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmPEImportItem: public SgAsmExecutableFileFormat {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPEImportItem.setDataPrototype(
        "bool", "by_ordinal", "= true",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPEImportItem.setDataPrototype(
        "unsigned", "ordinal", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPEImportItem.setDataPrototype(
        "unsigned", "hint", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPEImportItem.setDataPrototype(
        "SgAsmGenericString*", "name", "= createAndParent<SgAsmBasicString>(this)",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPEImportItem.setDataPrototype(
        "Rose::BinaryAnalysis::RelativeVirtualAddress", "hintname_rva", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPEImportItem.setDataPrototype(
        "size_t", "hintname_nalloc", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPEImportItem.setDataPrototype(
        "Rose::BinaryAnalysis::RelativeVirtualAddress", "bound_rva", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPEImportItem.setDataPrototype(
        "bool", "iat_written", "= false",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmPEImportItem);
#if defined(SgAsmPEImportItem_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmPEImportItem -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmPEImportItem");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
        s & BOOST_SERIALIZATION_NVP(p_by_ordinal);
        s & BOOST_SERIALIZATION_NVP(p_ordinal);
        s & BOOST_SERIALIZATION_NVP(p_hint);
        s & BOOST_SERIALIZATION_NVP(p_name);
        s & BOOST_SERIALIZATION_NVP(p_hintname_rva);
        s & BOOST_SERIALIZATION_NVP(p_hintname_nalloc);
        s & BOOST_SERIALIZATION_NVP(p_bound_rva);
        s & BOOST_SERIALIZATION_NVP(p_iat_written);
        debugSerializationEnd("SgAsmPEImportItem");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    bool const& get_by_ordinal() const;
    void set_by_ordinal(bool const&);
public:
    unsigned const& get_ordinal() const;
    void set_ordinal(unsigned const&);
public:
    unsigned const& get_hint() const;
    void set_hint(unsigned const&);
public:
    SgAsmGenericString* const& get_name() const;
    void set_name(SgAsmGenericString* const&);
public:
    Rose::BinaryAnalysis::RelativeVirtualAddress const& get_hintname_rva() const;
    Rose::BinaryAnalysis::RelativeVirtualAddress& get_hintname_rva();
    void set_hintname_rva(Rose::BinaryAnalysis::RelativeVirtualAddress const&);
public:
    size_t const& get_hintname_nalloc() const;
    void set_hintname_nalloc(size_t const&);
public:
    Rose::BinaryAnalysis::RelativeVirtualAddress const& get_bound_rva() const;
    Rose::BinaryAnalysis::RelativeVirtualAddress& get_bound_rva();
    void set_bound_rva(Rose::BinaryAnalysis::RelativeVirtualAddress const&);
public:
    bool const& get_iat_written() const;
    void set_iat_written(bool const&);
public:
    explicit SgAsmPEImportItem(SgAsmPEImportItemList *parent);
    explicit SgAsmPEImportItem(SgAsmPEImportDirectory*);
    SgAsmPEImportItem(SgAsmPEImportDirectory*, const std::string &name, unsigned hint=0);
    SgAsmPEImportItem(SgAsmPEImportDirectory*, const unsigned ordinal);
 
    virtual void dump(FILE*, const char *prefix, ssize_t idx) const;
 
    size_t hintNameRequiredSize() const;
 
    Rose::BinaryAnalysis::Address get_iatEntryVa() const;
 
private:
    void initFromParent(SgAsmPEImportItemList *parent);
 
    // Deprecated 2023-11
public:
    size_t hintname_required_size() const ROSE_DEPRECATED("use hintNameRequiredSize");
    Rose::BinaryAnalysis::Address get_iat_entry_va() const ROSE_DEPRECATED("use get_iatEntryVa");
public:
    virtual ~SgAsmPEImportItem();
 
public:
    SgAsmPEImportItem();
 
protected:
    void initializeProperties();
#endif // SgAsmPEImportItem_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmPEImportItem: public SgAsmExecutableFileFormat {…};
#endif // DOCUMENTATION
 
 
// SgAsmPEImportDirectoryList           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmPEImportDirectoryList);
IS_SERIALIZABLE(AsmPEImportDirectoryList);
 
#ifndef DOCUMENTATION
AsmPEImportDirectoryList.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmPEImportDirectoryList);
#if defined(SgAsmPEImportDirectoryList_HEADERS) || defined(DOCUMENTATION)
#include <sageContainer.h>
#endif // SgAsmPEImportDirectoryList_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmPEImportDirectoryList: public SgAsmExecutableFileFormat {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPEImportDirectoryList.setDataPrototype(
        "SgAsmPEImportDirectoryPtrList", "vector", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmPEImportDirectoryList);
#if defined(SgAsmPEImportDirectoryList_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmPEImportDirectoryList -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmPEImportDirectoryList");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
        s & BOOST_SERIALIZATION_NVP(p_vector);
        debugSerializationEnd("SgAsmPEImportDirectoryList");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgAsmPEImportDirectoryPtrList const& get_vector() const;
    SgAsmPEImportDirectoryPtrList& get_vector();
    void set_vector(SgAsmPEImportDirectoryPtrList const&);
public:
    virtual ~SgAsmPEImportDirectoryList();
 
public:
    SgAsmPEImportDirectoryList();
 
protected:
    void initializeProperties();
#endif // SgAsmPEImportDirectoryList_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmPEImportDirectoryList: public SgAsmExecutableFileFormat {…};
#endif // DOCUMENTATION
 
 
// SgAsmPEImportDirectory           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmPEImportDirectory);
IS_SERIALIZABLE(AsmPEImportDirectory);
 
#ifndef DOCUMENTATION
AsmPEImportDirectory.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmPEImportDirectory);
#if defined(SgAsmPEImportDirectory_HEADERS) || defined(DOCUMENTATION)
#include <Rose/BinaryAnalysis/Address.h>
#include <Rose/BinaryAnalysis/AddressIntervalSet.h>
#include <Rose/BinaryAnalysis/RelativeVirtualAddress.h>
#include <sageContainer.h>
 
#ifdef ROSE_SgAsmPEImportDirectory_IMPL
#include <SgAsmGenericString.h>
#include <SgAsmPEImportItemList.h>
#endif
#endif // SgAsmPEImportDirectory_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmPEImportDirectory: public SgAsmExecutableFileFormat {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPEImportDirectory.setDataPrototype(
        "SgAsmGenericString*", "dllName", "= nullptr",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPEImportDirectory.setDataPrototype(
        "Rose::BinaryAnalysis::RelativeVirtualAddress", "dllNameRva", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPEImportDirectory.setDataPrototype(
        "size_t", "dll_name_nalloc", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPEImportDirectory.setDataPrototype(
        "time_t", "time", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPEImportDirectory.setDataPrototype(
        "unsigned", "forwarder_chain", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPEImportDirectory.setDataPrototype(
        "Rose::BinaryAnalysis::RelativeVirtualAddress", "ilt_rva", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPEImportDirectory.setDataPrototype(
        "size_t", "ilt_nalloc", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPEImportDirectory.setDataPrototype(
        "Rose::BinaryAnalysis::RelativeVirtualAddress", "iat_rva", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPEImportDirectory.setDataPrototype(
        "size_t", "iat_nalloc", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPEImportDirectory.setDataPrototype(
        "SgAsmPEImportItemList*", "imports", "= createAndParent<SgAsmPEImportItemList>(this)",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmPEImportDirectory);
#if defined(SgAsmPEImportDirectory_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmPEImportDirectory -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmPEImportDirectory");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
        s & BOOST_SERIALIZATION_NVP(p_dllName);
        s & BOOST_SERIALIZATION_NVP(p_dllNameRva);
        s & BOOST_SERIALIZATION_NVP(p_dll_name_nalloc);
        s & BOOST_SERIALIZATION_NVP(p_time);
        s & BOOST_SERIALIZATION_NVP(p_forwarder_chain);
        s & BOOST_SERIALIZATION_NVP(p_ilt_rva);
        s & BOOST_SERIALIZATION_NVP(p_ilt_nalloc);
        s & BOOST_SERIALIZATION_NVP(p_iat_rva);
        s & BOOST_SERIALIZATION_NVP(p_iat_nalloc);
        s & BOOST_SERIALIZATION_NVP(p_imports);
        debugSerializationEnd("SgAsmPEImportDirectory");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
    // Local types
public:
#ifdef _MSC_VER
# pragma pack (1)
#endif
    struct PEImportDirectory_disk {
        uint32_t ilt_rva;               /* 0x00 Import Lookup Table RVA */
        uint32_t time;                  /* 0x04 Zero until the image is bound, then time stamp of the DLL */
        uint32_t forwarder_chain;       /* 0x08 Index of the first forwarder chain */
        uint32_t dll_name_rva;          /* 0x0c address of NUL-terminated DLL name */
        uint32_t iat_rva;               /* 0x10 Import Address Table (Thunk Table) RVA */
    }                                       /* 0x14 */
    struct PEImportDirectory_disk {…};
#if !defined(SWIG) && !defined(_MSC_VER)
    __attribute__((packed))
#endif
    ;
#ifdef _MSC_VER
# pragma pack ()
#endif
 
    // Properties
public:
public:
    SgAsmGenericString* const& get_dllName() const;
    void set_dllName(SgAsmGenericString* const&);
public:
    Rose::BinaryAnalysis::RelativeVirtualAddress const& get_dllNameRva() const;
    Rose::BinaryAnalysis::RelativeVirtualAddress& get_dllNameRva();
    void set_dllNameRva(Rose::BinaryAnalysis::RelativeVirtualAddress const&);
public:
    size_t const& get_dll_name_nalloc() const;
    void set_dll_name_nalloc(size_t const&);
public:
    time_t const& get_time() const;
    void set_time(time_t const&);
public:
    unsigned const& get_forwarder_chain() const;
    void set_forwarder_chain(unsigned const&);
public:
    Rose::BinaryAnalysis::RelativeVirtualAddress const& get_ilt_rva() const;
    Rose::BinaryAnalysis::RelativeVirtualAddress& get_ilt_rva();
    void set_ilt_rva(Rose::BinaryAnalysis::RelativeVirtualAddress const&);
public:
    size_t const& get_ilt_nalloc() const;
    void set_ilt_nalloc(size_t const&);
public:
    Rose::BinaryAnalysis::RelativeVirtualAddress const& get_iat_rva() const;
    Rose::BinaryAnalysis::RelativeVirtualAddress& get_iat_rva();
    void set_iat_rva(Rose::BinaryAnalysis::RelativeVirtualAddress const&);
public:
    size_t const& get_iat_nalloc() const;
    void set_iat_nalloc(size_t const&);
public:
    SgAsmPEImportItemList* const& get_imports() const;
    void set_imports(SgAsmPEImportItemList* const&);
    // Functions
public:
    explicit SgAsmPEImportDirectory(SgAsmPEImportSection *isec, const std::string &dll_name="");
 
    SgAsmPEImportDirectory *parse(Rose::BinaryAnalysis::Address va, bool isLastEntry);
 
    size_t reallocate(Rose::BinaryAnalysis::RelativeVirtualAddress starting_rva);
 
    void *encode(SgAsmPEImportDirectory::PEImportDirectory_disk*) const;
    virtual void unparse(std::ostream&, const SgAsmPEImportSection*, size_t idx) const;
    virtual void dump(FILE*, const char *prefix, ssize_t idx) const;
 
    size_t iatRequiredSize() const;
 
    int findImportItem(const SgAsmPEImportItem *item, int hint=0) const;
 
    size_t hintNameTableExtent(Rose::BinaryAnalysis::AddressIntervalSet &extent/*in,out*/) const;
 
private:
    void parse_ilt_iat(const Rose::BinaryAnalysis::RelativeVirtualAddress &table_start, bool assume_bound);
    void unparse_ilt_iat(std::ostream&,const Rose::BinaryAnalysis::RelativeVirtualAddress &table_start, bool assume_bound,
                         size_t nalloc) const;
 
    // Deprecated 2023-11
public:
    SgAsmGenericString* get_dll_name() const ROSE_DEPRECATED("use get_dllName");
    void set_dll_name(SgAsmGenericString*) ROSE_DEPRECATED("use set_dllName");
    const Rose::BinaryAnalysis::RelativeVirtualAddress& get_dll_name_rva() const ROSE_DEPRECATED("use get_dllNameRva");
    Rose::BinaryAnalysis::RelativeVirtualAddress& get_dll_name_rva() ROSE_DEPRECATED("use get_dllNameRva");
    void set_dll_name_rva(const Rose::BinaryAnalysis::RelativeVirtualAddress&) ROSE_DEPRECATED("use set_dllNameRva");
    size_t iat_required_size() const ROSE_DEPRECATED("use iatRequiredSize");
    int find_import_item(const SgAsmPEImportItem*, int=0) const ROSE_DEPRECATED("use findImportItem");
    size_t hintname_table_extent(Rose::BinaryAnalysis::AddressIntervalSet&) const ROSE_DEPRECATED("use hintNameTableExtent");
public:
    virtual ~SgAsmPEImportDirectory();
 
public:
    SgAsmPEImportDirectory();
 
protected:
    void initializeProperties();
#endif // SgAsmPEImportDirectory_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmPEImportDirectory: public SgAsmExecutableFileFormat {…};
#endif // DOCUMENTATION
 
 
// SgAsmPEFileHeader           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmPEFileHeader);
IS_SERIALIZABLE(AsmPEFileHeader);
 
#ifndef DOCUMENTATION
AsmPEFileHeader.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmPEFileHeader);
#if defined(SgAsmPEFileHeader_HEADERS) || defined(DOCUMENTATION)
#include <Rose/BinaryAnalysis/Address.h>
#include <Rose/BinaryAnalysis/RelativeVirtualAddress.h>
 
#ifdef ROSE_SgAsmPEFileHeader_IMPL
#include <SgAsmCoffSymbolTable.h>
#include <SgAsmPERVASizePairList.h>
#include <SgAsmPESectionTable.h>
#endif
#endif // SgAsmPEFileHeader_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmPEFileHeader: public SgAsmGenericHeader {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPEFileHeader.setDataPrototype(
        "unsigned", "e_cpu_type", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPEFileHeader.setDataPrototype(
        "unsigned", "e_nsections", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPEFileHeader.setDataPrototype(
        "unsigned", "e_time", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPEFileHeader.setDataPrototype(
        "Rose::BinaryAnalysis::Address", "e_coff_symtab", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPEFileHeader.setDataPrototype(
        "Rose::BinaryAnalysis::Address", "e_nt_hdr_size", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPEFileHeader.setDataPrototype(
        "unsigned", "e_coff_nsyms", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPEFileHeader.setDataPrototype(
        "unsigned", "e_flags", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPEFileHeader.setDataPrototype(
        "unsigned", "e_opt_magic", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPEFileHeader.setDataPrototype(
        "unsigned", "e_lmajor", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPEFileHeader.setDataPrototype(
        "unsigned", "e_lminor", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPEFileHeader.setDataPrototype(
        "unsigned", "e_code_size", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPEFileHeader.setDataPrototype(
        "unsigned", "e_data_size", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPEFileHeader.setDataPrototype(
        "unsigned", "e_bss_size", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPEFileHeader.setDataPrototype(
        "Rose::BinaryAnalysis::RelativeVirtualAddress", "e_code_rva", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPEFileHeader.setDataPrototype(
        "Rose::BinaryAnalysis::RelativeVirtualAddress", "e_data_rva", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPEFileHeader.setDataPrototype(
        "unsigned", "e_section_align", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPEFileHeader.setDataPrototype(
        "unsigned", "e_file_align", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPEFileHeader.setDataPrototype(
        "unsigned", "e_os_major", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPEFileHeader.setDataPrototype(
        "unsigned", "e_os_minor", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPEFileHeader.setDataPrototype(
        "unsigned", "e_user_major", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPEFileHeader.setDataPrototype(
        "unsigned", "e_user_minor", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPEFileHeader.setDataPrototype(
        "unsigned", "e_subsys_major", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPEFileHeader.setDataPrototype(
        "unsigned", "e_subsys_minor", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPEFileHeader.setDataPrototype(
        "unsigned", "e_reserved9", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPEFileHeader.setDataPrototype(
        "unsigned", "e_image_size", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPEFileHeader.setDataPrototype(
        "unsigned", "e_header_size", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPEFileHeader.setDataPrototype(
        "unsigned", "e_file_checksum", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPEFileHeader.setDataPrototype(
        "unsigned", "e_subsystem", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPEFileHeader.setDataPrototype(
        "unsigned", "e_dll_flags", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPEFileHeader.setDataPrototype(
        "unsigned", "e_stack_reserve_size", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPEFileHeader.setDataPrototype(
        "unsigned", "e_stack_commit_size", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPEFileHeader.setDataPrototype(
        "unsigned", "e_heap_reserve_size", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPEFileHeader.setDataPrototype(
        "unsigned", "e_heap_commit_size", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPEFileHeader.setDataPrototype(
        "unsigned", "e_loader_flags", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPEFileHeader.setDataPrototype(
        "unsigned", "e_num_rvasize_pairs", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPEFileHeader.setDataPrototype(
        "SgAsmPERVASizePairList*", "rvaSizePairs", "= nullptr",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPEFileHeader.setDataPrototype(
        "SgAsmPESectionTable*", "sectionTable", "= nullptr",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPEFileHeader.setDataPrototype(
        "SgAsmCoffSymbolTable*", "coffSymbolTable", "= nullptr",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmPEFileHeader);
#if defined(SgAsmPEFileHeader_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmPEFileHeader -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmPEFileHeader");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmGenericHeader);
        s & BOOST_SERIALIZATION_NVP(p_e_cpu_type);
        s & BOOST_SERIALIZATION_NVP(p_e_nsections);
        s & BOOST_SERIALIZATION_NVP(p_e_time);
        s & BOOST_SERIALIZATION_NVP(p_e_coff_symtab);
        s & BOOST_SERIALIZATION_NVP(p_e_nt_hdr_size);
        s & BOOST_SERIALIZATION_NVP(p_e_coff_nsyms);
        s & BOOST_SERIALIZATION_NVP(p_e_flags);
        s & BOOST_SERIALIZATION_NVP(p_e_opt_magic);
        s & BOOST_SERIALIZATION_NVP(p_e_lmajor);
        s & BOOST_SERIALIZATION_NVP(p_e_lminor);
        s & BOOST_SERIALIZATION_NVP(p_e_code_size);
        s & BOOST_SERIALIZATION_NVP(p_e_data_size);
        s & BOOST_SERIALIZATION_NVP(p_e_bss_size);
        s & BOOST_SERIALIZATION_NVP(p_e_code_rva);
        s & BOOST_SERIALIZATION_NVP(p_e_data_rva);
        s & BOOST_SERIALIZATION_NVP(p_e_section_align);
        s & BOOST_SERIALIZATION_NVP(p_e_file_align);
        s & BOOST_SERIALIZATION_NVP(p_e_os_major);
        s & BOOST_SERIALIZATION_NVP(p_e_os_minor);
        s & BOOST_SERIALIZATION_NVP(p_e_user_major);
        s & BOOST_SERIALIZATION_NVP(p_e_user_minor);
        s & BOOST_SERIALIZATION_NVP(p_e_subsys_major);
        s & BOOST_SERIALIZATION_NVP(p_e_subsys_minor);
        s & BOOST_SERIALIZATION_NVP(p_e_reserved9);
        s & BOOST_SERIALIZATION_NVP(p_e_image_size);
        s & BOOST_SERIALIZATION_NVP(p_e_header_size);
        s & BOOST_SERIALIZATION_NVP(p_e_file_checksum);
        s & BOOST_SERIALIZATION_NVP(p_e_subsystem);
        s & BOOST_SERIALIZATION_NVP(p_e_dll_flags);
        s & BOOST_SERIALIZATION_NVP(p_e_stack_reserve_size);
        s & BOOST_SERIALIZATION_NVP(p_e_stack_commit_size);
        s & BOOST_SERIALIZATION_NVP(p_e_heap_reserve_size);
        s & BOOST_SERIALIZATION_NVP(p_e_heap_commit_size);
        s & BOOST_SERIALIZATION_NVP(p_e_loader_flags);
        s & BOOST_SERIALIZATION_NVP(p_e_num_rvasize_pairs);
        s & BOOST_SERIALIZATION_NVP(p_rvaSizePairs);
        s & BOOST_SERIALIZATION_NVP(p_sectionTable);
        s & BOOST_SERIALIZATION_NVP(p_coffSymbolTable);
        debugSerializationEnd("SgAsmPEFileHeader");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
    // Local types
public:
#ifdef _MSC_VER
# pragma pack (1)
#endif
    /* File format of a PE File Header. All fields are little endian. */
    struct PEFileHeader_disk {
        unsigned char e_magic[4];       /* 0x00 magic number "PE\0\0" */
        uint16_t    e_cpu_type;         /* 0x04 e.g., 0x014c = Intel 386 */
        uint16_t    e_nsections;        /* 0x06 number of sections defined in the Section Table */
        uint32_t    e_time;             /* 0x08 time and date file was created or modified by the linker */
        uint32_t    e_coff_symtab;      /* 0x0c offset to COFF symbol table */
        uint32_t    e_coff_nsyms;       /* 0x10 number of symbols in COFF symbol table */
        uint16_t    e_nt_hdr_size;      /* 0x14 num remaining bytes in the header following the 'flags' field */
        uint16_t    e_flags;            /* 0x16 Bit flags: exe file, program/library image, fixed address, etc. */
    }                                       /* 0x18 */
    struct PEFileHeader_disk {…};
#if !defined(SWIG) && !defined(_MSC_VER)
    __attribute__((packed))
#endif
    ;
 
    struct PE32OptHeader_disk {
        uint16_t    e_opt_magic;        /* 0x18 magic number */
        uint16_t    e_lmajor;           /* 0x1a linker version */
        uint16_t    e_lminor;           /* 0x1c */
        uint16_t    e_code_size;        /* 0x1e Size of .text or sum of all code sections */
        uint32_t    e_data_size;        /* 0x20 Sum size of initialized data */
        uint32_t    e_bss_size;         /* 0x24 Sum size of uninitialized data */
        uint32_t    e_entrypoint_rva;   /* 0x28 RVA="relative virtual address"; relative to 'image_base', below */
        uint32_t    e_code_rva;         /* 0x2c Addr relative to image base for code section when memory mapped */
        uint32_t    e_data_rva;         /* 0x30 Address relative to image base for data section */
        uint32_t    e_image_base;       /* 0x34 Virt base of image (first byte of file, DOS header). 64k aligned */
        uint32_t    e_section_align;    /* 0x38 Alignment of sections in memory. Power of two 512<=x<=256M */
        uint32_t    e_file_align;       /* 0x3c Alignment factor (in bytes) for image pages */
        uint16_t    e_os_major;         /* 0x40 OS version number required to run this image */
        uint16_t    e_os_minor;         /* 0x42 */
        uint16_t    e_user_major;       /* 0x44 User-specified for differentiating between image revs */
        uint16_t    e_user_minor;       /* 0x46 */
        uint16_t    e_subsys_major;     /* 0x48 Subsystem version number */
        uint16_t    e_subsys_minor;     /* 0x4a */
        uint32_t    e_reserved9;        /* 0x4c */
        uint32_t    e_image_size;       /* 0x50 Virtual size of the image inc. all headers; section_align */
        uint32_t    e_header_size;      /* 0x54 Total header size (DOS Header + PE Header + Section table */
        uint32_t    e_file_checksum;    /* 0x58 Checksum for entire file; Set to zero by the linker */
        uint16_t    e_subsystem;        /* 0x5c Native, WindowsGUI, WindowsCharacter, OS/2 Character, etc. */
        uint16_t    e_dll_flags;        /* 0x5e Bit flags for library init/terminate per process or thread */
        uint32_t    e_stack_reserve_size;/*0x60 Virtual mem reserved for stack; non-committed pages are guards */
        uint32_t    e_stack_commit_size;/* 0x64 Size of valid stack; other pages are guards; <=stack_reserve_size*/
        uint32_t    e_heap_reserve_size;/* 0x68 Size (bytes) of local heap to reserve */
        uint32_t    e_heap_commit_size; /* 0x6c Size (bytes) of valid local heap */
        uint32_t    e_loader_flags;     /* 0x70 Reserved, must be zero */
        uint32_t    e_num_rvasize_pairs;/* 0x74 Num RVASizePair entries that follow this member; part of header */
    }                                       /* 0x78 */
    struct PE32OptHeader_disk {…};
#if !defined(SWIG) && !defined(_MSC_VER)
    __attribute__((packed))
#endif
    ;
 
    struct PE64OptHeader_disk {
        uint16_t    e_opt_magic;        /* 0x18 */
        uint16_t    e_lmajor;           /* 0x1a */
        uint16_t    e_lminor;           /* 0x1c */
        uint16_t    e_code_size;        /* 0x1e */
        uint32_t    e_data_size;        /* 0x20 */
        uint32_t    e_bss_size;         /* 0x24 */
        uint32_t    e_entrypoint_rva;   /* 0x28 */
        uint32_t    e_code_rva;         /* 0x2c */
        // uint32_t  e_data_rva;             /* Not present in PE32+ */
        uint64_t    e_image_base;       /* 0x30 */
        uint32_t    e_section_align;    /* 0x38 */
        uint32_t    e_file_align;       /* 0x3c */
        uint16_t    e_os_major;         /* 0x40 */
        uint16_t    e_os_minor;         /* 0x42 */
        uint16_t    e_user_major;       /* 0x44 */
        uint16_t    e_user_minor;       /* 0x46 */
        uint16_t    e_subsys_major;     /* 0x48 */
        uint16_t    e_subsys_minor;     /* 0x4a */
        uint32_t    e_reserved9;        /* 0x4c */
        uint32_t    e_image_size;       /* 0x50 */
        uint32_t    e_header_size;      /* 0x54 */
        uint32_t    e_file_checksum;    /* 0x58 */
        uint16_t    e_subsystem;        /* 0x5c */
        uint16_t    e_dll_flags;        /* 0x5e */
        uint64_t    e_stack_reserve_size;/*0x60 */
        uint64_t    e_stack_commit_size;/* 0x68 */
        uint64_t    e_heap_reserve_size;/* 0x70 */
        uint64_t    e_heap_commit_size; /* 0x78 */
        uint32_t    e_loader_flags;     /* 0x80 */
        uint32_t    e_num_rvasize_pairs;/* 0x84 */
    }                                       /* 0x88 */
    struct PE64OptHeader_disk {…};
#if !defined(SWIG) && !defined(_MSC_VER)
    __attribute__((packed))
#endif
        ;
#ifdef _MSC_VER
# pragma pack ()
#endif
 
    /* Bit flags for the PE header 'flags' member */
    enum HeaderFlags {
        HF_PROGRAM          = 0x0000,       /* Program image (no non-reserved bits set) */
        HF_EXECUTABLE       = 0x0002,       /* Clear indicates can't load: link errors or incrementally linked */
        HF_FIXED            = 0x0200,       /* Image *must* be loaded at image_base address or error */
        HF_LIBRARY          = 0x2000,       /* Library image */
        HF_RESERVED_MASK    = 0xddfd        /* Reserved bits */
    };
 
    /* Values for the PE header 'subsystem' member */
    enum Subsystem {
        HF_SPEC_UNKNOWN     = 0x0000,       /* Specified as 'unknown' in the file */
        HF_NATIVE           = 0x0001,       /* Native */
        HF_WINGUI           = 0x0002,       /* Windows GUI */
        HF_WINCHAR          = 0x0003,       /* Windows character */
        HF_OS2CHAR          = 0x0005,       /* OS/2 character */
        HF_POSIX            = 0x0007        /* POSIX character */
    };
 
    /* Bit flags for the PE header 'dll_flags' member */
    enum DLLFlags {
        DLL_PROC_INIT       = 0x0001,       /* Per-process library initialization */
        DLL_PROC_TERM       = 0x0002,       /* Per-process library termination */
        DLL_THRD_INIT       = 0x0004,       /* Per-thread library initialization */
        DLL_THRD_TERM       = 0x0008,       /* Per-thread library termination */
        DLL_RESERVED_MASK   = 0xfff0        /* Reserved bits */
    };
 
    enum PairPurpose {              // Values are important
        PAIR_EXPORTS            = 0,
        PAIR_IMPORTS            = 1,
        PAIR_RESOURCES          = 2,
        PAIR_EXCEPTIONS         = 3,
        PAIR_CERTIFICATES       = 4,
        PAIR_BASERELOCS         = 5,
        PAIR_DEBUG              = 6,
        PAIR_ARCHITECTURE       = 7,
        PAIR_GLOBALPTR          = 8,
        PAIR_TLS                = 9,    // Thread local storage
        PAIR_LOADCONFIG         = 10,
        PAIR_BOUNDIMPORT        = 11,
        PAIR_IAT                = 12,   // Import address table
        PAIR_DELAYIMPORT        = 13,   // Delay import descriptor
        PAIR_CLRRUNTIME         = 14,   // CLR(?) runtime header
        PAIR_RESERVED15         = 15    // Reserved (always zero according to specification)
    };
    enum PairPurpose {              // Values are important {…};
 
    // Properties
public:
public:
    unsigned const& get_e_cpu_type() const;
    void set_e_cpu_type(unsigned const&);
public:
    unsigned const& get_e_nsections() const;
    void set_e_nsections(unsigned const&);
public:
    unsigned const& get_e_time() const;
    void set_e_time(unsigned const&);
public:
    Rose::BinaryAnalysis::Address const& get_e_coff_symtab() const;
    void set_e_coff_symtab(Rose::BinaryAnalysis::Address const&);
public:
    Rose::BinaryAnalysis::Address const& get_e_nt_hdr_size() const;
    void set_e_nt_hdr_size(Rose::BinaryAnalysis::Address const&);
public:
    unsigned const& get_e_coff_nsyms() const;
    void set_e_coff_nsyms(unsigned const&);
public:
    unsigned const& get_e_flags() const;
    void set_e_flags(unsigned const&);
public:
    unsigned const& get_e_opt_magic() const;
    void set_e_opt_magic(unsigned const&);
public:
    unsigned const& get_e_lmajor() const;
    void set_e_lmajor(unsigned const&);
public:
    unsigned const& get_e_lminor() const;
    void set_e_lminor(unsigned const&);
public:
    unsigned const& get_e_code_size() const;
    void set_e_code_size(unsigned const&);
public:
    unsigned const& get_e_data_size() const;
    void set_e_data_size(unsigned const&);
public:
    unsigned const& get_e_bss_size() const;
    void set_e_bss_size(unsigned const&);
public:
    Rose::BinaryAnalysis::RelativeVirtualAddress const& get_e_code_rva() const;
    Rose::BinaryAnalysis::RelativeVirtualAddress& get_e_code_rva();
    void set_e_code_rva(Rose::BinaryAnalysis::RelativeVirtualAddress const&);
public:
    Rose::BinaryAnalysis::RelativeVirtualAddress const& get_e_data_rva() const;
    Rose::BinaryAnalysis::RelativeVirtualAddress& get_e_data_rva();
    void set_e_data_rva(Rose::BinaryAnalysis::RelativeVirtualAddress const&);
public:
    unsigned const& get_e_section_align() const;
    void set_e_section_align(unsigned const&);
public:
    unsigned const& get_e_file_align() const;
    void set_e_file_align(unsigned const&);
public:
    unsigned const& get_e_os_major() const;
    void set_e_os_major(unsigned const&);
public:
    unsigned const& get_e_os_minor() const;
    void set_e_os_minor(unsigned const&);
public:
    unsigned const& get_e_user_major() const;
    void set_e_user_major(unsigned const&);
public:
    unsigned const& get_e_user_minor() const;
    void set_e_user_minor(unsigned const&);
public:
    unsigned const& get_e_subsys_major() const;
    void set_e_subsys_major(unsigned const&);
public:
    unsigned const& get_e_subsys_minor() const;
    void set_e_subsys_minor(unsigned const&);
public:
    unsigned const& get_e_reserved9() const;
    void set_e_reserved9(unsigned const&);
public:
    unsigned const& get_e_image_size() const;
    void set_e_image_size(unsigned const&);
public:
    unsigned const& get_e_header_size() const;
    void set_e_header_size(unsigned const&);
public:
    unsigned const& get_e_file_checksum() const;
    void set_e_file_checksum(unsigned const&);
public:
    unsigned const& get_e_subsystem() const;
    void set_e_subsystem(unsigned const&);
public:
    unsigned const& get_e_dll_flags() const;
    void set_e_dll_flags(unsigned const&);
public:
    unsigned const& get_e_stack_reserve_size() const;
    void set_e_stack_reserve_size(unsigned const&);
public:
    unsigned const& get_e_stack_commit_size() const;
    void set_e_stack_commit_size(unsigned const&);
public:
    unsigned const& get_e_heap_reserve_size() const;
    void set_e_heap_reserve_size(unsigned const&);
public:
    unsigned const& get_e_heap_commit_size() const;
    void set_e_heap_commit_size(unsigned const&);
public:
    unsigned const& get_e_loader_flags() const;
    void set_e_loader_flags(unsigned const&);
public:
    unsigned const& get_e_num_rvasize_pairs() const;
    void set_e_num_rvasize_pairs(unsigned const&);
public:
    SgAsmPERVASizePairList* const& get_rvaSizePairs() const;
    void set_rvaSizePairs(SgAsmPERVASizePairList* const&);
public:
    SgAsmPESectionTable* const& get_sectionTable() const;
    void set_sectionTable(SgAsmPESectionTable* const&);
public:
    SgAsmCoffSymbolTable* const& get_coffSymbolTable() const;
    void set_coffSymbolTable(SgAsmCoffSymbolTable* const&);
    // Functions
public:
    explicit SgAsmPEFileHeader(SgAsmGenericFile*);
 
    virtual const char* formatName() const override;
 
    static bool isPe(SgAsmGenericFile*);
 
    std::string rvaSizePairName(PairPurpose, const char **short_name);
 
    void set_rvaSizePair(PairPurpose, SgAsmPESection*);
 
    void updateRvaSizePairs();
 
    void addRvaSizePairs();
 
    virtual SgAsmPEFileHeader *parse() override;
    virtual bool reallocate() override;
    virtual void unparse(std::ostream&) const override;
    virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
    void createTableSections();
 
    /* Loader memory maps */
    Rose::BinaryAnalysis::MemoryMap::Ptr get_loaderMap() const;
    void set_loaderMap(const Rose::BinaryAnalysis::MemoryMap::Ptr&);
 
private:
    void *encode(SgAsmPEFileHeader::PEFileHeader_disk*) const;
    void *encode(SgAsmPEFileHeader::PE32OptHeader_disk*) const;
    void *encode(SgAsmPEFileHeader::PE64OptHeader_disk*) const;
    Rose::BinaryAnalysis::MemoryMap::Ptr p_loader_map;
 
    // Deprecated 2023-11
public:
    SgAsmPERVASizePairList* get_rvasize_pairs() const ROSE_DEPRECATED("use get_rvaSizePairs");
    void set_rvasize_pairs(SgAsmPERVASizePairList*) ROSE_DEPRECATED("use set_rvaSizePairs");
    SgAsmPESectionTable* get_section_table() const ROSE_DEPRECATED("use get_sectionTable");
    void set_section_table(SgAsmPESectionTable*) ROSE_DEPRECATED("use set_sectionTable");
    SgAsmCoffSymbolTable* get_coff_symtab() const ROSE_DEPRECATED("use get_coffSymbolTable");
    void set_coff_symtab(SgAsmCoffSymbolTable*) ROSE_DEPRECATED("use set_coffSymbolTable");
    virtual const char *format_name() const override ROSE_DEPRECATED("use formatName");
    static bool is_PE (SgAsmGenericFile*) ROSE_DEPRECATED("use isPe");
    std::string rvasize_pair_name(PairPurpose, const char**) ROSE_DEPRECATED("use rvaSizePairName");
    void set_rvasize_pair(PairPurpose, SgAsmPESection*) ROSE_DEPRECATED("use set_rvaSizePair");
    void update_rvasize_pairs() ROSE_DEPRECATED("use updateRvaSizePairs");
    void add_rvasize_pairs() ROSE_DEPRECATED("use addRvaSizePairs");
    void create_table_sections() ROSE_DEPRECATED("use createTableSections");
    Rose::BinaryAnalysis::MemoryMap::Ptr get_loader_map() const ROSE_DEPRECATED("use get_loaderMap");
    void set_loader_map(const Rose::BinaryAnalysis::MemoryMap::Ptr&) ROSE_DEPRECATED("use set_loaderMap");
public:
    virtual ~SgAsmPEFileHeader();
 
public:
    SgAsmPEFileHeader();
 
protected:
    void initializeProperties();
#endif // SgAsmPEFileHeader_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmPEFileHeader: public SgAsmGenericHeader {…};
#endif // DOCUMENTATION
 
 
// SgAsmPEExportSection           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmPEExportSection);
IS_SERIALIZABLE(AsmPEExportSection);
 
#ifndef DOCUMENTATION
AsmPEExportSection.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmPEExportSection);
#if defined(SgAsmPEExportSection_HEADERS) || defined(DOCUMENTATION)
#ifdef ROSE_SgAsmPEExportSection_IMPL
#include <SgAsmPEExportDirectory.h>
#include <SgAsmPEExportEntryList.h>
#endif
#endif // SgAsmPEExportSection_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmPEExportSection: public SgAsmPESection {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPEExportSection.setDataPrototype(
        "SgAsmPEExportDirectory*", "exportDirectory", "= nullptr",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPEExportSection.setDataPrototype(
        "SgAsmPEExportEntryList*", "exports", "= createAndParent<SgAsmPEExportEntryList>(this)",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmPEExportSection);
#if defined(SgAsmPEExportSection_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmPEExportSection -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmPEExportSection");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmPESection);
        s & BOOST_SERIALIZATION_NVP(p_exportDirectory);
        s & BOOST_SERIALIZATION_NVP(p_exports);
        debugSerializationEnd("SgAsmPEExportSection");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgAsmPEExportDirectory* const& get_exportDirectory() const;
    void set_exportDirectory(SgAsmPEExportDirectory* const&);
public:
    SgAsmPEExportEntryList* const& get_exports() const;
    void set_exports(SgAsmPEExportEntryList* const&);
public:
    typedef uint32_t ExportAddress_disk;
 
    typedef uint32_t ExportNamePtr_disk;
 
    typedef uint16_t ExportOrdinal_disk;
 
    SgAsmPEExportSection(SgAsmPEFileHeader*);
    virtual SgAsmPEExportSection *parse() override;
    virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
    void addEntry(SgAsmPEExportEntry*);
 
    // Deprecated 2023-11
public:
    SgAsmPEExportDirectory* get_export_dir() const ROSE_DEPRECATED("use get_exportDirectory");
    void set_export_dir(SgAsmPEExportDirectory*) ROSE_DEPRECATED("use set_exportDirectory");
    void add_entry(SgAsmPEExportEntry*) ROSE_DEPRECATED("use addEntry");
public:
    virtual ~SgAsmPEExportSection();
 
public:
    SgAsmPEExportSection();
 
protected:
    void initializeProperties();
#endif // SgAsmPEExportSection_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmPEExportSection: public SgAsmPESection {…};
#endif // DOCUMENTATION
 
 
// SgAsmPESection           -- MACHINE GENERATED; DO NOT MODIFY --
 
#ifndef DOCUMENTATION
AstNodeClass& AsmPESection = nonTerminalConstructor(
    "AsmPESection",
    *this,
    "AsmPESection",
    "AsmPESectionTag",
    SubclassListBuilder()
        | AsmPEExportSection
        | AsmPEImportSection
        | AsmPEStringSection
    , true);
assert(AsmPESection.associatedGrammar != nullptr);
AsmPESection.setCppCondition("!defined(DOCUMENTATION)");
AsmPESection.isBoostSerializable(true);
AsmPESection.setAutomaticGenerationOfConstructor(false);
AsmPESection.setAutomaticGenerationOfDestructor(false);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
AsmPESection.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmPESection);
#if defined(SgAsmPESection_HEADERS) || defined(DOCUMENTATION)
#ifdef ROSE_SgAsmPESection_IMPL
#include <SgAsmPESectionTableEntry.h>
#endif
#endif // SgAsmPESection_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmPESection: public SgAsmGenericSection {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPESection.setDataPrototype(
        "SgAsmPESectionTableEntry*", "section_entry", "= nullptr",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmPESection);
#if defined(SgAsmPESection_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmPESection -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmPESection");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmGenericSection);
        s & BOOST_SERIALIZATION_NVP(p_section_entry);
        debugSerializationEnd("SgAsmPESection");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgAsmPESectionTableEntry* const& get_section_entry() const;
    void set_section_entry(SgAsmPESectionTableEntry* const&);
public:
    explicit SgAsmPESection(SgAsmPEFileHeader*);
 
    SgAsmPESection *initFromSectionTable(SgAsmPESectionTableEntry *entry, int id);
    virtual bool reallocate() override;
    virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
 
    // Deprecated 2023-11
public:
    SgAsmPESection *init_from_section_table(SgAsmPESectionTableEntry*, int) ROSE_DEPRECATED("use initFromSectionTable");
public:
    virtual ~SgAsmPESection();
 
public:
    SgAsmPESection();
 
protected:
    void initializeProperties();
#endif // SgAsmPESection_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmPESection: public SgAsmGenericSection {…};
#endif // DOCUMENTATION
 
 
// SgAsmPEExportEntryList           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmPEExportEntryList);
IS_SERIALIZABLE(AsmPEExportEntryList);
 
#ifndef DOCUMENTATION
AsmPEExportEntryList.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmPEExportEntryList);
#if defined(SgAsmPEExportEntryList_HEADERS) || defined(DOCUMENTATION)
#include <sageContainer.h>
#endif // SgAsmPEExportEntryList_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmPEExportEntryList: public SgAsmExecutableFileFormat {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPEExportEntryList.setDataPrototype(
        "SgAsmPEExportEntryPtrList", "exports", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmPEExportEntryList);
#if defined(SgAsmPEExportEntryList_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmPEExportEntryList -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmPEExportEntryList");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
        s & BOOST_SERIALIZATION_NVP(p_exports);
        debugSerializationEnd("SgAsmPEExportEntryList");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgAsmPEExportEntryPtrList const& get_exports() const;
    SgAsmPEExportEntryPtrList& get_exports();
    void set_exports(SgAsmPEExportEntryPtrList const&);
public:
    virtual ~SgAsmPEExportEntryList();
 
public:
    SgAsmPEExportEntryList();
 
protected:
    void initializeProperties();
#endif // SgAsmPEExportEntryList_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmPEExportEntryList: public SgAsmExecutableFileFormat {…};
#endif // DOCUMENTATION
 
 
// SgAsmPEExportEntry           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmPEExportEntry);
IS_SERIALIZABLE(AsmPEExportEntry);
 
#ifndef DOCUMENTATION
AsmPEExportEntry.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmPEExportEntry);
#if defined(SgAsmPEExportEntry_HEADERS) || defined(DOCUMENTATION)
#include <Rose/BinaryAnalysis/RelativeVirtualAddress.h>
#include <Sawyer/Result.h>
#endif // SgAsmPEExportEntry_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmPEExportEntry: public SgAsmExecutableFileFormat {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPEExportEntry.setDataPrototype(
        "SgAsmGenericString*", "name", "= nullptr",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPEExportEntry.setDataPrototype(
        "unsigned", "ordinal", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPEExportEntry.setDataPrototype(
        "Rose::BinaryAnalysis::RelativeVirtualAddress", "exportRva", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPEExportEntry.setDataPrototype(
        "SgAsmGenericString*", "forwarder", "= nullptr",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmPEExportEntry);
#if defined(SgAsmPEExportEntry_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmPEExportEntry -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmPEExportEntry");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
        s & BOOST_SERIALIZATION_NVP(p_name);
        s & BOOST_SERIALIZATION_NVP(p_ordinal);
        s & BOOST_SERIALIZATION_NVP(p_exportRva);
        s & BOOST_SERIALIZATION_NVP(p_forwarder);
        debugSerializationEnd("SgAsmPEExportEntry");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgAsmGenericString* const& get_name() const;
    void set_name(SgAsmGenericString*);
public:
    unsigned const& get_ordinal() const;
    void set_ordinal(unsigned const&);
public:
    Rose::BinaryAnalysis::RelativeVirtualAddress const& get_exportRva() const;
    Rose::BinaryAnalysis::RelativeVirtualAddress& get_exportRva();
    void set_exportRva(Rose::BinaryAnalysis::RelativeVirtualAddress const&);
public:
    SgAsmGenericString* const& get_forwarder() const;
    void set_forwarder(SgAsmGenericString*);
public:
    SgAsmPEExportEntry(SgAsmGenericString *name, unsigned ordinal, Rose::BinaryAnalysis::RelativeVirtualAddress export_rva,
                       SgAsmGenericString *forwarder);
    void dump(FILE *f,const char *prefix,ssize_t idx) const;
    /* Accessors. Override ROSETTA because we adjust parents. */
 
    Sawyer::Result<unsigned /*ordinal*/, std::string /*reason*/> biasedOrdinal() const;
 
    // Deprecated 2023-11
public:
    const Rose::BinaryAnalysis::RelativeVirtualAddress& get_export_rva() const ROSE_DEPRECATED("use get_exportRva");
    void set_export_rva(const Rose::BinaryAnalysis::RelativeVirtualAddress&) ROSE_DEPRECATED("use set_exportRva");
public:
    virtual ~SgAsmPEExportEntry();
 
public:
    SgAsmPEExportEntry();
 
protected:
    void initializeProperties();
#endif // SgAsmPEExportEntry_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmPEExportEntry: public SgAsmExecutableFileFormat {…};
#endif // DOCUMENTATION
 
 
// SgAsmPEExportDirectory           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmPEExportDirectory);
IS_SERIALIZABLE(AsmPEExportDirectory);
 
#ifndef DOCUMENTATION
AsmPEExportDirectory.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmPEExportDirectory);
#if defined(SgAsmPEExportDirectory_HEADERS) || defined(DOCUMENTATION)
#include <Rose/BinaryAnalysis/RelativeVirtualAddress.h>
 
#ifdef ROSE_SgAsmPEExportDirectory_IMPL
#include <SgAsmGenericString.h>
#endif
#endif // SgAsmPEExportDirectory_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmPEExportDirectory: public SgAsmExecutableFileFormat {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPEExportDirectory.setDataPrototype(
        "unsigned", "res1", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPEExportDirectory.setDataPrototype(
        "time_t", "timestamp", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPEExportDirectory.setDataPrototype(
        "unsigned", "vmajor", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPEExportDirectory.setDataPrototype(
        "unsigned", "vminor", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPEExportDirectory.setDataPrototype(
        "Rose::BinaryAnalysis::RelativeVirtualAddress", "name_rva", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPEExportDirectory.setDataPrototype(
        "unsigned", "ord_base", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPEExportDirectory.setDataPrototype(
        "size_t", "expaddr_n", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPEExportDirectory.setDataPrototype(
        "size_t", "nameptr_n", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPEExportDirectory.setDataPrototype(
        "Rose::BinaryAnalysis::RelativeVirtualAddress", "expaddr_rva", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPEExportDirectory.setDataPrototype(
        "Rose::BinaryAnalysis::RelativeVirtualAddress", "nameptr_rva", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPEExportDirectory.setDataPrototype(
        "Rose::BinaryAnalysis::RelativeVirtualAddress", "ordinals_rva", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmPEExportDirectory.setDataPrototype(
        "SgAsmGenericString*", "name", "= NULL",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmPEExportDirectory);
#if defined(SgAsmPEExportDirectory_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmPEExportDirectory -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmPEExportDirectory");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
        s & BOOST_SERIALIZATION_NVP(p_res1);
        s & BOOST_SERIALIZATION_NVP(p_timestamp);
        s & BOOST_SERIALIZATION_NVP(p_vmajor);
        s & BOOST_SERIALIZATION_NVP(p_vminor);
        s & BOOST_SERIALIZATION_NVP(p_name_rva);
        s & BOOST_SERIALIZATION_NVP(p_ord_base);
        s & BOOST_SERIALIZATION_NVP(p_expaddr_n);
        s & BOOST_SERIALIZATION_NVP(p_nameptr_n);
        s & BOOST_SERIALIZATION_NVP(p_expaddr_rva);
        s & BOOST_SERIALIZATION_NVP(p_nameptr_rva);
        s & BOOST_SERIALIZATION_NVP(p_ordinals_rva);
        s & BOOST_SERIALIZATION_NVP(p_name);
        debugSerializationEnd("SgAsmPEExportDirectory");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
    // Local types
public:
#ifdef _MSC_VER
# pragma pack (1)
#endif
    /* An Export Section begins with the Export Directory */
    struct PEExportDirectory_disk {
        uint32_t res1;         /* 0x00 Reserved, must be zero */
        uint32_t timestamp;    /* 0x04 Time that export data was created */
        uint16_t vmajor;       /* 0x08 Major version number (user defined) */
        uint16_t vminor;       /* 0x0a Minor version number (user defined) */
        uint32_t name_rva;     /* 0x0c Location of name of DLL */
        uint32_t ord_base;     /* 0x10 Starting ordinal for exports in this image (usually 1) */
        uint32_t expaddr_n;    /* 0x14 Number of entries in the export address table */
        uint32_t nameptr_n;    /* 0x18 Number of entries in the name pointer table and ordinal table */
        uint32_t expaddr_rva;  /* 0x1c Location of Export Address Table */
        uint32_t nameptr_rva;  /* 0x20 Location of Export Name Pointer Table */
        uint32_t ordinals_rva; /* 0x24 Location of Ordinal Table */
    }                               /* 0x28 */
    struct PEExportDirectory_disk {…};
#if !defined(SWIG) && !defined(_MSC_VER)
    __attribute__((packed))
#endif
    ;
#ifdef _MSC_VER
# pragma pack ()
#endif
 
    // Properties
public:
public:
    unsigned const& get_res1() const;
    void set_res1(unsigned const&);
public:
    time_t const& get_timestamp() const;
    void set_timestamp(time_t const&);
public:
    unsigned const& get_vmajor() const;
    void set_vmajor(unsigned const&);
public:
    unsigned const& get_vminor() const;
    void set_vminor(unsigned const&);
public:
    Rose::BinaryAnalysis::RelativeVirtualAddress const& get_name_rva() const;
    Rose::BinaryAnalysis::RelativeVirtualAddress& get_name_rva();
    void set_name_rva(Rose::BinaryAnalysis::RelativeVirtualAddress const&);
public:
    unsigned const& get_ord_base() const;
    void set_ord_base(unsigned const&);
public:
    size_t const& get_expaddr_n() const;
    void set_expaddr_n(size_t const&);
public:
    size_t const& get_nameptr_n() const;
    void set_nameptr_n(size_t const&);
public:
    Rose::BinaryAnalysis::RelativeVirtualAddress const& get_expaddr_rva() const;
    Rose::BinaryAnalysis::RelativeVirtualAddress& get_expaddr_rva();
    void set_expaddr_rva(Rose::BinaryAnalysis::RelativeVirtualAddress const&);
public:
    Rose::BinaryAnalysis::RelativeVirtualAddress const& get_nameptr_rva() const;
    Rose::BinaryAnalysis::RelativeVirtualAddress& get_nameptr_rva();
    void set_nameptr_rva(Rose::BinaryAnalysis::RelativeVirtualAddress const&);
public:
    Rose::BinaryAnalysis::RelativeVirtualAddress const& get_ordinals_rva() const;
    Rose::BinaryAnalysis::RelativeVirtualAddress& get_ordinals_rva();
    void set_ordinals_rva(Rose::BinaryAnalysis::RelativeVirtualAddress const&);
public:
    SgAsmGenericString* const& get_name() const;
    void set_name(SgAsmGenericString* const&);
    // Functions
public:
    explicit SgAsmPEExportDirectory(SgAsmPEExportSection*);
    void dump(FILE *f, const char *prefix, ssize_t idx) const;
public:
    virtual ~SgAsmPEExportDirectory();
 
public:
    SgAsmPEExportDirectory();
 
protected:
    void initializeProperties();
#endif // SgAsmPEExportDirectory_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmPEExportDirectory: public SgAsmExecutableFileFormat {…};
#endif // DOCUMENTATION
 
 
// SgAsmOperandList           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmOperandList);
IS_SERIALIZABLE(AsmOperandList);
 
#ifndef DOCUMENTATION
AsmOperandList.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmOperandList);
#if defined(SgAsmOperandList_HEADERS) || defined(DOCUMENTATION)
#include <sageContainer.h>
#endif // SgAsmOperandList_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmOperandList: public SgAsmNode {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmOperandList.setDataPrototype(
        "SgAsmExpressionPtrList", "operands", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmOperandList);
#if defined(SgAsmOperandList_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmOperandList -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmOperandList");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmNode);
        s & BOOST_SERIALIZATION_NVP(p_operands);
        debugSerializationEnd("SgAsmOperandList");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgAsmExpressionPtrList const& get_operands() const;
    SgAsmExpressionPtrList& get_operands();
    void set_operands(SgAsmExpressionPtrList const&);
public:
    void appendOperand(SgAsmExpression* operand);
 
    // Deprecated 2023-11
public:
    void append_operand(SgAsmExpression*) ROSE_DEPRECATED("use appendOperand");
public:
    virtual ~SgAsmOperandList();
 
public:
    SgAsmOperandList();
 
protected:
    void initializeProperties();
#endif // SgAsmOperandList_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmOperandList: public SgAsmNode {…};
#endif // DOCUMENTATION
 
 
// SgAsmNullInstruction           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmNullInstruction);
IS_SERIALIZABLE(AsmNullInstruction);
 
#ifndef DOCUMENTATION
AsmNullInstruction.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmNullInstruction: public SgAsmInstruction {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmNullInstruction);
#if defined(SgAsmNullInstruction_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmNullInstruction -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmNullInstruction");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmInstruction);
        debugSerializationEnd("SgAsmNullInstruction");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
    // there's only one kind of null instruction
    enum Kind { null_unknown };
 
public: // overrides
    virtual unsigned get_anyKind() const override;
public:
    virtual ~SgAsmNullInstruction();
 
public:
    SgAsmNullInstruction();
 
public:
    SgAsmNullInstruction(Rose::BinaryAnalysis::Address const& address,
                         uint8_t const& architectureId);
 
protected:
    void initializeProperties();
#endif // SgAsmNullInstruction_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmNullInstruction: public SgAsmInstruction {…};
#endif // DOCUMENTATION
 
 
// SgAsmNEStringTable           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmNEStringTable);
IS_SERIALIZABLE(AsmNEStringTable);
 
#ifndef DOCUMENTATION
AsmNEStringTable.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmNEStringTable);
#if defined(SgAsmNEStringTable_HEADERS) || defined(DOCUMENTATION)
#include <Rose/BinaryAnalysis/Address.h>
#endif // SgAsmNEStringTable_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmNEStringTable: public SgAsmGenericSection {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmNEStringTable);
#if defined(SgAsmNEStringTable_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmNEStringTable -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmNEStringTable");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmGenericSection);
        debugSerializationEnd("SgAsmNEStringTable");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
    SgAsmNEStringTable(SgAsmNEFileHeader *fhdr, Rose::BinaryAnalysis::Address offset, Rose::BinaryAnalysis::Address size);
    virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
    std::string get_string(Rose::BinaryAnalysis::Address offset);
public:
    virtual ~SgAsmNEStringTable();
 
public:
    SgAsmNEStringTable();
 
protected:
    void initializeProperties();
#endif // SgAsmNEStringTable_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmNEStringTable: public SgAsmGenericSection {…};
#endif // DOCUMENTATION
 
 
// SgAsmNESectionTable           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmNESectionTable);
IS_SERIALIZABLE(AsmNESectionTable);
 
#ifndef DOCUMENTATION
AsmNESectionTable.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmNESectionTable);
#if defined(SgAsmNESectionTable_HEADERS) || defined(DOCUMENTATION)
#include <Rose/BinaryAnalysis/Address.h>
#endif // SgAsmNESectionTable_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmNESectionTable: public SgAsmGenericSection {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmNESectionTable.setDataPrototype(
        "unsigned", "flags", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmNESectionTable.setDataPrototype(
        "unsigned", "sector", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmNESectionTable.setDataPrototype(
        "Rose::BinaryAnalysis::Address", "physicalSize", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmNESectionTable.setDataPrototype(
        "Rose::BinaryAnalysis::Address", "virtualSize", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmNESectionTable);
#if defined(SgAsmNESectionTable_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmNESectionTable -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmNESectionTable");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmGenericSection);
        s & BOOST_SERIALIZATION_NVP(p_flags);
        s & BOOST_SERIALIZATION_NVP(p_sector);
        s & BOOST_SERIALIZATION_NVP(p_physicalSize);
        s & BOOST_SERIALIZATION_NVP(p_virtualSize);
        debugSerializationEnd("SgAsmNESectionTable");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    unsigned const& get_flags() const;
    void set_flags(unsigned const&);
 
public:
    unsigned const& get_sector() const;
    void set_sector(unsigned const&);
 
public:
    Rose::BinaryAnalysis::Address const& get_physicalSize() const;
    void set_physicalSize(Rose::BinaryAnalysis::Address const&);
 
public:
    Rose::BinaryAnalysis::Address const& get_virtualSize() const;
    void set_virtualSize(Rose::BinaryAnalysis::Address const&);
public:
    explicit SgAsmNESectionTable(SgAsmNEFileHeader*);
    virtual void unparse(std::ostream&) const override;
    virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
 
    // Deprecated 2023-11
public:
    Rose::BinaryAnalysis::Address get_physical_size() const ROSE_DEPRECATED("use get_physicalSize");
    void set_physical_size(Rose::BinaryAnalysis::Address) ROSE_DEPRECATED("use set_physicalSize");
    Rose::BinaryAnalysis::Address get_virtual_size() const ROSE_DEPRECATED("use get_virtualSize");
    void set_virtual_size(Rose::BinaryAnalysis::Address) ROSE_DEPRECATED("use set_virtualSize");
public:
    virtual ~SgAsmNESectionTable();
 
public:
    SgAsmNESectionTable();
 
protected:
    void initializeProperties();
#endif // SgAsmNESectionTable_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmNESectionTable: public SgAsmGenericSection {…};
#endif // DOCUMENTATION
 
 
// SgAsmNESectionTableEntry           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmNESectionTableEntry);
IS_SERIALIZABLE(AsmNESectionTableEntry);
 
#ifndef DOCUMENTATION
AsmNESectionTableEntry.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmNESectionTableEntry);
#if defined(SgAsmNESectionTableEntry_HEADERS) || defined(DOCUMENTATION)
#include <Rose/BinaryAnalysis/Address.h>
#endif // SgAsmNESectionTableEntry_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmNESectionTableEntry: public SgAsmExecutableFileFormat {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmNESectionTableEntry.setDataPrototype(
        "unsigned", "flags", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmNESectionTableEntry.setDataPrototype(
        "unsigned", "sector", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmNESectionTableEntry.setDataPrototype(
        "Rose::BinaryAnalysis::Address", "physicalSize", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmNESectionTableEntry.setDataPrototype(
        "Rose::BinaryAnalysis::Address", "virtualSize", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmNESectionTableEntry);
#if defined(SgAsmNESectionTableEntry_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmNESectionTableEntry -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmNESectionTableEntry");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
        s & BOOST_SERIALIZATION_NVP(p_flags);
        s & BOOST_SERIALIZATION_NVP(p_sector);
        s & BOOST_SERIALIZATION_NVP(p_physicalSize);
        s & BOOST_SERIALIZATION_NVP(p_virtualSize);
        debugSerializationEnd("SgAsmNESectionTableEntry");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
    // Local types
public:
#ifdef _MSC_VER
# pragma pack (1)
#endif
    /* File format of a section table entry. All fields are little endian. */
    struct NESectionTableEntry_disk {
        uint16_t    sector;                 /* 0x00 File offset (sector size defined in hdr); zero means no file data */
        uint16_t    physical_size;          /* 0x02 Length of segment in file; zero means 64k if sector is non-zero */
        uint16_t    flags;                  /* 0x04 Segment bit flags */
        uint16_t    virtual_size;           /* 0x06 Total size of segment when mapped to memory; zero means 64k */
    }                                     /* 0x08 */
    struct NESectionTableEntry_disk {…};
// DQ (3/7/2013): Adding support to restrict visability to SWIG.
#ifndef SWIG
#ifndef _MSC_VER
                __attribute__((packed))
#endif
#endif
                ;
#ifdef _MSC_VER
# pragma pack ()
#endif
 
    enum NESectionFlags {
        SF_RESERVED         = 0x0e08,       /* these bits are reserved */
 
        SF_TYPE_MASK        = 0x0007,       /* segment-type field */
        SF_CODE             = 0x0000,       /* code-segment type */
        SF_DATA             = 0x0001,       /* data-segment (otherwise segment is code) */
        SF_ALLOC            = 0x0002,       /* loader allocates memory */
        SF_LOAD             = 0x0004,       /* load the segment */
 
        SF_MOVABLE          = 0x0010,       /* segment is not fixed */
        SF_PURE             = 0x0020,       /* segment is pure, or sharable; otherwise impure or non-sharable */
        SF_PRELOAD          = 0x0040,       /* segment will be preloaded; read-only if this is a data segment */
        SF_NOT_WRITABLE     = 0x0080,       /* code segment is execute only; data segment is read-only */
        SF_RELOCINFO        = 0x0100,       /* segment has relocation records */
        SF_DISCARDABLE      = 0x1000,       /* discardable */
        SF_DISCARD          = 0xf000        /* discard priority */
    };
 
    // Properties
public:
public:
    unsigned const& get_flags() const;
    void set_flags(unsigned const&);
 
public:
    unsigned const& get_sector() const;
    void set_sector(unsigned const&);
 
public:
    Rose::BinaryAnalysis::Address const& get_physicalSize() const;
    void set_physicalSize(Rose::BinaryAnalysis::Address const&);
 
public:
    Rose::BinaryAnalysis::Address const& get_virtualSize() const;
    void set_virtualSize(Rose::BinaryAnalysis::Address const&);
    // Functions
public:
    explicit SgAsmNESectionTableEntry(const SgAsmNESectionTableEntry::NESectionTableEntry_disk *disk);
    void *encode(SgAsmNESectionTableEntry::NESectionTableEntry_disk*) const;
    virtual void dump(FILE *f, const char *prefix, ssize_t idx) const {dump(f, prefix, idx, NULL);}
    void dump(FILE*, const char *prefix, ssize_t idx, SgAsmNEFileHeader *fhdr) const;
 
    // Deprecated 2023-11
public:
    Rose::BinaryAnalysis::Address get_physical_size() const ROSE_DEPRECATED("use get_physicalSize");
    void set_physical_size(Rose::BinaryAnalysis::Address) ROSE_DEPRECATED("use set_physicalSize");
    Rose::BinaryAnalysis::Address get_virtual_size() const ROSE_DEPRECATED("use get_virtualSize");
    void set_virtual_size(Rose::BinaryAnalysis::Address) ROSE_DEPRECATED("use set_virtualSize");
public:
    virtual ~SgAsmNESectionTableEntry();
 
public:
    SgAsmNESectionTableEntry();
 
protected:
    void initializeProperties();
#endif // SgAsmNESectionTableEntry_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmNESectionTableEntry: public SgAsmExecutableFileFormat {…};
#endif // DOCUMENTATION
 
 
// SgAsmNESection           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmNESection);
IS_SERIALIZABLE(AsmNESection);
 
#ifndef DOCUMENTATION
AsmNESection.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmNESection);
#if defined(SgAsmNESection_HEADERS) || defined(DOCUMENTATION)
#ifdef ROSE_SgAsmNESection_IMPL
#include <SgAsmNESectionTableEntry.h>
#include <SgAsmNERelocTable.h>
#endif
#endif // SgAsmNESection_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmNESection: public SgAsmGenericSection {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmNESection.setDataPrototype(
        "SgAsmNESectionTableEntry*", "sectionTableEntry", "= nullptr",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmNESection.setDataPrototype(
        "SgAsmNERelocTable*", "relocationTable", "= nullptr",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmNESection);
#if defined(SgAsmNESection_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmNESection -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmNESection");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmGenericSection);
        s & BOOST_SERIALIZATION_NVP(p_sectionTableEntry);
        s & BOOST_SERIALIZATION_NVP(p_relocationTable);
        debugSerializationEnd("SgAsmNESection");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgAsmNESectionTableEntry* const& get_sectionTableEntry() const;
    void set_sectionTableEntry(SgAsmNESectionTableEntry* const&);
 
public:
    SgAsmNERelocTable* const& get_relocationTable() const;
    void set_relocationTable(SgAsmNERelocTable* const&);
public:
    explicit SgAsmNESection(SgAsmNEFileHeader *fhdr);
    virtual void unparse(std::ostream&) const override;
    virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
 
    // Deprecated 2023-11
public:
    SgAsmNESectionTableEntry* get_st_entry() const ROSE_DEPRECATED("use get_sectionTableEntry");
    void set_st_entry(SgAsmNESectionTableEntry*) ROSE_DEPRECATED("use set_sectionTableEntry");
    SgAsmNERelocTable* get_reloc_table() const ROSE_DEPRECATED("use get_relocationTable");
    void set_reloc_table(SgAsmNERelocTable*) ROSE_DEPRECATED("use set_relocationTable");
public:
    virtual ~SgAsmNESection();
 
public:
    SgAsmNESection();
 
protected:
    void initializeProperties();
#endif // SgAsmNESection_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmNESection: public SgAsmGenericSection {…};
#endif // DOCUMENTATION
 
 
// SgAsmNERelocTable           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmNERelocTable);
IS_SERIALIZABLE(AsmNERelocTable);
 
#ifndef DOCUMENTATION
AsmNERelocTable.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmNERelocTable: public SgAsmGenericSection {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmNERelocTable.setDataPrototype(
        "SgAsmNERelocEntryPtrList", "entries", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmNERelocTable);
#if defined(SgAsmNERelocTable_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmNERelocTable -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmNERelocTable");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmGenericSection);
        s & BOOST_SERIALIZATION_NVP(p_entries);
        debugSerializationEnd("SgAsmNERelocTable");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgAsmNERelocEntryPtrList const& get_entries() const;
    SgAsmNERelocEntryPtrList& get_entries();
    void set_entries(SgAsmNERelocEntryPtrList const&);
public:
    explicit SgAsmNERelocTable(SgAsmNEFileHeader *fhdr, SgAsmNESection *section);
    virtual void unparse(std::ostream&) const override;
    virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
public:
    virtual ~SgAsmNERelocTable();
 
public:
    SgAsmNERelocTable();
 
protected:
    void initializeProperties();
#endif // SgAsmNERelocTable_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmNERelocTable: public SgAsmGenericSection {…};
#endif // DOCUMENTATION
 
 
// SgAsmNERelocEntry           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmNERelocEntry);
IS_SERIALIZABLE(AsmNERelocEntry);
 
#ifndef DOCUMENTATION
AsmNERelocEntry.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmNERelocEntry);
#if defined(SgAsmNERelocEntry_HEADERS) || defined(DOCUMENTATION)
#include <Rose/BinaryAnalysis/Address.h>
#endif // SgAsmNERelocEntry_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmNERelocEntry: public SgAsmExecutableFileFormat {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmNERelocEntry.setDataPrototype(
        "SgAsmNERelocEntry::NERelocSrcType", "src_type", "= SgAsmNERelocEntry::RF_SRCTYPE_8OFF",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmNERelocEntry.setDataPrototype(
        "SgAsmNERelocEntry::NERelocModifiers", "modifier", "= SgAsmNERelocEntry::RF_MODIFIER_SINGLE",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmNERelocEntry.setDataPrototype(
        "SgAsmNERelocEntry::NERelocTgtType", "tgt_type", "= SgAsmNERelocEntry::RF_TGTTYPE_IREF",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmNERelocEntry.setDataPrototype(
        "SgAsmNERelocEntry::NERelocFlags", "flags", "= SgAsmNERelocEntry::RF_ADDITIVE",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmNERelocEntry.setDataPrototype(
        "Rose::BinaryAnalysis::Address", "src_offset", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmNERelocEntry.setDataPrototype(
        "SgAsmNERelocEntry::iref_type", "iref", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmNERelocEntry.setDataPrototype(
        "SgAsmNERelocEntry::iord_type", "iord", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmNERelocEntry.setDataPrototype(
        "SgAsmNERelocEntry::iname_type", "iname", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmNERelocEntry.setDataPrototype(
        "SgAsmNERelocEntry::osfixup_type", "osfixup", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmNERelocEntry);
#if defined(SgAsmNERelocEntry_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmNERelocEntry -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmNERelocEntry");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
        s & BOOST_SERIALIZATION_NVP(p_src_type);
        s & BOOST_SERIALIZATION_NVP(p_modifier);
        s & BOOST_SERIALIZATION_NVP(p_tgt_type);
        s & BOOST_SERIALIZATION_NVP(p_flags);
        s & BOOST_SERIALIZATION_NVP(p_src_offset);
        s & BOOST_SERIALIZATION_NVP(p_iref);
        s & BOOST_SERIALIZATION_NVP(p_iord);
        s & BOOST_SERIALIZATION_NVP(p_iname);
        s & BOOST_SERIALIZATION_NVP(p_osfixup);
        debugSerializationEnd("SgAsmNERelocEntry");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
    // Local types
public:
    /* NERelocEntry_disk -- variable size with multiple levels of 'union'. It's easier to just parse it in NERelocEntry::ctor()
     * than defining it here as a struct. */
    enum NERelocSrcType {
        RF_SRCTYPE_8OFF     = 0,            /* Byte offset */
        RF_SRCTYPE_WORDSEG  = 2,            /* Word segment, 16-bit selector */
        RF_SRCTYPE_16PTR    = 3,            /* 16-bit far pointer */
        RF_SRCTYPE_16OFF    = 5,            /* 16-bit offset */
        RF_SRCTYPE_32PTR    = 6,            /* 32-bit far pointer */
        RF_SRCTYPE_32OFF    = 7,            /* 32-bit offset */
        RF_SRCTYPE_NEARCALL = 8,            /* near call or jump, WORD/DWROD based on section attribute */
        RF_SRCTYPE_48PTR    = 11,           /* 48-bit pointer */
        RF_SRCTYPE_32OFF_b  = 13            /* 32-bit offset (not sure how this differs from case 7) */
    };
 
    enum NERelocTgtType {
        RF_TGTTYPE_IREF     = 0,            /* Internal reference */
        RF_TGTTYPE_IORD     = 1,            /* Imported (extern) ordinal */
        RF_TGTTYPE_INAME    = 2,            /* Imported (extern) name */
        RF_TGTTYPE_OSFIXUP  = 3             /* Operating system fixup */
    };
 
    enum NERelocModifiers {
        RF_MODIFIER_SINGLE  = 1,
        RF_MODIFIER_MULTI   = 3
    };
 
    enum NERelocFlags {
        RF_ADDITIVE         = 0x01,         /* add target to source rather than replace source with target */
        RF_RESERVED         = 0x02,         /* reserved bits */
        RF_2EXTRA           = 0x04,         /* relocation info has size with new two bytes at end */
        RF_32ADD            = 0x08,         /* addition with 32-bits rather than 16 */
        RF_16SECTION        = 0x10,         /* 16-bit object number & module name rather than 8-bit */
        RF_8ORDINAL         = 0x20          /* Ordinal is 8-bits rather than 16 */
    };
 
    // DQ (8/7/2008): At only (I hope) the risk of using more memory that required, break the union so that we can better support
    // this in ROSETTA. One solution might be to implement a common base class of unsigned, unsigned, Rose::BinaryAnalysis::Address;
    // and then use member functions to access the data in the base class.
    struct iref_type { /*tgt_type==0x00: internal reference*/
        unsigned    sect_idx;       /* section index (1-origin) */
        unsigned    res1;           /* reserved */
        Rose::BinaryAnalysis::Address tgt_offset;
 
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
        template<class S>
        void serialize(S &s, const unsigned /*version*/) {
            s & BOOST_SERIALIZATION_NVP(sect_idx);
            s & BOOST_SERIALIZATION_NVP(res1);
            s & BOOST_SERIALIZATION_NVP(tgt_offset);
        }
#endif
 
        // Added to support RTI support in ROSE
        friend std::ostream & operator<< ( std::ostream & os, const iref_type & x );
 
        iref_type();
    };
    struct iref_type { /*tgt_type==0x00: internal reference*/ {…};
 
    struct iord_type { /*tgt_type==0x01: imported ordinal*/
        unsigned modref;                                /* 1-based index into import module table */
        unsigned ordinal;
        Rose::BinaryAnalysis::Address addend;           /* value to add (only present for flags & RF_2EXTRA) */
 
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
        template<class S>
        void serialize(S &s, const unsigned /*version*/) {
            s & BOOST_SERIALIZATION_NVP(modref);
            s & BOOST_SERIALIZATION_NVP(ordinal);
            s & BOOST_SERIALIZATION_NVP(addend);
        }
#endif
 
        // Added to support RTI support in ROSE
        friend std::ostream & operator<< ( std::ostream & os, const iord_type & x );
 
        iord_type();
    };
    struct iord_type { /*tgt_type==0x01: imported ordinal*/ {…};
 
    struct iname_type { /*tgt_type==0x02: imported name*/
        unsigned modref;                                /* 1-based index into import module table */
        unsigned nm_off;                                /* offset into import procedure names */
        Rose::BinaryAnalysis::Address addend;           /* value to add (only present for flags & RF_2EXTRA) */
 
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
        template<class S>
        void serialize(S &s, const unsigned /*version*/) {
            s & BOOST_SERIALIZATION_NVP(modref);
            s & BOOST_SERIALIZATION_NVP(nm_off);
            s & BOOST_SERIALIZATION_NVP(addend);
        }
#endif
 
        // Added to support RTI support in ROSE
        friend std::ostream & operator<< ( std::ostream & os, const iname_type & x );
 
        iname_type();
    };
    struct iname_type { /*tgt_type==0x02: imported name*/ {…};
 
    struct osfixup_type { /*tgt_type==0x03: operating system fixup*/
        unsigned    type;
        unsigned    res3;
 
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
        template<class S>
        void serialize(S &s, const unsigned /*version*/) {
            s & BOOST_SERIALIZATION_NVP(type);
            s & BOOST_SERIALIZATION_NVP(res3);
        }
#endif
 
        // Added to support RTI support in ROSE
        friend std::ostream & operator<< ( std::ostream & os, const osfixup_type & x );
 
        osfixup_type();
    };
    struct osfixup_type { /*tgt_type==0x03: operating system fixup*/ {…};
 
    // Properties
public:
public:
    SgAsmNERelocEntry::NERelocSrcType const& get_src_type() const;
    void set_src_type(SgAsmNERelocEntry::NERelocSrcType const&);
 
public:
    SgAsmNERelocEntry::NERelocModifiers const& get_modifier() const;
    void set_modifier(SgAsmNERelocEntry::NERelocModifiers const&);
 
public:
    SgAsmNERelocEntry::NERelocTgtType const& get_tgt_type() const;
    void set_tgt_type(SgAsmNERelocEntry::NERelocTgtType const&);
 
public:
    SgAsmNERelocEntry::NERelocFlags const& get_flags() const;
    void set_flags(SgAsmNERelocEntry::NERelocFlags const&);
 
public:
    Rose::BinaryAnalysis::Address const& get_src_offset() const;
    void set_src_offset(Rose::BinaryAnalysis::Address const&);
 
public:
    SgAsmNERelocEntry::iref_type const& get_iref() const;
    void set_iref(SgAsmNERelocEntry::iref_type const&);
 
public:
    SgAsmNERelocEntry::iord_type const& get_iord() const;
    void set_iord(SgAsmNERelocEntry::iord_type const&);
 
public:
    SgAsmNERelocEntry::iname_type const& get_iname() const;
    void set_iname(SgAsmNERelocEntry::iname_type const&);
 
public:
    SgAsmNERelocEntry::osfixup_type const& get_osfixup() const;
    void set_osfixup(SgAsmNERelocEntry::osfixup_type const&);
    // Functions
public:
    SgAsmNERelocEntry(SgAsmGenericSection *relocs, Rose::BinaryAnalysis::Address at, Rose::BinaryAnalysis::Address *rec_size);
    Rose::BinaryAnalysis::Address unparse(std::ostream&, const SgAsmGenericSection*, Rose::BinaryAnalysis::Address spos) const;
    void dump(FILE*, const char *prefix, ssize_t idx) const;
public:
    virtual ~SgAsmNERelocEntry();
 
public:
    SgAsmNERelocEntry();
 
protected:
    void initializeProperties();
#endif // SgAsmNERelocEntry_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmNERelocEntry: public SgAsmExecutableFileFormat {…};
#endif // DOCUMENTATION
 
 
// SgAsmNENameTable           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmNENameTable);
IS_SERIALIZABLE(AsmNENameTable);
 
#ifndef DOCUMENTATION
AsmNENameTable.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmNENameTable);
#if defined(SgAsmNENameTable_HEADERS) || defined(DOCUMENTATION)
#include <Rose/BinaryAnalysis/Address.h>
#endif // SgAsmNENameTable_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmNENameTable: public SgAsmGenericSection {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmNENameTable.setDataPrototype(
        "SgStringList", "names", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmNENameTable.setDataPrototype(
        "SgUnsignedList", "ordinals", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmNENameTable);
#if defined(SgAsmNENameTable_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmNENameTable -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmNENameTable");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmGenericSection);
        s & BOOST_SERIALIZATION_NVP(p_names);
        s & BOOST_SERIALIZATION_NVP(p_ordinals);
        debugSerializationEnd("SgAsmNENameTable");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgStringList const& get_names() const;
    void set_names(SgStringList const&);
 
public:
    SgUnsignedList const& get_ordinals() const;
    void set_ordinals(SgUnsignedList const&);
public:
    SgAsmNENameTable(SgAsmNEFileHeader *fhdr, Rose::BinaryAnalysis::Address offset);
    virtual void unparse(std::ostream&) const override;
    virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
    std::vector<std::string> get_namesByOrdinal(unsigned ordinal);
 
    // Deprecated 2023-11
public:
    std::vector<std::string> get_names_by_ordinal(unsigned) ROSE_DEPRECATED("use get_namesByOrdinal");
public:
    virtual ~SgAsmNENameTable();
 
public:
    SgAsmNENameTable();
 
protected:
    void initializeProperties();
#endif // SgAsmNENameTable_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmNENameTable: public SgAsmGenericSection {…};
#endif // DOCUMENTATION
 
 
// SgAsmNEModuleTable           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmNEModuleTable);
IS_SERIALIZABLE(AsmNEModuleTable);
 
#ifndef DOCUMENTATION
AsmNEModuleTable.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmNEModuleTable);
#if defined(SgAsmNEModuleTable_HEADERS) || defined(DOCUMENTATION)
#include <Rose/BinaryAnalysis/Address.h>
 
#ifdef ROSE_SgAsmNEModuleTable_IMPL
#include <SgAsmNEStringTable.h>
#endif
#endif // SgAsmNEModuleTable_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmNEModuleTable: public SgAsmGenericSection {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmNEModuleTable.setDataPrototype(
        "SgAsmNEStringTable*", "strtab", "= nullptr",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmNEModuleTable.setDataPrototype(
        "SgAddressList", "nameOffsets", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmNEModuleTable.setDataPrototype(
        "SgStringList", "names", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmNEModuleTable);
#if defined(SgAsmNEModuleTable_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmNEModuleTable -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmNEModuleTable");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmGenericSection);
        s & BOOST_SERIALIZATION_NVP(p_strtab);
        s & BOOST_SERIALIZATION_NVP(p_nameOffsets);
        s & BOOST_SERIALIZATION_NVP(p_names);
        debugSerializationEnd("SgAsmNEModuleTable");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgAsmNEStringTable* const& get_strtab() const;
    void set_strtab(SgAsmNEStringTable* const&);
 
public:
    SgAddressList const& get_nameOffsets() const;
    void set_nameOffsets(SgAddressList const&);
 
public:
    SgStringList const& get_names() const;
    void set_names(SgStringList const&);
public:
    SgAsmNEModuleTable(SgAsmNEFileHeader *fhdr, SgAsmNEStringTable *strtab, Rose::BinaryAnalysis::Address offset,
                       Rose::BinaryAnalysis::Address size);
    virtual void unparse(std::ostream&) const override;
    virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
 
    // Deprecated 2023-11
public:
    const SgAddressList& get_name_offsets() const ROSE_DEPRECATED("use get_nameOffsets");
    void set_name_offsets(const SgAddressList&) ROSE_DEPRECATED("use set_nameOffsets");
public:
    virtual ~SgAsmNEModuleTable();
 
public:
    SgAsmNEModuleTable();
 
protected:
    void initializeProperties();
#endif // SgAsmNEModuleTable_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmNEModuleTable: public SgAsmGenericSection {…};
#endif // DOCUMENTATION
 
 
// SgAsmNEFileHeader           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmNEFileHeader);
IS_SERIALIZABLE(AsmNEFileHeader);
 
#ifndef DOCUMENTATION
AsmNEFileHeader.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmNEFileHeader);
#if defined(SgAsmNEFileHeader_HEADERS) || defined(DOCUMENTATION)
#include <Rose/BinaryAnalysis/Address.h>
 
#ifdef ROSE_SgAsmNEFileHeader_IMPL
#include <SgAsmDOSExtendedHeader.h>
#include <SgAsmNEEntryTable.h>
#include <SgAsmNEModuleTable.h>
#include <SgAsmNENameTable.h>
#include <SgAsmNESectionTable.h>
#endif
#endif // SgAsmNEFileHeader_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmNEFileHeader: public SgAsmGenericHeader {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmNEFileHeader.setDataPrototype(
        "unsigned", "e_linker_major", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmNEFileHeader.setDataPrototype(
        "unsigned", "e_linker_minor", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmNEFileHeader.setDataPrototype(
        "unsigned", "e_checksum", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmNEFileHeader.setDataPrototype(
        "unsigned", "e_flags1", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmNEFileHeader.setDataPrototype(
        "unsigned", "e_autodata_sn", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmNEFileHeader.setDataPrototype(
        "unsigned", "e_bss_size", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmNEFileHeader.setDataPrototype(
        "unsigned", "e_stack_size", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmNEFileHeader.setDataPrototype(
        "unsigned", "e_csip", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmNEFileHeader.setDataPrototype(
        "unsigned", "e_sssp", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmNEFileHeader.setDataPrototype(
        "unsigned", "e_nsections", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmNEFileHeader.setDataPrototype(
        "unsigned", "e_nmodrefs", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmNEFileHeader.setDataPrototype(
        "unsigned", "e_nnonresnames", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmNEFileHeader.setDataPrototype(
        "unsigned", "e_nmovable_entries", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmNEFileHeader.setDataPrototype(
        "unsigned", "e_sector_align", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmNEFileHeader.setDataPrototype(
        "unsigned", "e_nresources", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmNEFileHeader.setDataPrototype(
        "unsigned", "e_exetype", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmNEFileHeader.setDataPrototype(
        "unsigned", "e_flags2", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmNEFileHeader.setDataPrototype(
        "unsigned", "e_res1", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmNEFileHeader.setDataPrototype(
        "unsigned", "e_winvers", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmNEFileHeader.setDataPrototype(
        "Rose::BinaryAnalysis::Address", "e_entrytab_rfo", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmNEFileHeader.setDataPrototype(
        "Rose::BinaryAnalysis::Address", "e_entrytab_size", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmNEFileHeader.setDataPrototype(
        "Rose::BinaryAnalysis::Address", "e_sectab_rfo", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmNEFileHeader.setDataPrototype(
        "Rose::BinaryAnalysis::Address", "e_rsrctab_rfo", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmNEFileHeader.setDataPrototype(
        "Rose::BinaryAnalysis::Address", "e_resnametab_rfo", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmNEFileHeader.setDataPrototype(
        "Rose::BinaryAnalysis::Address", "e_modreftab_rfo", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmNEFileHeader.setDataPrototype(
        "Rose::BinaryAnalysis::Address", "e_importnametab_rfo", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmNEFileHeader.setDataPrototype(
        "Rose::BinaryAnalysis::Address", "e_nonresnametab_offset", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmNEFileHeader.setDataPrototype(
        "Rose::BinaryAnalysis::Address", "e_fastload_sector", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmNEFileHeader.setDataPrototype(
        "Rose::BinaryAnalysis::Address", "e_fastload_nsectors", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmNEFileHeader.setDataPrototype(
        "SgAsmDOSExtendedHeader*", "dos2Header", "= nullptr",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmNEFileHeader.setDataPrototype(
        "SgAsmNESectionTable*", "sectionTable", "= nullptr",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmNEFileHeader.setDataPrototype(
        "SgAsmNENameTable*", "residentNameTable", "= nullptr",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmNEFileHeader.setDataPrototype(
        "SgAsmNENameTable*", "nonresidentNameTable", "= nullptr",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmNEFileHeader.setDataPrototype(
        "SgAsmNEModuleTable*", "moduleTable", "= nullptr",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmNEFileHeader.setDataPrototype(
        "SgAsmNEEntryTable*", "entryTable", "= nullptr",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmNEFileHeader);
#if defined(SgAsmNEFileHeader_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmNEFileHeader -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmNEFileHeader");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmGenericHeader);
        s & BOOST_SERIALIZATION_NVP(p_e_linker_major);
        s & BOOST_SERIALIZATION_NVP(p_e_linker_minor);
        s & BOOST_SERIALIZATION_NVP(p_e_checksum);
        s & BOOST_SERIALIZATION_NVP(p_e_flags1);
        s & BOOST_SERIALIZATION_NVP(p_e_autodata_sn);
        s & BOOST_SERIALIZATION_NVP(p_e_bss_size);
        s & BOOST_SERIALIZATION_NVP(p_e_stack_size);
        s & BOOST_SERIALIZATION_NVP(p_e_csip);
        s & BOOST_SERIALIZATION_NVP(p_e_sssp);
        s & BOOST_SERIALIZATION_NVP(p_e_nsections);
        s & BOOST_SERIALIZATION_NVP(p_e_nmodrefs);
        s & BOOST_SERIALIZATION_NVP(p_e_nnonresnames);
        s & BOOST_SERIALIZATION_NVP(p_e_nmovable_entries);
        s & BOOST_SERIALIZATION_NVP(p_e_sector_align);
        s & BOOST_SERIALIZATION_NVP(p_e_nresources);
        s & BOOST_SERIALIZATION_NVP(p_e_exetype);
        s & BOOST_SERIALIZATION_NVP(p_e_flags2);
        s & BOOST_SERIALIZATION_NVP(p_e_res1);
        s & BOOST_SERIALIZATION_NVP(p_e_winvers);
        s & BOOST_SERIALIZATION_NVP(p_e_entrytab_rfo);
        s & BOOST_SERIALIZATION_NVP(p_e_entrytab_size);
        s & BOOST_SERIALIZATION_NVP(p_e_sectab_rfo);
        s & BOOST_SERIALIZATION_NVP(p_e_rsrctab_rfo);
        s & BOOST_SERIALIZATION_NVP(p_e_resnametab_rfo);
        s & BOOST_SERIALIZATION_NVP(p_e_modreftab_rfo);
        s & BOOST_SERIALIZATION_NVP(p_e_importnametab_rfo);
        s & BOOST_SERIALIZATION_NVP(p_e_nonresnametab_offset);
        s & BOOST_SERIALIZATION_NVP(p_e_fastload_sector);
        s & BOOST_SERIALIZATION_NVP(p_e_fastload_nsectors);
        s & BOOST_SERIALIZATION_NVP(p_dos2Header);
        s & BOOST_SERIALIZATION_NVP(p_sectionTable);
        s & BOOST_SERIALIZATION_NVP(p_residentNameTable);
        s & BOOST_SERIALIZATION_NVP(p_nonresidentNameTable);
        s & BOOST_SERIALIZATION_NVP(p_moduleTable);
        s & BOOST_SERIALIZATION_NVP(p_entryTable);
        debugSerializationEnd("SgAsmNEFileHeader");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
    // Local types
public:
#ifdef _MSC_VER
# pragma pack (1)
#endif
    /* File format of an NE File Header. All fields are little endian.
     *
     * NOTES
     *
     * e_sssp: The value specified in SS is an index (1-origin) into the segment table. If SS addresses the automatic data segment
     *         and SP is zero then SP is set to the address obtained by adding the size of the automatic data segment to the size
     *         of the stack. */
    struct NEFileHeader_disk {
         unsigned char e_magic[2];           /* 0x00 magic number "NE" */
         unsigned char e_linker_major;       /* 0x02 linker major version number */
         unsigned char e_linker_minor;       /* 0x03 linker minor version number */
         uint16_t    e_entrytab_rfo;         /* 0x04 entry table offset relative to start of header */
         uint16_t    e_entrytab_size;        /* 0x06 size of entry table in bytes */
         uint32_t    e_checksum;             /* 0x08 32-bit CRC of entire file (this word is taken a zero during the calculation) */
         uint16_t    e_flags1;               /* 0x0c file-level bit flags (see HeaderFlags1) */
         uint16_t    e_autodata_sn;          /* 0x0e auto data section number if (flags & 0x3)==0; else zero */
         uint16_t    e_bss_size;             /* 0x10 num bytes added to data segment for BSS */
         uint16_t    e_stack_size;           /* 0x12 num bytes added to data segment for stack (zero of SS!=DS registers) */
         uint32_t    e_csip;                 /* 0x14 section number:offset of CS:IP */
         uint32_t    e_sssp;                 /* 0x18 section number:offset of SS:SP (see note 1 above) */
         uint16_t    e_nsections;            /* 0x1c number of entries in the section table */
         uint16_t    e_nmodrefs;             /* 0x1e number of entries in the module reference table */
         uint16_t    e_nnonresnames;         /* 0x20 number of entries in the non-resident name table */
         uint16_t    e_sectab_rfo;           /* 0x22 offset of section table relative to start of header */
         uint16_t    e_rsrctab_rfo;          /* 0x24 offset of resource table relative to start of header */
         uint16_t    e_resnametab_rfo;       /* 0x26 offset of resident name table relative to start of header */
         uint16_t    e_modreftab_rfo;        /* 0x28 offset of module reference table relative to start of header */
         uint16_t    e_importnametab_rfo;    /* 0x2a offset of imported names table relative to start of header */
         uint32_t    e_nonresnametab_offset; /* 0x2c file offset of non-resident name table */
         uint16_t    e_nmovable_entries;     /* 0x30 number of movable entries in Entry Table */
         uint16_t    e_sector_align;         /* 0x32 sector alignment shift count (log2 of segment sector size) */
         uint16_t    e_nresources;           /* 0x34 number of resource entries */
         unsigned char e_exetype;            /* 0x36 executable type (2==windows) */
         unsigned char e_flags2;             /* 0x37 additional flags (see HeaderFlags2) */
         uint16_t    e_fastload_sector;      /* 0x38 sector offset to fast-load area (only for Windows) */
         uint16_t    e_fastload_nsectors;    /* 0x3a size of fast-load area in sectors (only for Windows) */
         uint16_t    e_res1;                 /* 0x3c reserved */
         uint16_t    e_winvers;              /* 0x3e expected version number for Windows (only for Windows) */
       }                                     /* 0x40 */
    struct NEFileHeader_disk {…};
// DQ (3/7/2013): Adding support to restrict visability to SWIG.
#ifndef SWIG
#ifndef _MSC_VER
          __attribute__((packed))
#endif
#endif
          ;
#ifdef _MSC_VER
# pragma pack ()
#endif
 
    /* Bit flags for the NE header 'e_flags' member.
     *
     * If HF_LIBRARY (bit 15) is set then the CS:IP registers point to an initialization procedure called with the value in the AX
     * register equal to the module handle. The initialization procedure must execute a far return to the caller. The resulting
     * value in AX is a status indicator (non-zero for success, zero for failure). */
    enum HeaderFlags1 {
         HF1_RESERVED         = 0x57f4,      /* Reserved bits */
         HF1_NO_DATA          = 0x0000,      /* (flags&0x03==0) => an exe not containing a data segment */
         HF1_SINGLE_DATA      = 0x0001,      /* Executable contains one data segment; set if file is a DLL */
         HF1_MULTIPLE_DATA    = 0x0002,      /* Exe with multiple data segments; set if a windows application */
         HF1_LOADER_SEGMENT   = 0x0800,      /* First segment contains code that loads the application */
         HF1_FATAL_ERRORS     = 0x2000,      /* Errors detected at link time; module will not load */
         HF1_LIBRARY          = 0x8000       /* Module is a library */
       };
 
    /* Bit flags for the NE header 'e_flags2' member. */
    enum HeaderFlags2 {
         HF2_RESERVED         = 0xf1,        /* Reserved bits */
         HF2_PROTECTED_MODE   = 0x02,        /* Windows 2.x application that runs in 3.x protected mode */
         HF2_PFONTS           = 0x04,        /* Windows 2.x application that supports proportional fonts */
         HF2_FASTLOAD         = 0x08         /* Executable contains a fast-load area */
       };
 
    // Properties
public:
public:
    unsigned const& get_e_linker_major() const;
    void set_e_linker_major(unsigned const&);
 
public:
    unsigned const& get_e_linker_minor() const;
    void set_e_linker_minor(unsigned const&);
 
public:
    unsigned const& get_e_checksum() const;
    void set_e_checksum(unsigned const&);
 
public:
    unsigned const& get_e_flags1() const;
    void set_e_flags1(unsigned const&);
 
public:
    unsigned const& get_e_autodata_sn() const;
    void set_e_autodata_sn(unsigned const&);
 
public:
    unsigned const& get_e_bss_size() const;
    void set_e_bss_size(unsigned const&);
 
public:
    unsigned const& get_e_stack_size() const;
    void set_e_stack_size(unsigned const&);
 
public:
    unsigned const& get_e_csip() const;
    void set_e_csip(unsigned const&);
 
public:
    unsigned const& get_e_sssp() const;
    void set_e_sssp(unsigned const&);
 
public:
    unsigned const& get_e_nsections() const;
    void set_e_nsections(unsigned const&);
 
public:
    unsigned const& get_e_nmodrefs() const;
    void set_e_nmodrefs(unsigned const&);
 
public:
    unsigned const& get_e_nnonresnames() const;
    void set_e_nnonresnames(unsigned const&);
 
public:
    unsigned const& get_e_nmovable_entries() const;
    void set_e_nmovable_entries(unsigned const&);
 
public:
    unsigned const& get_e_sector_align() const;
    void set_e_sector_align(unsigned const&);
 
public:
    unsigned const& get_e_nresources() const;
    void set_e_nresources(unsigned const&);
 
public:
    unsigned const& get_e_exetype() const;
    void set_e_exetype(unsigned const&);
 
public:
    unsigned const& get_e_flags2() const;
    void set_e_flags2(unsigned const&);
 
public:
    unsigned const& get_e_res1() const;
    void set_e_res1(unsigned const&);
 
public:
    unsigned const& get_e_winvers() const;
    void set_e_winvers(unsigned const&);
 
public:
    Rose::BinaryAnalysis::Address const& get_e_entrytab_rfo() const;
    void set_e_entrytab_rfo(Rose::BinaryAnalysis::Address const&);
 
public:
    Rose::BinaryAnalysis::Address const& get_e_entrytab_size() const;
    void set_e_entrytab_size(Rose::BinaryAnalysis::Address const&);
 
public:
    Rose::BinaryAnalysis::Address const& get_e_sectab_rfo() const;
    void set_e_sectab_rfo(Rose::BinaryAnalysis::Address const&);
 
public:
    Rose::BinaryAnalysis::Address const& get_e_rsrctab_rfo() const;
    void set_e_rsrctab_rfo(Rose::BinaryAnalysis::Address const&);
 
public:
    Rose::BinaryAnalysis::Address const& get_e_resnametab_rfo() const;
    void set_e_resnametab_rfo(Rose::BinaryAnalysis::Address const&);
 
public:
    Rose::BinaryAnalysis::Address const& get_e_modreftab_rfo() const;
    void set_e_modreftab_rfo(Rose::BinaryAnalysis::Address const&);
 
public:
    Rose::BinaryAnalysis::Address const& get_e_importnametab_rfo() const;
    void set_e_importnametab_rfo(Rose::BinaryAnalysis::Address const&);
 
public:
    Rose::BinaryAnalysis::Address const& get_e_nonresnametab_offset() const;
    void set_e_nonresnametab_offset(Rose::BinaryAnalysis::Address const&);
 
public:
    Rose::BinaryAnalysis::Address const& get_e_fastload_sector() const;
    void set_e_fastload_sector(Rose::BinaryAnalysis::Address const&);
 
public:
    Rose::BinaryAnalysis::Address const& get_e_fastload_nsectors() const;
    void set_e_fastload_nsectors(Rose::BinaryAnalysis::Address const&);
 
public:
    SgAsmDOSExtendedHeader* const& get_dos2Header() const;
    void set_dos2Header(SgAsmDOSExtendedHeader* const&);
 
public:
    SgAsmNESectionTable* const& get_sectionTable() const;
    void set_sectionTable(SgAsmNESectionTable* const&);
 
public:
    SgAsmNENameTable* const& get_residentNameTable() const;
    void set_residentNameTable(SgAsmNENameTable* const&);
 
public:
    SgAsmNENameTable* const& get_nonresidentNameTable() const;
    void set_nonresidentNameTable(SgAsmNENameTable* const&);
 
public:
    SgAsmNEModuleTable* const& get_moduleTable() const;
    void set_moduleTable(SgAsmNEModuleTable* const&);
 
public:
    SgAsmNEEntryTable* const& get_entryTable() const;
    void set_entryTable(SgAsmNEEntryTable* const&);
    // Functions
public:
    SgAsmNEFileHeader(SgAsmGenericFile *f, Rose::BinaryAnalysis::Address offset);
 
    static bool isNe (SgAsmGenericFile*);
    static SgAsmNEFileHeader *parse(SgAsmDOSFileHeader*);
    virtual void unparse(std::ostream&) const override;
    virtual const char *formatName() const override;
    virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
 
private:
    void *encode(SgAsmNEFileHeader::NEFileHeader_disk*) const;
 
    // Deprecated 2023-11
public:
    SgAsmDOSExtendedHeader* get_dos2_header() const ROSE_DEPRECATED("use get_dos2Header");
    void set_dos2_header(SgAsmDOSExtendedHeader*) ROSE_DEPRECATED("use set_dos2Header");
    SgAsmNESectionTable* get_section_table() const ROSE_DEPRECATED("use get_sectionTable");
    void set_section_table(SgAsmNESectionTable*) ROSE_DEPRECATED("use set_sectionTable");
    SgAsmNENameTable* get_resname_table() const ROSE_DEPRECATED("use get_residentNameTable");
    void set_resname_table(SgAsmNENameTable*) ROSE_DEPRECATED("use set_residentNameTable");
    SgAsmNENameTable* get_nonresname_table() const ROSE_DEPRECATED("use get_nonresidentNameTable");
    void set_nonresname_table(SgAsmNENameTable*) ROSE_DEPRECATED("use set_nonresidentNameTable");
    SgAsmNEModuleTable* get_module_table() const ROSE_DEPRECATED("use get_moduleTable");
    void set_module_table(SgAsmNEModuleTable*) ROSE_DEPRECATED("use set_moduleTable");
    SgAsmNEEntryTable* get_entry_table() const ROSE_DEPRECATED("use get_entryTable");
    void set_entry_table(SgAsmNEEntryTable*) ROSE_DEPRECATED("use set_entryTable");
    static bool is_NE (SgAsmGenericFile*) ROSE_DEPRECATED("use isNe");
    virtual const char *format_name() const override ROSE_DEPRECATED("use formatName");
public:
    virtual ~SgAsmNEFileHeader();
 
public:
    SgAsmNEFileHeader();
 
protected:
    void initializeProperties();
#endif // SgAsmNEFileHeader_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmNEFileHeader: public SgAsmGenericHeader {…};
#endif // DOCUMENTATION
 
 
// SgAsmNEEntryTable           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmNEEntryTable);
IS_SERIALIZABLE(AsmNEEntryTable);
 
#ifndef DOCUMENTATION
AsmNEEntryTable.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmNEEntryTable);
#if defined(SgAsmNEEntryTable_HEADERS) || defined(DOCUMENTATION)
#include <Rose/BinaryAnalysis/Address.h>
#endif // SgAsmNEEntryTable_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmNEEntryTable: public SgAsmGenericSection {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmNEEntryTable.setDataPrototype(
        "SgSizeTList", "bundle_sizes", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmNEEntryTable.setDataPrototype(
        "SgAsmNEEntryPointPtrList", "entries", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmNEEntryTable);
#if defined(SgAsmNEEntryTable_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmNEEntryTable -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmNEEntryTable");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmGenericSection);
        s & BOOST_SERIALIZATION_NVP(p_bundle_sizes);
        s & BOOST_SERIALIZATION_NVP(p_entries);
        debugSerializationEnd("SgAsmNEEntryTable");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgSizeTList const& get_bundle_sizes() const;
    void set_bundle_sizes(SgSizeTList const&);
 
public:
    SgAsmNEEntryPointPtrList const& get_entries() const;
    SgAsmNEEntryPointPtrList& get_entries();
    void set_entries(SgAsmNEEntryPointPtrList const&);
public:
    SgAsmNEEntryTable(SgAsmNEFileHeader *fhdr, Rose::BinaryAnalysis::Address offset, Rose::BinaryAnalysis::Address size);
    void populate_entries();
    virtual void unparse(std::ostream&) const override;
    virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
public:
    virtual ~SgAsmNEEntryTable();
 
public:
    SgAsmNEEntryTable();
 
protected:
    void initializeProperties();
#endif // SgAsmNEEntryTable_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmNEEntryTable: public SgAsmGenericSection {…};
#endif // DOCUMENTATION
 
 
// SgAsmNEEntryPoint           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmNEEntryPoint);
IS_SERIALIZABLE(AsmNEEntryPoint);
 
#ifndef DOCUMENTATION
AsmNEEntryPoint.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmNEEntryPoint: public SgAsmExecutableFileFormat {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmNEEntryPoint.setDataPrototype(
        "SgAsmNEEntryPoint::NEEntryFlags", "flags", "= SgAsmNEEntryPoint::EF_ZERO",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmNEEntryPoint.setDataPrototype(
        "unsigned", "int3f", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmNEEntryPoint.setDataPrototype(
        "unsigned", "sectionIndex", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmNEEntryPoint.setDataPrototype(
        "unsigned", "sectionOffset", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmNEEntryPoint);
#if defined(SgAsmNEEntryPoint_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmNEEntryPoint -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmNEEntryPoint");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
        s & BOOST_SERIALIZATION_NVP(p_flags);
        s & BOOST_SERIALIZATION_NVP(p_int3f);
        s & BOOST_SERIALIZATION_NVP(p_sectionIndex);
        s & BOOST_SERIALIZATION_NVP(p_sectionOffset);
        debugSerializationEnd("SgAsmNEEntryPoint");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
    // Local types
public:
    enum NEEntryFlags {
        EF_ZERO             = 0x00,                     /* No flags set */
        EF_RESERVED         = 0xfc,                     /* Reserved bits */
        EF_EXPORTED         = 0x01,                     /* Exported */
        EF_GLOBAL           = 0x02                      /* Uses a global (shared) data section */
    };
 
    // Properties
public:
public:
    SgAsmNEEntryPoint::NEEntryFlags const& get_flags() const;
    void set_flags(SgAsmNEEntryPoint::NEEntryFlags const&);
 
public:
    unsigned const& get_int3f() const;
    void set_int3f(unsigned const&);
 
public:
    unsigned const& get_sectionIndex() const;
    void set_sectionIndex(unsigned const&);
 
public:
    unsigned const& get_sectionOffset() const;
    void set_sectionOffset(unsigned const&);
    // Functions
public:
    SgAsmNEEntryPoint(SgAsmNEEntryPoint::NEEntryFlags flags, unsigned int3f, unsigned s_idx, unsigned s_off);
    void dump(FILE*, const char *prefix, ssize_t idx) const;
 
    // Deprecated 2023-11
public:
    unsigned get_section_idx() const ROSE_DEPRECATED("use get_sectionIndex");
    void set_section_idx(unsigned) ROSE_DEPRECATED("use set_sectionIndex");
    unsigned get_section_offset() const ROSE_DEPRECATED("use get_sectionOffset");
    void set_section_offset(unsigned) ROSE_DEPRECATED("use set_sectionOffset");
public:
    virtual ~SgAsmNEEntryPoint();
 
public:
    SgAsmNEEntryPoint();
 
protected:
    void initializeProperties();
#endif // SgAsmNEEntryPoint_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmNEEntryPoint: public SgAsmExecutableFileFormat {…};
#endif // DOCUMENTATION
 
 
// SgAsmMipsInstruction           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmMipsInstruction);
IS_SERIALIZABLE(AsmMipsInstruction);
 
#ifndef DOCUMENTATION
AsmMipsInstruction.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmMipsInstruction);
#if defined(SgAsmMipsInstruction_HEADERS) || defined(DOCUMENTATION)
#include <Rose/BinaryAnalysis/InstructionEnumsMips.h>
#endif // SgAsmMipsInstruction_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmMipsInstruction: public SgAsmInstruction {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmMipsInstruction.setDataPrototype(
        "Rose::BinaryAnalysis::MipsInstructionKind", "kind", "= Rose::BinaryAnalysis::mips_unknown_instruction",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmMipsInstruction);
#if defined(SgAsmMipsInstruction_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmMipsInstruction -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmMipsInstruction");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmInstruction);
        s & BOOST_SERIALIZATION_NVP(p_kind);
        debugSerializationEnd("SgAsmMipsInstruction");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    Rose::BinaryAnalysis::MipsInstructionKind const& get_kind() const;
    void set_kind(Rose::BinaryAnalysis::MipsInstructionKind const&);
public:
    // Overrides are documented in the base class
    virtual unsigned get_anyKind() const override;
public:
    virtual ~SgAsmMipsInstruction();
 
public:
    SgAsmMipsInstruction();
 
public:
    SgAsmMipsInstruction(Rose::BinaryAnalysis::Address const& address,
                         uint8_t const& architectureId,
                         Rose::BinaryAnalysis::MipsInstructionKind const& kind);
 
protected:
    void initializeProperties();
#endif // SgAsmMipsInstruction_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmMipsInstruction: public SgAsmInstruction {…};
#endif // DOCUMENTATION
 
 
// SgAsmMemoryReferenceExpression           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmMemoryReferenceExpression);
IS_SERIALIZABLE(AsmMemoryReferenceExpression);
 
#ifndef DOCUMENTATION
AsmMemoryReferenceExpression.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmMemoryReferenceExpression: public SgAsmExpression {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmMemoryReferenceExpression.setDataPrototype(
        "SgAsmExpression*", "address", "= nullptr",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmMemoryReferenceExpression.setDataPrototype(
        "SgAsmExpression*", "segment", "= nullptr",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmMemoryReferenceExpression);
#if defined(SgAsmMemoryReferenceExpression_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmMemoryReferenceExpression -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmMemoryReferenceExpression");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExpression);
        s & BOOST_SERIALIZATION_NVP(p_address);
        s & BOOST_SERIALIZATION_NVP(p_segment);
        debugSerializationEnd("SgAsmMemoryReferenceExpression");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgAsmExpression* const& get_address() const;
    void set_address(SgAsmExpression* const&);
public:
    SgAsmExpression* const& get_segment() const;
    void set_segment(SgAsmExpression* const&);
public:
    virtual ~SgAsmMemoryReferenceExpression();
 
public:
    SgAsmMemoryReferenceExpression();
 
public:
    SgAsmMemoryReferenceExpression(SgAsmExpression* const& address,
                                   SgAsmExpression* const& segment);
 
protected:
    void initializeProperties();
#endif // SgAsmMemoryReferenceExpression_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmMemoryReferenceExpression: public SgAsmExpression {…};
#endif // DOCUMENTATION
 
 
// SgAsmM68kInstruction           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmM68kInstruction);
IS_SERIALIZABLE(AsmM68kInstruction);
 
#ifndef DOCUMENTATION
AsmM68kInstruction.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmM68kInstruction);
#if defined(SgAsmM68kInstruction_HEADERS) || defined(DOCUMENTATION)
#include <Rose/BinaryAnalysis/InstructionEnumsM68k.h>
#endif // SgAsmM68kInstruction_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmM68kInstruction: public SgAsmInstruction {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmM68kInstruction.setDataPrototype(
        "Rose::BinaryAnalysis::M68kInstructionKind", "kind", "= Rose::BinaryAnalysis::m68k_unknown_instruction",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmM68kInstruction.setDataPrototype(
        "Rose::BinaryAnalysis::M68kDataFormat", "dataFormat", "= Rose::BinaryAnalysis::m68k_fmt_unknown",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmM68kInstruction);
#if defined(SgAsmM68kInstruction_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmM68kInstruction -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmM68kInstruction");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmInstruction);
        s & BOOST_SERIALIZATION_NVP(p_kind);
        s & BOOST_SERIALIZATION_NVP(p_dataFormat);
        debugSerializationEnd("SgAsmM68kInstruction");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    Rose::BinaryAnalysis::M68kInstructionKind const& get_kind() const;
    void set_kind(Rose::BinaryAnalysis::M68kInstructionKind const&);
public:
    Rose::BinaryAnalysis::M68kDataFormat const& get_dataFormat() const;
    void set_dataFormat(Rose::BinaryAnalysis::M68kDataFormat const&);
public:
    // Overrides are documented in the base class
    virtual unsigned get_anyKind() const override;
public:
    virtual ~SgAsmM68kInstruction();
 
public:
    SgAsmM68kInstruction();
 
public:
    SgAsmM68kInstruction(Rose::BinaryAnalysis::Address const& address,
                         uint8_t const& architectureId,
                         Rose::BinaryAnalysis::M68kInstructionKind const& kind,
                         Rose::BinaryAnalysis::M68kDataFormat const& dataFormat);
 
protected:
    void initializeProperties();
#endif // SgAsmM68kInstruction_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmM68kInstruction: public SgAsmInstruction {…};
#endif // DOCUMENTATION
 
 
// SgAsmLESectionTable           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmLESectionTable);
IS_SERIALIZABLE(AsmLESectionTable);
 
#ifndef DOCUMENTATION
AsmLESectionTable.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmLESectionTable);
#if defined(SgAsmLESectionTable_HEADERS) || defined(DOCUMENTATION)
#include <Rose/BinaryAnalysis/Address.h>
#endif // SgAsmLESectionTable_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmLESectionTable: public SgAsmGenericSection {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmLESectionTable);
#if defined(SgAsmLESectionTable_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmLESectionTable -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmLESectionTable");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmGenericSection);
        debugSerializationEnd("SgAsmLESectionTable");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
    SgAsmLESectionTable(SgAsmLEFileHeader *fhdr, Rose::BinaryAnalysis::Address offset, Rose::BinaryAnalysis::Address size);
    virtual void unparse(std::ostream&) const override;
    virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
public:
    virtual ~SgAsmLESectionTable();
 
public:
    SgAsmLESectionTable();
 
protected:
    void initializeProperties();
#endif // SgAsmLESectionTable_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmLESectionTable: public SgAsmGenericSection {…};
#endif // DOCUMENTATION
 
 
// SgAsmLESectionTableEntry           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmLESectionTableEntry);
IS_SERIALIZABLE(AsmLESectionTableEntry);
 
#ifndef DOCUMENTATION
AsmLESectionTableEntry.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmLESectionTableEntry);
#if defined(SgAsmLESectionTableEntry_HEADERS) || defined(DOCUMENTATION)
#include <Rose/BinaryAnalysis/Address.h>
#include <Rose/BinaryAnalysis/ByteOrder.h>
#endif // SgAsmLESectionTableEntry_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmLESectionTableEntry: public SgAsmExecutableFileFormat {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmLESectionTableEntry.setDataPrototype(
        "unsigned", "flags", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmLESectionTableEntry.setDataPrototype(
        "unsigned", "pageMapIndex", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmLESectionTableEntry.setDataPrototype(
        "unsigned", "pageMapNEntries", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmLESectionTableEntry.setDataPrototype(
        "unsigned", "res1", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmLESectionTableEntry.setDataPrototype(
        "Rose::BinaryAnalysis::Address", "mappedSize", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmLESectionTableEntry.setDataPrototype(
        "Rose::BinaryAnalysis::Address", "baseAddr", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmLESectionTableEntry);
#if defined(SgAsmLESectionTableEntry_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmLESectionTableEntry -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmLESectionTableEntry");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
        s & BOOST_SERIALIZATION_NVP(p_flags);
        s & BOOST_SERIALIZATION_NVP(p_pageMapIndex);
        s & BOOST_SERIALIZATION_NVP(p_pageMapNEntries);
        s & BOOST_SERIALIZATION_NVP(p_res1);
        s & BOOST_SERIALIZATION_NVP(p_mappedSize);
        s & BOOST_SERIALIZATION_NVP(p_baseAddr);
        debugSerializationEnd("SgAsmLESectionTableEntry");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
    // Local types
public:
#ifdef _MSC_VER
# pragma pack (1)
#endif
    /* File format of a section table entry. Fields are big- or little-endian depending on file header. */
    struct LESectionTableEntry_disk {
        uint32_t    mapped_size;            /* 0x00 virtual segment size in bytes */
        uint32_t    base_addr;              /* 0x04 relocation base address */
        uint32_t    flags;                  /* 0x08 bit flags, see LESectionFlags */
        uint32_t    pagemap_index;          /* 0x0c */
        uint32_t    pagemap_nentries;       /* 0x10 number of entries in the page map */
        uint32_t    res1;                   /* 0x14 reserved */
    }                                     /* 0x18 */
    struct LESectionTableEntry_disk {…};
// DQ (3/7/2013): Adding support to restrict visability to SWIG.
#ifndef SWIG
#ifndef _MSC_VER
                __attribute__((packed))
#endif
#endif
                ;
#ifdef _MSC_VER
# pragma pack ()
#endif
 
    /* SF_BIG_BIT: The "big/default" bit, for data segments, controls the setting of the Big bit in the segment descriptor. (The
     *             Big bit, or B-bit, determines whether ESP or SP is used as the stack pointer.) For code segments, this bit
     *             controls the setting of the Default bit in the segment descriptor. (The Default bit, or D-bit, determines
     *             whether the default word size is 32-bits or 16-bits. It also affects the interpretation of the instruction
     *             stream.) */
    enum LESectionFlags {
        SF_RESERVED         = 0xffff0800,   /* Reserved bits (FIXME) */
 
        SF_READABLE         = 0x00000001,   
        SF_WRITABLE         = 0x00000002,   
        SF_EXECUTABLE       = 0x00000004,   
        SF_RESOURCE         = 0x00000008,   
        SF_DISCARDABLE      = 0x00000010,   
        SF_SHARED           = 0x00000020,   
        SF_PRELOAD_PAGES    = 0x00000040,   
        SF_INVALID_PAGES    = 0x00000080,   
        SF_TYPE_MASK        = 0x00000300,        /*NO_STRINGIFY*/
        SF_TYPE_NORMAL      = 0x00000000,
        SF_TYPE_ZERO        = 0x00000100,   
        SF_TYPE_RESIDENT    = 0x00000200,   
        SF_TYPE_RESCONT     = 0x00000300,   
        SF_RES_LONG_LOCK    = 0x00000400,   
        SF_1616_ALIAS       = 0x00001000,   
        SF_BIG_BIT          = 0x00002000,   
        SF_CODE_CONFORM     = 0x00004000,   
        SF_IO_PRIV          = 0x00008000    
    };
    enum LESectionFlags {…};
 
    // Properties
public:
public:
    unsigned const& get_flags() const;
    void set_flags(unsigned const&);
 
public:
    unsigned const& get_pageMapIndex() const;
    void set_pageMapIndex(unsigned const&);
 
public:
    unsigned const& get_pageMapNEntries() const;
    void set_pageMapNEntries(unsigned const&);
 
public:
    unsigned const& get_res1() const;
    void set_res1(unsigned const&);
 
public:
    Rose::BinaryAnalysis::Address const& get_mappedSize() const;
    void set_mappedSize(Rose::BinaryAnalysis::Address const&);
 
public:
    Rose::BinaryAnalysis::Address const& get_baseAddr() const;
    void set_baseAddr(Rose::BinaryAnalysis::Address const&);
    // Functions
public:
    SgAsmLESectionTableEntry(Rose::BinaryAnalysis::ByteOrder::Endianness sex,
                             const SgAsmLESectionTableEntry::LESectionTableEntry_disk *disk);
    void *encode(Rose::BinaryAnalysis::ByteOrder::Endianness, SgAsmLESectionTableEntry::LESectionTableEntry_disk*) const;
    virtual void dump(FILE *f, const char *prefix, ssize_t idx) const;
 
    // Deprecated 2023-11
public:
    unsigned get_pagemap_index() const ROSE_DEPRECATED("use get pageMapIndex");
    void set_pagemap_index(unsigned) ROSE_DEPRECATED("use set_pageMapIndex");
    unsigned get_pagemap_nentries() const ROSE_DEPRECATED("use get_pageMapNEntries");
    void set_pagemap_nentries(unsigned) ROSE_DEPRECATED("use set_pageMapNEntries");
    Rose::BinaryAnalysis::Address get_mapped_size() const ROSE_DEPRECATED("use get_mappedSize");
    void set_mapped_size(Rose::BinaryAnalysis::Address) ROSE_DEPRECATED("use set_mappedSize");
    Rose::BinaryAnalysis::Address get_base_addr() const ROSE_DEPRECATED("use get_baseAddr");
    void set_base_addr(Rose::BinaryAnalysis::Address) ROSE_DEPRECATED("use set_baseAddr");
public:
    virtual ~SgAsmLESectionTableEntry();
 
public:
    SgAsmLESectionTableEntry();
 
protected:
    void initializeProperties();
#endif // SgAsmLESectionTableEntry_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmLESectionTableEntry: public SgAsmExecutableFileFormat {…};
#endif // DOCUMENTATION
 
 
// SgAsmLESection           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmLESection);
IS_SERIALIZABLE(AsmLESection);
 
#ifndef DOCUMENTATION
AsmLESection.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmLESection);
#if defined(SgAsmLESection_HEADERS) || defined(DOCUMENTATION)
#ifdef ROSE_SgAsmLESection_IMPL
#include <SgAsmLESectionTableEntry.h>
#endif
#endif // SgAsmLESection_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmLESection: public SgAsmGenericSection {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmLESection.setDataPrototype(
        "SgAsmLESectionTableEntry*", "sectionTableEntry", "= nullptr",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmLESection);
#if defined(SgAsmLESection_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmLESection -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmLESection");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmGenericSection);
        s & BOOST_SERIALIZATION_NVP(p_sectionTableEntry);
        debugSerializationEnd("SgAsmLESection");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgAsmLESectionTableEntry* const& get_sectionTableEntry() const;
    void set_sectionTableEntry(SgAsmLESectionTableEntry* const&);
public:
    explicit SgAsmLESection(SgAsmLEFileHeader*);
    virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
 
    // Deprecated 2023-11
public:
    SgAsmLESectionTableEntry* get_st_entry() const ROSE_DEPRECATED("use get_sectionTableEntry");
    void set_st_entry(SgAsmLESectionTableEntry*) ROSE_DEPRECATED("use set_sectionTableEntry");
public:
    virtual ~SgAsmLESection();
 
public:
    SgAsmLESection();
 
protected:
    void initializeProperties();
#endif // SgAsmLESection_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmLESection: public SgAsmGenericSection {…};
#endif // DOCUMENTATION
 
 
// SgAsmLERelocTable           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmLERelocTable);
IS_SERIALIZABLE(AsmLERelocTable);
 
#ifndef DOCUMENTATION
AsmLERelocTable.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmLERelocTable);
#if defined(SgAsmLERelocTable_HEADERS) || defined(DOCUMENTATION)
#include <Rose/BinaryAnalysis/Address.h>
#endif // SgAsmLERelocTable_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmLERelocTable: public SgAsmGenericSection {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmLERelocTable.setDataPrototype(
        "SgAsmLERelocEntryPtrList", "entries", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmLERelocTable);
#if defined(SgAsmLERelocTable_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmLERelocTable -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmLERelocTable");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmGenericSection);
        s & BOOST_SERIALIZATION_NVP(p_entries);
        debugSerializationEnd("SgAsmLERelocTable");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgAsmLERelocEntryPtrList const& get_entries() const;
    SgAsmLERelocEntryPtrList& get_entries();
    void set_entries(SgAsmLERelocEntryPtrList const&);
public:
    SgAsmLERelocTable(SgAsmLEFileHeader *fhdr, Rose::BinaryAnalysis::Address offset);
    virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
public:
    virtual ~SgAsmLERelocTable();
 
public:
    SgAsmLERelocTable();
 
protected:
    void initializeProperties();
#endif // SgAsmLERelocTable_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmLERelocTable: public SgAsmGenericSection {…};
#endif // DOCUMENTATION
 
 
// SgAsmLEPageTable           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmLEPageTable);
IS_SERIALIZABLE(AsmLEPageTable);
 
#ifndef DOCUMENTATION
AsmLEPageTable.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmLEPageTable);
#if defined(SgAsmLEPageTable_HEADERS) || defined(DOCUMENTATION)
#include <Rose/BinaryAnalysis/Address.h>
#endif // SgAsmLEPageTable_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmLEPageTable: public SgAsmGenericSection {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmLEPageTable.setDataPrototype(
        "SgAsmLEPageTableEntryPtrList", "entries", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmLEPageTable);
#if defined(SgAsmLEPageTable_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmLEPageTable -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmLEPageTable");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmGenericSection);
        s & BOOST_SERIALIZATION_NVP(p_entries);
        debugSerializationEnd("SgAsmLEPageTable");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgAsmLEPageTableEntryPtrList const& get_entries() const;
    SgAsmLEPageTableEntryPtrList& get_entries();
    void set_entries(SgAsmLEPageTableEntryPtrList const&);
public:
    SgAsmLEPageTable(SgAsmLEFileHeader *fhdr, Rose::BinaryAnalysis::Address offset, Rose::BinaryAnalysis::Address size);
    virtual void unparse(std::ostream&) const override;
    virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
    SgAsmLEPageTableEntry *get_page(size_t idx);
public:
    virtual ~SgAsmLEPageTable();
 
public:
    SgAsmLEPageTable();
 
protected:
    void initializeProperties();
#endif // SgAsmLEPageTable_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmLEPageTable: public SgAsmGenericSection {…};
#endif // DOCUMENTATION
 
 
// SgAsmLEPageTableEntry           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmLEPageTableEntry);
IS_SERIALIZABLE(AsmLEPageTableEntry);
 
#ifndef DOCUMENTATION
AsmLEPageTableEntry.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmLEPageTableEntry);
#if defined(SgAsmLEPageTableEntry_HEADERS) || defined(DOCUMENTATION)
#include <Rose/BinaryAnalysis/ByteOrder.h>
#endif // SgAsmLEPageTableEntry_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmLEPageTableEntry: public SgAsmExecutableFileFormat {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmLEPageTableEntry.setDataPrototype(
        "unsigned", "pageno", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmLEPageTableEntry.setDataPrototype(
        "unsigned", "flags", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmLEPageTableEntry);
#if defined(SgAsmLEPageTableEntry_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmLEPageTableEntry -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmLEPageTableEntry");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
        s & BOOST_SERIALIZATION_NVP(p_pageno);
        s & BOOST_SERIALIZATION_NVP(p_flags);
        debugSerializationEnd("SgAsmLEPageTableEntry");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
    // Local types
public:
    /* The object page table provides information about a logical page in a section. A logical page may be an enumerated page, a
     * pseudo page, or an iterated page. The page table allows for efficient access to a page when a page fault occurs, while still
     * allowing the physical page to be located in the preload page, demand load page, or iterated data page sections of the
     * executable file. Entries in the page table use 1-origin indices.  This table is parallel with the Fixup Page Table (they are
     * both indexed by the logical page number). */
 
#ifdef _MSC_VER
# pragma pack (1)
#endif
    /* File format for a page table entry */
    struct LEPageTableEntry_disk {
        uint16_t            pageno_hi;
        unsigned char       pageno_lo;
        unsigned char       flags;
    }
    struct LEPageTableEntry_disk {…};
// DQ (3/7/2013): Adding support to restrict visability to SWIG.
#ifndef SWIG
#ifndef _MSC_VER
                __attribute__((packed))
#endif
#endif
                ;
#ifdef _MSC_VER
# pragma pack ()
#endif
 
    // Properties
public:
public:
    unsigned const& get_pageno() const;
    void set_pageno(unsigned const&);
 
public:
    unsigned const& get_flags() const;
    void set_flags(unsigned const&);
    // Functions
public:
    SgAsmLEPageTableEntry(Rose::BinaryAnalysis::ByteOrder::Endianness sex,
                          const SgAsmLEPageTableEntry::LEPageTableEntry_disk *disk);
    void dump(FILE*, const char *prefix, ssize_t idx) const;
    void *encode(Rose::BinaryAnalysis::ByteOrder::Endianness, SgAsmLEPageTableEntry::LEPageTableEntry_disk*) const;
public:
    virtual ~SgAsmLEPageTableEntry();
 
public:
    SgAsmLEPageTableEntry();
 
protected:
    void initializeProperties();
#endif // SgAsmLEPageTableEntry_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmLEPageTableEntry: public SgAsmExecutableFileFormat {…};
#endif // DOCUMENTATION
 
 
// SgAsmLENameTable           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmLENameTable);
IS_SERIALIZABLE(AsmLENameTable);
 
#ifndef DOCUMENTATION
AsmLENameTable.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmLENameTable);
#if defined(SgAsmLENameTable_HEADERS) || defined(DOCUMENTATION)
#include <Rose/BinaryAnalysis/Address.h>
#endif // SgAsmLENameTable_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmLENameTable: public SgAsmGenericSection {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmLENameTable.setDataPrototype(
        "SgStringList", "names", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmLENameTable.setDataPrototype(
        "SgUnsignedList", "ordinals", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmLENameTable);
#if defined(SgAsmLENameTable_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmLENameTable -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmLENameTable");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmGenericSection);
        s & BOOST_SERIALIZATION_NVP(p_names);
        s & BOOST_SERIALIZATION_NVP(p_ordinals);
        debugSerializationEnd("SgAsmLENameTable");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgStringList const& get_names() const;
    void set_names(SgStringList const&);
 
public:
    SgUnsignedList const& get_ordinals() const;
    void set_ordinals(SgUnsignedList const&);
public:
    /* This table contains a module name followed by the list of exported function names. Each name is associated with an "ordinal"
     * which serves as an index into the Entry Table. The ordinal for the first string (module name) is meaningless and should be
     * zero. In the non-resident name table the first entry is a module description and the functions are not always resident in
     * system memory (they are discardable). */
    SgAsmLENameTable(SgAsmLEFileHeader *fhdr, Rose::BinaryAnalysis::Address offset);
    virtual void unparse(std::ostream&) const override;
    virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
public:
    virtual ~SgAsmLENameTable();
 
public:
    SgAsmLENameTable();
 
protected:
    void initializeProperties();
#endif // SgAsmLENameTable_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmLENameTable: public SgAsmGenericSection {…};
#endif // DOCUMENTATION
 
 
// SgAsmLEFileHeader           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmLEFileHeader);
IS_SERIALIZABLE(AsmLEFileHeader);
 
#ifndef DOCUMENTATION
AsmLEFileHeader.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmLEFileHeader);
#if defined(SgAsmLEFileHeader_HEADERS) || defined(DOCUMENTATION)
#include <Rose/BinaryAnalysis/Address.h>
#include <Rose/BinaryAnalysis/ByteOrder.h>
 
#ifdef ROSE_SgAsmLEFileHeader_IMPL
#include <SgAsmDOSExtendedHeader.h>
#include <SgAsmLEEntryTable.h>
#include <SgAsmLENameTable.h>
#include <SgAsmLEPageTable.h>
#include <SgAsmLERelocTable.h>
#include <SgAsmLESectionTable.h>
#endif
#endif // SgAsmLEFileHeader_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmLEFileHeader: public SgAsmGenericHeader {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmLEFileHeader.setDataPrototype(
        "unsigned", "e_byte_order", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmLEFileHeader.setDataPrototype(
        "unsigned", "e_word_order", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmLEFileHeader.setDataPrototype(
        "unsigned", "e_format_level", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmLEFileHeader.setDataPrototype(
        "unsigned", "e_cpu_type", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmLEFileHeader.setDataPrototype(
        "unsigned", "e_os_type", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmLEFileHeader.setDataPrototype(
        "unsigned", "e_module_version", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmLEFileHeader.setDataPrototype(
        "unsigned", "e_flags", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmLEFileHeader.setDataPrototype(
        "unsigned", "e_eip_section", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmLEFileHeader.setDataPrototype(
        "unsigned", "e_esp_section", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmLEFileHeader.setDataPrototype(
        "unsigned", "e_last_page_size", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmLEFileHeader.setDataPrototype(
        "unsigned", "e_page_offset_shift", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmLEFileHeader.setDataPrototype(
        "unsigned", "e_fixup_sect_cksum", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmLEFileHeader.setDataPrototype(
        "unsigned", "e_loader_sect_cksum", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmLEFileHeader.setDataPrototype(
        "unsigned", "e_secttab_nentries", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmLEFileHeader.setDataPrototype(
        "unsigned", "e_rsrctab_nentries", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmLEFileHeader.setDataPrototype(
        "unsigned", "e_fmtdirtab_nentries", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmLEFileHeader.setDataPrototype(
        "unsigned", "e_import_modtab_nentries", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmLEFileHeader.setDataPrototype(
        "unsigned", "e_preload_npages", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmLEFileHeader.setDataPrototype(
        "unsigned", "e_nonresnametab_size", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmLEFileHeader.setDataPrototype(
        "unsigned", "e_nonresnametab_cksum", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmLEFileHeader.setDataPrototype(
        "unsigned", "e_auto_ds_section", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmLEFileHeader.setDataPrototype(
        "unsigned", "e_debug_info_size", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmLEFileHeader.setDataPrototype(
        "unsigned", "e_num_instance_preload", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmLEFileHeader.setDataPrototype(
        "unsigned", "e_num_instance_demand", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmLEFileHeader.setDataPrototype(
        "unsigned", "e_heap_size", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmLEFileHeader.setDataPrototype(
        "Rose::BinaryAnalysis::Address", "e_npages", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmLEFileHeader.setDataPrototype(
        "Rose::BinaryAnalysis::Address", "e_eip", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmLEFileHeader.setDataPrototype(
        "Rose::BinaryAnalysis::Address", "e_esp", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmLEFileHeader.setDataPrototype(
        "Rose::BinaryAnalysis::Address", "e_page_size", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmLEFileHeader.setDataPrototype(
        "Rose::BinaryAnalysis::Address", "e_fixup_sect_size", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmLEFileHeader.setDataPrototype(
        "Rose::BinaryAnalysis::Address", "e_loader_sect_size", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmLEFileHeader.setDataPrototype(
        "Rose::BinaryAnalysis::Address", "e_secttab_rfo", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmLEFileHeader.setDataPrototype(
        "Rose::BinaryAnalysis::Address", "e_pagetab_rfo", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmLEFileHeader.setDataPrototype(
        "Rose::BinaryAnalysis::Address", "e_iterpages_offset", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmLEFileHeader.setDataPrototype(
        "Rose::BinaryAnalysis::Address", "e_rsrctab_rfo", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmLEFileHeader.setDataPrototype(
        "Rose::BinaryAnalysis::Address", "e_resnametab_rfo", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmLEFileHeader.setDataPrototype(
        "Rose::BinaryAnalysis::Address", "e_entrytab_rfo", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmLEFileHeader.setDataPrototype(
        "Rose::BinaryAnalysis::Address", "e_fmtdirtab_rfo", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmLEFileHeader.setDataPrototype(
        "Rose::BinaryAnalysis::Address", "e_fixup_pagetab_rfo", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmLEFileHeader.setDataPrototype(
        "Rose::BinaryAnalysis::Address", "e_fixup_rectab_rfo", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmLEFileHeader.setDataPrototype(
        "Rose::BinaryAnalysis::Address", "e_import_modtab_rfo", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmLEFileHeader.setDataPrototype(
        "Rose::BinaryAnalysis::Address", "e_import_proctab_rfo", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmLEFileHeader.setDataPrototype(
        "Rose::BinaryAnalysis::Address", "e_ppcksumtab_rfo", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmLEFileHeader.setDataPrototype(
        "Rose::BinaryAnalysis::Address", "e_data_pages_offset", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmLEFileHeader.setDataPrototype(
        "Rose::BinaryAnalysis::Address", "e_nonresnametab_offset", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmLEFileHeader.setDataPrototype(
        "Rose::BinaryAnalysis::Address", "e_debug_info_rfo", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmLEFileHeader.setDataPrototype(
        "SgAsmDOSExtendedHeader*", "dos2Header", "= nullptr",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmLEFileHeader.setDataPrototype(
        "SgAsmLESectionTable*", "sectionTable", "= nullptr",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmLEFileHeader.setDataPrototype(
        "SgAsmLEPageTable*", "pageTable", "= nullptr",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmLEFileHeader.setDataPrototype(
        "SgAsmLENameTable*", "residentNameTable", "= nullptr",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmLEFileHeader.setDataPrototype(
        "SgAsmLENameTable*", "nonresidentNameTable", "= nullptr",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmLEFileHeader.setDataPrototype(
        "SgAsmLEEntryTable*", "entryTable", "= nullptr",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmLEFileHeader.setDataPrototype(
        "SgAsmLERelocTable*", "relocationTable", "= nullptr",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmLEFileHeader);
#if defined(SgAsmLEFileHeader_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmLEFileHeader -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmLEFileHeader");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmGenericHeader);
        s & BOOST_SERIALIZATION_NVP(p_e_byte_order);
        s & BOOST_SERIALIZATION_NVP(p_e_word_order);
        s & BOOST_SERIALIZATION_NVP(p_e_format_level);
        s & BOOST_SERIALIZATION_NVP(p_e_cpu_type);
        s & BOOST_SERIALIZATION_NVP(p_e_os_type);
        s & BOOST_SERIALIZATION_NVP(p_e_module_version);
        s & BOOST_SERIALIZATION_NVP(p_e_flags);
        s & BOOST_SERIALIZATION_NVP(p_e_eip_section);
        s & BOOST_SERIALIZATION_NVP(p_e_esp_section);
        s & BOOST_SERIALIZATION_NVP(p_e_last_page_size);
        s & BOOST_SERIALIZATION_NVP(p_e_page_offset_shift);
        s & BOOST_SERIALIZATION_NVP(p_e_fixup_sect_cksum);
        s & BOOST_SERIALIZATION_NVP(p_e_loader_sect_cksum);
        s & BOOST_SERIALIZATION_NVP(p_e_secttab_nentries);
        s & BOOST_SERIALIZATION_NVP(p_e_rsrctab_nentries);
        s & BOOST_SERIALIZATION_NVP(p_e_fmtdirtab_nentries);
        s & BOOST_SERIALIZATION_NVP(p_e_import_modtab_nentries);
        s & BOOST_SERIALIZATION_NVP(p_e_preload_npages);
        s & BOOST_SERIALIZATION_NVP(p_e_nonresnametab_size);
        s & BOOST_SERIALIZATION_NVP(p_e_nonresnametab_cksum);
        s & BOOST_SERIALIZATION_NVP(p_e_auto_ds_section);
        s & BOOST_SERIALIZATION_NVP(p_e_debug_info_size);
        s & BOOST_SERIALIZATION_NVP(p_e_num_instance_preload);
        s & BOOST_SERIALIZATION_NVP(p_e_num_instance_demand);
        s & BOOST_SERIALIZATION_NVP(p_e_heap_size);
        s & BOOST_SERIALIZATION_NVP(p_e_npages);
        s & BOOST_SERIALIZATION_NVP(p_e_eip);
        s & BOOST_SERIALIZATION_NVP(p_e_esp);
        s & BOOST_SERIALIZATION_NVP(p_e_page_size);
        s & BOOST_SERIALIZATION_NVP(p_e_fixup_sect_size);
        s & BOOST_SERIALIZATION_NVP(p_e_loader_sect_size);
        s & BOOST_SERIALIZATION_NVP(p_e_secttab_rfo);
        s & BOOST_SERIALIZATION_NVP(p_e_pagetab_rfo);
        s & BOOST_SERIALIZATION_NVP(p_e_iterpages_offset);
        s & BOOST_SERIALIZATION_NVP(p_e_rsrctab_rfo);
        s & BOOST_SERIALIZATION_NVP(p_e_resnametab_rfo);
        s & BOOST_SERIALIZATION_NVP(p_e_entrytab_rfo);
        s & BOOST_SERIALIZATION_NVP(p_e_fmtdirtab_rfo);
        s & BOOST_SERIALIZATION_NVP(p_e_fixup_pagetab_rfo);
        s & BOOST_SERIALIZATION_NVP(p_e_fixup_rectab_rfo);
        s & BOOST_SERIALIZATION_NVP(p_e_import_modtab_rfo);
        s & BOOST_SERIALIZATION_NVP(p_e_import_proctab_rfo);
        s & BOOST_SERIALIZATION_NVP(p_e_ppcksumtab_rfo);
        s & BOOST_SERIALIZATION_NVP(p_e_data_pages_offset);
        s & BOOST_SERIALIZATION_NVP(p_e_nonresnametab_offset);
        s & BOOST_SERIALIZATION_NVP(p_e_debug_info_rfo);
        s & BOOST_SERIALIZATION_NVP(p_dos2Header);
        s & BOOST_SERIALIZATION_NVP(p_sectionTable);
        s & BOOST_SERIALIZATION_NVP(p_pageTable);
        s & BOOST_SERIALIZATION_NVP(p_residentNameTable);
        s & BOOST_SERIALIZATION_NVP(p_nonresidentNameTable);
        s & BOOST_SERIALIZATION_NVP(p_entryTable);
        s & BOOST_SERIALIZATION_NVP(p_relocationTable);
        debugSerializationEnd("SgAsmLEFileHeader");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
    // Local types
public:
#ifdef _MSC_VER
# pragma pack (1)
#endif
    /* File format of an LE/LX File Header (they are identical except bytes 0x2c-0x2f) */
    struct LEFileHeader_disk {
        unsigned char e_magic[2];           /* 0x00 magic number "LX" */
        unsigned char e_byte_order;         /* 0x02 byte order (0=>little endian; otherwise big endian) */
        unsigned char e_word_order;         /* 0x03 word order (0=>little endian; otherwise big endian) */
        uint32_t    e_format_level;         /* 0x04 LX file format version number */
        uint16_t    e_cpu_type;             /* 0x08 1=>80286, 2=>80386, 3=>80486,4=80586, etc. (see ctor) */
        uint16_t    e_os_type;              /* 0x0a 0=>unknown, 1=>0S/2, 2=>Windows, 3=>DOS 4.x, 4=>Windows 386 */
        uint32_t    e_module_version;       /* 0x0c user-specified module version number */
        uint32_t    e_flags;                /* 0x10 bit flags (see LXFileHeaderFlags) */
        uint32_t    e_npages;               /* 0x14 number of physically contained pages (see e_page_size) */
        uint32_t    e_eip_section;          /* 0x18 the section number to which e_eip is relative */
        uint32_t    e_eip;                  /* 0x1c entry address relative to e_eip_section */
        uint32_t    e_esp_section;          /* 0x20 the section number to which e_esp is relative */
        uint32_t    e_esp;                  /* 0x24 starting stack address relative to e_esp_section */
        uint32_t    e_page_size;            /* 0x28 page size in bytes */
        uint32_t    e_lps_or_shift;         /* 0x2c size of last page (LE) or shift for page table's page offset field (LX) */
        uint32_t    e_fixup_sect_size;      /* 0x30 total size of fixup info in bytes (fixup page/record tables + import names) */
        uint32_t    e_fixup_sect_cksum;     /* 0x34 cryptographic checksum of all fixup info, or zero */
        uint32_t    e_loader_sect_size;     /* 0x38 size of memory resident tables (section table through per-page checksum table) */
        uint32_t    e_loader_sect_cksum;    /* 0x3c cryptographic checksum for all loader info, or zero */
        uint32_t    e_secttab_rfo;          /* 0x40 offset of section table relative to this header */
        uint32_t    e_secttab_nentries;     /* 0x44 number of entries in section table */
        uint32_t    e_pagetab_rfo;          /* 0x48 section page table offset relative to this header */
        uint32_t    e_iterpages_offset;     /* 0x4c section iterated pages offset (absolute file offset) */
        uint32_t    e_rsrctab_rfo;          /* 0x50 offset of resource table relative to this header */
        uint32_t    e_rsrctab_nentries;     /* 0x54 number of entries in the resource table */
        uint32_t    e_resnametab_rfo;       /* 0x58 offset of resident name table relative to this header */
        uint32_t    e_entrytab_rfo;         /* 0x5c offset of entry table relative to this header */
        uint32_t    e_fmtdirtab_rfo;        /* 0x60 offset of module format directives relative to this header */
        uint32_t    e_fmtdirtab_nentries;   /* 0x64 number of entries in module format directives table */
        uint32_t    e_fixup_pagetab_rfo;    /* 0x68 offset of fixup page table relative to this header */
        uint32_t    e_fixup_rectab_rfo;     /* 0x6c offset of fixup record table relative to this header */
        uint32_t    e_import_modtab_rfo;    /* 0x70 offset of import module name table relative to this header */
        uint32_t    e_import_modtab_nentries;/*0x74 number of entries in import module name table */
        uint32_t    e_import_proctab_rfo;   /* 0x78 offset of import procedure name table relative to this header */
        uint32_t    e_ppcksumtab_rfo;       /* 0x7c offset of per-page checksum table relative to this header */
        uint32_t    e_data_pages_offset;    /* 0x80 offset of data pages (absolute file offset) */
        uint32_t    e_preload_npages;       /* 0x84 number of preload pages (not respected by OS/2) */
        uint32_t    e_nonresnametab_offset; /* 0x88 offset of non-resident name table (absolute file offset) */
        uint32_t    e_nonresnametab_size;   /* 0x8c size of non-resident name table in bytes */
        uint32_t    e_nonresnametab_cksum;  /* 0x90 cryptographic checksum of the non-resident name table */
        uint32_t    e_auto_ds_section;      /* 0x94 auto data segment section number (not used by 32-bit modules) */
        uint32_t    e_debug_info_rfo;       /* 0x98 offset of debug information relative to this header */
        uint32_t    e_debug_info_size;      /* 0x9c size of debug information in bytes */
        uint32_t    e_num_instance_preload; /* 0xa0 number of instance data pages found in the preload section */
        uint32_t    e_num_instance_demand;  /* 0xa4 number of instance data pages found in the demand section */
        uint32_t    e_heap_size;            /* 0xa8 number of bytes added to auto data segment by loader (not used by 32-bit) */
    }                                       /* 0xac */
    struct LEFileHeader_disk {…};
// DQ (3/7/2013): Adding support to restrict visability to SWIG.
#ifndef SWIG
#ifndef _MSC_VER
          __attribute__((packed))
#endif
#endif
          ;
#ifdef _MSC_VER
# pragma pack ()
#endif
 
    enum LEFileHeaderFlags {
        HF_RESERVED         = 0xbffc5ccb,   /* Reserved bits */
        HF_PROC_LIB_INIT    = 0x00000004,   /* Per-process library initialization; not used for executables */
        HF_IFIXUPS_APPLIED  = 0x00000010,   /* Sections have preferred load addresses and internal relocs have been applied */
        HF_EFIXUPS_APPLIED  = 0x00000020,   /* External fixups for the module have been applied */
        HF_PM_WINDOW_NO     = 0x00000100,   /* Incompatible with PM windowing */
        HF_PM_WINDOW_OK     = 0x00000200,   /* Compatible with PM windowing */
        HF_PM_WINDOW_USE    = 0x00000300,   /* Uses PM windowing API */
        HF_NOT_LOADABLE     = 0x00002000,   /* Module is not loadable (has errors or incrementally linked) */
        HF_PROC_LIB_TERM    = 0x40000000,   /* Per-process library termination; not used for executables */
 
        HF_MODTYPE_MASK     = 0x00038000,   /* Module type mask */
        HF_MODTYPE_PROG     = 0x00000000,   /* Program module (other modules cannot link to this one) */
        HF_MODTYPE_LIB      = 0x00008000,   /* Library module */
        HF_MODTYPE_PLIB     = 0x00018000,   /* Protected memory library module */
        HF_MODTYPE_PDEV     = 0x00020000,   /* Physical device driver module */
        HF_MODTYPE_VDEV     = 0x00028000    /* Virtual device driver module */
    };
 
    // Properties
public:
public:
    unsigned const& get_e_byte_order() const;
    void set_e_byte_order(unsigned const&);
 
public:
    unsigned const& get_e_word_order() const;
    void set_e_word_order(unsigned const&);
 
public:
    unsigned const& get_e_format_level() const;
    void set_e_format_level(unsigned const&);
 
public:
    unsigned const& get_e_cpu_type() const;
    void set_e_cpu_type(unsigned const&);
 
public:
    unsigned const& get_e_os_type() const;
    void set_e_os_type(unsigned const&);
 
public:
    unsigned const& get_e_module_version() const;
    void set_e_module_version(unsigned const&);
 
public:
    unsigned const& get_e_flags() const;
    void set_e_flags(unsigned const&);
 
public:
    unsigned const& get_e_eip_section() const;
    void set_e_eip_section(unsigned const&);
 
public:
    unsigned const& get_e_esp_section() const;
    void set_e_esp_section(unsigned const&);
 
public:
    unsigned const& get_e_last_page_size() const;
    void set_e_last_page_size(unsigned const&);
 
public:
    unsigned const& get_e_page_offset_shift() const;
    void set_e_page_offset_shift(unsigned const&);
 
public:
    unsigned const& get_e_fixup_sect_cksum() const;
    void set_e_fixup_sect_cksum(unsigned const&);
 
public:
    unsigned const& get_e_loader_sect_cksum() const;
    void set_e_loader_sect_cksum(unsigned const&);
 
public:
    unsigned const& get_e_secttab_nentries() const;
    void set_e_secttab_nentries(unsigned const&);
 
public:
    unsigned const& get_e_rsrctab_nentries() const;
    void set_e_rsrctab_nentries(unsigned const&);
 
public:
    unsigned const& get_e_fmtdirtab_nentries() const;
    void set_e_fmtdirtab_nentries(unsigned const&);
 
public:
    unsigned const& get_e_import_modtab_nentries() const;
    void set_e_import_modtab_nentries(unsigned const&);
 
public:
    unsigned const& get_e_preload_npages() const;
    void set_e_preload_npages(unsigned const&);
 
public:
    unsigned const& get_e_nonresnametab_size() const;
    void set_e_nonresnametab_size(unsigned const&);
 
public:
    unsigned const& get_e_nonresnametab_cksum() const;
    void set_e_nonresnametab_cksum(unsigned const&);
 
public:
    unsigned const& get_e_auto_ds_section() const;
    void set_e_auto_ds_section(unsigned const&);
 
public:
    unsigned const& get_e_debug_info_size() const;
    void set_e_debug_info_size(unsigned const&);
 
public:
    unsigned const& get_e_num_instance_preload() const;
    void set_e_num_instance_preload(unsigned const&);
 
public:
    unsigned const& get_e_num_instance_demand() const;
    void set_e_num_instance_demand(unsigned const&);
 
public:
    unsigned const& get_e_heap_size() const;
    void set_e_heap_size(unsigned const&);
 
public:
    Rose::BinaryAnalysis::Address const& get_e_npages() const;
    void set_e_npages(Rose::BinaryAnalysis::Address const&);
 
public:
    Rose::BinaryAnalysis::Address const& get_e_eip() const;
    void set_e_eip(Rose::BinaryAnalysis::Address const&);
 
public:
    Rose::BinaryAnalysis::Address const& get_e_esp() const;
    void set_e_esp(Rose::BinaryAnalysis::Address const&);
 
public:
    Rose::BinaryAnalysis::Address const& get_e_page_size() const;
    void set_e_page_size(Rose::BinaryAnalysis::Address const&);
 
public:
    Rose::BinaryAnalysis::Address const& get_e_fixup_sect_size() const;
    void set_e_fixup_sect_size(Rose::BinaryAnalysis::Address const&);
 
public:
    Rose::BinaryAnalysis::Address const& get_e_loader_sect_size() const;
    void set_e_loader_sect_size(Rose::BinaryAnalysis::Address const&);
 
public:
    Rose::BinaryAnalysis::Address const& get_e_secttab_rfo() const;
    void set_e_secttab_rfo(Rose::BinaryAnalysis::Address const&);
 
public:
    Rose::BinaryAnalysis::Address const& get_e_pagetab_rfo() const;
    void set_e_pagetab_rfo(Rose::BinaryAnalysis::Address const&);
 
public:
    Rose::BinaryAnalysis::Address const& get_e_iterpages_offset() const;
    void set_e_iterpages_offset(Rose::BinaryAnalysis::Address const&);
 
public:
    Rose::BinaryAnalysis::Address const& get_e_rsrctab_rfo() const;
    void set_e_rsrctab_rfo(Rose::BinaryAnalysis::Address const&);
 
public:
    Rose::BinaryAnalysis::Address const& get_e_resnametab_rfo() const;
    void set_e_resnametab_rfo(Rose::BinaryAnalysis::Address const&);
 
public:
    Rose::BinaryAnalysis::Address const& get_e_entrytab_rfo() const;
    void set_e_entrytab_rfo(Rose::BinaryAnalysis::Address const&);
 
public:
    Rose::BinaryAnalysis::Address const& get_e_fmtdirtab_rfo() const;
    void set_e_fmtdirtab_rfo(Rose::BinaryAnalysis::Address const&);
 
public:
    Rose::BinaryAnalysis::Address const& get_e_fixup_pagetab_rfo() const;
    void set_e_fixup_pagetab_rfo(Rose::BinaryAnalysis::Address const&);
 
public:
    Rose::BinaryAnalysis::Address const& get_e_fixup_rectab_rfo() const;
    void set_e_fixup_rectab_rfo(Rose::BinaryAnalysis::Address const&);
 
public:
    Rose::BinaryAnalysis::Address const& get_e_import_modtab_rfo() const;
    void set_e_import_modtab_rfo(Rose::BinaryAnalysis::Address const&);
 
public:
    Rose::BinaryAnalysis::Address const& get_e_import_proctab_rfo() const;
    void set_e_import_proctab_rfo(Rose::BinaryAnalysis::Address const&);
 
public:
    Rose::BinaryAnalysis::Address const& get_e_ppcksumtab_rfo() const;
    void set_e_ppcksumtab_rfo(Rose::BinaryAnalysis::Address const&);
 
public:
    Rose::BinaryAnalysis::Address const& get_e_data_pages_offset() const;
    void set_e_data_pages_offset(Rose::BinaryAnalysis::Address const&);
 
public:
    Rose::BinaryAnalysis::Address const& get_e_nonresnametab_offset() const;
    void set_e_nonresnametab_offset(Rose::BinaryAnalysis::Address const&);
 
public:
    Rose::BinaryAnalysis::Address const& get_e_debug_info_rfo() const;
    void set_e_debug_info_rfo(Rose::BinaryAnalysis::Address const&);
 
public:
    SgAsmDOSExtendedHeader* const& get_dos2Header() const;
    void set_dos2Header(SgAsmDOSExtendedHeader* const&);
 
public:
    SgAsmLESectionTable* const& get_sectionTable() const;
    void set_sectionTable(SgAsmLESectionTable* const&);
 
public:
    SgAsmLEPageTable* const& get_pageTable() const;
    void set_pageTable(SgAsmLEPageTable* const&);
 
public:
    SgAsmLENameTable* const& get_residentNameTable() const;
    void set_residentNameTable(SgAsmLENameTable* const&);
 
public:
    SgAsmLENameTable* const& get_nonresidentNameTable() const;
    void set_nonresidentNameTable(SgAsmLENameTable* const&);
 
public:
    SgAsmLEEntryTable* const& get_entryTable() const;
    void set_entryTable(SgAsmLEEntryTable* const&);
 
public:
    SgAsmLERelocTable* const& get_relocationTable() const;
    void set_relocationTable(SgAsmLERelocTable* const&);
    // Functions
public:
    SgAsmLEFileHeader(SgAsmGenericFile *f, Rose::BinaryAnalysis::Address offset);
    virtual void unparse(std::ostream&) const override;
    virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
 
    // Overloaded base class virtual function
    const char *formatName() const override;
 
    static bool isLe (SgAsmGenericFile*);
    static SgAsmLEFileHeader *parse(SgAsmDOSFileHeader*);
 
private:
    void *encode(Rose::BinaryAnalysis::ByteOrder::Endianness sex, SgAsmLEFileHeader::LEFileHeader_disk*) const;
 
    // Deprecated 2023-11
public:
    SgAsmDOSExtendedHeader* get_dos2_header() const ROSE_DEPRECATED("use get_dos2Header");
    void set_dos2_header(SgAsmDOSExtendedHeader*) ROSE_DEPRECATED("use set_dos2Header");
    SgAsmLESectionTable* get_section_table() const ROSE_DEPRECATED("use get_sectionTable");
    void set_section_table(SgAsmLESectionTable*) ROSE_DEPRECATED("use set_sectionTable");
    SgAsmLEPageTable* get_page_table() const ROSE_DEPRECATED("use get_pageTable");
    void set_page_table(SgAsmLEPageTable*) ROSE_DEPRECATED("use set_pageTable");
    SgAsmLENameTable* get_resname_table() const ROSE_DEPRECATED("use get_residentNameTable");
    void set_resname_table(SgAsmLENameTable*) ROSE_DEPRECATED("use set_residentNameTable");
    SgAsmLENameTable* get_nonresname_table() const ROSE_DEPRECATED("use get_nonresidentNameTable");
    void set_nonresname_table(SgAsmLENameTable*) ROSE_DEPRECATED("use set_nonresidentNameTable");
    SgAsmLEEntryTable* get_entry_table() const ROSE_DEPRECATED("use get_entryTable");
    void set_entry_table(SgAsmLEEntryTable*) ROSE_DEPRECATED("use set_entryTable");
    SgAsmLERelocTable* get_reloc_table() const ROSE_DEPRECATED("use get_relocationTable");
    void set_reloc_table(SgAsmLERelocTable*) ROSE_DEPRECATED("use set_relocationTable");
    const char *format_name() const override ROSE_DEPRECATED("use formatName");
    static bool is_LE (SgAsmGenericFile*) ROSE_DEPRECATED("use isLe");
public:
    virtual ~SgAsmLEFileHeader();
 
public:
    SgAsmLEFileHeader();
 
protected:
    void initializeProperties();
#endif // SgAsmLEFileHeader_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmLEFileHeader: public SgAsmGenericHeader {…};
#endif // DOCUMENTATION
 
 
// SgAsmLEEntryTable           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmLEEntryTable);
IS_SERIALIZABLE(AsmLEEntryTable);
 
#ifndef DOCUMENTATION
AsmLEEntryTable.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmLEEntryTable);
#if defined(SgAsmLEEntryTable_HEADERS) || defined(DOCUMENTATION)
#include <Rose/BinaryAnalysis/Address.h>
#endif // SgAsmLEEntryTable_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmLEEntryTable: public SgAsmGenericSection {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmLEEntryTable.setDataPrototype(
        "SgSizeTList", "bundle_sizes", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmLEEntryTable.setDataPrototype(
        "SgAsmLEEntryPointPtrList", "entries", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmLEEntryTable);
#if defined(SgAsmLEEntryTable_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmLEEntryTable -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmLEEntryTable");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmGenericSection);
        s & BOOST_SERIALIZATION_NVP(p_bundle_sizes);
        s & BOOST_SERIALIZATION_NVP(p_entries);
        debugSerializationEnd("SgAsmLEEntryTable");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgSizeTList const& get_bundle_sizes() const;
    void set_bundle_sizes(SgSizeTList const&);
 
public:
    SgAsmLEEntryPointPtrList const& get_entries() const;
    SgAsmLEEntryPointPtrList& get_entries();
    void set_entries(SgAsmLEEntryPointPtrList const&);
public:
    SgAsmLEEntryTable(SgAsmLEFileHeader *fhdr, Rose::BinaryAnalysis::Address offset);
    virtual void unparse(std::ostream&) const override;
    virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
public:
    virtual ~SgAsmLEEntryTable();
 
public:
    SgAsmLEEntryTable();
 
protected:
    void initializeProperties();
#endif // SgAsmLEEntryTable_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmLEEntryTable: public SgAsmGenericSection {…};
#endif // DOCUMENTATION
 
 
// SgAsmLEEntryPoint           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmLEEntryPoint);
IS_SERIALIZABLE(AsmLEEntryPoint);
 
#ifndef DOCUMENTATION
AsmLEEntryPoint.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmLEEntryPoint);
#if defined(SgAsmLEEntryPoint_HEADERS) || defined(DOCUMENTATION)
#include <Rose/BinaryAnalysis/Address.h>
#include <Rose/BinaryAnalysis/ByteOrder.h>
#include <sageContainer.h>
#endif // SgAsmLEEntryPoint_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmLEEntryPoint: public SgAsmExecutableFileFormat {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmLEEntryPoint.setDataPrototype(
        "SgAsmLEEntryPointPtrList", "entries", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmLEEntryPoint.setDataPrototype(
        "unsigned", "flags", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmLEEntryPoint.setDataPrototype(
        "unsigned", "objnum", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmLEEntryPoint.setDataPrototype(
        "unsigned", "entry_type", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmLEEntryPoint.setDataPrototype(
        "unsigned", "res1", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmLEEntryPoint.setDataPrototype(
        "Rose::BinaryAnalysis::Address", "entry_offset", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmLEEntryPoint);
#if defined(SgAsmLEEntryPoint_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmLEEntryPoint -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmLEEntryPoint");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
        s & BOOST_SERIALIZATION_NVP(p_entries);
        s & BOOST_SERIALIZATION_NVP(p_flags);
        s & BOOST_SERIALIZATION_NVP(p_objnum);
        s & BOOST_SERIALIZATION_NVP(p_entry_type);
        s & BOOST_SERIALIZATION_NVP(p_res1);
        s & BOOST_SERIALIZATION_NVP(p_entry_offset);
        debugSerializationEnd("SgAsmLEEntryPoint");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
    // Local types
public:
#ifdef _MSC_VER
# pragma pack (1)
#endif
    /* If 0x01 bit of "flags" is clear then the remainder (next 9 bytes) of the entry point is not stored in the file and the
     * next entry point description follows immediately after the flag. */
    struct LEEntryPoint_disk {
        uint8_t     flags;          /* 0x00 Bit flags (0x01=>non-empty bundle; 0x02=>32-bit entry*/
        uint16_t    objnum;         /* 0x01 Object number */
        uint8_t     entry_type;     /* 0x03 Flags for entry type */
        uint32_t    entry_offset;   /* 0x04 Offset of entry point */
        uint16_t    res1;           /* 0x08 Reserved */
    }                               /* 0x0a */
    struct LEEntryPoint_disk {…};
// DQ (3/7/2013): Adding support to restrict visability to SWIG.
#ifndef SWIG
#ifndef _MSC_VER
                __attribute__((packed))
#endif
#endif
                ;
#ifdef _MSC_VER
# pragma pack ()
#endif
 
    // Properties
public:
public:
    SgAsmLEEntryPointPtrList const& get_entries() const;
    SgAsmLEEntryPointPtrList& get_entries();
    void set_entries(SgAsmLEEntryPointPtrList const&);
 
public:
    unsigned const& get_flags() const;
    void set_flags(unsigned const&);
 
public:
    unsigned const& get_objnum() const;
    void set_objnum(unsigned const&);
 
public:
    unsigned const& get_entry_type() const;
    void set_entry_type(unsigned const&);
 
public:
    unsigned const& get_res1() const;
    void set_res1(unsigned const&);
 
public:
    Rose::BinaryAnalysis::Address const& get_entry_offset() const;
    void set_entry_offset(Rose::BinaryAnalysis::Address const&);
    // Functions
public:
    SgAsmLEEntryPoint(Rose::BinaryAnalysis::ByteOrder::Endianness sex, const SgAsmLEEntryPoint::LEEntryPoint_disk *disk);
    SgAsmLEEntryPoint(Rose::BinaryAnalysis::ByteOrder::Endianness sex, unsigned flags);
    Rose::BinaryAnalysis::Address unparse(std::ostream&, Rose::BinaryAnalysis::ByteOrder::Endianness, const SgAsmGenericSection*,
                                          Rose::BinaryAnalysis::Address spos) const;
    void dump(FILE*, const char *prefix, ssize_t idx) const;
public:
    virtual ~SgAsmLEEntryPoint();
 
public:
    SgAsmLEEntryPoint();
 
protected:
    void initializeProperties();
#endif // SgAsmLEEntryPoint_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmLEEntryPoint: public SgAsmExecutableFileFormat {…};
#endif // DOCUMENTATION
 
 
// SgAsmJvmSynthetic           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmJvmSynthetic);
IS_SERIALIZABLE(AsmJvmSynthetic);
 
#ifndef DOCUMENTATION
AsmJvmSynthetic.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmJvmSynthetic: public SgAsmJvmAttribute {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmJvmSynthetic);
#if defined(SgAsmJvmSynthetic_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmJvmSynthetic -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmJvmSynthetic");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmJvmAttribute);
        debugSerializationEnd("SgAsmJvmSynthetic");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
    explicit SgAsmJvmSynthetic(SgAsmJvmAttributeTable* table);
 
    virtual SgAsmJvmAttribute* parse(SgAsmJvmConstantPool* pool) override;
public:
    virtual ~SgAsmJvmSynthetic();
 
public:
    SgAsmJvmSynthetic();
 
protected:
    void initializeProperties();
#endif // SgAsmJvmSynthetic_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmJvmSynthetic: public SgAsmJvmAttribute {…};
#endif // DOCUMENTATION
 
 
// SgAsmJvmStackMapVerificationType           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmJvmStackMapVerificationType);
IS_SERIALIZABLE(AsmJvmStackMapVerificationType);
 
#ifndef DOCUMENTATION
AsmJvmStackMapVerificationType.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmJvmStackMapVerificationType: public SgAsmJvmNode {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmStackMapVerificationType.setDataPrototype(
        "uint8_t", "tag", "= 9",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmStackMapVerificationType.setDataPrototype(
        "uint16_t", "cpool_index", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmStackMapVerificationType.setDataPrototype(
        "uint16_t", "offset", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmJvmStackMapVerificationType);
#if defined(SgAsmJvmStackMapVerificationType_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmJvmStackMapVerificationType -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmJvmStackMapVerificationType");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmJvmNode);
        s & BOOST_SERIALIZATION_NVP(p_tag);
        s & BOOST_SERIALIZATION_NVP(p_cpool_index);
        s & BOOST_SERIALIZATION_NVP(p_offset);
        debugSerializationEnd("SgAsmJvmStackMapVerificationType");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
private:
    enum verification_type_tag {
        ITEM_Top = 0,
        ITEM_Integer = 1,
        ITEM_Float = 2,
        ITEM_Double = 3,
        ITEM_Long = 4,
        ITEM_Null = 5,
        ITEM_UninitializedThis = 6,
        ITEM_Object = 7,
        ITEM_Uninitialized = 8
    };
 
    // Local types (for documentation purposes only)
#ifdef DOCUMENTATION
    union verification_type_info {
        Top_variable_info;
        Integer_variable_info;
        Float_variable_info;
        Long_variable_info;
        Double_variable_info;
        Null_variable_info;
        UninitializedThis_variable_info;
        Object_variable_info;
        Uninitialized_variable_info;
    };
 
    struct Top_variable_info {
        uint8_t tag;
    };
    struct Integer_variable_info {
        uint8_t tag;
    };
    struct Float_variable_info {
        uint8_t tag;
    };
    struct Long_variable_info {
        uint8_t tag;
    };
    struct Double_variable_info {
        uint8_t tag;
    };
    struct Null_variable_info {
        uint8_t tag;
    };
    struct UnitializedThis_variable_info {
        uint8_t tag;
    };
    struct Object_variable_info {
        uint8_t tag;
        uint16_t cpool_index;
    };
    struct Unitialized_variable_info {
        uint8_t tag;
        uint16_t offset;
    };
#endif
 
    // Properties
public:
public:
    uint8_t const& get_tag() const;
    void set_tag(uint8_t const&);
 /* Not a legal entry */
public:
    uint16_t const& get_cpool_index() const;
    void set_cpool_index(uint16_t const&);
public:
    uint16_t const& get_offset() const;
    void set_offset(uint16_t const&);
    // Functions
public:
    explicit SgAsmJvmStackMapVerificationType(SgAsmJvmStackMapFrame* frame);
 
    SgAsmJvmStackMapVerificationType* parse(SgAsmJvmConstantPool* pool);
 
    virtual void unparse(std::ostream&) const override;
 
    void dump(FILE*, const char *prefix, ssize_t idx) const override;
public:
    virtual ~SgAsmJvmStackMapVerificationType();
 
public:
    SgAsmJvmStackMapVerificationType();
 
protected:
    void initializeProperties();
#endif // SgAsmJvmStackMapVerificationType_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmJvmStackMapVerificationType: public SgAsmJvmNode {…};
#endif // DOCUMENTATION
 
 
// SgAsmJvmStackMapTable           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmJvmStackMapTable);
IS_SERIALIZABLE(AsmJvmStackMapTable);
 
#ifndef DOCUMENTATION
AsmJvmStackMapTable.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmJvmStackMapTable);
#if defined(SgAsmJvmStackMapTable_HEADERS) || defined(DOCUMENTATION)
#include <sageContainer.h>
#endif // SgAsmJvmStackMapTable_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmJvmStackMapTable: public SgAsmJvmAttribute {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmStackMapTable.setDataPrototype(
        "SgAsmJvmStackMapFramePtrList", "entries", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmJvmStackMapTable);
#if defined(SgAsmJvmStackMapTable_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmJvmStackMapTable -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmJvmStackMapTable");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmJvmAttribute);
        s & BOOST_SERIALIZATION_NVP(p_entries);
        debugSerializationEnd("SgAsmJvmStackMapTable");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
    // Properties
public:
public:
    SgAsmJvmStackMapFramePtrList const& get_entries() const;
    SgAsmJvmStackMapFramePtrList& get_entries();
    void set_entries(SgAsmJvmStackMapFramePtrList const&);
    // Functions
public:
    explicit SgAsmJvmStackMapTable(SgAsmJvmAttributeTable* table);
 
    virtual SgAsmJvmStackMapTable* parse(SgAsmJvmConstantPool* pool) override;
 
    virtual void unparse(std::ostream&) const override;
 
    void dump(FILE*, const char *prefix, ssize_t idx) const override;
public:
    virtual ~SgAsmJvmStackMapTable();
 
public:
    SgAsmJvmStackMapTable();
 
protected:
    void initializeProperties();
#endif // SgAsmJvmStackMapTable_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmJvmStackMapTable: public SgAsmJvmAttribute {…};
#endif // DOCUMENTATION
 
 
// SgAsmJvmStackMapFrame           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmJvmStackMapFrame);
IS_SERIALIZABLE(AsmJvmStackMapFrame);
 
#ifndef DOCUMENTATION
AsmJvmStackMapFrame.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmJvmStackMapFrame);
#if defined(SgAsmJvmStackMapFrame_HEADERS) || defined(DOCUMENTATION)
#include <sageContainer.h>
#endif // SgAsmJvmStackMapFrame_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmJvmStackMapFrame: public SgAsmJvmNode {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmStackMapFrame.setDataPrototype(
        "SgAsmJvmStackMapVerificationTypePtrList", "stack", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmStackMapFrame.setDataPrototype(
        "SgAsmJvmStackMapVerificationTypePtrList", "locals", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmStackMapFrame.setDataPrototype(
        "uint8_t", "frame_type", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmStackMapFrame.setDataPrototype(
        "uint16_t", "offset_delta", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmJvmStackMapFrame);
#if defined(SgAsmJvmStackMapFrame_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmJvmStackMapFrame -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmJvmStackMapFrame");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmJvmNode);
        s & BOOST_SERIALIZATION_NVP(p_stack);
        s & BOOST_SERIALIZATION_NVP(p_locals);
        s & BOOST_SERIALIZATION_NVP(p_frame_type);
        s & BOOST_SERIALIZATION_NVP(p_offset_delta);
        debugSerializationEnd("SgAsmJvmStackMapFrame");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
private:
public:
public:
    SgAsmJvmStackMapVerificationTypePtrList const& get_stack() const;
    SgAsmJvmStackMapVerificationTypePtrList& get_stack();
    void set_stack(SgAsmJvmStackMapVerificationTypePtrList const&);
public:
    SgAsmJvmStackMapVerificationTypePtrList const& get_locals() const;
    SgAsmJvmStackMapVerificationTypePtrList& get_locals();
    void set_locals(SgAsmJvmStackMapVerificationTypePtrList const&);
    // Local types (for documentation purposes only)
#ifdef DOCUMENTATION
    union stack_map_frame {
        same_frame;
        same_locals_1_stack_item_frame;
        same_locals_1_stack_item_frame_extended;
        chop_frame;
        same_frame_extended;
        append_frame;
        full_frame;
    };
    union stack_map_frame {…};
 
    struct same_frame {
        uint8_t frame_type; /* 0-63 */
    };
    struct same_frame {…};
    struct same_locals_1_stack_item_frame {
        uint8_t frame_type; /* 64-127 */
        verification_type_info stack;
    };
    struct same_locals_1_stack_item_frame {…};
    struct same_locals_1_stack_item_extended {
        uint8_t frame_type; /* 247 */
        uint16_t offset_delta;
        verification_type_info stack;
    };
    struct same_locals_1_stack_item_extended {…};
    struct chop_frame {
        uint8_t frame_type; /* 248-250 */
        uint16_t offset_delta;
    };
    struct chop_frame {…};
    struct same_frame_extended {
        uint8_t frame_type; /* 251 */
        uint16_t offset_delta;
    };
    struct same_frame_extended {…};
    struct append_frame {
        uint8_t frame_type; /* 252-254 */
        uint16_t offset_delta;
        verification_type_info stack;
    };
    struct append_frame {…};
    struct full_frame {
        uint8_t frame_type; /* 252-254 */
        uint16_t offset_delta;
        uint16_t number_of_locals;
        verification_type_info stack[number_of_locals];
        uint16_t number_of_stack_items;
        verification_type_info stack[number_of_stack_items];
    };
    struct full_frame {…};
#endif
 
    // Properties
private:
public:
    uint8_t const& get_frame_type() const;
    void set_frame_type(uint8_t const&);
public:
    uint16_t const& get_offset_delta() const;
    void set_offset_delta(uint16_t const&);
    // Functions
public:
    explicit SgAsmJvmStackMapFrame(SgAsmJvmStackMapTable* table);
 
    SgAsmJvmStackMapFrame* parse(SgAsmJvmConstantPool* pool);
 
    virtual void unparse(std::ostream&) const override;
 
    void dump(FILE*, const char *prefix, ssize_t idx) const override;
public:
    virtual ~SgAsmJvmStackMapFrame();
 
public:
    SgAsmJvmStackMapFrame();
 
protected:
    void initializeProperties();
#endif // SgAsmJvmStackMapFrame_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmJvmStackMapFrame: public SgAsmJvmNode {…};
#endif // DOCUMENTATION
 
 
// SgAsmJvmSourceFile           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmJvmSourceFile);
IS_SERIALIZABLE(AsmJvmSourceFile);
 
#ifndef DOCUMENTATION
AsmJvmSourceFile.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmJvmSourceFile: public SgAsmJvmAttribute {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmSourceFile.setDataPrototype(
        "uint16_t", "sourcefile_index", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmJvmSourceFile);
#if defined(SgAsmJvmSourceFile_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmJvmSourceFile -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmJvmSourceFile");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmJvmAttribute);
        s & BOOST_SERIALIZATION_NVP(p_sourcefile_index);
        debugSerializationEnd("SgAsmJvmSourceFile");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    uint16_t const& get_sourcefile_index() const;
    void set_sourcefile_index(uint16_t const&);
public:
    explicit SgAsmJvmSourceFile(SgAsmJvmAttributeTable* table);
 
    virtual SgAsmJvmAttribute* parse(SgAsmJvmConstantPool* pool) override;
 
    virtual void unparse(std::ostream&) const override;
 
    virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
public:
    virtual ~SgAsmJvmSourceFile();
 
public:
    SgAsmJvmSourceFile();
 
protected:
    void initializeProperties();
#endif // SgAsmJvmSourceFile_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmJvmSourceFile: public SgAsmJvmAttribute {…};
#endif // DOCUMENTATION
 
 
// SgAsmJvmSignature           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmJvmSignature);
IS_SERIALIZABLE(AsmJvmSignature);
 
#ifndef DOCUMENTATION
AsmJvmSignature.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmJvmSignature: public SgAsmJvmAttribute {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmSignature.setDataPrototype(
        "uint16_t", "signature_index", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmJvmSignature);
#if defined(SgAsmJvmSignature_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmJvmSignature -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmJvmSignature");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmJvmAttribute);
        s & BOOST_SERIALIZATION_NVP(p_signature_index);
        debugSerializationEnd("SgAsmJvmSignature");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    uint16_t const& get_signature_index() const;
    void set_signature_index(uint16_t const&);
public:
    explicit SgAsmJvmSignature(SgAsmJvmAttributeTable* table);
 
    virtual SgAsmJvmAttribute* parse(SgAsmJvmConstantPool* pool) override;
 
    virtual void unparse(std::ostream&) const override;
 
    virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
public:
    virtual ~SgAsmJvmSignature();
 
public:
    SgAsmJvmSignature();
 
protected:
    void initializeProperties();
#endif // SgAsmJvmSignature_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmJvmSignature: public SgAsmJvmAttribute {…};
#endif // DOCUMENTATION
 
 
// SgAsmJvmNestMembers           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmJvmNestMembers);
IS_SERIALIZABLE(AsmJvmNestMembers);
 
#ifndef DOCUMENTATION
AsmJvmNestMembers.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmJvmNestMembers);
#if defined(SgAsmJvmNestMembers_HEADERS) || defined(DOCUMENTATION)
#include <sageContainer.h>
#endif // SgAsmJvmNestMembers_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmJvmNestMembers: public SgAsmJvmAttribute {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmNestMembers.setDataPrototype(
        "SgUnsigned16List", "classes", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmJvmNestMembers);
#if defined(SgAsmJvmNestMembers_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmJvmNestMembers -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmJvmNestMembers");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmJvmAttribute);
        s & BOOST_SERIALIZATION_NVP(p_classes);
        debugSerializationEnd("SgAsmJvmNestMembers");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgUnsigned16List const& get_classes() const;
    void set_classes(SgUnsigned16List const&);
public:
    explicit SgAsmJvmNestMembers(SgAsmJvmAttributeTable* table);
 
    virtual SgAsmJvmNestMembers* parse(SgAsmJvmConstantPool* pool) override;
 
    virtual void unparse(std::ostream&) const override;
 
    virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
public:
    virtual ~SgAsmJvmNestMembers();
 
public:
    SgAsmJvmNestMembers();
 
protected:
    void initializeProperties();
#endif // SgAsmJvmNestMembers_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmJvmNestMembers: public SgAsmJvmAttribute {…};
#endif // DOCUMENTATION
 
 
// SgAsmJvmNestHost           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmJvmNestHost);
IS_SERIALIZABLE(AsmJvmNestHost);
 
#ifndef DOCUMENTATION
AsmJvmNestHost.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmJvmNestHost: public SgAsmJvmAttribute {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmNestHost.setDataPrototype(
        "uint16_t", "host_class_index", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmJvmNestHost);
#if defined(SgAsmJvmNestHost_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmJvmNestHost -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmJvmNestHost");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmJvmAttribute);
        s & BOOST_SERIALIZATION_NVP(p_host_class_index);
        debugSerializationEnd("SgAsmJvmNestHost");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    uint16_t const& get_host_class_index() const;
    void set_host_class_index(uint16_t const&);
public:
    explicit SgAsmJvmNestHost(SgAsmJvmAttributeTable* table);
 
    virtual SgAsmJvmNestHost* parse(SgAsmJvmConstantPool* pool) override;
 
    virtual void unparse(std::ostream&) const override;
 
    virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
public:
    virtual ~SgAsmJvmNestHost();
 
public:
    SgAsmJvmNestHost();
 
protected:
    void initializeProperties();
#endif // SgAsmJvmNestHost_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmJvmNestHost: public SgAsmJvmAttribute {…};
#endif // DOCUMENTATION
 
 
// SgAsmJvmModuleMainClass           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmJvmModuleMainClass);
IS_SERIALIZABLE(AsmJvmModuleMainClass);
 
#ifndef DOCUMENTATION
AsmJvmModuleMainClass.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmJvmModuleMainClass: public SgAsmJvmAttribute {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmModuleMainClass.setDataPrototype(
        "uint16_t", "main_class_index", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmJvmModuleMainClass);
#if defined(SgAsmJvmModuleMainClass_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmJvmModuleMainClass -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmJvmModuleMainClass");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmJvmAttribute);
        s & BOOST_SERIALIZATION_NVP(p_main_class_index);
        debugSerializationEnd("SgAsmJvmModuleMainClass");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    uint16_t const& get_main_class_index() const;
    void set_main_class_index(uint16_t const&);
public:
    explicit SgAsmJvmModuleMainClass(SgAsmJvmExceptionTable* table);
 
    virtual SgAsmJvmAttribute* parse(SgAsmJvmConstantPool* pool) override;
 
    virtual void unparse(std::ostream&) const override;
 
    virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
public:
    virtual ~SgAsmJvmModuleMainClass();
 
public:
    SgAsmJvmModuleMainClass();
 
protected:
    void initializeProperties();
#endif // SgAsmJvmModuleMainClass_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmJvmModuleMainClass: public SgAsmJvmAttribute {…};
#endif // DOCUMENTATION
 
 
// SgAsmJvmMethodTable           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmJvmMethodTable);
IS_SERIALIZABLE(AsmJvmMethodTable);
 
#ifndef DOCUMENTATION
AsmJvmMethodTable.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmJvmMethodTable: public SgAsmGenericSection {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmMethodTable.setDataPrototype(
        "SgAsmJvmMethodPtrList", "methods", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmJvmMethodTable);
#if defined(SgAsmJvmMethodTable_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmJvmMethodTable -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmJvmMethodTable");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmGenericSection);
        s & BOOST_SERIALIZATION_NVP(p_methods);
        debugSerializationEnd("SgAsmJvmMethodTable");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgAsmJvmMethodPtrList const& get_methods() const;
    SgAsmJvmMethodPtrList& get_methods();
    void set_methods(SgAsmJvmMethodPtrList const&);
public:
    explicit SgAsmJvmMethodTable(SgAsmJvmFileHeader*);
 
    virtual SgAsmJvmMethodTable* parse() override;
 
    virtual void unparse(std::ostream&) const override;
 
    virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
public:
    virtual ~SgAsmJvmMethodTable();
 
public:
    SgAsmJvmMethodTable();
 
protected:
    void initializeProperties();
#endif // SgAsmJvmMethodTable_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmJvmMethodTable: public SgAsmGenericSection {…};
#endif // DOCUMENTATION
 
 
// SgAsmJvmMethodParameters           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmJvmMethodParameters);
IS_SERIALIZABLE(AsmJvmMethodParameters);
 
#ifndef DOCUMENTATION
AsmJvmMethodParameters.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmJvmMethodParameters);
#if defined(SgAsmJvmMethodParameters_HEADERS) || defined(DOCUMENTATION)
#include <sageContainer.h>
#endif // SgAsmJvmMethodParameters_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmJvmMethodParameters: public SgAsmJvmAttribute {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmMethodParameters.setDataPrototype(
        "SgAsmJvmMethodParametersEntryPtrList", "parameters", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmJvmMethodParameters);
#if defined(SgAsmJvmMethodParameters_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmJvmMethodParameters -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmJvmMethodParameters");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmJvmAttribute);
        s & BOOST_SERIALIZATION_NVP(p_parameters);
        debugSerializationEnd("SgAsmJvmMethodParameters");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgAsmJvmMethodParametersEntryPtrList const& get_parameters() const;
    SgAsmJvmMethodParametersEntryPtrList& get_parameters();
    void set_parameters(SgAsmJvmMethodParametersEntryPtrList const&);
public:
    explicit SgAsmJvmMethodParameters(SgAsmJvmAttributeTable* table);
 
    virtual SgAsmJvmMethodParameters* parse(SgAsmJvmConstantPool* pool) override;
 
    virtual void unparse(std::ostream&) const override;
 
    virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
public:
    virtual ~SgAsmJvmMethodParameters();
 
public:
    SgAsmJvmMethodParameters();
 
protected:
    void initializeProperties();
#endif // SgAsmJvmMethodParameters_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmJvmMethodParameters: public SgAsmJvmAttribute {…};
#endif // DOCUMENTATION
 
 
// SgAsmJvmMethodParametersEntry           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmJvmMethodParametersEntry);
IS_SERIALIZABLE(AsmJvmMethodParametersEntry);
 
#ifndef DOCUMENTATION
AsmJvmMethodParametersEntry.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmJvmMethodParametersEntry: public SgAsmJvmNode {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmMethodParametersEntry.setDataPrototype(
        "uint16_t", "name_index", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmMethodParametersEntry.setDataPrototype(
        "uint16_t", "access_flags", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmJvmMethodParametersEntry);
#if defined(SgAsmJvmMethodParametersEntry_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmJvmMethodParametersEntry -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmJvmMethodParametersEntry");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmJvmNode);
        s & BOOST_SERIALIZATION_NVP(p_name_index);
        s & BOOST_SERIALIZATION_NVP(p_access_flags);
        debugSerializationEnd("SgAsmJvmMethodParametersEntry");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    uint16_t const& get_name_index() const;
    void set_name_index(uint16_t const&);
public:
    uint16_t const& get_access_flags() const;
    void set_access_flags(uint16_t const&);
 public:
    explicit SgAsmJvmMethodParametersEntry(SgAsmJvmMethodParameters*);
 
    SgAsmJvmMethodParametersEntry* parse(SgAsmJvmConstantPool*);
 
    virtual void unparse(std::ostream&) const override;
 
    void dump(FILE*, const char *prefix, ssize_t idx) const override;
public:
    virtual ~SgAsmJvmMethodParametersEntry();
 
public:
    SgAsmJvmMethodParametersEntry();
 
protected:
    void initializeProperties();
#endif // SgAsmJvmMethodParametersEntry_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmJvmMethodParametersEntry: public SgAsmJvmNode {…};
#endif // DOCUMENTATION
 
 
// SgAsmJvmMethod           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmJvmMethod);
IS_SERIALIZABLE(AsmJvmMethod);
 
#ifndef DOCUMENTATION
AsmJvmMethod.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmJvmMethod);
#if defined(SgAsmJvmMethod_HEADERS) || defined(DOCUMENTATION)
#ifdef ROSE_SgAsmJvmMethod_IMPL
#include <SgAsmInstructionList.h>
#include <SgAsmJvmAttributeTable.h>
#endif
#endif // SgAsmJvmMethod_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmJvmMethod: public SgAsmJvmNode {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmMethod.setDataPrototype(
        "uint16_t", "access_flags", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmMethod.setDataPrototype(
        "uint16_t", "name_index", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmMethod.setDataPrototype(
        "uint16_t", "descriptor_index", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmMethod.setDataPrototype(
        "SgAsmJvmAttributeTable*", "attribute_table", "= nullptr",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmMethod.setDataPrototype(
        "SgAsmInstructionList*", "instruction_list", "= createAndParent<SgAsmInstructionList>(this)",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmJvmMethod);
#if defined(SgAsmJvmMethod_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmJvmMethod -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmJvmMethod");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmJvmNode);
        s & BOOST_SERIALIZATION_NVP(p_access_flags);
        s & BOOST_SERIALIZATION_NVP(p_name_index);
        s & BOOST_SERIALIZATION_NVP(p_descriptor_index);
        s & BOOST_SERIALIZATION_NVP(p_attribute_table);
        s & BOOST_SERIALIZATION_NVP(p_instruction_list);
        debugSerializationEnd("SgAsmJvmMethod");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    uint16_t const& get_access_flags() const;
    void set_access_flags(uint16_t const&);
public:
    uint16_t const& get_name_index() const;
    void set_name_index(uint16_t const&);
public:
    uint16_t const& get_descriptor_index() const;
    void set_descriptor_index(uint16_t const&);
public:
    SgAsmJvmAttributeTable* const& get_attribute_table() const;
    void set_attribute_table(SgAsmJvmAttributeTable* const&);
public:
    SgAsmInstructionList* const& get_instruction_list() const;
    void set_instruction_list(SgAsmInstructionList* const&);
public:
    explicit SgAsmJvmMethod(SgAsmJvmMethodTable*);
 
    SgAsmJvmMethod* parse(SgAsmJvmConstantPool*);
 
    virtual void unparse(std::ostream&) const override;
 
    void dump(FILE*, const char *prefix, ssize_t idx) const override;
public:
    virtual ~SgAsmJvmMethod();
 
public:
    SgAsmJvmMethod();
 
protected:
    void initializeProperties();
#endif // SgAsmJvmMethod_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmJvmMethod: public SgAsmJvmNode {…};
#endif // DOCUMENTATION
 
 
// SgAsmJvmLocalVariableTypeTable           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmJvmLocalVariableTypeTable);
IS_SERIALIZABLE(AsmJvmLocalVariableTypeTable);
 
#ifndef DOCUMENTATION
AsmJvmLocalVariableTypeTable.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmJvmLocalVariableTypeTable);
#if defined(SgAsmJvmLocalVariableTypeTable_HEADERS) || defined(DOCUMENTATION)
#include <sageContainer.h>
#endif // SgAsmJvmLocalVariableTypeTable_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmJvmLocalVariableTypeTable: public SgAsmJvmAttribute {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmLocalVariableTypeTable.setDataPrototype(
        "SgAsmJvmLocalVariableTypeEntryPtrList", "local_variable_type_table", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmJvmLocalVariableTypeTable);
#if defined(SgAsmJvmLocalVariableTypeTable_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmJvmLocalVariableTypeTable -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmJvmLocalVariableTypeTable");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmJvmAttribute);
        s & BOOST_SERIALIZATION_NVP(p_local_variable_type_table);
        debugSerializationEnd("SgAsmJvmLocalVariableTypeTable");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgAsmJvmLocalVariableTypeEntryPtrList const& get_local_variable_type_table() const;
    SgAsmJvmLocalVariableTypeEntryPtrList& get_local_variable_type_table();
    void set_local_variable_type_table(SgAsmJvmLocalVariableTypeEntryPtrList const&);
public:
    explicit SgAsmJvmLocalVariableTypeTable(SgAsmJvmAttributeTable* table);
 
    virtual SgAsmJvmLocalVariableTypeTable* parse(SgAsmJvmConstantPool* pool) override;
 
    virtual void unparse(std::ostream&) const override;
 
    virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
public:
    virtual ~SgAsmJvmLocalVariableTypeTable();
 
public:
    SgAsmJvmLocalVariableTypeTable();
 
protected:
    void initializeProperties();
#endif // SgAsmJvmLocalVariableTypeTable_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmJvmLocalVariableTypeTable: public SgAsmJvmAttribute {…};
#endif // DOCUMENTATION
 
 
// SgAsmJvmLocalVariableTypeEntry           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmJvmLocalVariableTypeEntry);
IS_SERIALIZABLE(AsmJvmLocalVariableTypeEntry);
 
#ifndef DOCUMENTATION
AsmJvmLocalVariableTypeEntry.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmJvmLocalVariableTypeEntry: public SgAsmJvmNode {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmLocalVariableTypeEntry.setDataPrototype(
        "uint16_t", "start_pc", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmLocalVariableTypeEntry.setDataPrototype(
        "uint16_t", "length", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmLocalVariableTypeEntry.setDataPrototype(
        "uint16_t", "name_index", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmLocalVariableTypeEntry.setDataPrototype(
        "uint16_t", "signature_index", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmLocalVariableTypeEntry.setDataPrototype(
        "uint16_t", "index", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmJvmLocalVariableTypeEntry);
#if defined(SgAsmJvmLocalVariableTypeEntry_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmJvmLocalVariableTypeEntry -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmJvmLocalVariableTypeEntry");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmJvmNode);
        s & BOOST_SERIALIZATION_NVP(p_start_pc);
        s & BOOST_SERIALIZATION_NVP(p_length);
        s & BOOST_SERIALIZATION_NVP(p_name_index);
        s & BOOST_SERIALIZATION_NVP(p_signature_index);
        s & BOOST_SERIALIZATION_NVP(p_index);
        debugSerializationEnd("SgAsmJvmLocalVariableTypeEntry");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    uint16_t const& get_start_pc() const;
    void set_start_pc(uint16_t const&);
public:
    uint16_t const& get_length() const;
    void set_length(uint16_t const&);
public:
    uint16_t const& get_name_index() const;
    void set_name_index(uint16_t const&);
public:
    uint16_t const& get_signature_index() const;
    void set_signature_index(uint16_t const&);
public:
    uint16_t const& get_index() const;
    void set_index(uint16_t const&);
 public:
    explicit SgAsmJvmLocalVariableTypeEntry(SgAsmJvmLocalVariableTypeTable*);
 
    SgAsmJvmLocalVariableTypeEntry* parse(SgAsmJvmConstantPool*);
 
    virtual void unparse(std::ostream&) const override;
 
    void dump(FILE*, const char *prefix, ssize_t idx) const override;
public:
    virtual ~SgAsmJvmLocalVariableTypeEntry();
 
public:
    SgAsmJvmLocalVariableTypeEntry();
 
protected:
    void initializeProperties();
#endif // SgAsmJvmLocalVariableTypeEntry_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmJvmLocalVariableTypeEntry: public SgAsmJvmNode {…};
#endif // DOCUMENTATION
 
 
// SgAsmJvmLocalVariableTable           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmJvmLocalVariableTable);
IS_SERIALIZABLE(AsmJvmLocalVariableTable);
 
#ifndef DOCUMENTATION
AsmJvmLocalVariableTable.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmJvmLocalVariableTable);
#if defined(SgAsmJvmLocalVariableTable_HEADERS) || defined(DOCUMENTATION)
#include <sageContainer.h>
#endif // SgAsmJvmLocalVariableTable_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmJvmLocalVariableTable: public SgAsmJvmAttribute {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmLocalVariableTable.setDataPrototype(
        "SgAsmJvmLocalVariableEntryPtrList", "local_variable_table", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmJvmLocalVariableTable);
#if defined(SgAsmJvmLocalVariableTable_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmJvmLocalVariableTable -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmJvmLocalVariableTable");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmJvmAttribute);
        s & BOOST_SERIALIZATION_NVP(p_local_variable_table);
        debugSerializationEnd("SgAsmJvmLocalVariableTable");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgAsmJvmLocalVariableEntryPtrList const& get_local_variable_table() const;
    SgAsmJvmLocalVariableEntryPtrList& get_local_variable_table();
    void set_local_variable_table(SgAsmJvmLocalVariableEntryPtrList const&);
public:
    explicit SgAsmJvmLocalVariableTable(SgAsmJvmAttributeTable* table);
 
    virtual SgAsmJvmLocalVariableTable* parse(SgAsmJvmConstantPool* pool) override;
 
    virtual void unparse(std::ostream&) const override;
 
    virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
public:
    virtual ~SgAsmJvmLocalVariableTable();
 
public:
    SgAsmJvmLocalVariableTable();
 
protected:
    void initializeProperties();
#endif // SgAsmJvmLocalVariableTable_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmJvmLocalVariableTable: public SgAsmJvmAttribute {…};
#endif // DOCUMENTATION
 
 
// SgAsmJvmLocalVariableEntry           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmJvmLocalVariableEntry);
IS_SERIALIZABLE(AsmJvmLocalVariableEntry);
 
#ifndef DOCUMENTATION
AsmJvmLocalVariableEntry.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmJvmLocalVariableEntry: public SgAsmJvmNode {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmLocalVariableEntry.setDataPrototype(
        "uint16_t", "start_pc", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmLocalVariableEntry.setDataPrototype(
        "uint16_t", "length", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmLocalVariableEntry.setDataPrototype(
        "uint16_t", "name_index", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmLocalVariableEntry.setDataPrototype(
        "uint16_t", "descriptor_index", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmLocalVariableEntry.setDataPrototype(
        "uint16_t", "index", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmJvmLocalVariableEntry);
#if defined(SgAsmJvmLocalVariableEntry_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmJvmLocalVariableEntry -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmJvmLocalVariableEntry");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmJvmNode);
        s & BOOST_SERIALIZATION_NVP(p_start_pc);
        s & BOOST_SERIALIZATION_NVP(p_length);
        s & BOOST_SERIALIZATION_NVP(p_name_index);
        s & BOOST_SERIALIZATION_NVP(p_descriptor_index);
        s & BOOST_SERIALIZATION_NVP(p_index);
        debugSerializationEnd("SgAsmJvmLocalVariableEntry");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    uint16_t const& get_start_pc() const;
    void set_start_pc(uint16_t const&);
public:
    uint16_t const& get_length() const;
    void set_length(uint16_t const&);
public:
    uint16_t const& get_name_index() const;
    void set_name_index(uint16_t const&);
public:
    uint16_t const& get_descriptor_index() const;
    void set_descriptor_index(uint16_t const&);
public:
    uint16_t const& get_index() const;
    void set_index(uint16_t const&);
 public:
    explicit SgAsmJvmLocalVariableEntry(SgAsmJvmLocalVariableTable*);
 
    SgAsmJvmLocalVariableEntry* parse(SgAsmJvmConstantPool*);
 
    virtual void unparse(std::ostream&) const override;
 
    void dump(FILE*, const char *prefix, ssize_t idx) const override;
public:
    virtual ~SgAsmJvmLocalVariableEntry();
 
public:
    SgAsmJvmLocalVariableEntry();
 
protected:
    void initializeProperties();
#endif // SgAsmJvmLocalVariableEntry_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmJvmLocalVariableEntry: public SgAsmJvmNode {…};
#endif // DOCUMENTATION
 
 
// SgAsmJvmLineNumberTable           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmJvmLineNumberTable);
IS_SERIALIZABLE(AsmJvmLineNumberTable);
 
#ifndef DOCUMENTATION
AsmJvmLineNumberTable.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmJvmLineNumberTable);
#if defined(SgAsmJvmLineNumberTable_HEADERS) || defined(DOCUMENTATION)
#include <sageContainer.h>
#endif // SgAsmJvmLineNumberTable_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmJvmLineNumberTable: public SgAsmJvmAttribute {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmLineNumberTable.setDataPrototype(
        "SgAsmJvmLineNumberEntryPtrList", "line_number_table", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmJvmLineNumberTable);
#if defined(SgAsmJvmLineNumberTable_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmJvmLineNumberTable -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmJvmLineNumberTable");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmJvmAttribute);
        s & BOOST_SERIALIZATION_NVP(p_line_number_table);
        debugSerializationEnd("SgAsmJvmLineNumberTable");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgAsmJvmLineNumberEntryPtrList const& get_line_number_table() const;
    SgAsmJvmLineNumberEntryPtrList& get_line_number_table();
    void set_line_number_table(SgAsmJvmLineNumberEntryPtrList const&);
public:
    explicit SgAsmJvmLineNumberTable(SgAsmJvmAttributeTable* table);
 
    virtual SgAsmJvmLineNumberTable* parse(SgAsmJvmConstantPool* pool) override;
 
    virtual void unparse(std::ostream&) const override;
 
    virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
public:
    virtual ~SgAsmJvmLineNumberTable();
 
public:
    SgAsmJvmLineNumberTable();
 
protected:
    void initializeProperties();
#endif // SgAsmJvmLineNumberTable_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmJvmLineNumberTable: public SgAsmJvmAttribute {…};
#endif // DOCUMENTATION
 
 
// SgAsmJvmLineNumberEntry           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmJvmLineNumberEntry);
IS_SERIALIZABLE(AsmJvmLineNumberEntry);
 
#ifndef DOCUMENTATION
AsmJvmLineNumberEntry.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmJvmLineNumberEntry: public SgAsmJvmNode {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmLineNumberEntry.setDataPrototype(
        "uint16_t", "start_pc", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmLineNumberEntry.setDataPrototype(
        "uint16_t", "line_number", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmJvmLineNumberEntry);
#if defined(SgAsmJvmLineNumberEntry_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmJvmLineNumberEntry -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmJvmLineNumberEntry");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmJvmNode);
        s & BOOST_SERIALIZATION_NVP(p_start_pc);
        s & BOOST_SERIALIZATION_NVP(p_line_number);
        debugSerializationEnd("SgAsmJvmLineNumberEntry");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    uint16_t const& get_start_pc() const;
    void set_start_pc(uint16_t const&);
public:
    uint16_t const& get_line_number() const;
    void set_line_number(uint16_t const&);
 public:
    explicit SgAsmJvmLineNumberEntry(SgAsmJvmLineNumberTable*);
 
    SgAsmJvmLineNumberEntry* parse(SgAsmJvmConstantPool*);
 
    virtual void unparse(std::ostream&) const override;
 
    void dump(FILE*, const char *prefix, ssize_t idx) const override;
public:
    virtual ~SgAsmJvmLineNumberEntry();
 
public:
    SgAsmJvmLineNumberEntry();
 
protected:
    void initializeProperties();
#endif // SgAsmJvmLineNumberEntry_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmJvmLineNumberEntry: public SgAsmJvmNode {…};
#endif // DOCUMENTATION
 
 
// SgAsmJvmInstruction           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmJvmInstruction);
IS_SERIALIZABLE(AsmJvmInstruction);
 
#ifndef DOCUMENTATION
AsmJvmInstruction.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmJvmInstruction);
#if defined(SgAsmJvmInstruction_HEADERS) || defined(DOCUMENTATION)
#include <Rose/BinaryAnalysis/InstructionEnumsJvm.h>
#endif // SgAsmJvmInstruction_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmJvmInstruction: public SgAsmInstruction {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmInstruction.setDataPrototype(
        "Rose::BinaryAnalysis::JvmInstructionKind", "kind", "= Rose::BinaryAnalysis::JvmInstructionKind::unknown",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmJvmInstruction);
#if defined(SgAsmJvmInstruction_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmJvmInstruction -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmJvmInstruction");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmInstruction);
        s & BOOST_SERIALIZATION_NVP(p_kind);
        debugSerializationEnd("SgAsmJvmInstruction");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    Rose::BinaryAnalysis::JvmInstructionKind const& get_kind() const;
    void set_kind(Rose::BinaryAnalysis::JvmInstructionKind const&);
public:
    // Overrides are documented in the base class
    virtual unsigned get_anyKind() const override;
public:
    virtual ~SgAsmJvmInstruction();
 
public:
    SgAsmJvmInstruction();
 
public:
    SgAsmJvmInstruction(Rose::BinaryAnalysis::Address const& address,
                        uint8_t const& architectureId,
                        Rose::BinaryAnalysis::JvmInstructionKind const& kind);
 
protected:
    void initializeProperties();
#endif // SgAsmJvmInstruction_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmJvmInstruction: public SgAsmInstruction {…};
#endif // DOCUMENTATION
 
 
// SgAsmJvmInnerClasses           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmJvmInnerClasses);
IS_SERIALIZABLE(AsmJvmInnerClasses);
 
#ifndef DOCUMENTATION
AsmJvmInnerClasses.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmJvmInnerClasses);
#if defined(SgAsmJvmInnerClasses_HEADERS) || defined(DOCUMENTATION)
#include <sageContainer.h>
#endif // SgAsmJvmInnerClasses_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmJvmInnerClasses: public SgAsmJvmAttribute {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmInnerClasses.setDataPrototype(
        "SgAsmJvmInnerClassesEntryPtrList", "classes", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmJvmInnerClasses);
#if defined(SgAsmJvmInnerClasses_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmJvmInnerClasses -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmJvmInnerClasses");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmJvmAttribute);
        s & BOOST_SERIALIZATION_NVP(p_classes);
        debugSerializationEnd("SgAsmJvmInnerClasses");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgAsmJvmInnerClassesEntryPtrList const& get_classes() const;
    SgAsmJvmInnerClassesEntryPtrList& get_classes();
    void set_classes(SgAsmJvmInnerClassesEntryPtrList const&);
public:
    explicit SgAsmJvmInnerClasses(SgAsmJvmAttributeTable* table);
 
    SgAsmJvmInnerClasses* parse(SgAsmJvmConstantPool*) override;
 
    virtual void unparse(std::ostream&) const override;
 
    virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
public:
    virtual ~SgAsmJvmInnerClasses();
 
public:
    SgAsmJvmInnerClasses();
 
protected:
    void initializeProperties();
#endif // SgAsmJvmInnerClasses_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmJvmInnerClasses: public SgAsmJvmAttribute {…};
#endif // DOCUMENTATION
 
 
// SgAsmJvmInnerClassesEntry           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmJvmInnerClassesEntry);
IS_SERIALIZABLE(AsmJvmInnerClassesEntry);
 
#ifndef DOCUMENTATION
AsmJvmInnerClassesEntry.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmJvmInnerClassesEntry: public SgAsmJvmNode {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmInnerClassesEntry.setDataPrototype(
        "uint16_t", "inner_class_info_index", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmInnerClassesEntry.setDataPrototype(
        "uint16_t", "outer_class_info_index", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmInnerClassesEntry.setDataPrototype(
        "uint16_t", "inner_name_index", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmInnerClassesEntry.setDataPrototype(
        "uint16_t", "inner_class_access_flags", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmJvmInnerClassesEntry);
#if defined(SgAsmJvmInnerClassesEntry_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmJvmInnerClassesEntry -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmJvmInnerClassesEntry");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmJvmNode);
        s & BOOST_SERIALIZATION_NVP(p_inner_class_info_index);
        s & BOOST_SERIALIZATION_NVP(p_outer_class_info_index);
        s & BOOST_SERIALIZATION_NVP(p_inner_name_index);
        s & BOOST_SERIALIZATION_NVP(p_inner_class_access_flags);
        debugSerializationEnd("SgAsmJvmInnerClassesEntry");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    uint16_t const& get_inner_class_info_index() const;
    void set_inner_class_info_index(uint16_t const&);
public:
    uint16_t const& get_outer_class_info_index() const;
    void set_outer_class_info_index(uint16_t const&);
public:
    uint16_t const& get_inner_name_index() const;
    void set_inner_name_index(uint16_t const&);
public:
    uint16_t const& get_inner_class_access_flags() const;
    void set_inner_class_access_flags(uint16_t const&);
public:
    explicit SgAsmJvmInnerClassesEntry(SgAsmJvmInnerClasses*);
 
    SgAsmJvmInnerClassesEntry* parse(SgAsmJvmConstantPool*);
 
    virtual void unparse(std::ostream&) const override;
 
    void dump(FILE*, const char *prefix, ssize_t idx) const override;
public:
    virtual ~SgAsmJvmInnerClassesEntry();
 
public:
    SgAsmJvmInnerClassesEntry();
 
protected:
    void initializeProperties();
#endif // SgAsmJvmInnerClassesEntry_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmJvmInnerClassesEntry: public SgAsmJvmNode {…};
#endif // DOCUMENTATION
 
 
// SgAsmJvmFileHeader           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmJvmFileHeader);
IS_SERIALIZABLE(AsmJvmFileHeader);
 
#ifndef DOCUMENTATION
AsmJvmFileHeader.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmJvmFileHeader: public SgAsmGenericHeader {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmFileHeader.setDataPrototype(
        "uint16_t", "minor_version", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmFileHeader.setDataPrototype(
        "uint16_t", "major_version", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmFileHeader.setDataPrototype(
        "uint16_t", "access_flags", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmFileHeader.setDataPrototype(
        "uint16_t", "this_class", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmFileHeader.setDataPrototype(
        "uint16_t", "super_class", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmFileHeader.setDataPrototype(
        "SgAsmJvmConstantPool*", "constant_pool", "= nullptr",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmFileHeader.setDataPrototype(
        "std::list<uint16_t>", "interfaces", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmFileHeader.setDataPrototype(
        "SgAsmJvmFieldTable*", "field_table", "= nullptr",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmFileHeader.setDataPrototype(
        "SgAsmJvmMethodTable*", "method_table", "= nullptr",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmFileHeader.setDataPrototype(
        "SgAsmJvmAttributeTable*", "attribute_table", "= nullptr",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmJvmFileHeader);
#if defined(SgAsmJvmFileHeader_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmJvmFileHeader -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmJvmFileHeader");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmGenericHeader);
        s & BOOST_SERIALIZATION_NVP(p_minor_version);
        s & BOOST_SERIALIZATION_NVP(p_major_version);
        s & BOOST_SERIALIZATION_NVP(p_access_flags);
        s & BOOST_SERIALIZATION_NVP(p_this_class);
        s & BOOST_SERIALIZATION_NVP(p_super_class);
        s & BOOST_SERIALIZATION_NVP(p_constant_pool);
        s & BOOST_SERIALIZATION_NVP(p_interfaces);
        s & BOOST_SERIALIZATION_NVP(p_field_table);
        s & BOOST_SERIALIZATION_NVP(p_method_table);
        s & BOOST_SERIALIZATION_NVP(p_attribute_table);
        debugSerializationEnd("SgAsmJvmFileHeader");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    uint16_t const& get_minor_version() const;
    void set_minor_version(uint16_t const&);
public:
    uint16_t const& get_major_version() const;
    void set_major_version(uint16_t const&);
public:
    uint16_t const& get_access_flags() const;
    void set_access_flags(uint16_t const&);
public:
    uint16_t const& get_this_class() const;
    void set_this_class(uint16_t const&);
public:
    uint16_t const& get_super_class() const;
    void set_super_class(uint16_t const&);
public:
    SgAsmJvmConstantPool* const& get_constant_pool() const;
    void set_constant_pool(SgAsmJvmConstantPool* const&);
public:
    std::list<uint16_t> const& get_interfaces() const;
    std::list<uint16_t>& get_interfaces();
    void set_interfaces(std::list<uint16_t> const&);
public:
    SgAsmJvmFieldTable* const& get_field_table() const;
    void set_field_table(SgAsmJvmFieldTable* const&);
public:
    SgAsmJvmMethodTable* const& get_method_table() const;
    void set_method_table(SgAsmJvmMethodTable* const&);
public:
    SgAsmJvmAttributeTable* const& get_attribute_table() const;
    void set_attribute_table(SgAsmJvmAttributeTable* const&);
public:
    explicit SgAsmJvmFileHeader(SgAsmGenericFile *);
 
    virtual SgAsmJvmFileHeader* parse() override;
 
    virtual void unparse(std::ostream&) const override;
 
    static bool is_JVM(SgAsmGenericFile*);
 
protected:
    // Some extra clean-up actions on destruction
    virtual void destructorHelper() override;
public:
    virtual ~SgAsmJvmFileHeader();
 
public:
    SgAsmJvmFileHeader();
 
protected:
    void initializeProperties();
#endif // SgAsmJvmFileHeader_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmJvmFileHeader: public SgAsmGenericHeader {…};
#endif // DOCUMENTATION
 
 
// SgAsmJvmFieldTable           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmJvmFieldTable);
IS_SERIALIZABLE(AsmJvmFieldTable);
 
#ifndef DOCUMENTATION
AsmJvmFieldTable.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmJvmFieldTable: public SgAsmGenericSection {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmFieldTable.setDataPrototype(
        "SgAsmJvmFieldPtrList", "fields", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmJvmFieldTable);
#if defined(SgAsmJvmFieldTable_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmJvmFieldTable -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmJvmFieldTable");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmGenericSection);
        s & BOOST_SERIALIZATION_NVP(p_fields);
        debugSerializationEnd("SgAsmJvmFieldTable");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgAsmJvmFieldPtrList const& get_fields() const;
    SgAsmJvmFieldPtrList& get_fields();
    void set_fields(SgAsmJvmFieldPtrList const&);
public:
    explicit SgAsmJvmFieldTable(SgAsmJvmFileHeader*);
 
    virtual SgAsmJvmFieldTable* parse() override;
 
    virtual void unparse(std::ostream&) const override;
 
    virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
public:
    virtual ~SgAsmJvmFieldTable();
 
public:
    SgAsmJvmFieldTable();
 
protected:
    void initializeProperties();
#endif // SgAsmJvmFieldTable_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmJvmFieldTable: public SgAsmGenericSection {…};
#endif // DOCUMENTATION
 
 
// SgAsmJvmField           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmJvmField);
IS_SERIALIZABLE(AsmJvmField);
 
#ifndef DOCUMENTATION
AsmJvmField.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmJvmField);
#if defined(SgAsmJvmField_HEADERS) || defined(DOCUMENTATION)
#ifdef ROSE_SgAsmJvmField_IMPL
#include <SgAsmJvmAttributeTable.h>
#endif
#endif // SgAsmJvmField_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmJvmField: public SgAsmJvmNode {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmField.setDataPrototype(
        "uint16_t", "access_flags", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmField.setDataPrototype(
        "uint16_t", "name_index", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmField.setDataPrototype(
        "uint16_t", "descriptor_index", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmField.setDataPrototype(
        "SgAsmJvmAttributeTable*", "attribute_table", "= nullptr",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmJvmField);
#if defined(SgAsmJvmField_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmJvmField -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmJvmField");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmJvmNode);
        s & BOOST_SERIALIZATION_NVP(p_access_flags);
        s & BOOST_SERIALIZATION_NVP(p_name_index);
        s & BOOST_SERIALIZATION_NVP(p_descriptor_index);
        s & BOOST_SERIALIZATION_NVP(p_attribute_table);
        debugSerializationEnd("SgAsmJvmField");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    uint16_t const& get_access_flags() const;
    void set_access_flags(uint16_t const&);
public:
    uint16_t const& get_name_index() const;
    void set_name_index(uint16_t const&);
public:
    uint16_t const& get_descriptor_index() const;
    void set_descriptor_index(uint16_t const&);
public:
    SgAsmJvmAttributeTable* const& get_attribute_table() const;
    void set_attribute_table(SgAsmJvmAttributeTable* const&);
 public:
    explicit SgAsmJvmField(SgAsmJvmFieldTable*);
 
    SgAsmJvmField* parse(SgAsmJvmConstantPool* pool);
 
    virtual void unparse(std::ostream&) const override;
 
    void dump(FILE*, const char *prefix, ssize_t idx) const override;
public:
    virtual ~SgAsmJvmField();
 
public:
    SgAsmJvmField();
 
protected:
    void initializeProperties();
#endif // SgAsmJvmField_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmJvmField: public SgAsmJvmNode {…};
#endif // DOCUMENTATION
 
 
// SgAsmJvmExceptionTable           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmJvmExceptionTable);
IS_SERIALIZABLE(AsmJvmExceptionTable);
 
#ifndef DOCUMENTATION
AsmJvmExceptionTable.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmJvmExceptionTable);
#if defined(SgAsmJvmExceptionTable_HEADERS) || defined(DOCUMENTATION)
#include <sageContainer.h>
#endif // SgAsmJvmExceptionTable_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmJvmExceptionTable: public SgAsmJvmNode {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmExceptionTable.setDataPrototype(
        "SgAsmJvmExceptionHandlerPtrList", "handlers", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmJvmExceptionTable);
#if defined(SgAsmJvmExceptionTable_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmJvmExceptionTable -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmJvmExceptionTable");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmJvmNode);
        s & BOOST_SERIALIZATION_NVP(p_handlers);
        debugSerializationEnd("SgAsmJvmExceptionTable");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgAsmJvmExceptionHandlerPtrList const& get_handlers() const;
    SgAsmJvmExceptionHandlerPtrList& get_handlers();
    void set_handlers(SgAsmJvmExceptionHandlerPtrList const&);
public:
    explicit SgAsmJvmExceptionTable(SgAsmJvmCodeAttribute*);
 
    SgAsmJvmExceptionTable* parse(SgAsmJvmConstantPool*);
 
    virtual void unparse(std::ostream&) const override;
 
    void dump(FILE*, const char *prefix, ssize_t idx) const override;
public:
    virtual ~SgAsmJvmExceptionTable();
 
public:
    SgAsmJvmExceptionTable();
 
protected:
    void initializeProperties();
#endif // SgAsmJvmExceptionTable_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmJvmExceptionTable: public SgAsmJvmNode {…};
#endif // DOCUMENTATION
 
 
// SgAsmJvmExceptions           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmJvmExceptions);
IS_SERIALIZABLE(AsmJvmExceptions);
 
#ifndef DOCUMENTATION
AsmJvmExceptions.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmJvmExceptions);
#if defined(SgAsmJvmExceptions_HEADERS) || defined(DOCUMENTATION)
#include <sageContainer.h>
#endif // SgAsmJvmExceptions_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmJvmExceptions: public SgAsmJvmAttribute {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmExceptions.setDataPrototype(
        "SgUnsigned16List", "exception_index_table", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmJvmExceptions);
#if defined(SgAsmJvmExceptions_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmJvmExceptions -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmJvmExceptions");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmJvmAttribute);
        s & BOOST_SERIALIZATION_NVP(p_exception_index_table);
        debugSerializationEnd("SgAsmJvmExceptions");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgUnsigned16List const& get_exception_index_table() const;
    void set_exception_index_table(SgUnsigned16List const&);
 public:
    explicit SgAsmJvmExceptions(SgAsmJvmAttributeTable* table);
 
    SgAsmJvmExceptions* parse(SgAsmJvmConstantPool*) override;
 
    virtual void unparse(std::ostream&) const override;
 
    void dump(FILE*, const char *prefix, ssize_t idx) const override;
public:
    virtual ~SgAsmJvmExceptions();
 
public:
    SgAsmJvmExceptions();
 
protected:
    void initializeProperties();
#endif // SgAsmJvmExceptions_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmJvmExceptions: public SgAsmJvmAttribute {…};
#endif // DOCUMENTATION
 
 
// SgAsmJvmExceptionHandler           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmJvmExceptionHandler);
IS_SERIALIZABLE(AsmJvmExceptionHandler);
 
#ifndef DOCUMENTATION
AsmJvmExceptionHandler.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmJvmExceptionHandler: public SgAsmJvmNode {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmExceptionHandler.setDataPrototype(
        "uint16_t", "start_pc", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmExceptionHandler.setDataPrototype(
        "uint16_t", "end_pc", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmExceptionHandler.setDataPrototype(
        "uint16_t", "handler_pc", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmExceptionHandler.setDataPrototype(
        "uint16_t", "catch_type", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmJvmExceptionHandler);
#if defined(SgAsmJvmExceptionHandler_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmJvmExceptionHandler -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmJvmExceptionHandler");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmJvmNode);
        s & BOOST_SERIALIZATION_NVP(p_start_pc);
        s & BOOST_SERIALIZATION_NVP(p_end_pc);
        s & BOOST_SERIALIZATION_NVP(p_handler_pc);
        s & BOOST_SERIALIZATION_NVP(p_catch_type);
        debugSerializationEnd("SgAsmJvmExceptionHandler");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    uint16_t const& get_start_pc() const;
    void set_start_pc(uint16_t const&);
public:
    uint16_t const& get_end_pc() const;
    void set_end_pc(uint16_t const&);
public:
    uint16_t const& get_handler_pc() const;
    void set_handler_pc(uint16_t const&);
public:
    uint16_t const& get_catch_type() const;
    void set_catch_type(uint16_t const&);
 public:
    explicit SgAsmJvmExceptionHandler(SgAsmJvmExceptionTable* table);
 
    SgAsmJvmExceptionHandler* parse(SgAsmJvmConstantPool*);
 
    virtual void unparse(std::ostream&) const override;
 
    void dump(FILE*, const char *prefix, ssize_t idx) const override;
public:
    virtual ~SgAsmJvmExceptionHandler();
 
public:
    SgAsmJvmExceptionHandler();
 
protected:
    void initializeProperties();
#endif // SgAsmJvmExceptionHandler_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmJvmExceptionHandler: public SgAsmJvmNode {…};
#endif // DOCUMENTATION
 
 
// SgAsmJvmEnclosingMethod           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmJvmEnclosingMethod);
IS_SERIALIZABLE(AsmJvmEnclosingMethod);
 
#ifndef DOCUMENTATION
AsmJvmEnclosingMethod.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmJvmEnclosingMethod: public SgAsmJvmAttribute {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmEnclosingMethod.setDataPrototype(
        "uint16_t", "class_index", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmEnclosingMethod.setDataPrototype(
        "uint16_t", "method_index", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmJvmEnclosingMethod);
#if defined(SgAsmJvmEnclosingMethod_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmJvmEnclosingMethod -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmJvmEnclosingMethod");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmJvmAttribute);
        s & BOOST_SERIALIZATION_NVP(p_class_index);
        s & BOOST_SERIALIZATION_NVP(p_method_index);
        debugSerializationEnd("SgAsmJvmEnclosingMethod");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    uint16_t const& get_class_index() const;
    void set_class_index(uint16_t const&);
public:
    uint16_t const& get_method_index() const;
    void set_method_index(uint16_t const&);
public:
    explicit SgAsmJvmEnclosingMethod(SgAsmJvmAttributeTable* table);
 
    virtual SgAsmJvmEnclosingMethod* parse(SgAsmJvmConstantPool* pool) override;
 
    virtual void unparse(std::ostream&) const override;
 
    virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
public:
    virtual ~SgAsmJvmEnclosingMethod();
 
public:
    SgAsmJvmEnclosingMethod();
 
protected:
    void initializeProperties();
#endif // SgAsmJvmEnclosingMethod_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmJvmEnclosingMethod: public SgAsmJvmAttribute {…};
#endif // DOCUMENTATION
 
 
// SgAsmJvmDeprecated           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmJvmDeprecated);
IS_SERIALIZABLE(AsmJvmDeprecated);
 
#ifndef DOCUMENTATION
AsmJvmDeprecated.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmJvmDeprecated: public SgAsmJvmAttribute {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmJvmDeprecated);
#if defined(SgAsmJvmDeprecated_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmJvmDeprecated -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmJvmDeprecated");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmJvmAttribute);
        debugSerializationEnd("SgAsmJvmDeprecated");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
    explicit SgAsmJvmDeprecated(SgAsmJvmAttributeTable* table);
 
    virtual SgAsmJvmAttribute* parse(SgAsmJvmConstantPool* pool) override;
public:
    virtual ~SgAsmJvmDeprecated();
 
public:
    SgAsmJvmDeprecated();
 
protected:
    void initializeProperties();
#endif // SgAsmJvmDeprecated_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmJvmDeprecated: public SgAsmJvmAttribute {…};
#endif // DOCUMENTATION
 
 
// SgAsmJvmConstantValue           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmJvmConstantValue);
IS_SERIALIZABLE(AsmJvmConstantValue);
 
#ifndef DOCUMENTATION
AsmJvmConstantValue.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmJvmConstantValue: public SgAsmJvmAttribute {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmConstantValue.setDataPrototype(
        "uint16_t", "constantvalue_index", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmJvmConstantValue);
#if defined(SgAsmJvmConstantValue_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmJvmConstantValue -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmJvmConstantValue");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmJvmAttribute);
        s & BOOST_SERIALIZATION_NVP(p_constantvalue_index);
        debugSerializationEnd("SgAsmJvmConstantValue");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    uint16_t const& get_constantvalue_index() const;
    void set_constantvalue_index(uint16_t const&);
public:
    explicit SgAsmJvmConstantValue(SgAsmJvmAttributeTable* table);
 
    virtual SgAsmJvmAttribute* parse(SgAsmJvmConstantPool* pool) override;
 
    virtual void unparse(std::ostream&) const override;
 
    virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
public:
    virtual ~SgAsmJvmConstantValue();
 
public:
    SgAsmJvmConstantValue();
 
protected:
    void initializeProperties();
#endif // SgAsmJvmConstantValue_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmJvmConstantValue: public SgAsmJvmAttribute {…};
#endif // DOCUMENTATION
 
 
// SgAsmJvmConstantPool           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmJvmConstantPool);
IS_SERIALIZABLE(AsmJvmConstantPool);
 
#ifndef DOCUMENTATION
AsmJvmConstantPool.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmJvmConstantPool: public SgAsmGenericSection {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmConstantPool.setDataPrototype(
        "SgAsmJvmConstantPoolEntryPtrList", "entries", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmJvmConstantPool);
#if defined(SgAsmJvmConstantPool_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmJvmConstantPool -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmJvmConstantPool");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmGenericSection);
        s & BOOST_SERIALIZATION_NVP(p_entries);
        debugSerializationEnd("SgAsmJvmConstantPool");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgAsmJvmConstantPoolEntryPtrList const& get_entries() const;
    SgAsmJvmConstantPoolEntryPtrList& get_entries();
    void set_entries(SgAsmJvmConstantPoolEntryPtrList const&);
public:
    explicit SgAsmJvmConstantPool(SgAsmJvmFileHeader*);
 
    virtual SgAsmJvmConstantPool* parse() override;
 
    SgAsmJvmConstantPoolEntry* get_entry(size_t index) const;
    std::string get_utf8_string(size_t index) const;
 
    virtual void unparse(std::ostream&) const override;
 
    virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
 
protected:
    // Some extra clean-up actions on destruction
    virtual void destructorHelper() override;
public:
    virtual ~SgAsmJvmConstantPool();
 
public:
    SgAsmJvmConstantPool();
 
protected:
    void initializeProperties();
#endif // SgAsmJvmConstantPool_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmJvmConstantPool: public SgAsmGenericSection {…};
#endif // DOCUMENTATION
 
 
// SgAsmJvmConstantPoolEntry           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmJvmConstantPoolEntry);
IS_SERIALIZABLE(AsmJvmConstantPoolEntry);
 
#ifndef DOCUMENTATION
AsmJvmConstantPoolEntry.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmJvmConstantPoolEntry: public SgAsmJvmNode {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmConstantPoolEntry.setDataPrototype(
        "SgAsmJvmConstantPoolEntry::Kind", "tag", "= SgAsmJvmConstantPoolEntry::EMPTY",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmConstantPoolEntry.setDataPrototype(
        "uint32_t", "bytes", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmConstantPoolEntry.setDataPrototype(
        "uint32_t", "hi_bytes", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmConstantPoolEntry.setDataPrototype(
        "uint32_t", "low_bytes", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmConstantPoolEntry.setDataPrototype(
        "uint16_t", "bootstrap_method_attr_index", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmConstantPoolEntry.setDataPrototype(
        "uint16_t", "class_index", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmConstantPoolEntry.setDataPrototype(
        "uint16_t", "descriptor_index", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmConstantPoolEntry.setDataPrototype(
        "uint16_t", "name_index", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmConstantPoolEntry.setDataPrototype(
        "uint16_t", "name_and_type_index", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmConstantPoolEntry.setDataPrototype(
        "uint16_t", "reference_index", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmConstantPoolEntry.setDataPrototype(
        "uint8_t", "reference_kind", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmConstantPoolEntry.setDataPrototype(
        "uint16_t", "string_index", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmConstantPoolEntry.setDataPrototype(
        "uint16_t", "length", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmConstantPoolEntry.setDataPrototype(
        "char*", "utf8_bytes", "= nullptr",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmJvmConstantPoolEntry);
#if defined(SgAsmJvmConstantPoolEntry_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmJvmConstantPoolEntry -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmJvmConstantPoolEntry");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmJvmNode);
        s & BOOST_SERIALIZATION_NVP(p_tag);
        s & BOOST_SERIALIZATION_NVP(p_bytes);
        s & BOOST_SERIALIZATION_NVP(p_hi_bytes);
        s & BOOST_SERIALIZATION_NVP(p_low_bytes);
        s & BOOST_SERIALIZATION_NVP(p_bootstrap_method_attr_index);
        s & BOOST_SERIALIZATION_NVP(p_class_index);
        s & BOOST_SERIALIZATION_NVP(p_descriptor_index);
        s & BOOST_SERIALIZATION_NVP(p_name_index);
        s & BOOST_SERIALIZATION_NVP(p_name_and_type_index);
        s & BOOST_SERIALIZATION_NVP(p_reference_index);
        s & BOOST_SERIALIZATION_NVP(p_reference_kind);
        s & BOOST_SERIALIZATION_NVP(p_string_index);
        s & BOOST_SERIALIZATION_NVP(p_length);
        debugSerializationEnd("SgAsmJvmConstantPoolEntry");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
    // Local types
public:
    enum Kind {
        EMPTY = 0,
        CONSTANT_Utf8 = 1,
        CONSTANT_Integer = 3,
        CONSTANT_Float = 4,
        CONSTANT_Long = 5,
        CONSTANT_Double = 6,
        CONSTANT_Class = 7,
        CONSTANT_String = 8,
        CONSTANT_Fieldref = 9,
        CONSTANT_Methodref = 10,
        CONSTANT_InterfaceMethodref = 11,
        CONSTANT_NameAndType = 12,
        CONSTANT_MethodHandle = 15,
        CONSTANT_MethodType = 16,
        CONSTANT_Dynamic = 17,
        CONSTANT_InvokeDynamic = 18,
        CONSTANT_Module = 19,
        CONSTANT_Package = 20
    };
    enum Kind {…};
 
#ifdef DOCUMENTATION
#endif
    struct CONSTANT_Class_info {
        uint8_t tag;
        uint16_t name_index;
    };
    struct CONSTANT_Class_info {…};
 
    struct CONSTANT_Fieldref_info {
        uint8_t tag;
        uint16_t class_index;
        uint16_t name_and_type_index;
    };
    struct CONSTANT_Fieldref_info {…};
    struct CONSTANT_Methodref_info {
        uint8_t tag;
        uint16_t class_index;
        uint16_t name_and_type_index;
    };
    struct CONSTANT_Methodref_info {…};
    struct CONSTANT_InterfaceMethodref_info {
        uint8_t tag;
        uint16_t class_index;
        uint16_t name_and_type_index;
    };
    struct CONSTANT_InterfaceMethodref_info {…};
 
    struct CONSTANT_String_info {
        uint8_t tag;
        uint16_t string_index;
    };
    struct CONSTANT_String_info {…};
 
    struct CONSTANT_Integer_info {
        uint8_t tag;
        uint32_t bytes;
    };
    struct CONSTANT_Integer_info {…};
    struct CONSTANT_Float_info {
        uint8_t tag;
        uint32_t bytes;
    };
    struct CONSTANT_Float_info {…};
    struct CONSTANT_Long_info {
        uint8_t tag;
        uint32_t hi_bytes;
        uint32_t low_bytes;
    };
    struct CONSTANT_Long_info {…};
    struct CONSTANT_Double_info {
        uint8_t tag;
        uint32_t hi_bytes;
        uint32_t low_bytes;
    };
    struct CONSTANT_Double_info {…};
 
    struct CONSTANT_NameAndType_info {
        uint8_t tag;
        uint16_t name_index;
        uint16_t descriptor_index;
    };
    struct CONSTANT_NameAndType_info {…};
 
    struct CONSTANT_Utf8_info {
        uint8_t tag;
        uint16_t length;
        uint8_t* bytes;
    };
    struct CONSTANT_Utf8_info {…};
 
    struct CONSTANT_MethodHandle_info {
        uint8_t tag;
        uint8_t reference_kind;
        uint16_t reference_index;
    };
    struct CONSTANT_MethodHandle_info {…};
 
    struct CONSTANT_MethodType_info {
        uint8_t tag;
        uint16_t descriptor_index;
    };
    struct CONSTANT_MethodType_info {…};
 
    struct CONSTANT_Dynamic_info {
        uint8_t tag;
        uint16_t bootstrap_method_attr_index;
        uint16_t name_and_type_index;
    };
    struct CONSTANT_Dynamic_info {…};
    struct CONSTANT_InvokeDynamic_info {
        uint8_t tag;
        uint16_t bootstrap_method_attr_index;
        uint16_t name_and_type_index;
    };
    struct CONSTANT_InvokeDynamic_info {…};
 
    struct CONSTANT_Module_info {
        uint8_t tag;
        uint16_t name_index;
    };
    struct CONSTANT_Module_info {…};
 
    struct CONSTANT_Package_info {
        uint8_t tag;
        uint16_t name_index;
    };
    struct CONSTANT_Package_info {…};
 
    // Properties
public:
public:
    SgAsmJvmConstantPoolEntry::Kind const& get_tag() const;
    void set_tag(SgAsmJvmConstantPoolEntry::Kind const&);
public:
    uint32_t const& get_bytes() const;
    void set_bytes(uint32_t const&);
public:
    uint32_t const& get_hi_bytes() const;
    void set_hi_bytes(uint32_t const&);
public:
    uint32_t const& get_low_bytes() const;
    void set_low_bytes(uint32_t const&);
public:
    uint16_t const& get_bootstrap_method_attr_index() const;
    void set_bootstrap_method_attr_index(uint16_t const&);
public:
    uint16_t const& get_class_index() const;
    void set_class_index(uint16_t const&);
public:
    uint16_t const& get_descriptor_index() const;
    void set_descriptor_index(uint16_t const&);
public:
    uint16_t const& get_name_index() const;
    void set_name_index(uint16_t const&);
public:
    uint16_t const& get_name_and_type_index() const;
    void set_name_and_type_index(uint16_t const&);
public:
    uint16_t const& get_reference_index() const;
    void set_reference_index(uint16_t const&);
public:
    uint8_t const& get_reference_kind() const;
    void set_reference_kind(uint8_t const&);
public:
    uint16_t const& get_string_index() const;
    void set_string_index(uint16_t const&);
public:
    uint16_t const& get_length() const;
    void set_length(uint16_t const&);
    // [Robb Matzke 2023-03-22]: I (and the serialization) have no idea what this points to, and therefore it cannot be
    // serialized. E.g., how many 'chars' should be serialized? Is the length stored in the `length` property? If so, `utf8_bytes`
    // should probably be an std::vector instead, which is a serializable thing. Furthermore, the data member cannot be 'const'
    // because that prevents it from being initialized by some de-serialization mechanisms (e.g., boost::serialize creates a default
    // constructed object and then fills it in).
public:
    char* const& get_utf8_bytes() const;
    void set_utf8_bytes(char* const&);
    // Functions
public:
    explicit SgAsmJvmConstantPoolEntry(SgAsmJvmConstantPoolEntry::Kind tag);
 
    SgAsmJvmConstantPoolEntry* parse(SgAsmJvmConstantPool* pool);
    virtual void unparse(std::ostream&) const override;
 
    void dump(FILE*, const char *prefix, ssize_t idx) const override;
 
    static std::string to_string(SgAsmJvmConstantPoolEntry::Kind);
public:
    virtual ~SgAsmJvmConstantPoolEntry();
 
public:
    SgAsmJvmConstantPoolEntry();
 
protected:
    void initializeProperties();
#endif // SgAsmJvmConstantPoolEntry_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmJvmConstantPoolEntry: public SgAsmJvmNode {…};
#endif // DOCUMENTATION
 
 
// SgAsmJvmCodeAttribute           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmJvmCodeAttribute);
IS_SERIALIZABLE(AsmJvmCodeAttribute);
 
#ifndef DOCUMENTATION
AsmJvmCodeAttribute.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmJvmCodeAttribute);
#if defined(SgAsmJvmCodeAttribute_HEADERS) || defined(DOCUMENTATION)
#include <Rose/BinaryAnalysis/Address.h>
#endif // SgAsmJvmCodeAttribute_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmJvmCodeAttribute: public SgAsmJvmAttribute {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmCodeAttribute.setDataPrototype(
        "uint16_t", "max_stack", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmCodeAttribute.setDataPrototype(
        "uint16_t", "max_locals", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmCodeAttribute.setDataPrototype(
        "uint32_t", "code_length", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmCodeAttribute.setDataPrototype(
        "const char*", "code", "= nullptr",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmCodeAttribute.setDataPrototype(
        "SgAsmJvmExceptionTable*", "exception_table", "= nullptr",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmCodeAttribute.setDataPrototype(
        "SgAsmJvmAttributeTable*", "attribute_table", "= nullptr",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmCodeAttribute.setDataPrototype(
        "Rose::BinaryAnalysis::Address", "code_offset", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmJvmCodeAttribute);
#if defined(SgAsmJvmCodeAttribute_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmJvmCodeAttribute -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmJvmCodeAttribute");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmJvmAttribute);
        s & BOOST_SERIALIZATION_NVP(p_max_stack);
        s & BOOST_SERIALIZATION_NVP(p_max_locals);
        s & BOOST_SERIALIZATION_NVP(p_code_length);
        s & BOOST_SERIALIZATION_NVP(p_exception_table);
        s & BOOST_SERIALIZATION_NVP(p_attribute_table);
        s & BOOST_SERIALIZATION_NVP(p_code_offset);
        debugSerializationEnd("SgAsmJvmCodeAttribute");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    uint16_t const& get_max_stack() const;
    void set_max_stack(uint16_t const&);
public:
    uint16_t const& get_max_locals() const;
    void set_max_locals(uint16_t const&);
public:
    uint32_t const& get_code_length() const;
    void set_code_length(uint32_t const&);
    // FIXME[Robb Matzke 2023-03-20]: is the lack of serialization a bug?
public:
    const char* const& get_code() const;
    void set_code(const char* const&);
public:
    SgAsmJvmExceptionTable* const& get_exception_table() const;
    void set_exception_table(SgAsmJvmExceptionTable* const&);
public:
    SgAsmJvmAttributeTable* const& get_attribute_table() const;
    void set_attribute_table(SgAsmJvmAttributeTable* const&);
public:
    Rose::BinaryAnalysis::Address const& get_code_offset() const;
    void set_code_offset(Rose::BinaryAnalysis::Address const&);
public:
    explicit SgAsmJvmCodeAttribute(SgAsmJvmAttributeTable* table);
 
    virtual SgAsmJvmAttribute* parse(SgAsmJvmConstantPool* pool) override;
 
    virtual void unparse(std::ostream&) const override;
 
    virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
public:
    virtual ~SgAsmJvmCodeAttribute();
 
public:
    SgAsmJvmCodeAttribute();
 
protected:
    void initializeProperties();
#endif // SgAsmJvmCodeAttribute_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmJvmCodeAttribute: public SgAsmJvmAttribute {…};
#endif // DOCUMENTATION
 
 
// SgAsmJvmClass           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmJvmClass);
IS_SERIALIZABLE(AsmJvmClass);
 
#ifndef DOCUMENTATION
AsmJvmClass.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmJvmClass: public SgAsmJvmNode {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmJvmClass);
#if defined(SgAsmJvmClass_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmJvmClass -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmJvmClass");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmJvmNode);
        debugSerializationEnd("SgAsmJvmClass");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    virtual ~SgAsmJvmClass();
 
public:
    SgAsmJvmClass();
 
protected:
    void initializeProperties();
#endif // SgAsmJvmClass_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmJvmClass: public SgAsmJvmNode {…};
#endif // DOCUMENTATION
 
 
// SgAsmJvmBootstrapMethods           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmJvmBootstrapMethods);
IS_SERIALIZABLE(AsmJvmBootstrapMethods);
 
#ifndef DOCUMENTATION
AsmJvmBootstrapMethods.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmJvmBootstrapMethods);
#if defined(SgAsmJvmBootstrapMethods_HEADERS) || defined(DOCUMENTATION)
#include <sageContainer.h>
#endif // SgAsmJvmBootstrapMethods_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmJvmBootstrapMethods: public SgAsmJvmAttribute {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmBootstrapMethods.setDataPrototype(
        "SgAsmJvmBootstrapMethodPtrList", "bootstrap_methods", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmJvmBootstrapMethods);
#if defined(SgAsmJvmBootstrapMethods_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmJvmBootstrapMethods -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmJvmBootstrapMethods");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmJvmAttribute);
        s & BOOST_SERIALIZATION_NVP(p_bootstrap_methods);
        debugSerializationEnd("SgAsmJvmBootstrapMethods");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
    // Properties
public:
public:
    SgAsmJvmBootstrapMethodPtrList const& get_bootstrap_methods() const;
    SgAsmJvmBootstrapMethodPtrList& get_bootstrap_methods();
    void set_bootstrap_methods(SgAsmJvmBootstrapMethodPtrList const&);
    // Functions
public:
    explicit SgAsmJvmBootstrapMethods(SgAsmJvmAttributeTable*);
 
    virtual SgAsmJvmBootstrapMethods* parse(SgAsmJvmConstantPool* pool) override;
 
    virtual void unparse(std::ostream&) const override;
 
    void dump(FILE*, const char *prefix, ssize_t idx) const override;
public:
    virtual ~SgAsmJvmBootstrapMethods();
 
public:
    SgAsmJvmBootstrapMethods();
 
protected:
    void initializeProperties();
#endif // SgAsmJvmBootstrapMethods_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmJvmBootstrapMethods: public SgAsmJvmAttribute {…};
#endif // DOCUMENTATION
 
 
// SgAsmJvmBootstrapMethod           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmJvmBootstrapMethod);
IS_SERIALIZABLE(AsmJvmBootstrapMethod);
 
#ifndef DOCUMENTATION
AsmJvmBootstrapMethod.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmJvmBootstrapMethod);
#if defined(SgAsmJvmBootstrapMethod_HEADERS) || defined(DOCUMENTATION)
#include <sageContainer.h>
#endif // SgAsmJvmBootstrapMethod_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmJvmBootstrapMethod: public SgAsmJvmNode {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmBootstrapMethod.setDataPrototype(
        "uint16_t", "bootstrap_method_ref", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmBootstrapMethod.setDataPrototype(
        "SgUnsigned16List", "bootstrap_arguments", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmJvmBootstrapMethod);
#if defined(SgAsmJvmBootstrapMethod_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmJvmBootstrapMethod -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmJvmBootstrapMethod");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmJvmNode);
        s & BOOST_SERIALIZATION_NVP(p_bootstrap_method_ref);
        s & BOOST_SERIALIZATION_NVP(p_bootstrap_arguments);
        debugSerializationEnd("SgAsmJvmBootstrapMethod");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    uint16_t const& get_bootstrap_method_ref() const;
    void set_bootstrap_method_ref(uint16_t const&);
public:
    SgUnsigned16List const& get_bootstrap_arguments() const;
    void set_bootstrap_arguments(SgUnsigned16List const&);
 public:
    explicit SgAsmJvmBootstrapMethod(SgAsmJvmBootstrapMethods*);
 
    SgAsmJvmBootstrapMethod* parse(SgAsmJvmConstantPool*);
 
    virtual void unparse(std::ostream&) const override;
 
    void dump(FILE*, const char *prefix, ssize_t idx) const override;
public:
    virtual ~SgAsmJvmBootstrapMethod();
 
public:
    SgAsmJvmBootstrapMethod();
 
protected:
    void initializeProperties();
#endif // SgAsmJvmBootstrapMethod_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmJvmBootstrapMethod: public SgAsmJvmNode {…};
#endif // DOCUMENTATION
 
 
// SgAsmJvmAttributeTable           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmJvmAttributeTable);
IS_SERIALIZABLE(AsmJvmAttributeTable);
 
#ifndef DOCUMENTATION
AsmJvmAttributeTable.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmJvmAttributeTable: public SgAsmGenericSection {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmAttributeTable.setDataPrototype(
        "SgAsmJvmAttributePtrList", "attributes", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmJvmAttributeTable);
#if defined(SgAsmJvmAttributeTable_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmJvmAttributeTable -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmJvmAttributeTable");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmGenericSection);
        s & BOOST_SERIALIZATION_NVP(p_attributes);
        debugSerializationEnd("SgAsmJvmAttributeTable");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgAsmJvmAttributePtrList const& get_attributes() const;
    SgAsmJvmAttributePtrList& get_attributes();
    void set_attributes(SgAsmJvmAttributePtrList const&);
public:
    explicit SgAsmJvmAttributeTable(SgAsmJvmFileHeader*, SgAsmNode*);
 
    using SgAsmGenericSection::parse; // Removes warning messages on some compilers
                                      // ("hidden virtual overloaded function")
    SgAsmJvmAttributeTable* parse(SgAsmJvmConstantPool*);
 
    virtual void unparse(std::ostream&) const override;
 
    virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
public:
    virtual ~SgAsmJvmAttributeTable();
 
public:
    SgAsmJvmAttributeTable();
 
protected:
    void initializeProperties();
#endif // SgAsmJvmAttributeTable_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmJvmAttributeTable: public SgAsmGenericSection {…};
#endif // DOCUMENTATION
 
 
// SgAsmJvmAttribute           -- MACHINE GENERATED; DO NOT MODIFY --
 
#ifndef DOCUMENTATION
AstNodeClass& AsmJvmAttribute = nonTerminalConstructor(
    "AsmJvmAttribute",
    *this,
    "AsmJvmAttribute",
    "AsmJvmAttributeTag",
    SubclassListBuilder()
        | AsmJvmBootstrapMethods
        | AsmJvmCodeAttribute
        | AsmJvmConstantValue
        | AsmJvmDeprecated
        | AsmJvmEnclosingMethod
        | AsmJvmExceptions
        | AsmJvmInnerClasses
        | AsmJvmLineNumberTable
        | AsmJvmLocalVariableTable
        | AsmJvmLocalVariableTypeTable
        | AsmJvmMethodParameters
        | AsmJvmModuleMainClass
        | AsmJvmNestHost
        | AsmJvmNestMembers
        | AsmJvmSignature
        | AsmJvmSourceFile
        | AsmJvmStackMapTable
        | AsmJvmSynthetic
    , false);
assert(AsmJvmAttribute.associatedGrammar != nullptr);
AsmJvmAttribute.setCppCondition("!defined(DOCUMENTATION)");
AsmJvmAttribute.isBoostSerializable(true);
AsmJvmAttribute.setAutomaticGenerationOfConstructor(false);
AsmJvmAttribute.setAutomaticGenerationOfDestructor(false);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
AsmJvmAttribute.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmJvmAttribute: public SgAsmJvmNode {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmAttribute.setDataPrototype(
        "uint16_t", "attribute_name_index", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmJvmAttribute.setDataPrototype(
        "uint32_t", "attribute_length", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmJvmAttribute);
#if defined(SgAsmJvmAttribute_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmJvmAttribute -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmJvmAttribute");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmJvmNode);
        s & BOOST_SERIALIZATION_NVP(p_attribute_name_index);
        s & BOOST_SERIALIZATION_NVP(p_attribute_length);
        debugSerializationEnd("SgAsmJvmAttribute");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    uint16_t const& get_attribute_name_index() const;
    void set_attribute_name_index(uint16_t const&);
public:
    uint32_t const& get_attribute_length() const;
    void set_attribute_length(uint32_t const&);
public:
    static SgAsmJvmAttribute* instance(SgAsmJvmConstantPool* pool, SgAsmJvmAttributeTable* parent);
 
    virtual SgAsmJvmAttribute* parse(SgAsmJvmConstantPool* pool);
 
    virtual void unparse(std::ostream&) const override;
 
    virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
public:
    virtual ~SgAsmJvmAttribute();
 
protected:
    SgAsmJvmAttribute();
 
protected:
    void initializeProperties();
#endif // SgAsmJvmAttribute_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmJvmAttribute: public SgAsmJvmNode {…};
#endif // DOCUMENTATION
 
 
// SgAsmJvmNode           -- MACHINE GENERATED; DO NOT MODIFY --
 
#ifndef DOCUMENTATION
AstNodeClass& AsmJvmNode = nonTerminalConstructor(
    "AsmJvmNode",
    *this,
    "AsmJvmNode",
    "AsmJvmNodeTag",
    SubclassListBuilder()
        | AsmJvmAttribute
        | AsmJvmBootstrapMethod
        | AsmJvmClass
        | AsmJvmConstantPoolEntry
        | AsmJvmExceptionHandler
        | AsmJvmExceptionTable
        | AsmJvmField
        | AsmJvmInnerClassesEntry
        | AsmJvmLineNumberEntry
        | AsmJvmLocalVariableEntry
        | AsmJvmLocalVariableTypeEntry
        | AsmJvmMethod
        | AsmJvmMethodParametersEntry
        | AsmJvmStackMapFrame
        | AsmJvmStackMapVerificationType
    , false);
assert(AsmJvmNode.associatedGrammar != nullptr);
AsmJvmNode.setCppCondition("!defined(DOCUMENTATION)");
AsmJvmNode.isBoostSerializable(true);
AsmJvmNode.setAutomaticGenerationOfConstructor(false);
AsmJvmNode.setAutomaticGenerationOfDestructor(false);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
AsmJvmNode.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmJvmNode: public SgAsmNode {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmJvmNode);
#if defined(SgAsmJvmNode_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmJvmNode -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmJvmNode");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmNode);
        debugSerializationEnd("SgAsmJvmNode");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
    virtual void unparse(std::ostream&) const;
 
    virtual void dump(FILE*, const char *prefix, ssize_t idx) const;
public:
    virtual ~SgAsmJvmNode();
 
protected:
    SgAsmJvmNode();
 
protected:
    void initializeProperties();
#endif // SgAsmJvmNode_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmJvmNode: public SgAsmNode {…};
#endif // DOCUMENTATION
 
 
// SgAsmInterpretationList           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmInterpretationList);
IS_SERIALIZABLE(AsmInterpretationList);
 
#ifndef DOCUMENTATION
AsmInterpretationList.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmInterpretationList);
#if defined(SgAsmInterpretationList_HEADERS) || defined(DOCUMENTATION)
#include <sageContainer.h>
#endif // SgAsmInterpretationList_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmInterpretationList: public SgAsmNode {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmInterpretationList.setDataPrototype(
        "SgAsmInterpretationPtrList", "interpretations", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmInterpretationList);
#if defined(SgAsmInterpretationList_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmInterpretationList -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmInterpretationList");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmNode);
        s & BOOST_SERIALIZATION_NVP(p_interpretations);
        debugSerializationEnd("SgAsmInterpretationList");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgAsmInterpretationPtrList const& get_interpretations() const;
    SgAsmInterpretationPtrList& get_interpretations();
    void set_interpretations(SgAsmInterpretationPtrList const&);
public:
    virtual ~SgAsmInterpretationList();
 
public:
    SgAsmInterpretationList();
 
protected:
    void initializeProperties();
#endif // SgAsmInterpretationList_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmInterpretationList: public SgAsmNode {…};
#endif // DOCUMENTATION
 
 
// SgAsmInterpretation           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmInterpretation);
IS_SERIALIZABLE(AsmInterpretation);
 
#ifndef DOCUMENTATION
AsmInterpretation.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmInterpretation);
#if defined(SgAsmInterpretation_HEADERS) || defined(DOCUMENTATION)
#include <Rose/BinaryAnalysis/BasicTypes.h>
#include <Rose/BinaryAnalysis/InstructionMap.h>
#include <Rose/BinaryAnalysis/MemoryMap.h>
 
#ifdef ROSE_SgAsmInterpretation_IMPL
#include <SgAsmBlock.h>
#include <SgAsmGenericHeaderList.h>
#endif
#endif // SgAsmInterpretation_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmInterpretation: public SgAsmNode {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmInterpretation.setDataPrototype(
        "SgAsmGenericHeaderList*", "headers", "= createAndParent<SgAsmGenericHeaderList>(this)",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmInterpretation.setDataPrototype(
        "SgAsmBlock*", "globalBlock", "= nullptr",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmInterpretation.setDataPrototype(
        "bool", "coverageComputed", "= false",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmInterpretation.setDataPrototype(
        "double", "percentageCoverage", "= NAN",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmInterpretation);
#if defined(SgAsmInterpretation_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmInterpretation -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmInterpretation");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmNode);
        s & BOOST_SERIALIZATION_NVP(p_headers);
        s & BOOST_SERIALIZATION_NVP(p_globalBlock);
        s & BOOST_SERIALIZATION_NVP(p_map);
        s & BOOST_SERIALIZATION_NVP(instruction_map);
        s & BOOST_SERIALIZATION_NVP(p_coverageComputed);
        s & BOOST_SERIALIZATION_NVP(p_percentageCoverage);
        debugSerializationEnd("SgAsmInterpretation");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgAsmGenericHeaderList* const& get_headers() const;
    void set_headers(SgAsmGenericHeaderList* const&);
public:
    SgAsmBlock* const& get_globalBlock() const;
    void set_globalBlock(SgAsmBlock* const&);
    // ROSETTA doesn't understand this type, but we want this treated like a property whose data member name is "p_map"
    // and which has automatically generator accessors and mutators named "get_map" and "set_map" and is serialized.
private:
    Rose::BinaryAnalysis::MemoryMap::Ptr p_map;
 
public:
    Rose::BinaryAnalysis::MemoryMap::Ptr const& get_map() const;
    void set_map(Rose::BinaryAnalysis::MemoryMap::Ptr const&);
    // ROSETTA doesn't understand this type, but we want it serialized. Therfore, we'll define it as a property, but we'll
    // supply our own accessor and no mutator.
private:
    mutable Rose::BinaryAnalysis::InstructionMap instruction_map;
 
public:
 // cached instruction map
 
    Rose::BinaryAnalysis::InstructionMap& get_instructionMap(bool recompute = false);
    void set_instructionMap(const Rose::BinaryAnalysis::InstructionMap&);
public:
    bool const& get_coverageComputed() const;
    void set_coverageComputed(bool const&);
public:
    double const& get_percentageCoverage() const;
    void set_percentageCoverage(double const&);
public:
    SgAsmGenericFilePtrList get_files() const;
 
    void insertInstructions(Rose::BinaryAnalysis::InstructionMap&/*in,out*/);
 
    void eraseInstructions(Rose::BinaryAnalysis::InstructionMap&/*in,out*/);
 
    // Deprecated 2023-11
public:
    SgAsmBlock* get_global_block() const ROSE_DEPRECATED("use get_globalBlock");
    void set_global_block(SgAsmBlock*) ROSE_DEPRECATED("use set_globalBlock");
    Rose::BinaryAnalysis::InstructionMap& get_instruction_map(bool=false) ROSE_DEPRECATED("use get_instructionMap");
    void set_instruction_map(const Rose::BinaryAnalysis::InstructionMap&) ROSE_DEPRECATED("use set_instructionMap");
    void insert_instructions(Rose::BinaryAnalysis::InstructionMap&) ROSE_DEPRECATED("use insertInstructions");
    void erase_instructions(Rose::BinaryAnalysis::InstructionMap&) ROSE_DEPRECATED("use eraseInstructions");
public:
    virtual ~SgAsmInterpretation();
 
public:
    SgAsmInterpretation();
 
protected:
    void initializeProperties();
#endif // SgAsmInterpretation_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmInterpretation: public SgAsmNode {…};
#endif // DOCUMENTATION
 
 
// SgAsmIntegerValueExpression           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmIntegerValueExpression);
IS_SERIALIZABLE(AsmIntegerValueExpression);
 
#ifndef DOCUMENTATION
AsmIntegerValueExpression.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmIntegerValueExpression: public SgAsmConstantExpression {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmIntegerValueExpression.setDataPrototype(
        "SgNode*", "baseNode", "= nullptr",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmIntegerValueExpression);
#if defined(SgAsmIntegerValueExpression_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmIntegerValueExpression -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmIntegerValueExpression");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmConstantExpression);
        s & BOOST_SERIALIZATION_NVP(p_baseNode);
        debugSerializationEnd("SgAsmIntegerValueExpression");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgNode* const& get_baseNode() const;
    void set_baseNode(SgNode* const&);
public:
    SgAsmIntegerValueExpression(uint64_t n, SgAsmType *type);
 
    SgAsmIntegerValueExpression(const Sawyer::Container::BitVector &bv, SgAsmType *type);
 
    static uint64_t virtualAddress(SgNode*);
 
    std::string get_label(bool quiet=false) const;
 
    size_t get_significantBits() const;
 
    void makeRelativeTo(SgNode *baseNode);
 
    uint64_t get_baseAddress() const;
 
    uint64_t get_absoluteValue(size_t nbits=0) const;
 
    void set_absoluteValue(uint64_t);
 
    int64_t get_signedValue() const;
 
    int64_t get_relativeValue() const;
 
    void set_relativeValue(int64_t v, size_t nbits=64);
 
    uint64_t get_value() const { return get_absoluteValue(); }
public:
    virtual ~SgAsmIntegerValueExpression();
 
public:
    SgAsmIntegerValueExpression();
 
protected:
    void initializeProperties();
#endif // SgAsmIntegerValueExpression_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmIntegerValueExpression: public SgAsmConstantExpression {…};
#endif // DOCUMENTATION
 
 
// SgAsmIntegerType           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmIntegerType);
IS_SERIALIZABLE(AsmIntegerType);
 
#ifndef DOCUMENTATION
AsmIntegerType.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmIntegerType);
#if defined(SgAsmIntegerType_HEADERS) || defined(DOCUMENTATION)
#include <Rose/BinaryAnalysis/ByteOrder.h>
#endif // SgAsmIntegerType_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmIntegerType: public SgAsmScalarType {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmIntegerType.setDataPrototype(
        "bool", "isSigned", "= false",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmIntegerType);
#if defined(SgAsmIntegerType_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmIntegerType -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmIntegerType");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmScalarType);
        s & BOOST_SERIALIZATION_NVP(p_isSigned);
        debugSerializationEnd("SgAsmIntegerType");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    bool get_isSigned() const;
public:
    SgAsmIntegerType(Rose::BinaryAnalysis::ByteOrder::Endianness, size_t nBits, bool isSigned);
 
    static SgAsmIntegerType* instanceUnsigned(Rose::BinaryAnalysis::ByteOrder::Endianness, size_t nBits);
 
    static SgAsmIntegerType* instanceSigned(Rose::BinaryAnalysis::ByteOrder::Endianness, size_t nBits);
 
    // Overrides documented in base class
    virtual void check() const override;
    virtual std::string toString() const override;
public:
    virtual ~SgAsmIntegerType();
 
public:
    SgAsmIntegerType();
 
protected:
    void initializeProperties();
#endif // SgAsmIntegerType_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmIntegerType: public SgAsmScalarType {…};
#endif // DOCUMENTATION
 
 
// SgAsmInstructionList           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmInstructionList);
IS_SERIALIZABLE(AsmInstructionList);
 
#ifndef DOCUMENTATION
AsmInstructionList.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmInstructionList);
#if defined(SgAsmInstructionList_HEADERS) || defined(DOCUMENTATION)
#include <sageContainer.h>
#endif // SgAsmInstructionList_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmInstructionList: public SgAsmNode {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmInstructionList.setDataPrototype(
        "SgAsmInstructionPtrList", "instructions", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmInstructionList);
#if defined(SgAsmInstructionList_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmInstructionList -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmInstructionList");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmNode);
        s & BOOST_SERIALIZATION_NVP(p_instructions);
        debugSerializationEnd("SgAsmInstructionList");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgAsmInstructionPtrList const& get_instructions() const;
    SgAsmInstructionPtrList& get_instructions();
    void set_instructions(SgAsmInstructionPtrList const&);
public:
    virtual ~SgAsmInstructionList();
 
public:
    SgAsmInstructionList();
 
protected:
    void initializeProperties();
#endif // SgAsmInstructionList_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmInstructionList: public SgAsmNode {…};
#endif // DOCUMENTATION
 
 
// SgAsmIndirectRegisterExpression           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmIndirectRegisterExpression);
IS_SERIALIZABLE(AsmIndirectRegisterExpression);
 
#ifndef DOCUMENTATION
AsmIndirectRegisterExpression.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmIndirectRegisterExpression: public SgAsmRegisterReferenceExpression {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmIndirectRegisterExpression.setDataPrototype(
        "Rose::BinaryAnalysis::RegisterDescriptor", "stride", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmIndirectRegisterExpression.setDataPrototype(
        "Rose::BinaryAnalysis::RegisterDescriptor", "offset", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmIndirectRegisterExpression.setDataPrototype(
        "size_t", "index", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmIndirectRegisterExpression.setDataPrototype(
        "size_t", "modulus", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmIndirectRegisterExpression);
#if defined(SgAsmIndirectRegisterExpression_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmIndirectRegisterExpression -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmIndirectRegisterExpression");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmRegisterReferenceExpression);
        s & BOOST_SERIALIZATION_NVP(p_stride);
        s & BOOST_SERIALIZATION_NVP(p_offset);
        s & BOOST_SERIALIZATION_NVP(p_index);
        s & BOOST_SERIALIZATION_NVP(p_modulus);
        debugSerializationEnd("SgAsmIndirectRegisterExpression");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    Rose::BinaryAnalysis::RegisterDescriptor const& get_stride() const;
    void set_stride(Rose::BinaryAnalysis::RegisterDescriptor const&);
public:
    Rose::BinaryAnalysis::RegisterDescriptor const& get_offset() const;
    void set_offset(Rose::BinaryAnalysis::RegisterDescriptor const&);
public:
    size_t const& get_index() const;
    void set_index(size_t const&);
public:
    size_t const& get_modulus() const;
    void set_modulus(size_t const&);
public:
    virtual ~SgAsmIndirectRegisterExpression();
 
public:
    SgAsmIndirectRegisterExpression();
 
public:
    SgAsmIndirectRegisterExpression(Rose::BinaryAnalysis::RegisterDescriptor const& descriptor,
                                    Rose::BinaryAnalysis::RegisterDescriptor const& stride,
                                    Rose::BinaryAnalysis::RegisterDescriptor const& offset,
                                    size_t const& index,
                                    size_t const& modulus);
 
protected:
    void initializeProperties();
#endif // SgAsmIndirectRegisterExpression_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmIndirectRegisterExpression: public SgAsmRegisterReferenceExpression {…};
#endif // DOCUMENTATION
 
 
// SgAsmGenericSymbolList           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmGenericSymbolList);
IS_SERIALIZABLE(AsmGenericSymbolList);
 
#ifndef DOCUMENTATION
AsmGenericSymbolList.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmGenericSymbolList);
#if defined(SgAsmGenericSymbolList_HEADERS) || defined(DOCUMENTATION)
#include <sageContainer.h>
#endif // SgAsmGenericSymbolList_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmGenericSymbolList: public SgAsmExecutableFileFormat {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmGenericSymbolList.setDataPrototype(
        "SgAsmGenericSymbolPtrList", "symbols", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmGenericSymbolList);
#if defined(SgAsmGenericSymbolList_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmGenericSymbolList -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmGenericSymbolList");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
        s & BOOST_SERIALIZATION_NVP(p_symbols);
        debugSerializationEnd("SgAsmGenericSymbolList");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgAsmGenericSymbolPtrList const& get_symbols() const;
    SgAsmGenericSymbolPtrList& get_symbols();
    void set_symbols(SgAsmGenericSymbolPtrList const&);
public:
    virtual ~SgAsmGenericSymbolList();
 
public:
    SgAsmGenericSymbolList();
 
protected:
    void initializeProperties();
#endif // SgAsmGenericSymbolList_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmGenericSymbolList: public SgAsmExecutableFileFormat {…};
#endif // DOCUMENTATION
 
 
// SgAsmGenericSectionList           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmGenericSectionList);
IS_SERIALIZABLE(AsmGenericSectionList);
 
#ifndef DOCUMENTATION
AsmGenericSectionList.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmGenericSectionList);
#if defined(SgAsmGenericSectionList_HEADERS) || defined(DOCUMENTATION)
#include <sageContainer.h>
#endif // SgAsmGenericSectionList_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmGenericSectionList: public SgAsmExecutableFileFormat {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmGenericSectionList.setDataPrototype(
        "SgAsmGenericSectionPtrList", "sections", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmGenericSectionList);
#if defined(SgAsmGenericSectionList_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmGenericSectionList -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmGenericSectionList");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
        s & BOOST_SERIALIZATION_NVP(p_sections);
        debugSerializationEnd("SgAsmGenericSectionList");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgAsmGenericSectionPtrList const& get_sections() const;
    SgAsmGenericSectionPtrList& get_sections();
    void set_sections(SgAsmGenericSectionPtrList const&);
public:
    virtual ~SgAsmGenericSectionList();
 
public:
    SgAsmGenericSectionList();
 
protected:
    void initializeProperties();
#endif // SgAsmGenericSectionList_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmGenericSectionList: public SgAsmExecutableFileFormat {…};
#endif // DOCUMENTATION
 
 
// SgAsmGenericHeaderList           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmGenericHeaderList);
IS_SERIALIZABLE(AsmGenericHeaderList);
 
#ifndef DOCUMENTATION
AsmGenericHeaderList.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmGenericHeaderList);
#if defined(SgAsmGenericHeaderList_HEADERS) || defined(DOCUMENTATION)
#include <sageContainer.h>
#endif // SgAsmGenericHeaderList_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmGenericHeaderList: public SgAsmExecutableFileFormat {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmGenericHeaderList.setDataPrototype(
        "SgAsmGenericHeaderPtrList", "headers", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmGenericHeaderList);
#if defined(SgAsmGenericHeaderList_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmGenericHeaderList -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmGenericHeaderList");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
        s & BOOST_SERIALIZATION_NVP(p_headers);
        debugSerializationEnd("SgAsmGenericHeaderList");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgAsmGenericHeaderPtrList const& get_headers() const;
    SgAsmGenericHeaderPtrList& get_headers();
    void set_headers(SgAsmGenericHeaderPtrList const&);
public:
    virtual ~SgAsmGenericHeaderList();
 
public:
    SgAsmGenericHeaderList();
 
protected:
    void initializeProperties();
#endif // SgAsmGenericHeaderList_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmGenericHeaderList: public SgAsmExecutableFileFormat {…};
#endif // DOCUMENTATION
 
 
// SgAsmGenericFormat           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmGenericFormat);
IS_SERIALIZABLE(AsmGenericFormat);
 
#ifndef DOCUMENTATION
AsmGenericFormat.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmGenericFormat);
#if defined(SgAsmGenericFormat_HEADERS) || defined(DOCUMENTATION)
#include <Rose/BinaryAnalysis/ByteOrder.h>
#endif // SgAsmGenericFormat_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmGenericFormat: public SgAsmExecutableFileFormat {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmGenericFormat.setDataPrototype(
        "SgAsmGenericFormat::ExecFamily", "family", "= SgAsmGenericFormat::FAMILY_UNSPECIFIED",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmGenericFormat.setDataPrototype(
        "SgAsmGenericFormat::ExecPurpose", "purpose", "= SgAsmGenericFormat::PURPOSE_EXECUTABLE",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmGenericFormat.setDataPrototype(
        "Rose::BinaryAnalysis::ByteOrder::Endianness", "sex", "= Rose::BinaryAnalysis::ByteOrder::ORDER_UNSPECIFIED",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmGenericFormat.setDataPrototype(
        "unsigned", "version", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmGenericFormat.setDataPrototype(
        "bool", "isCurrentVersion", "= false",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmGenericFormat.setDataPrototype(
        "SgAsmGenericFormat::ExecABI", "abi", "= SgAsmGenericFormat::ABI_UNSPECIFIED",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmGenericFormat.setDataPrototype(
        "unsigned", "abiVersion", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmGenericFormat.setDataPrototype(
        "size_t", "wordSize", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmGenericFormat);
#if defined(SgAsmGenericFormat_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmGenericFormat -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmGenericFormat");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
        s & BOOST_SERIALIZATION_NVP(p_family);
        s & BOOST_SERIALIZATION_NVP(p_purpose);
        s & BOOST_SERIALIZATION_NVP(p_sex);
        s & BOOST_SERIALIZATION_NVP(p_version);
        s & BOOST_SERIALIZATION_NVP(p_isCurrentVersion);
        s & BOOST_SERIALIZATION_NVP(p_abi);
        s & BOOST_SERIALIZATION_NVP(p_abiVersion);
        s & BOOST_SERIALIZATION_NVP(p_wordSize);
        debugSerializationEnd("SgAsmGenericFormat");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgAsmGenericFormat::ExecFamily const& get_family() const;
    void set_family(SgAsmGenericFormat::ExecFamily const&);
public:
    SgAsmGenericFormat::ExecPurpose const& get_purpose() const;
    void set_purpose(SgAsmGenericFormat::ExecPurpose const&);
public:
    Rose::BinaryAnalysis::ByteOrder::Endianness const& get_sex() const;
    void set_sex(Rose::BinaryAnalysis::ByteOrder::Endianness const&);
public:
    unsigned const& get_version() const;
    void set_version(unsigned const&);
public:
    bool const& get_isCurrentVersion() const;
    void set_isCurrentVersion(bool const&);
public:
    SgAsmGenericFormat::ExecABI const& get_abi() const;
    void set_abi(SgAsmGenericFormat::ExecABI const&);
public:
    unsigned const& get_abiVersion() const;
    void set_abiVersion(unsigned const&);
public:
    size_t const& get_wordSize() const;
    void set_wordSize(size_t const&);
public:
    void dump(FILE*, const char *prefix, ssize_t idx) const;
 
    // Deprecated 2023-11
public:
    bool get_is_current_version() const ROSE_DEPRECATED("use get_isCurrentVersion");
    void set_is_current_version(bool) ROSE_DEPRECATED("use set_isCurrentVersion");
    unsigned get_abi_version() const ROSE_DEPRECATED("use get_abiVersion");
    void set_abi_version(unsigned) ROSE_DEPRECATED("use set_abiVersion");
    size_t get_word_size() const ROSE_DEPRECATED("use get_wordSize");
    void set_word_size(size_t) ROSE_DEPRECATED("use set_wordSize");
public:
    virtual ~SgAsmGenericFormat();
 
public:
    SgAsmGenericFormat();
 
protected:
    void initializeProperties();
#endif // SgAsmGenericFormat_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmGenericFormat: public SgAsmExecutableFileFormat {…};
#endif // DOCUMENTATION
 
 
// SgAsmGenericFileList           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmGenericFileList);
IS_SERIALIZABLE(AsmGenericFileList);
 
#ifndef DOCUMENTATION
AsmGenericFileList.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmGenericFileList);
#if defined(SgAsmGenericFileList_HEADERS) || defined(DOCUMENTATION)
#include <sageContainer.h>
#endif // SgAsmGenericFileList_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmGenericFileList: public SgAsmNode {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmGenericFileList.setDataPrototype(
        "SgAsmGenericFilePtrList", "files", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmGenericFileList);
#if defined(SgAsmGenericFileList_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmGenericFileList -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmGenericFileList");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmNode);
        s & BOOST_SERIALIZATION_NVP(p_files);
        debugSerializationEnd("SgAsmGenericFileList");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgAsmGenericFilePtrList const& get_files() const;
    SgAsmGenericFilePtrList& get_files();
    void set_files(SgAsmGenericFilePtrList const&);
public:
    virtual ~SgAsmGenericFileList();
 
public:
    SgAsmGenericFileList();
 
protected:
    void initializeProperties();
#endif // SgAsmGenericFileList_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmGenericFileList: public SgAsmNode {…};
#endif // DOCUMENTATION
 
 
// SgAsmGenericFile           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmGenericFile);
IS_SERIALIZABLE(AsmGenericFile);
 
#ifndef DOCUMENTATION
AsmGenericFile.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmGenericFile);
#if defined(SgAsmGenericFile_HEADERS) || defined(DOCUMENTATION)
#include <Rose/BinaryAnalysis/Address.h>
#include <Rose/BinaryAnalysis/MemoryMap.h>
#include <Rose/BinaryAnalysis/AddressIntervalSet.h>
 
#include "DataConversion.h"
#include "StatSerializer.h"                         // non-intrusive serialization of struct stat
 
#ifdef ROSE_SgAsmGenericFile_IMPL
#include <SgAsmDwarfCompilationUnitList.h>
#include <SgAsmGenericSectionList.h>
#include <SgAsmGenericHeaderList.h>
#endif
 
#include <sys/stat.h>
#endif // SgAsmGenericFile_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmGenericFile: public SgAsmExecutableFileFormat {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmGenericFile.setDataPrototype(
        "SgAsmDwarfCompilationUnitList*", "dwarfInfo", "= nullptr",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmGenericFile.setDataPrototype(
        "std::string", "name", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmGenericFile.setDataPrototype(
        "int", "fd", "= -1",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmGenericFile.setDataPrototype(
        "struct stat", "sb", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmGenericFile.setDataPrototype(
        "SgFileContentList", "data", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmGenericFile.setDataPrototype(
        "SgAsmGenericHeaderList*", "headers", "= createAndParent<SgAsmGenericHeaderList>(this)",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmGenericFile.setDataPrototype(
        "SgAsmGenericSectionList*", "holes", "= createAndParent<SgAsmGenericSectionList>(this)",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmGenericFile.setDataPrototype(
        "bool", "truncateZeros", "= false",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmGenericFile.setDataPrototype(
        "bool", "trackingReferences", "= true",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmGenericFile.setDataPrototype(
        "Rose::BinaryAnalysis::AddressIntervalSet", "referencedExtents", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmGenericFile.setDataPrototype(
        "bool", "neuter", "= false",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmGenericFile);
#if defined(SgAsmGenericFile_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmGenericFile -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmGenericFile");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
        s & BOOST_SERIALIZATION_NVP(p_dwarfInfo);
        s & BOOST_SERIALIZATION_NVP(p_name);
        s & BOOST_SERIALIZATION_NVP(p_sb);
        s & BOOST_SERIALIZATION_NVP(p_data);
        s & BOOST_SERIALIZATION_NVP(p_headers);
        s & BOOST_SERIALIZATION_NVP(p_holes);
        s & BOOST_SERIALIZATION_NVP(p_truncateZeros);
        s & BOOST_SERIALIZATION_NVP(p_trackingReferences);
        s & BOOST_SERIALIZATION_NVP(p_referencedExtents);
        s & BOOST_SERIALIZATION_NVP(p_neuter);
        debugSerializationEnd("SgAsmGenericFile");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
    // Local types
public:
    enum AddressSpace {
        ADDRSP_MEMORY = 0x0001,
        ADDRSP_FILE   = 0x0002,
        ADDRSP_ALL    = 0x0003
    };
    enum AddressSpace {…};
 
    enum Elasticity {
        ELASTIC_NONE  = 0,                          
        ELASTIC_UNREF = 1,                          
        ELASTIC_HOLE  = 2                           
    };
    enum Elasticity {…};
 
    // Properties
public:
public:
    SgAsmDwarfCompilationUnitList* const& get_dwarfInfo() const;
    void set_dwarfInfo(SgAsmDwarfCompilationUnitList* const&);
public:
    std::string const& get_name() const;
    void set_name(std::string const&);
public:
    int const& get_fd() const;
    void set_fd(int const&);
public:
    struct stat const& get_sb() const;
 
public:
    SgFileContentList const& get_data() const;
    void set_data(SgFileContentList const&);
public:
    SgAsmGenericHeaderList* const& get_headers() const;
    void set_headers(SgAsmGenericHeaderList* const&);
public:
    SgAsmGenericSectionList* const& get_holes() const;
    void set_holes(SgAsmGenericSectionList* const&);
public:
    bool const& get_truncateZeros() const;
    void set_truncateZeros(bool const&);
public:
    bool const& get_trackingReferences() const;
    void set_trackingReferences(bool const&);
public:
    Rose::BinaryAnalysis::AddressIntervalSet const& get_referencedExtents() const;
    void set_referencedExtents(Rose::BinaryAnalysis::AddressIntervalSet const&);
public:
    bool const& get_neuter() const;
    void set_neuter(bool const&);
    // Non-property data members
private:
    mutable Rose::BinaryAnalysis::AddressIntervalSet *p_unreferenced_cache = nullptr;
    DataConverter *p_data_converter = nullptr;
 
    // Functions
public:
    SgAsmGenericFile* parse(std::string file_name);
 
    void reallocate();
 
    void unparse(std::ostream&) const;
 
    void extendToEof(std::ostream&) const;
 
    void dump(FILE*) const;
 
    void dumpAll(bool in_cwd=true, const char *ext=NULL);
 
    void dumpAll(const std::string& dumpname);
 
    const Rose::BinaryAnalysis::AddressIntervalSet& get_unreferencedExtents() const;
 
    void markReferencedExtent(Rose::BinaryAnalysis::Address start_rva, Rose::BinaryAnalysis::Address size);
 
    DataConverter* get_dataConverter() const;
    void set_dataConverter(DataConverter*);
    Rose::BinaryAnalysis::Address get_currentSize() const;
 
    Rose::BinaryAnalysis::Address get_originalSize() const;
 
    size_t readContent(Rose::BinaryAnalysis::Address offset, void *dst_buf, Rose::BinaryAnalysis::Address size, bool strict=true);
 
    size_t readContent(const Rose::BinaryAnalysis::MemoryMap::Ptr&, Rose::BinaryAnalysis::Address va, void *dst_buf,
                       Rose::BinaryAnalysis::Address size, bool strict=true);
 
    std::string readContentString(const Rose::BinaryAnalysis::MemoryMap::Ptr&, Rose::BinaryAnalysis::Address va, bool strict=true);
 
    std::string readContentString(Rose::BinaryAnalysis::Address abs_offset, bool strict=true);
 
    const SgFileContentList& content() { return p_data; }
 
    SgFileContentList content(Rose::BinaryAnalysis::Address offset, Rose::BinaryAnalysis::Address size);
 
    SgAsmGenericSectionPtrList get_mappedSections() const;
 
    SgAsmGenericSectionPtrList get_sections(bool include_holes=true) const;
 
    SgAsmGenericSectionPtrList get_sectionsById(int id) const;
 
    SgAsmGenericSectionPtrList get_sectionsByName(std::string, char sep='\0') const;
 
    SgAsmGenericSectionPtrList get_sectionsByOffset(Rose::BinaryAnalysis::Address offset, Rose::BinaryAnalysis::Address size) const;
 
    SgAsmGenericSectionPtrList get_sectionsByRva(Rose::BinaryAnalysis::Address rva) const;
 
    SgAsmGenericSectionPtrList get_sectionsByVa(Rose::BinaryAnalysis::Address va) const;
 
    SgAsmGenericSection *get_sectionById(int id, size_t *nfound=0) const;
 
    SgAsmGenericSection *get_sectionByName(const std::string&, char sep=0, size_t *nfound=0) const;
 
    SgAsmGenericSection*
    get_sectionByOffset(Rose::BinaryAnalysis::Address offset, Rose::BinaryAnalysis::Address size, size_t *nfound=0) const;
 
    SgAsmGenericSection *get_sectionByRva(Rose::BinaryAnalysis::Address rva, size_t *nfound=0) const;
 
    SgAsmGenericSection *get_sectionByVa(Rose::BinaryAnalysis::Address va, size_t *nfound=0) const;
 
    SgAsmGenericSection *get_bestSectionByVa(Rose::BinaryAnalysis::Address va, size_t *nfound=0) const;
 
    static SgAsmGenericSection *bestSectionByVa(const SgAsmGenericSectionPtrList &sections, Rose::BinaryAnalysis::Address va);
 
    void shiftExtend(SgAsmGenericSection*, Rose::BinaryAnalysis::Address sa, Rose::BinaryAnalysis::Address sn, AddressSpace,
                     Elasticity);
    void shiftExtend(SgAsmGenericSection *s, Rose::BinaryAnalysis::Address sa, Rose::BinaryAnalysis::Address sn);
    Rose::BinaryAnalysis::Address get_nextSectionOffset(Rose::BinaryAnalysis::Address offset);
 
    void addHole(SgAsmGenericSection*);
 
    void removeHole(SgAsmGenericSection*);
 
    void fillHoles();
 
    void unfillHoles();
 
    void addHeader(SgAsmGenericHeader*);
 
    void removeHeader(SgAsmGenericHeader*);
 
    SgAsmGenericHeader *get_header(SgAsmExecutableFileFormat::ExecFamily);
 
    const char *formatName() const;
 
protected:
    // Some extra clean-up actions on destruction
    virtual void destructorHelper() override;
 
    // Deprecated 2023-11
public:
    SgAsmDwarfCompilationUnitList* get_dwarf_info() const ROSE_DEPRECATED("use get_dwarfInfo");
    void set_dwarf_info(SgAsmDwarfCompilationUnitList*) ROSE_DEPRECATED("use set_dwarfInfo");
    bool get_truncate_zeros() const ROSE_DEPRECATED("use get_truncateZeros");
    void set_truncate_zeros(bool) ROSE_DEPRECATED("use set_truncateZeros");
    bool get_tracking_references() const ROSE_DEPRECATED("use get_trackingReferences");
    void set_tracking_references(bool) ROSE_DEPRECATED("use set_trackingReferences");
    const Rose::BinaryAnalysis::AddressIntervalSet& get_referenced_extents() const ROSE_DEPRECATED("use get_referencedExtents");
    void set_referenced_extents(const Rose::BinaryAnalysis::AddressIntervalSet&) ROSE_DEPRECATED("use set_referencedExtents");
    void extend_to_eof(std::ostream&) const ROSE_DEPRECATED("use extendToEof");
    void dump_all(bool in_cwd=true, const char *ext=NULL) ROSE_DEPRECATED("use dumpAll");
    void dump_all(const std::string& dumpname) ROSE_DEPRECATED("use dumpAll");
    const Rose::BinaryAnalysis::AddressIntervalSet& get_unreferenced_extents() const
        ROSE_DEPRECATED("use get_unreferencedExtents");
    void mark_referenced_extent(Rose::BinaryAnalysis::Address, Rose::BinaryAnalysis::Address)
        ROSE_DEPRECATED("use markReferencedExtent");
    DataConverter* get_data_converter() const ROSE_DEPRECATED("use get_dataConverter");
    void set_data_converter(DataConverter*) ROSE_DEPRECATED("use set_dataConverter");
    Rose::BinaryAnalysis::Address get_current_size() const ROSE_DEPRECATED("use get_currentSize");
    Rose::BinaryAnalysis::Address get_orig_size() const ROSE_DEPRECATED("use get_originalSize");
    size_t read_content(Rose::BinaryAnalysis::Address, void*, Rose::BinaryAnalysis::Address, bool=true)
        ROSE_DEPRECATED("use readContent");
    size_t read_content(const Rose::BinaryAnalysis::MemoryMap::Ptr&, Rose::BinaryAnalysis::Address, void*,
                        Rose::BinaryAnalysis::Address, bool=true) ROSE_DEPRECATED("use readContent");
    std::string read_content_str(const Rose::BinaryAnalysis::MemoryMap::Ptr&, Rose::BinaryAnalysis::Address, bool=true)
        ROSE_DEPRECATED("use readContentString");
    std::string read_content_str(Rose::BinaryAnalysis::Address, bool=true) ROSE_DEPRECATED("use readContentString");
    SgAsmGenericSectionPtrList get_mapped_sections() const ROSE_DEPRECATED("use get_mappedSections");
    SgAsmGenericSectionPtrList get_sections_by_id(int id) const ROSE_DEPRECATED("use get_sectionById");
    SgAsmGenericSectionPtrList get_sections_by_name(std::string, char='\0') const ROSE_DEPRECATED("use get_sectionsByName");
    SgAsmGenericSectionPtrList get_sections_by_offset(Rose::BinaryAnalysis::Address, Rose::BinaryAnalysis::Address) const
        ROSE_DEPRECATED("use get_sectionsByOffset");
    SgAsmGenericSectionPtrList get_sections_by_rva(Rose::BinaryAnalysis::Address) const ROSE_DEPRECATED("use get_sectionsByRva");
    SgAsmGenericSectionPtrList get_sections_by_va(Rose::BinaryAnalysis::Address) const ROSE_DEPRECATED("use get_sectionsByVa");
    SgAsmGenericSection *get_section_by_id(int, size_t* = nullptr) const ROSE_DEPRECATED("use get_sectionById");
    SgAsmGenericSection *get_section_by_name(const std::string&, char=0, size_t* = nullptr) const
        ROSE_DEPRECATED("use get_sectionByName");
    SgAsmGenericSection*get_section_by_offset(Rose::BinaryAnalysis::Address, Rose::BinaryAnalysis::Address, size_t* = nullptr) const
        ROSE_DEPRECATED("use get_sectionByOffset");
    SgAsmGenericSection *get_section_by_rva(Rose::BinaryAnalysis::Address, size_t* = nullptr) const
        ROSE_DEPRECATED("use get_sectionByRva");
    SgAsmGenericSection *get_section_by_va(Rose::BinaryAnalysis::Address, size_t* = nullptr) const
        ROSE_DEPRECATED("use get_sectionByVa");
    SgAsmGenericSection *get_best_section_by_va(Rose::BinaryAnalysis::Address, size_t* = nullptr) const
        ROSE_DEPRECATED("use get_bestSectionByVa");
    static SgAsmGenericSection *best_section_by_va(const SgAsmGenericSectionPtrList&, Rose::BinaryAnalysis::Address)
        ROSE_DEPRECATED("use bestSectionByVa");
    void shift_extend(SgAsmGenericSection*, Rose::BinaryAnalysis::Address, Rose::BinaryAnalysis::Address, AddressSpace, Elasticity)
        ROSE_DEPRECATED("use shiftExtend");
    void shift_extend(SgAsmGenericSection*, Rose::BinaryAnalysis::Address, Rose::BinaryAnalysis::Address)
        ROSE_DEPRECATED("use shiftExtend");
    Rose::BinaryAnalysis::Address get_next_section_offset(Rose::BinaryAnalysis::Address)
        ROSE_DEPRECATED("use get_nextSectionOffset");
    void add_hole(SgAsmGenericSection*) ROSE_DEPRECATED("use addHole");
    void remove_hole(SgAsmGenericSection*) ROSE_DEPRECATED("use remoeHole");
    void fill_holes() ROSE_DEPRECATED("use fillHoles");
    void unfill_holes() ROSE_DEPRECATED("use unfillHoles");
    void add_header(SgAsmGenericHeader*) ROSE_DEPRECATED("use addHeader");
    void remove_header(SgAsmGenericHeader*) ROSE_DEPRECATED("use removeHeader");
    const char *format_name() const ROSE_DEPRECATED("use formatName");
public:
    virtual ~SgAsmGenericFile();
 
public:
    SgAsmGenericFile();
 
protected:
    void initializeProperties();
#endif // SgAsmGenericFile_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmGenericFile: public SgAsmExecutableFileFormat {…};
#endif // DOCUMENTATION
 
 
// SgAsmGenericDLLList           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmGenericDLLList);
IS_SERIALIZABLE(AsmGenericDLLList);
 
#ifndef DOCUMENTATION
AsmGenericDLLList.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmGenericDLLList);
#if defined(SgAsmGenericDLLList_HEADERS) || defined(DOCUMENTATION)
#include <sageContainer.h>
#endif // SgAsmGenericDLLList_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmGenericDLLList: public SgAsmExecutableFileFormat {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmGenericDLLList.setDataPrototype(
        "SgAsmGenericDLLPtrList", "dlls", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmGenericDLLList);
#if defined(SgAsmGenericDLLList_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmGenericDLLList -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmGenericDLLList");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
        s & BOOST_SERIALIZATION_NVP(p_dlls);
        debugSerializationEnd("SgAsmGenericDLLList");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgAsmGenericDLLPtrList const& get_dlls() const;
    SgAsmGenericDLLPtrList& get_dlls();
    void set_dlls(SgAsmGenericDLLPtrList const&);
public:
    virtual ~SgAsmGenericDLLList();
 
public:
    SgAsmGenericDLLList();
 
protected:
    void initializeProperties();
#endif // SgAsmGenericDLLList_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmGenericDLLList: public SgAsmExecutableFileFormat {…};
#endif // DOCUMENTATION
 
 
// SgAsmGenericDLL           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmGenericDLL);
IS_SERIALIZABLE(AsmGenericDLL);
 
#ifndef DOCUMENTATION
AsmGenericDLL.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmGenericDLL);
#if defined(SgAsmGenericDLL_HEADERS) || defined(DOCUMENTATION)
#include <sageContainer.h>
 
#ifdef ROSE_SgAsmGenericDLL_IMPL
#include <SgAsmBasicString.h>
#endif
#endif // SgAsmGenericDLL_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmGenericDLL: public SgAsmExecutableFileFormat {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmGenericDLL.setDataPrototype(
        "SgAsmGenericString*", "name", "= createAndParent<SgAsmBasicString>(this)",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmGenericDLL.setDataPrototype(
        "SgStringList", "symbols", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmGenericDLL);
#if defined(SgAsmGenericDLL_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmGenericDLL -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmGenericDLL");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
        s & BOOST_SERIALIZATION_NVP(p_name);
        s & BOOST_SERIALIZATION_NVP(p_symbols);
        debugSerializationEnd("SgAsmGenericDLL");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgAsmGenericString* const& get_name() const;
    void set_name(SgAsmGenericString *s);
public:
    SgStringList const& get_symbols() const;
    void set_symbols(SgStringList const&);
public:
    explicit SgAsmGenericDLL(SgAsmGenericString *s);
 
    virtual void dump(FILE*, const char *prefix, ssize_t idx) const;
 
    void addSymbol(const std::string&);
 
    // Deprecated 2023-11
public:
    void add_symbol(const std::string&) ROSE_DEPRECATED("use addSymbol");
public:
    virtual ~SgAsmGenericDLL();
 
public:
    SgAsmGenericDLL();
 
protected:
    void initializeProperties();
#endif // SgAsmGenericDLL_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmGenericDLL: public SgAsmExecutableFileFormat {…};
#endif // DOCUMENTATION
 
 
// SgAsmFunction           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmFunction);
IS_SERIALIZABLE(AsmFunction);
 
#ifndef DOCUMENTATION
AsmFunction.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmFunction);
#if defined(SgAsmFunction_HEADERS) || defined(DOCUMENTATION)
#include <Rose/BinaryAnalysis/Address.h>
#include <Rose/BinaryAnalysis/AddressIntervalSet.h>
#include <sageContainer.h>
 
#ifdef ROSE_SgAsmFunction_IMPL
#include <SgAsmInstruction.h>
#endif
#endif // SgAsmFunction_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmFunction: public SgAsmSynthesizedDeclaration {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmFunction.setDataPrototype(
        "std::string", "name", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmFunction.setDataPrototype(
        "unsigned", "reason", "= SgAsmFunction::FUNC_NONE",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmFunction.setDataPrototype(
        "std::string", "reasonComment", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmFunction.setDataPrototype(
        "SgAsmFunction::function_kind_enum", "functionKind", "= SgAsmFunction::e_unknown",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmFunction.setDataPrototype(
        "SgAsmFunction::MayReturn", "mayReturn", "= SgAsmFunction::RET_UNKNOWN",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmFunction.setDataPrototype(
        "std::string", "nameMd5", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmFunction.setDataPrototype(
        "SgAsmStatementPtrList", "statementList", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmFunction.setDataPrototype(
        "SgAsmStatementPtrList", "dest", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmFunction.setDataPrototype(
        "Rose::BinaryAnalysis::Address", "entryVa", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmFunction.setDataPrototype(
        "SgSymbolTable*", "symbolTable", "= nullptr",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmFunction.setDataPrototype(
        "size_t", "cachedVertex", "= (size_t)(-1)",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmFunction.setDataPrototype(
        "int64_t", "stackDelta", "= SgAsmInstruction::INVALID_STACK_DELTA",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmFunction.setDataPrototype(
        "std::string", "callingConvention", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmFunction);
#if defined(SgAsmFunction_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmFunction -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmFunction");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmSynthesizedDeclaration);
        s & BOOST_SERIALIZATION_NVP(p_name);
        s & BOOST_SERIALIZATION_NVP(p_reason);
        s & BOOST_SERIALIZATION_NVP(p_reasonComment);
        s & BOOST_SERIALIZATION_NVP(p_functionKind);
        s & BOOST_SERIALIZATION_NVP(p_mayReturn);
        s & BOOST_SERIALIZATION_NVP(p_nameMd5);
        s & BOOST_SERIALIZATION_NVP(p_statementList);
        s & BOOST_SERIALIZATION_NVP(p_dest);
        s & BOOST_SERIALIZATION_NVP(p_entryVa);
        s & BOOST_SERIALIZATION_NVP(p_cachedVertex);
        s & BOOST_SERIALIZATION_NVP(p_stackDelta);
        s & BOOST_SERIALIZATION_NVP(p_callingConvention);
        debugSerializationEnd("SgAsmFunction");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
    // Local types
public:
    enum MayReturn {
            RET_UNKNOWN,                    
            RET_NEVER,                      
            RET_SOMETIMES,                  
            RET_ALWAYS                      
    };
    enum MayReturn {…};
 
    enum FunctionReason {
            // NOTE: If you add more here, then fix Partitioner::parse_switches()
            //       Also fix SgAsmFunction::reason_key()
            FUNC_NONE        = 0x00000000,  
            FUNC_THUNK_TARGET= 0x00004000,  
            FUNC_EXCEPTION_HANDLER
                             = 0x00008000,  
            FUNC_ENTRY_POINT = 0x00010000,  
            FUNC_CALL_TARGET = 0x00020000,  
            FUNC_CALL_INSN   = 0x00040000,  
            FUNC_EH_FRAME    = 0x00080000,  
            FUNC_SYMBOL      = 0x00100000,  
            FUNC_PATTERN     = 0x00200000,  
            FUNC_GRAPH       = 0x00400000,  
            FUNC_USERDEF     = 0x00800000,  
            FUNC_PADDING     = 0x01000000,  
            FUNC_DISCONT     = 0x02000000,  
            FUNC_INSNHEAD    = 0x04000000,  
            FUNC_IMPORT      = 0x08000000,  
            FUNC_LEFTOVERS   = 0x10000000,  
            FUNC_INTRABLOCK  = 0x20000000,  
            FUNC_THUNK       = 0x40000000,  
            FUNC_EXPORT      = 0x80000000,  
            FUNC_DEFAULT     = 0xefff80ff,  
            /*========= Miscellaneous Reasons ===========================================================================
             * The first half of the range (1-127, inclusive) is used for algorithms defined by ROSE.  The second half is
             * availalble for users to use as they see fit. */
            FUNC_MISCMASK    = 0x000000ff,  
            FUNC_INTERPADFUNC = 1,          
            FUNC_PESCRAMBLER_DISPATCH = 2, 
            FUNC_CONFIGURED = 3,           
            FUNC_CMDLINE = 4,              
            FUNC_SCAN_RO_DATA = 5,         
            FUNC_INSN_RO_DATA = 6,         
    };
    enum FunctionReason {…};
 
    enum function_kind_enum {
        e_unknown  = 0,
        e_standard = 1,
        e_library  = 2,
        e_imported = 3,
        e_thunk     = 4,
        e_last
    };
    enum function_kind_enum {…};
 
    // Properties
public:
public:
    std::string const& get_name() const;
    void set_name(std::string const&);
public:
    unsigned const& get_reason() const;
    void set_reason(unsigned const&);
public:
    std::string const& get_reasonComment() const;
    void set_reasonComment(std::string const&);
public:
    SgAsmFunction::function_kind_enum const& get_functionKind() const;
    void set_functionKind(SgAsmFunction::function_kind_enum const&);
public:
    SgAsmFunction::MayReturn const& get_mayReturn() const;
    void set_mayReturn(SgAsmFunction::MayReturn const&);
public:
    std::string const& get_nameMd5() const;
    void set_nameMd5(std::string const&);
public:
    SgAsmStatementPtrList const& get_statementList() const;
    SgAsmStatementPtrList& get_statementList();
    void set_statementList(SgAsmStatementPtrList const&);
    // FIXME[Robb P Matzke 2017-02-13]: unused?
public:
    SgAsmStatementPtrList const& get_dest() const;
    void set_dest(SgAsmStatementPtrList const&);
 
public:
    Rose::BinaryAnalysis::Address const& get_entryVa() const;
    void set_entryVa(Rose::BinaryAnalysis::Address const&);
public:
    SgSymbolTable* const& get_symbolTable() const;
    void set_symbolTable(SgSymbolTable* const&);
    // FIXME[Robb P Matzke 2017-02-13]: what is this?
public:
    size_t const& get_cachedVertex() const;
    void set_cachedVertex(size_t const&);
 
public:
    int64_t const& get_stackDelta() const;
    void set_stackDelta(int64_t const&);
public:
    std::string const& get_callingConvention() const;
    void set_callingConvention(std::string const&);
    // Functions
public:
    void appendStatement(SgAsmStatement*);
 
    void removeStatement(SgAsmStatement* statement);
 
    SgAsmBlock* get_entryBlock() const;
 
    static std::string reasonKey(const std::string &prefix = "");
 
    std::string reasonString(bool pad) const;
 
    static std::string reasonString(bool pad, unsigned reason);
 
    class NodeSelector {
    public:
            virtual ~NodeSelector() {}
            virtual bool operator()(SgNode*) = 0;
    };
    class NodeSelector {…};
 
    size_t get_extent(Rose::BinaryAnalysis::AddressIntervalSet *emap=NULL, Rose::BinaryAnalysis::Address *lo_addr=NULL,
                      Rose::BinaryAnalysis::Address *hi_addr=NULL, NodeSelector *selector=NULL);
 
    bool get_sha1(uint8_t digest[20]/*out*/, NodeSelector *selector=NULL);
 
    // Deprecated 2023-11
public:
    function_kind_enum get_function_kind() const ROSE_DEPRECATED("use get_functionKind");
    void set_function_kind(function_kind_enum) ROSE_DEPRECATED("use set_functionKind");
    MayReturn get_may_return() const ROSE_DEPRECATED("use get_mayReturn");
    void set_may_return(MayReturn) ROSE_DEPRECATED("use set_mayReturn");
    const std::string& get_name_md5() const ROSE_DEPRECATED("use get_nameMd5");
    void set_name_md5(const std::string&) ROSE_DEPRECATED("use set_nameMd5");
    Rose::BinaryAnalysis::Address get_entry_va() const ROSE_DEPRECATED("use get_entryVa");
    void set_entry_va(Rose::BinaryAnalysis::Address) ROSE_DEPRECATED("use set_entryVa");
    SgSymbolTable* get_symbol_table() const ROSE_DEPRECATED("use get_symbolTable");
    void set_symbol_table(SgSymbolTable*) ROSE_DEPRECATED("use set_symbolTable");
    size_t get_cached_vertex() const ROSE_DEPRECATED("use get_cachedVertex");
    void set_cached_vertex(size_t) ROSE_DEPRECATED("use set_cachedVertex");
    void append_statement(SgAsmStatement*) ROSE_DEPRECATED("use appendStatement");
    void remove_statement(SgAsmStatement* statement) ROSE_DEPRECATED("use removeStatement");
    SgAsmBlock* get_entry_block() const ROSE_DEPRECATED("use get_entryBlock");
    static std::string reason_key(const std::string &prefix="") ROSE_DEPRECATED("use reasonKey");
    std::string reason_str(bool) const ROSE_DEPRECATED("use reasonString");
    static std::string reason_str(bool, unsigned) ROSE_DEPRECATED("use reasonString");
public:
    virtual ~SgAsmFunction();
 
public:
    SgAsmFunction();
 
public:
    SgAsmFunction(Rose::BinaryAnalysis::Address const& address,
                  std::string const& name,
                  unsigned const& reason,
                  SgAsmFunction::function_kind_enum const& functionKind);
 
protected:
    void initializeProperties();
#endif // SgAsmFunction_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmFunction: public SgAsmSynthesizedDeclaration {…};
#endif // DOCUMENTATION
 
 
// SgAsmSynthesizedDeclaration           -- MACHINE GENERATED; DO NOT MODIFY --
 
#ifndef DOCUMENTATION
AstNodeClass& AsmSynthesizedDeclaration = nonTerminalConstructor(
    "AsmSynthesizedDeclaration",
    *this,
    "AsmSynthesizedDeclaration",
    "AsmSynthesizedDeclarationTag",
    SubclassListBuilder()
        | AsmFunction
        | AsmSynthesizedDataStructureDeclaration
        | AsmSynthesizedFieldDeclaration
    , false);
assert(AsmSynthesizedDeclaration.associatedGrammar != nullptr);
AsmSynthesizedDeclaration.setCppCondition("!defined(DOCUMENTATION)");
AsmSynthesizedDeclaration.isBoostSerializable(true);
AsmSynthesizedDeclaration.setAutomaticGenerationOfConstructor(false);
AsmSynthesizedDeclaration.setAutomaticGenerationOfDestructor(false);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
AsmSynthesizedDeclaration.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmSynthesizedDeclaration: public SgAsmStatement {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmSynthesizedDeclaration);
#if defined(SgAsmSynthesizedDeclaration_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmSynthesizedDeclaration -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmSynthesizedDeclaration");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmStatement);
        debugSerializationEnd("SgAsmSynthesizedDeclaration");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    virtual ~SgAsmSynthesizedDeclaration();
 
protected:
    SgAsmSynthesizedDeclaration();
 
protected:
    explicit SgAsmSynthesizedDeclaration(Rose::BinaryAnalysis::Address const& address);
 
protected:
    void initializeProperties();
#endif // SgAsmSynthesizedDeclaration_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmSynthesizedDeclaration: public SgAsmStatement {…};
#endif // DOCUMENTATION
 
 
// SgAsmFloatValueExpression           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmFloatValueExpression);
IS_SERIALIZABLE(AsmFloatValueExpression);
 
#ifndef DOCUMENTATION
AsmFloatValueExpression.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmFloatValueExpression: public SgAsmConstantExpression {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmFloatValueExpression);
#if defined(SgAsmFloatValueExpression_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmFloatValueExpression -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmFloatValueExpression");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmConstantExpression);
        s & BOOST_SERIALIZATION_NVP(p_nativeValue);
        s & BOOST_SERIALIZATION_NVP(p_nativeValueIsValid);
        debugSerializationEnd("SgAsmFloatValueExpression");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
private:
    // This node stores its primary representation of the value in the p_bitVector of a parent class.  However, since we
    // often access the value as a native "double", and since converting to/from a bit vector is costly, we want to cache
    // the native double value whenever we compute it.  ROSETTA does not need to be aware of the cached value since it can
    // be recomputed from the bit vector, and in fact, ROSETTA can't handle cache data members because it doesn't
    // understand "mutable".
    //
    // However, Rosebud handles this just fine.
private:
    mutable double p_nativeValue;
 
public:
 
private:
    mutable bool p_nativeValueIsValid;
 
public:
public:
    SgAsmFloatValueExpression(double nativeValue, SgAsmType*);
 
    SgAsmFloatValueExpression(const Sawyer::Container::BitVector&, SgAsmType*);
 
    void set_nativeValue(double);
 
    double get_nativeValue() const;
 
    void updateBitVector();
 
    void updateNativeValue() const;
public:
    virtual ~SgAsmFloatValueExpression();
 
public:
    SgAsmFloatValueExpression();
 
protected:
    void initializeProperties();
#endif // SgAsmFloatValueExpression_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmFloatValueExpression: public SgAsmConstantExpression {…};
#endif // DOCUMENTATION
 
 
// SgAsmFloatType           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmFloatType);
IS_SERIALIZABLE(AsmFloatType);
 
#ifndef DOCUMENTATION
AsmFloatType.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmFloatType);
#if defined(SgAsmFloatType_HEADERS) || defined(DOCUMENTATION)
#include <Sawyer/BitVector.h>
#include <Rose/BitFlags.h>
#include <Rose/BinaryAnalysis/ByteOrder.h>
#endif // SgAsmFloatType_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmFloatType: public SgAsmScalarType {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmFloatType.setDataPrototype(
        "size_t", "significandOffset", "= (size_t)(-1)",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmFloatType.setDataPrototype(
        "size_t", "significandNBits", "= (size_t)(-1)",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmFloatType.setDataPrototype(
        "size_t", "signBitOffset", "= (size_t)(-1)",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmFloatType.setDataPrototype(
        "size_t", "exponentOffset", "= (size_t)(-1)",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmFloatType.setDataPrototype(
        "size_t", "exponentNBits", "= (size_t)(-1)",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmFloatType.setDataPrototype(
        "uint64_t", "exponentBias", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmFloatType.setDataPrototype(
        "unsigned", "flags", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmFloatType);
#if defined(SgAsmFloatType_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmFloatType -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmFloatType");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmScalarType);
        s & BOOST_SERIALIZATION_NVP(p_significandOffset);
        s & BOOST_SERIALIZATION_NVP(p_significandNBits);
        s & BOOST_SERIALIZATION_NVP(p_signBitOffset);
        s & BOOST_SERIALIZATION_NVP(p_exponentOffset);
        s & BOOST_SERIALIZATION_NVP(p_exponentNBits);
        s & BOOST_SERIALIZATION_NVP(p_exponentBias);
        s & BOOST_SERIALIZATION_NVP(p_flags);
        debugSerializationEnd("SgAsmFloatType");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
    enum Flag {
        GRADUAL_UNDERFLOW           = 0x00000001,   
        IMPLICIT_BIT_CONVENTION     = 0x00000002    
    };
    enum Flag {…};
 
    typedef Rose::BitFlags<Flag> Flags;
 
    typedef Sawyer::Container::BitVector::BitRange BitRange;
 
public:
public:
 
public:
 
public:
 
public:
 
public:
 
public:
 
public:
public:
    SgAsmFloatType(Rose::BinaryAnalysis::ByteOrder::Endianness, size_t nBits,
                   const BitRange &significandBits, const BitRange exponentBits, size_t signBit,
                   uint64_t exponentBias, Flags flags);
 
    static SgAsmFloatType* instanceIeee32(Rose::BinaryAnalysis::ByteOrder::Endianness);
    static SgAsmFloatType* instanceIeee64(Rose::BinaryAnalysis::ByteOrder::Endianness);
    BitRange significandBits() const;
 
    BitRange exponentBits() const;
 
    size_t signBit() const;
 
    uint64_t exponentBias() const;
 
    Flags flags() const;
 
    static Flags ieeeFlags();
 
    bool gradualUnderflow() const;
 
    bool implicitBitConvention() const;
 
    // Overrides documented in base class
    virtual void check() const override;
    virtual std::string toString() const override;
public:
    virtual ~SgAsmFloatType();
 
public:
    SgAsmFloatType();
 
protected:
    void initializeProperties();
#endif // SgAsmFloatType_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmFloatType: public SgAsmScalarType {…};
#endif // DOCUMENTATION
 
 
// SgAsmScalarType           -- MACHINE GENERATED; DO NOT MODIFY --
 
#ifndef DOCUMENTATION
AstNodeClass& AsmScalarType = nonTerminalConstructor(
    "AsmScalarType",
    *this,
    "AsmScalarType",
    "AsmScalarTypeTag",
    SubclassListBuilder()
        | AsmFloatType
        | AsmIntegerType
        | AsmPointerType
    , false);
assert(AsmScalarType.associatedGrammar != nullptr);
AsmScalarType.setCppCondition("!defined(DOCUMENTATION)");
AsmScalarType.isBoostSerializable(true);
AsmScalarType.setAutomaticGenerationOfConstructor(false);
AsmScalarType.setAutomaticGenerationOfDestructor(false);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
AsmScalarType.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmScalarType);
#if defined(SgAsmScalarType_HEADERS) || defined(DOCUMENTATION)
#include <Rose/BinaryAnalysis/ByteOrder.h>
#endif // SgAsmScalarType_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmScalarType: public SgAsmType {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmScalarType.setDataPrototype(
        "Rose::BinaryAnalysis::ByteOrder::Endianness", "minorOrder", "= Rose::BinaryAnalysis::ByteOrder::ORDER_UNSPECIFIED",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmScalarType.setDataPrototype(
        "Rose::BinaryAnalysis::ByteOrder::Endianness", "majorOrder", "= Rose::BinaryAnalysis::ByteOrder::ORDER_UNSPECIFIED",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmScalarType.setDataPrototype(
        "size_t", "majorNBytes", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmScalarType.setDataPrototype(
        "size_t", "nBits", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmScalarType);
#if defined(SgAsmScalarType_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmScalarType -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmScalarType");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmType);
        s & BOOST_SERIALIZATION_NVP(p_minorOrder);
        s & BOOST_SERIALIZATION_NVP(p_majorOrder);
        s & BOOST_SERIALIZATION_NVP(p_majorNBytes);
        s & BOOST_SERIALIZATION_NVP(p_nBits);
        debugSerializationEnd("SgAsmScalarType");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
 
public:
public:
public:
protected:
    SgAsmScalarType(Rose::BinaryAnalysis::ByteOrder::Endianness, size_t nBits);
 
public:
    virtual size_t get_nBits() const override;
 
    Rose::BinaryAnalysis::ByteOrder::Endianness get_minorOrder() const;
 
    Rose::BinaryAnalysis::ByteOrder::Endianness get_majorOrder() const;
 
    size_t get_majorNBytes() const;
 
    // Overrides documented in base class
    virtual void check() const override;
    virtual std::string toString() const override;
public:
    virtual ~SgAsmScalarType();
 
protected:
    SgAsmScalarType();
 
protected:
    void initializeProperties();
#endif // SgAsmScalarType_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmScalarType: public SgAsmType {…};
#endif // DOCUMENTATION
 
 
// SgAsmType           -- MACHINE GENERATED; DO NOT MODIFY --
 
#ifndef DOCUMENTATION
AstNodeClass& AsmType = nonTerminalConstructor(
    "AsmType",
    *this,
    "AsmType",
    "AsmTypeTag",
    SubclassListBuilder()
        | AsmScalarType
        | AsmVectorType
        | AsmVoidType
    , false);
assert(AsmType.associatedGrammar != nullptr);
AsmType.setCppCondition("!defined(DOCUMENTATION)");
AsmType.isBoostSerializable(true);
AsmType.setAutomaticGenerationOfConstructor(false);
AsmType.setAutomaticGenerationOfDestructor(false);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
AsmType.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmType: public SgAsmNode {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmType);
#if defined(SgAsmType_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmType -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmType");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmNode);
        debugSerializationEnd("SgAsmType");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
private:
    static Sawyer::Container::Map<std::string, SgAsmType*> p_typeRegistry;
 
public:
    virtual void check() const;
 
    virtual std::string toString() const {
        abort();                                    // ROSETTA limitation: intended pure virtual
        return NULL;                                // Windows limitation: return value required [Too, 2014-08-11]
    }
    virtual std::string toString() const  {…}
 
    virtual size_t get_nBits() const {
        abort();                                    // ROSETTA limitation: intended pure virtual
        return (size_t)-1;                          // Windows limitation: return value required [Too, 2014-08-11]
    }
    virtual size_t get_nBits() const  {…}
 
    virtual size_t get_nBytes() const;
 
    template<class Type>                                    // Type is a subclass of SgAsmType
    static Type* registerOrDelete(Type *toInsert) {
        ASSERT_not_null(toInsert);
        std::string key = toInsert->toString();
        Type *retval = dynamic_cast<Type*>(p_typeRegistry.insertMaybe(key, toInsert));
        ASSERT_not_null(retval);
        if (retval!=toInsert)
            delete toInsert;
        return retval;
    }
    static Type* registerOrDelete(Type *toInsert) {…}
public:
    virtual ~SgAsmType();
 
protected:
    SgAsmType();
 
protected:
    void initializeProperties();
#endif // SgAsmType_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmType: public SgAsmNode {…};
#endif // DOCUMENTATION
 
 
// SgAsmExprListExp           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmExprListExp);
IS_SERIALIZABLE(AsmExprListExp);
 
#ifndef DOCUMENTATION
AsmExprListExp.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmExprListExp);
#if defined(SgAsmExprListExp_HEADERS) || defined(DOCUMENTATION)
#include <sageContainer.h>
#endif // SgAsmExprListExp_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmExprListExp: public SgAsmExpression {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmExprListExp.setDataPrototype(
        "SgAsmExpressionPtrList", "expressions", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmExprListExp);
#if defined(SgAsmExprListExp_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmExprListExp -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmExprListExp");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExpression);
        s & BOOST_SERIALIZATION_NVP(p_expressions);
        debugSerializationEnd("SgAsmExprListExp");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgAsmExpressionPtrList const& get_expressions() const;
    SgAsmExpressionPtrList& get_expressions();
    void set_expressions(SgAsmExpressionPtrList const&);
public:
    virtual ~SgAsmExprListExp();
 
public:
    SgAsmExprListExp();
 
protected:
    void initializeProperties();
#endif // SgAsmExprListExp_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmExprListExp: public SgAsmExpression {…};
#endif // DOCUMENTATION
 
 
// SgAsmElfSymverSection           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmElfSymverSection);
IS_SERIALIZABLE(AsmElfSymverSection);
 
#ifndef DOCUMENTATION
AsmElfSymverSection.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmElfSymverSection);
#if defined(SgAsmElfSymverSection_HEADERS) || defined(DOCUMENTATION)
#include <Rose/BinaryAnalysis/Address.h>
 
#ifdef ROSE_SgAsmElfSymverSection_IMPL
#include <SgAsmElfSymverEntryList.h>
#endif
#endif // SgAsmElfSymverSection_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmElfSymverSection: public SgAsmElfSection {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfSymverSection.setDataPrototype(
        "SgAsmElfSymverEntryList*", "entries", "= createAndParent<SgAsmElfSymverEntryList>(this)",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmElfSymverSection);
#if defined(SgAsmElfSymverSection_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmElfSymverSection -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmElfSymverSection");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmElfSection);
        s & BOOST_SERIALIZATION_NVP(p_entries);
        debugSerializationEnd("SgAsmElfSymverSection");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgAsmElfSymverEntryList* const& get_entries() const;
    void set_entries(SgAsmElfSymverEntryList* const&);
public:
    explicit SgAsmElfSymverSection(SgAsmElfFileHeader*);
 
    virtual SgAsmElfSymverSection* parse() override;
 
    using SgAsmElfSection::calculateSizes;
    virtual Rose::BinaryAnalysis::Address
    calculateSizes(size_t *total, size_t *required, size_t *optional, size_t *nentries) const override;
 
    virtual void unparse(std::ostream&) const override;
 
    virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
 
    // Deprecated 2023-11
public:
    using SgAsmElfSection::calculate_sizes;
    virtual Rose::BinaryAnalysis::Address calculate_sizes(size_t*, size_t*, size_t*, size_t*) const override
        ROSE_DEPRECATED("use calculateSizes");
public:
    virtual ~SgAsmElfSymverSection();
 
public:
    SgAsmElfSymverSection();
 
protected:
    void initializeProperties();
#endif // SgAsmElfSymverSection_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmElfSymverSection: public SgAsmElfSection {…};
#endif // DOCUMENTATION
 
 
// SgAsmElfSymverNeededSection           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmElfSymverNeededSection);
IS_SERIALIZABLE(AsmElfSymverNeededSection);
 
#ifndef DOCUMENTATION
AsmElfSymverNeededSection.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmElfSymverNeededSection);
#if defined(SgAsmElfSymverNeededSection_HEADERS) || defined(DOCUMENTATION)
#include <Rose/BinaryAnalysis/Address.h>
 
#ifdef ROSE_SgAsmElfSymverNeededSection_IMPL
#include <SgAsmElfSymverNeededEntryList.h>
#endif
#endif // SgAsmElfSymverNeededSection_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmElfSymverNeededSection: public SgAsmElfSection {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfSymverNeededSection.setDataPrototype(
        "SgAsmElfSymverNeededEntryList*", "entries", "= createAndParent<SgAsmElfSymverNeededEntryList>(this)",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmElfSymverNeededSection);
#if defined(SgAsmElfSymverNeededSection_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmElfSymverNeededSection -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmElfSymverNeededSection");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmElfSection);
        s & BOOST_SERIALIZATION_NVP(p_entries);
        debugSerializationEnd("SgAsmElfSymverNeededSection");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgAsmElfSymverNeededEntryList* const& get_entries() const;
    void set_entries(SgAsmElfSymverNeededEntryList* const&);
public:
    SgAsmElfSymverNeededSection(SgAsmElfFileHeader *fhdr, SgAsmElfStringSection *strsec);
 
    virtual SgAsmElfSymverNeededSection* parse() override;
 
    using SgAsmElfSection::calculate_sizes;
    virtual Rose::BinaryAnalysis::Address
    calculateSizes(size_t *total, size_t *required, size_t *optional, size_t *nentries) const override;
 
    virtual void unparse(std::ostream&) const override;
 
    virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
 
    // Deprecated 2023-11
public:
    virtual Rose::BinaryAnalysis::Address calculate_sizes(size_t*, size_t*, size_t*, size_t*) const override
        ROSE_DEPRECATED("use calculateSizes");
public:
    virtual ~SgAsmElfSymverNeededSection();
 
public:
    SgAsmElfSymverNeededSection();
 
protected:
    void initializeProperties();
#endif // SgAsmElfSymverNeededSection_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmElfSymverNeededSection: public SgAsmElfSection {…};
#endif // DOCUMENTATION
 
 
// SgAsmElfSymverNeededEntryList           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmElfSymverNeededEntryList);
IS_SERIALIZABLE(AsmElfSymverNeededEntryList);
 
#ifndef DOCUMENTATION
AsmElfSymverNeededEntryList.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmElfSymverNeededEntryList);
#if defined(SgAsmElfSymverNeededEntryList_HEADERS) || defined(DOCUMENTATION)
#include <sageContainer.h>
#endif // SgAsmElfSymverNeededEntryList_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmElfSymverNeededEntryList: public SgAsmExecutableFileFormat {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfSymverNeededEntryList.setDataPrototype(
        "SgAsmElfSymverNeededEntryPtrList", "entries", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmElfSymverNeededEntryList);
#if defined(SgAsmElfSymverNeededEntryList_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmElfSymverNeededEntryList -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmElfSymverNeededEntryList");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
        s & BOOST_SERIALIZATION_NVP(p_entries);
        debugSerializationEnd("SgAsmElfSymverNeededEntryList");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgAsmElfSymverNeededEntryPtrList const& get_entries() const;
    SgAsmElfSymverNeededEntryPtrList& get_entries();
    void set_entries(SgAsmElfSymverNeededEntryPtrList const&);
public:
    virtual ~SgAsmElfSymverNeededEntryList();
 
public:
    SgAsmElfSymverNeededEntryList();
 
protected:
    void initializeProperties();
#endif // SgAsmElfSymverNeededEntryList_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmElfSymverNeededEntryList: public SgAsmExecutableFileFormat {…};
#endif // DOCUMENTATION
 
 
// SgAsmElfSymverNeededEntry           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmElfSymverNeededEntry);
IS_SERIALIZABLE(AsmElfSymverNeededEntry);
 
#ifndef DOCUMENTATION
AsmElfSymverNeededEntry.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmElfSymverNeededEntry);
#if defined(SgAsmElfSymverNeededEntry_HEADERS) || defined(DOCUMENTATION)
#include <Rose/BinaryAnalysis/ByteOrder.h>
 
#ifdef ROSE_SgAsmElfSymverNeededEntry_IMPL
#include <SgAsmElfSymverNeededAuxList.h>
#include <SgAsmGenericString.h>
#endif
#endif // SgAsmElfSymverNeededEntry_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmElfSymverNeededEntry: public SgAsmExecutableFileFormat {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfSymverNeededEntry.setDataPrototype(
        "size_t", "version", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfSymverNeededEntry.setDataPrototype(
        "SgAsmGenericString*", "fileName", "= nullptr",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfSymverNeededEntry.setDataPrototype(
        "SgAsmElfSymverNeededAuxList*", "entries", "= createAndParent<SgAsmElfSymverNeededAuxList>(this)",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmElfSymverNeededEntry);
#if defined(SgAsmElfSymverNeededEntry_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmElfSymverNeededEntry -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmElfSymverNeededEntry");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
        s & BOOST_SERIALIZATION_NVP(p_version);
        s & BOOST_SERIALIZATION_NVP(p_fileName);
        s & BOOST_SERIALIZATION_NVP(p_entries);
        debugSerializationEnd("SgAsmElfSymverNeededEntry");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
    // Local types
public:
#ifdef _MSC_VER
# pragma pack (1)
#endif
 
    struct ElfSymverNeededEntry_disk {
        uint16_t      vn_version;                   
        uint16_t      vn_cnt;                       
        uint32_t      vn_file;                      
        uint32_t      vn_aux;                       
        uint32_t      vn_next;                      
    }
    struct ElfSymverNeededEntry_disk {…};
#if !defined(SWIG) && !defined(_MSC_VER)
    __attribute__((packed))
#endif
    ;
 
#ifdef _MSC_VER
# pragma pack ()
#endif
 
    // Properties
public:
public:
    size_t const& get_version() const;
    void set_version(size_t const&);
public:
    SgAsmGenericString* const& get_fileName() const;
    void set_fileName(SgAsmGenericString* const&);
public:
    SgAsmElfSymverNeededAuxList* const& get_entries() const;
    void set_entries(SgAsmElfSymverNeededAuxList* const&);
    // Functions
public:
    explicit SgAsmElfSymverNeededEntry(SgAsmElfSymverNeededSection*);
 
    void parse(Rose::BinaryAnalysis::ByteOrder::Endianness, const SgAsmElfSymverNeededEntry::ElfSymverNeededEntry_disk*);
 
    void *encode(Rose::BinaryAnalysis::ByteOrder::Endianness, SgAsmElfSymverNeededEntry::ElfSymverNeededEntry_disk*) const;
 
    virtual void dump(FILE *f, const char *prefix, ssize_t idx) const;
 
    // Deprecated 2023-11
public:
    SgAsmGenericString* get_file_name() const ROSE_DEPRECATED("use get_fileName");
    void set_file_name(SgAsmGenericString*) ROSE_DEPRECATED("use set_fileName");
public:
    virtual ~SgAsmElfSymverNeededEntry();
 
public:
    SgAsmElfSymverNeededEntry();
 
protected:
    void initializeProperties();
#endif // SgAsmElfSymverNeededEntry_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmElfSymverNeededEntry: public SgAsmExecutableFileFormat {…};
#endif // DOCUMENTATION
 
 
// SgAsmElfSymverNeededAuxList           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmElfSymverNeededAuxList);
IS_SERIALIZABLE(AsmElfSymverNeededAuxList);
 
#ifndef DOCUMENTATION
AsmElfSymverNeededAuxList.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmElfSymverNeededAuxList);
#if defined(SgAsmElfSymverNeededAuxList_HEADERS) || defined(DOCUMENTATION)
#include <sageContainer.h>
#endif // SgAsmElfSymverNeededAuxList_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmElfSymverNeededAuxList: public SgAsmExecutableFileFormat {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfSymverNeededAuxList.setDataPrototype(
        "SgAsmElfSymverNeededAuxPtrList", "entries", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmElfSymverNeededAuxList);
#if defined(SgAsmElfSymverNeededAuxList_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmElfSymverNeededAuxList -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmElfSymverNeededAuxList");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
        s & BOOST_SERIALIZATION_NVP(p_entries);
        debugSerializationEnd("SgAsmElfSymverNeededAuxList");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgAsmElfSymverNeededAuxPtrList const& get_entries() const;
    SgAsmElfSymverNeededAuxPtrList& get_entries();
    void set_entries(SgAsmElfSymverNeededAuxPtrList const&);
public:
    virtual ~SgAsmElfSymverNeededAuxList();
 
public:
    SgAsmElfSymverNeededAuxList();
 
protected:
    void initializeProperties();
#endif // SgAsmElfSymverNeededAuxList_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmElfSymverNeededAuxList: public SgAsmExecutableFileFormat {…};
#endif // DOCUMENTATION
 
 
// SgAsmElfSymverNeededAux           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmElfSymverNeededAux);
IS_SERIALIZABLE(AsmElfSymverNeededAux);
 
#ifndef DOCUMENTATION
AsmElfSymverNeededAux.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmElfSymverNeededAux);
#if defined(SgAsmElfSymverNeededAux_HEADERS) || defined(DOCUMENTATION)
#include <Rose/BinaryAnalysis/ByteOrder.h>
 
#ifdef ROSE_SgAsmElfSymverNeededAux_IMPL
#include <SgAsmGenericString.h>
#endif
#endif // SgAsmElfSymverNeededAux_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmElfSymverNeededAux: public SgAsmExecutableFileFormat {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfSymverNeededAux.setDataPrototype(
        "uint32_t", "hash", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfSymverNeededAux.setDataPrototype(
        "int", "flags", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfSymverNeededAux.setDataPrototype(
        "size_t", "other", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfSymverNeededAux.setDataPrototype(
        "SgAsmGenericString*", "name", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmElfSymverNeededAux);
#if defined(SgAsmElfSymverNeededAux_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmElfSymverNeededAux -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmElfSymverNeededAux");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
        s & BOOST_SERIALIZATION_NVP(p_hash);
        s & BOOST_SERIALIZATION_NVP(p_flags);
        s & BOOST_SERIALIZATION_NVP(p_other);
        s & BOOST_SERIALIZATION_NVP(p_name);
        debugSerializationEnd("SgAsmElfSymverNeededAux");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
    // Local types
public:
#ifdef _MSC_VER
# pragma pack (1)
#endif
 
    struct ElfSymverNeededAux_disk {
        uint32_t      vna_hash;                     
        uint16_t      vna_flags;                    
        uint16_t      vna_other;                    
        uint32_t      vna_name;                     
        uint32_t      vna_next;                     
    }
    struct ElfSymverNeededAux_disk {…};
#if !defined(SWIG) && !defined(_MSC_VER)
    __attribute__((packed))
#endif
    ;
 
#ifdef _MSC_VER
# pragma pack ()
#endif
 
    // Properties
public:
public:
    uint32_t const& get_hash() const;
    void set_hash(uint32_t const&);
public:
    int const& get_flags() const;
    void set_flags(int const&);
public:
    size_t const& get_other() const;
    void set_other(size_t const&);
public:
    SgAsmGenericString* const& get_name() const;
    void set_name(SgAsmGenericString* const&);
    // Functions
public:
    SgAsmElfSymverNeededAux(SgAsmElfSymverNeededEntry *entry, SgAsmElfSymverNeededSection *symver);
 
    void parse(Rose::BinaryAnalysis::ByteOrder::Endianness, const SgAsmElfSymverNeededAux::ElfSymverNeededAux_disk*);
 
    void *encode(Rose::BinaryAnalysis::ByteOrder::Endianness, SgAsmElfSymverNeededAux::ElfSymverNeededAux_disk*) const;
 
    virtual void dump(FILE *f, const char *prefix, ssize_t idx) const;
public:
    virtual ~SgAsmElfSymverNeededAux();
 
public:
    SgAsmElfSymverNeededAux();
 
protected:
    void initializeProperties();
#endif // SgAsmElfSymverNeededAux_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmElfSymverNeededAux: public SgAsmExecutableFileFormat {…};
#endif // DOCUMENTATION
 
 
// SgAsmElfSymverEntryList           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmElfSymverEntryList);
IS_SERIALIZABLE(AsmElfSymverEntryList);
 
#ifndef DOCUMENTATION
AsmElfSymverEntryList.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmElfSymverEntryList);
#if defined(SgAsmElfSymverEntryList_HEADERS) || defined(DOCUMENTATION)
#include <sageContainer.h>
#endif // SgAsmElfSymverEntryList_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmElfSymverEntryList: public SgAsmExecutableFileFormat {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfSymverEntryList.setDataPrototype(
        "SgAsmElfSymverEntryPtrList", "entries", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmElfSymverEntryList);
#if defined(SgAsmElfSymverEntryList_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmElfSymverEntryList -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmElfSymverEntryList");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
        s & BOOST_SERIALIZATION_NVP(p_entries);
        debugSerializationEnd("SgAsmElfSymverEntryList");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgAsmElfSymverEntryPtrList const& get_entries() const;
    SgAsmElfSymverEntryPtrList& get_entries();
    void set_entries(SgAsmElfSymverEntryPtrList const&);
public:
    virtual ~SgAsmElfSymverEntryList();
 
public:
    SgAsmElfSymverEntryList();
 
protected:
    void initializeProperties();
#endif // SgAsmElfSymverEntryList_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmElfSymverEntryList: public SgAsmExecutableFileFormat {…};
#endif // DOCUMENTATION
 
 
// SgAsmElfSymverEntry           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmElfSymverEntry);
IS_SERIALIZABLE(AsmElfSymverEntry);
 
#ifndef DOCUMENTATION
AsmElfSymverEntry.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmElfSymverEntry: public SgAsmExecutableFileFormat {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfSymverEntry.setDataPrototype(
        "size_t", "value", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmElfSymverEntry);
#if defined(SgAsmElfSymverEntry_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmElfSymverEntry -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmElfSymverEntry");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
        s & BOOST_SERIALIZATION_NVP(p_value);
        debugSerializationEnd("SgAsmElfSymverEntry");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    size_t const& get_value() const;
    void set_value(size_t const&);
public:
    explicit SgAsmElfSymverEntry(SgAsmElfSymverSection*);
 
    virtual void dump(FILE *f, const char *prefix, ssize_t idx) const;
public:
    virtual ~SgAsmElfSymverEntry();
 
public:
    SgAsmElfSymverEntry();
 
protected:
    void initializeProperties();
#endif // SgAsmElfSymverEntry_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmElfSymverEntry: public SgAsmExecutableFileFormat {…};
#endif // DOCUMENTATION
 
 
// SgAsmElfSymverDefinedSection           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmElfSymverDefinedSection);
IS_SERIALIZABLE(AsmElfSymverDefinedSection);
 
#ifndef DOCUMENTATION
AsmElfSymverDefinedSection.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmElfSymverDefinedSection);
#if defined(SgAsmElfSymverDefinedSection_HEADERS) || defined(DOCUMENTATION)
#include <Rose/BinaryAnalysis/Address.h>
 
#ifdef ROSE_SgAsmElfSymverDefinedSection_IMPL
#include <SgAsmElfSymverDefinedEntryList.h>
#endif
#endif // SgAsmElfSymverDefinedSection_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmElfSymverDefinedSection: public SgAsmElfSection {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfSymverDefinedSection.setDataPrototype(
        "SgAsmElfSymverDefinedEntryList*", "entries", "= createAndParent<SgAsmElfSymverDefinedEntryList>(this)",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmElfSymverDefinedSection);
#if defined(SgAsmElfSymverDefinedSection_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmElfSymverDefinedSection -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmElfSymverDefinedSection");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmElfSection);
        s & BOOST_SERIALIZATION_NVP(p_entries);
        debugSerializationEnd("SgAsmElfSymverDefinedSection");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgAsmElfSymverDefinedEntryList* const& get_entries() const;
    void set_entries(SgAsmElfSymverDefinedEntryList* const&);
public:
    SgAsmElfSymverDefinedSection(SgAsmElfFileHeader *fhdr, SgAsmElfStringSection *strsec);
 
    virtual SgAsmElfSymverDefinedSection* parse() override;
 
    using SgAsmElfSection::calculateSizes;
    virtual Rose::BinaryAnalysis::Address
    calculateSizes(size_t *total, size_t *required, size_t *optional, size_t *nentries) const override;
 
    virtual void unparse(std::ostream&) const override;
 
    virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
 
    // Deprecated 2023-11
public:
    using SgAsmElfSection::calculate_sizes;
    virtual Rose::BinaryAnalysis::Address calculate_sizes(size_t*, size_t*, size_t*, size_t*) const override
        ROSE_DEPRECATED("use calculateSizes");
public:
    virtual ~SgAsmElfSymverDefinedSection();
 
public:
    SgAsmElfSymverDefinedSection();
 
protected:
    void initializeProperties();
#endif // SgAsmElfSymverDefinedSection_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmElfSymverDefinedSection: public SgAsmElfSection {…};
#endif // DOCUMENTATION
 
 
// SgAsmElfSymverDefinedEntryList           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmElfSymverDefinedEntryList);
IS_SERIALIZABLE(AsmElfSymverDefinedEntryList);
 
#ifndef DOCUMENTATION
AsmElfSymverDefinedEntryList.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmElfSymverDefinedEntryList);
#if defined(SgAsmElfSymverDefinedEntryList_HEADERS) || defined(DOCUMENTATION)
#include <sageContainer.h>
#endif // SgAsmElfSymverDefinedEntryList_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmElfSymverDefinedEntryList: public SgAsmExecutableFileFormat {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfSymverDefinedEntryList.setDataPrototype(
        "SgAsmElfSymverDefinedEntryPtrList", "entries", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmElfSymverDefinedEntryList);
#if defined(SgAsmElfSymverDefinedEntryList_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmElfSymverDefinedEntryList -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmElfSymverDefinedEntryList");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
        s & BOOST_SERIALIZATION_NVP(p_entries);
        debugSerializationEnd("SgAsmElfSymverDefinedEntryList");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgAsmElfSymverDefinedEntryPtrList const& get_entries() const;
    SgAsmElfSymverDefinedEntryPtrList& get_entries();
    void set_entries(SgAsmElfSymverDefinedEntryPtrList const&);
public:
    virtual ~SgAsmElfSymverDefinedEntryList();
 
public:
    SgAsmElfSymverDefinedEntryList();
 
protected:
    void initializeProperties();
#endif // SgAsmElfSymverDefinedEntryList_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmElfSymverDefinedEntryList: public SgAsmExecutableFileFormat {…};
#endif // DOCUMENTATION
 
 
// SgAsmElfSymverDefinedEntry           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmElfSymverDefinedEntry);
IS_SERIALIZABLE(AsmElfSymverDefinedEntry);
 
#ifndef DOCUMENTATION
AsmElfSymverDefinedEntry.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmElfSymverDefinedEntry);
#if defined(SgAsmElfSymverDefinedEntry_HEADERS) || defined(DOCUMENTATION)
#include <Rose/BinaryAnalysis/ByteOrder.h>
 
#ifdef ROSE_SgAsmElfSymverDefinedEntry_IMPL
#include <SgAsmElfSymverDefinedAuxList.h>
#endif
#endif // SgAsmElfSymverDefinedEntry_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmElfSymverDefinedEntry: public SgAsmExecutableFileFormat {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfSymverDefinedEntry.setDataPrototype(
        "size_t", "version", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfSymverDefinedEntry.setDataPrototype(
        "int", "flags", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfSymverDefinedEntry.setDataPrototype(
        "size_t", "index", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfSymverDefinedEntry.setDataPrototype(
        "uint32_t", "hash", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfSymverDefinedEntry.setDataPrototype(
        "SgAsmElfSymverDefinedAuxList*", "entries", "= createAndParent<SgAsmElfSymverDefinedAuxList>(this)",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmElfSymverDefinedEntry);
#if defined(SgAsmElfSymverDefinedEntry_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmElfSymverDefinedEntry -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmElfSymverDefinedEntry");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
        s & BOOST_SERIALIZATION_NVP(p_version);
        s & BOOST_SERIALIZATION_NVP(p_flags);
        s & BOOST_SERIALIZATION_NVP(p_index);
        s & BOOST_SERIALIZATION_NVP(p_hash);
        s & BOOST_SERIALIZATION_NVP(p_entries);
        debugSerializationEnd("SgAsmElfSymverDefinedEntry");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
    // Local types
public:
#ifdef _MSC_VER
# pragma pack (1)
#endif
    struct ElfSymverDefinedEntry_disk {
        uint16_t      vd_version;                   
        uint16_t      vd_flags;                     
        uint16_t      vd_ndx;                       
        uint16_t      vd_cnt;                       
        uint32_t      vd_hash;                      
        uint32_t      vd_aux;                       
        uint32_t      vd_next;                      
    }
    struct ElfSymverDefinedEntry_disk {…};
#if !defined(SWIG) && !defined(_MSC_VER)
    __attribute__((packed))
#endif
    ;
 
#ifdef _MSC_VER
# pragma pack ()
#endif
 
    // Properties
public:
public:
    size_t const& get_version() const;
    void set_version(size_t const&);
public:
    int const& get_flags() const;
    void set_flags(int const&);
public:
    size_t const& get_index() const;
    void set_index(size_t const&);
public:
    uint32_t const& get_hash() const;
    void set_hash(uint32_t const&);
public:
    SgAsmElfSymverDefinedAuxList* const& get_entries() const;
    void set_entries(SgAsmElfSymverDefinedAuxList* const&);
    // Functions
public:
    explicit SgAsmElfSymverDefinedEntry(SgAsmElfSymverDefinedSection *symver_defined);
 
    void parse(Rose::BinaryAnalysis::ByteOrder::Endianness, const SgAsmElfSymverDefinedEntry::ElfSymverDefinedEntry_disk*);
 
    void *encode(Rose::BinaryAnalysis::ByteOrder::Endianness, SgAsmElfSymverDefinedEntry::ElfSymverDefinedEntry_disk*) const;
 
    virtual void dump(FILE *f, const char *prefix, ssize_t idx) const;
public:
    virtual ~SgAsmElfSymverDefinedEntry();
 
public:
    SgAsmElfSymverDefinedEntry();
 
protected:
    void initializeProperties();
#endif // SgAsmElfSymverDefinedEntry_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmElfSymverDefinedEntry: public SgAsmExecutableFileFormat {…};
#endif // DOCUMENTATION
 
 
// SgAsmElfSymverDefinedAuxList           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmElfSymverDefinedAuxList);
IS_SERIALIZABLE(AsmElfSymverDefinedAuxList);
 
#ifndef DOCUMENTATION
AsmElfSymverDefinedAuxList.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmElfSymverDefinedAuxList);
#if defined(SgAsmElfSymverDefinedAuxList_HEADERS) || defined(DOCUMENTATION)
#include <sageContainer.h>
#endif // SgAsmElfSymverDefinedAuxList_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmElfSymverDefinedAuxList: public SgAsmExecutableFileFormat {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfSymverDefinedAuxList.setDataPrototype(
        "SgAsmElfSymverDefinedAuxPtrList", "entries", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmElfSymverDefinedAuxList);
#if defined(SgAsmElfSymverDefinedAuxList_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmElfSymverDefinedAuxList -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmElfSymverDefinedAuxList");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
        s & BOOST_SERIALIZATION_NVP(p_entries);
        debugSerializationEnd("SgAsmElfSymverDefinedAuxList");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgAsmElfSymverDefinedAuxPtrList const& get_entries() const;
    SgAsmElfSymverDefinedAuxPtrList& get_entries();
    void set_entries(SgAsmElfSymverDefinedAuxPtrList const&);
public:
    virtual ~SgAsmElfSymverDefinedAuxList();
 
public:
    SgAsmElfSymverDefinedAuxList();
 
protected:
    void initializeProperties();
#endif // SgAsmElfSymverDefinedAuxList_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmElfSymverDefinedAuxList: public SgAsmExecutableFileFormat {…};
#endif // DOCUMENTATION
 
 
// SgAsmElfSymverDefinedAux           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmElfSymverDefinedAux);
IS_SERIALIZABLE(AsmElfSymverDefinedAux);
 
#ifndef DOCUMENTATION
AsmElfSymverDefinedAux.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmElfSymverDefinedAux);
#if defined(SgAsmElfSymverDefinedAux_HEADERS) || defined(DOCUMENTATION)
#include <Rose/BinaryAnalysis/ByteOrder.h>
 
#ifdef ROSE_SgAsmElfSymverDefinedAux_IMPL
#include <SgAsmGenericString.h>
#endif
#endif // SgAsmElfSymverDefinedAux_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmElfSymverDefinedAux: public SgAsmExecutableFileFormat {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfSymverDefinedAux.setDataPrototype(
        "SgAsmGenericString*", "name", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmElfSymverDefinedAux);
#if defined(SgAsmElfSymverDefinedAux_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmElfSymverDefinedAux -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmElfSymverDefinedAux");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
        s & BOOST_SERIALIZATION_NVP(p_name);
        debugSerializationEnd("SgAsmElfSymverDefinedAux");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
    // Local types
public:
#ifdef _MSC_VER
# pragma pack (1)
#endif
 
    struct ElfSymverDefinedAux_disk {
        uint32_t      vda_name;                     
        uint32_t      vda_next;                     
    }
    struct ElfSymverDefinedAux_disk {…};
#if !defined(SWIG) && !defined(_MSC_VER)
    __attribute__((packed))
#endif
    ;
 
#ifdef _MSC_VER
# pragma pack ()
#endif
 
    // Properties
public:
public:
    SgAsmGenericString* const& get_name() const;
    void set_name(SgAsmGenericString* const&);
    // Functions
public:
    explicit SgAsmElfSymverDefinedAux(SgAsmElfSymverDefinedEntry *symver_def_entry, SgAsmElfSymverDefinedSection *symver_def_sec);
 
    void parse(Rose::BinaryAnalysis::ByteOrder::Endianness, const SgAsmElfSymverDefinedAux::ElfSymverDefinedAux_disk*);
 
    void *encode(Rose::BinaryAnalysis::ByteOrder::Endianness, SgAsmElfSymverDefinedAux::ElfSymverDefinedAux_disk*) const;
 
    virtual void dump(FILE *f, const char *prefix, ssize_t idx) const;
public:
    virtual ~SgAsmElfSymverDefinedAux();
 
public:
    SgAsmElfSymverDefinedAux();
 
protected:
    void initializeProperties();
#endif // SgAsmElfSymverDefinedAux_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmElfSymverDefinedAux: public SgAsmExecutableFileFormat {…};
#endif // DOCUMENTATION
 
 
// SgAsmElfSymbolSection           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmElfSymbolSection);
IS_SERIALIZABLE(AsmElfSymbolSection);
 
#ifndef DOCUMENTATION
AsmElfSymbolSection.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmElfSymbolSection);
#if defined(SgAsmElfSymbolSection_HEADERS) || defined(DOCUMENTATION)
#include <Rose/BinaryAnalysis/Address.h>
 
#ifdef ROSE_SgAsmElfSymbolSection_IMPL
#include <SgAsmElfSymbolList.h>
#endif
#endif // SgAsmElfSymbolSection_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmElfSymbolSection: public SgAsmElfSection {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfSymbolSection.setDataPrototype(
        "bool", "isDynamic", "= false",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfSymbolSection.setDataPrototype(
        "SgAsmElfSymbolList*", "symbols", "= createAndParent<SgAsmElfSymbolList>(this)",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmElfSymbolSection);
#if defined(SgAsmElfSymbolSection_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmElfSymbolSection -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmElfSymbolSection");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmElfSection);
        s & BOOST_SERIALIZATION_NVP(p_isDynamic);
        s & BOOST_SERIALIZATION_NVP(p_symbols);
        debugSerializationEnd("SgAsmElfSymbolSection");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    bool const& get_isDynamic() const;
    void set_isDynamic(bool const&);
public:
    SgAsmElfSymbolList* const& get_symbols() const;
    void set_symbols(SgAsmElfSymbolList* const&);
public:
    SgAsmElfSymbolSection(SgAsmElfFileHeader *fhdr, SgAsmElfStringSection *strsec);
 
    virtual SgAsmElfSymbolSection* parse() override;
 
    virtual void finishParsing() override;
 
    size_t indexOf(SgAsmElfSymbol*);
 
    using SgAsmElfSection::calculateSizes;
    virtual Rose::BinaryAnalysis::Address
    calculateSizes(size_t *total, size_t *required, size_t *optional, size_t *nentries) const override;
 
    virtual bool reallocate() override;
 
    virtual void unparse(std::ostream&) const override;
 
    virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
 
    // Deprecated 2023-11
public:
    bool get_is_dynamic() const ROSE_DEPRECATED("use get_isDynamic");
    void set_is_dynamic(bool) ROSE_DEPRECATED("use set_isDynamic");
    virtual void finish_parsing() override ROSE_DEPRECATED("use finishParsing");
    size_t index_of(SgAsmElfSymbol*) ROSE_DEPRECATED("use indexOf");
    using SgAsmElfSection::calculate_sizes;
    virtual Rose::BinaryAnalysis::Address calculate_sizes(size_t*, size_t*, size_t*, size_t*) const override
        ROSE_DEPRECATED("use calculateSizes");
public:
    virtual ~SgAsmElfSymbolSection();
 
public:
    SgAsmElfSymbolSection();
 
protected:
    void initializeProperties();
#endif // SgAsmElfSymbolSection_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmElfSymbolSection: public SgAsmElfSection {…};
#endif // DOCUMENTATION
 
 
// SgAsmElfSymbolList           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmElfSymbolList);
IS_SERIALIZABLE(AsmElfSymbolList);
 
#ifndef DOCUMENTATION
AsmElfSymbolList.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmElfSymbolList);
#if defined(SgAsmElfSymbolList_HEADERS) || defined(DOCUMENTATION)
#include <sageContainer.h>
#endif // SgAsmElfSymbolList_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmElfSymbolList: public SgAsmExecutableFileFormat {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfSymbolList.setDataPrototype(
        "SgAsmElfSymbolPtrList", "symbols", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmElfSymbolList);
#if defined(SgAsmElfSymbolList_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmElfSymbolList -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmElfSymbolList");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
        s & BOOST_SERIALIZATION_NVP(p_symbols);
        debugSerializationEnd("SgAsmElfSymbolList");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgAsmElfSymbolPtrList const& get_symbols() const;
    SgAsmElfSymbolPtrList& get_symbols();
    void set_symbols(SgAsmElfSymbolPtrList const&);
public:
    virtual ~SgAsmElfSymbolList();
 
public:
    SgAsmElfSymbolList();
 
protected:
    void initializeProperties();
#endif // SgAsmElfSymbolList_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmElfSymbolList: public SgAsmExecutableFileFormat {…};
#endif // DOCUMENTATION
 
 
// SgAsmElfSymbol           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmElfSymbol);
IS_SERIALIZABLE(AsmElfSymbol);
 
#ifndef DOCUMENTATION
AsmElfSymbol.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmElfSymbol);
#if defined(SgAsmElfSymbol_HEADERS) || defined(DOCUMENTATION)
#include <Rose/BinaryAnalysis/Address.h>
#include <Rose/BinaryAnalysis/ByteOrder.h>
#include <sageContainer.h>
#endif // SgAsmElfSymbol_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmElfSymbol: public SgAsmGenericSymbol {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfSymbol.setDataPrototype(
        "unsigned char", "st_info", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfSymbol.setDataPrototype(
        "unsigned char", "st_res1", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfSymbol.setDataPrototype(
        "unsigned", "st_shndx", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfSymbol.setDataPrototype(
        "Rose::BinaryAnalysis::Address", "st_size", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfSymbol.setDataPrototype(
        "SgUnsignedCharList", "extra", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmElfSymbol);
#if defined(SgAsmElfSymbol_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmElfSymbol -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmElfSymbol");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmGenericSymbol);
        s & BOOST_SERIALIZATION_NVP(p_st_info);
        s & BOOST_SERIALIZATION_NVP(p_st_res1);
        s & BOOST_SERIALIZATION_NVP(p_st_shndx);
        s & BOOST_SERIALIZATION_NVP(p_st_size);
        s & BOOST_SERIALIZATION_NVP(p_extra);
        debugSerializationEnd("SgAsmElfSymbol");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
    // Local types
public:
    enum ElfSymBinding {
        STB_LOCAL=0,
        STB_GLOBAL=1,
        STB_WEAK=2
    };
 
    enum ElfSymType {
        STT_NOTYPE      = 0,                    
        STT_OBJECT      = 1,                    
        STT_FUNC        = 2,                    
        STT_SECTION     = 3,                    
        STT_FILE        = 4,                    
        STT_COMMON      = 5,                    
        STT_TLS         = 6,                    
        STT_IFUNC       = 10                    
    };
    enum ElfSymType {…};
 
#ifdef _MSC_VER
# pragma pack (1)
#endif
 
    struct Elf32SymbolEntry_disk {
        uint32_t      st_name;                      
        uint32_t      st_value;                     
        uint32_t      st_size;                      
        unsigned char st_info;                      
        unsigned char st_res1;                      
        uint16_t      st_shndx;                     
    }
    struct Elf32SymbolEntry_disk {…};
#if !defined(SWIG) && !defined(_MSC_VER)
    __attribute__((packed))
#endif
    ;
 
    struct Elf64SymbolEntry_disk {
        uint32_t      st_name;
        unsigned char st_info;
        unsigned char st_res1;
        uint16_t      st_shndx;
        uint64_t      st_value;
        uint64_t      st_size;
    }
    struct Elf64SymbolEntry_disk {…};
#if !defined(SWIG) && !defined(_MSC_VER)
    __attribute__((packed))
#endif
    ;
 
#ifdef _MSC_VER
# pragma pack ()
#endif
 
    // Properties
public:
public:
    unsigned char const& get_st_info() const;
    void set_st_info(unsigned char const&);
public:
    unsigned char const& get_st_res1() const;
    void set_st_res1(unsigned char const&);
public:
    unsigned const& get_st_shndx() const;
    void set_st_shndx(unsigned const&);
public:
    Rose::BinaryAnalysis::Address const& get_st_size() const;
    void set_st_size(Rose::BinaryAnalysis::Address const&);
public:
    SgUnsignedCharList const& get_extra() const;
    SgUnsignedCharList& get_extra();
    void set_extra(SgUnsignedCharList const&);
    // Functions
public:
    explicit SgAsmElfSymbol(SgAsmElfSymbolSection*);
 
    void parse(Rose::BinaryAnalysis::ByteOrder::Endianness, const SgAsmElfSymbol::Elf32SymbolEntry_disk*);
 
    void parse(Rose::BinaryAnalysis::ByteOrder::Endianness, const SgAsmElfSymbol::Elf64SymbolEntry_disk*);
 
    void *encode(Rose::BinaryAnalysis::ByteOrder::Endianness, SgAsmElfSymbol::Elf32SymbolEntry_disk*) const;
    void *encode(Rose::BinaryAnalysis::ByteOrder::Endianness, SgAsmElfSymbol::Elf64SymbolEntry_disk*) const;
    virtual void dump(FILE *f, const char *prefix, ssize_t idx) const override;
    void dump(FILE*, const char *prefix, ssize_t idx, SgAsmGenericSection*) const;
    SgAsmElfSymbol::ElfSymBinding get_elfBinding() const;
 
    SgAsmElfSymbol::ElfSymType get_elfType() const;
 
    static std::string toString(SgAsmElfSymbol::ElfSymBinding);
 
    static std::string toString(SgAsmElfSymbol::ElfSymType);
 
private:
    void parse_common();                            // initialization common to all parse() methods
 
    // Deprecated 2023-11
public:
    SgAsmElfSymbol::ElfSymBinding get_elf_binding() const ROSE_DEPRECATED("use get_elfBinding");
    SgAsmElfSymbol::ElfSymType get_elf_type() const ROSE_DEPRECATED("use get_elfType");
    static std::string to_string(SgAsmElfSymbol::ElfSymBinding) ROSE_DEPRECATED("use toString");
    static std::string to_string(SgAsmElfSymbol::ElfSymType) ROSE_DEPRECATED("use toString");
public:
    virtual ~SgAsmElfSymbol();
 
public:
    SgAsmElfSymbol();
 
protected:
    void initializeProperties();
#endif // SgAsmElfSymbol_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmElfSymbol: public SgAsmGenericSymbol {…};
#endif // DOCUMENTATION
 
 
// SgAsmElfStrtab           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmElfStrtab);
IS_SERIALIZABLE(AsmElfStrtab);
 
#ifndef DOCUMENTATION
AsmElfStrtab.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmElfStrtab);
#if defined(SgAsmElfStrtab_HEADERS) || defined(DOCUMENTATION)
#include <Rose/BinaryAnalysis/Address.h>
#endif // SgAsmElfStrtab_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmElfStrtab: public SgAsmGenericStrtab {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmElfStrtab);
#if defined(SgAsmElfStrtab_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmElfStrtab -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmElfStrtab");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmGenericStrtab);
        debugSerializationEnd("SgAsmElfStrtab");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
    explicit SgAsmElfStrtab(class SgAsmElfSection *containing_section);
 
    void destructorHelper() override;
 
    virtual SgAsmElfStrtab *parse() override;
 
    virtual void unparse(std::ostream&) const;
 
    virtual SgAsmStringStorage *createStorage(Rose::BinaryAnalysis::Address offset, bool shared) override;
 
    virtual Rose::BinaryAnalysis::Address get_storageSize(const SgAsmStringStorage*) override;
 
    virtual void allocateOverlap(SgAsmStringStorage*) override;
 
    virtual void rebind(SgAsmStringStorage*, Rose::BinaryAnalysis::Address) override;
 
    // Deprecated 2023-11
public:
    virtual SgAsmStringStorage *create_storage(Rose::BinaryAnalysis::Address, bool) override ROSE_DEPRECATED("use createStorage");
    virtual Rose::BinaryAnalysis::Address get_storage_size(const SgAsmStringStorage*) override
        ROSE_DEPRECATED("use get_storageSize");
    virtual void allocate_overlap(SgAsmStringStorage*) override ROSE_DEPRECATED("use allocateOverlap");
public:
    virtual ~SgAsmElfStrtab();
 
public:
    SgAsmElfStrtab();
 
protected:
    void initializeProperties();
#endif // SgAsmElfStrtab_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmElfStrtab: public SgAsmGenericStrtab {…};
#endif // DOCUMENTATION
 
 
// SgAsmElfStringSection           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmElfStringSection);
IS_SERIALIZABLE(AsmElfStringSection);
 
#ifndef DOCUMENTATION
AsmElfStringSection.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmElfStringSection);
#if defined(SgAsmElfStringSection_HEADERS) || defined(DOCUMENTATION)
#include <Rose/BinaryAnalysis/Address.h>
#endif // SgAsmElfStringSection_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmElfStringSection: public SgAsmElfSection {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfStringSection.setDataPrototype(
        "SgAsmElfStrtab*", "strtab", "= nullptr",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmElfStringSection);
#if defined(SgAsmElfStringSection_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmElfStringSection -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmElfStringSection");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmElfSection);
        s & BOOST_SERIALIZATION_NVP(p_strtab);
        debugSerializationEnd("SgAsmElfStringSection");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgAsmElfStrtab* const& get_strtab() const;
    void set_strtab(SgAsmElfStrtab* const&);
public:
    explicit SgAsmElfStringSection(SgAsmElfFileHeader*);
 
    virtual SgAsmElfStringSection *parse() override;
 
    virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
 
    virtual void set_size(Rose::BinaryAnalysis::Address newsize) override;
 
    virtual bool reallocate() override;
 
    virtual void unparse(std::ostream&) const override;
public:
    virtual ~SgAsmElfStringSection();
 
public:
    SgAsmElfStringSection();
 
protected:
    void initializeProperties();
#endif // SgAsmElfStringSection_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmElfStringSection: public SgAsmElfSection {…};
#endif // DOCUMENTATION
 
 
// SgAsmElfSegmentTable           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmElfSegmentTable);
IS_SERIALIZABLE(AsmElfSegmentTable);
 
#ifndef DOCUMENTATION
AsmElfSegmentTable.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmElfSegmentTable);
#if defined(SgAsmElfSegmentTable_HEADERS) || defined(DOCUMENTATION)
#include <Rose/BinaryAnalysis/Address.h>
#endif // SgAsmElfSegmentTable_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmElfSegmentTable: public SgAsmGenericSection {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmElfSegmentTable);
#if defined(SgAsmElfSegmentTable_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmElfSegmentTable -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmElfSegmentTable");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmGenericSection);
        debugSerializationEnd("SgAsmElfSegmentTable");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
    explicit SgAsmElfSegmentTable(SgAsmElfFileHeader*);
 
    virtual SgAsmElfSegmentTable *parse() override;
 
    SgAsmElfSegmentTableEntry *addSection(SgAsmElfSection*);
 
    Rose::BinaryAnalysis::Address calculateSizes(size_t *entsize, size_t *required, size_t *optional, size_t *entcount) const;
 
    virtual bool reallocate() override;
 
    virtual void unparse(std::ostream&) const override;
 
    virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
 
    // Deprecated 2023-11
public:
    SgAsmElfSegmentTableEntry *add_section(SgAsmElfSection*) ROSE_DEPRECATED("use addSection");
    Rose::BinaryAnalysis::Address calculate_sizes(size_t*, size_t*, size_t*, size_t*) const ROSE_DEPRECATED("use calculateSizes");
public:
    virtual ~SgAsmElfSegmentTable();
 
public:
    SgAsmElfSegmentTable();
 
protected:
    void initializeProperties();
#endif // SgAsmElfSegmentTable_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmElfSegmentTable: public SgAsmGenericSection {…};
#endif // DOCUMENTATION
 
 
// SgAsmElfSegmentTableEntryList           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmElfSegmentTableEntryList);
IS_SERIALIZABLE(AsmElfSegmentTableEntryList);
 
#ifndef DOCUMENTATION
AsmElfSegmentTableEntryList.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmElfSegmentTableEntryList);
#if defined(SgAsmElfSegmentTableEntryList_HEADERS) || defined(DOCUMENTATION)
#include <sageContainer.h>
#endif // SgAsmElfSegmentTableEntryList_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmElfSegmentTableEntryList: public SgAsmExecutableFileFormat {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfSegmentTableEntryList.setDataPrototype(
        "SgAsmElfSegmentTableEntryPtrList", "entries", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmElfSegmentTableEntryList);
#if defined(SgAsmElfSegmentTableEntryList_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmElfSegmentTableEntryList -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmElfSegmentTableEntryList");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
        s & BOOST_SERIALIZATION_NVP(p_entries);
        debugSerializationEnd("SgAsmElfSegmentTableEntryList");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgAsmElfSegmentTableEntryPtrList const& get_entries() const;
    SgAsmElfSegmentTableEntryPtrList& get_entries();
    void set_entries(SgAsmElfSegmentTableEntryPtrList const&);
public:
    virtual ~SgAsmElfSegmentTableEntryList();
 
public:
    SgAsmElfSegmentTableEntryList();
 
protected:
    void initializeProperties();
#endif // SgAsmElfSegmentTableEntryList_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmElfSegmentTableEntryList: public SgAsmExecutableFileFormat {…};
#endif // DOCUMENTATION
 
 
// SgAsmElfSegmentTableEntry           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmElfSegmentTableEntry);
IS_SERIALIZABLE(AsmElfSegmentTableEntry);
 
#ifndef DOCUMENTATION
AsmElfSegmentTableEntry.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmElfSegmentTableEntry);
#if defined(SgAsmElfSegmentTableEntry_HEADERS) || defined(DOCUMENTATION)
#include <Rose/BinaryAnalysis/Address.h>
#include <Rose/BinaryAnalysis/ByteOrder.h>
#include <sageContainer.h>
#endif // SgAsmElfSegmentTableEntry_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmElfSegmentTableEntry: public SgAsmExecutableFileFormat {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfSegmentTableEntry.setDataPrototype(
        "size_t", "index", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfSegmentTableEntry.setDataPrototype(
        "SgAsmElfSegmentTableEntry::SegmentType", "type", "= SgAsmElfSegmentTableEntry::PT_LOAD",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfSegmentTableEntry.setDataPrototype(
        "SgAsmElfSegmentTableEntry::SegmentFlags", "flags", "= SgAsmElfSegmentTableEntry::PF_NONE",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfSegmentTableEntry.setDataPrototype(
        "Rose::BinaryAnalysis::Address", "offset", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfSegmentTableEntry.setDataPrototype(
        "Rose::BinaryAnalysis::Address", "vaddr", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfSegmentTableEntry.setDataPrototype(
        "Rose::BinaryAnalysis::Address", "paddr", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfSegmentTableEntry.setDataPrototype(
        "Rose::BinaryAnalysis::Address", "filesz", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfSegmentTableEntry.setDataPrototype(
        "Rose::BinaryAnalysis::Address", "memsz", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfSegmentTableEntry.setDataPrototype(
        "Rose::BinaryAnalysis::Address", "align", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfSegmentTableEntry.setDataPrototype(
        "SgUnsignedCharList", "extra", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmElfSegmentTableEntry);
#if defined(SgAsmElfSegmentTableEntry_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmElfSegmentTableEntry -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmElfSegmentTableEntry");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
        s & BOOST_SERIALIZATION_NVP(p_index);
        s & BOOST_SERIALIZATION_NVP(p_type);
        s & BOOST_SERIALIZATION_NVP(p_flags);
        s & BOOST_SERIALIZATION_NVP(p_offset);
        s & BOOST_SERIALIZATION_NVP(p_vaddr);
        s & BOOST_SERIALIZATION_NVP(p_paddr);
        s & BOOST_SERIALIZATION_NVP(p_filesz);
        s & BOOST_SERIALIZATION_NVP(p_memsz);
        s & BOOST_SERIALIZATION_NVP(p_align);
        s & BOOST_SERIALIZATION_NVP(p_extra);
        debugSerializationEnd("SgAsmElfSegmentTableEntry");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
    // Local types
public:
    enum SegmentType {
        PT_NULL         = 0,                        
        PT_LOAD         = 1,                        
        PT_DYNAMIC      = 2,                        
        PT_INTERP       = 3,                        
        PT_NOTE         = 4,                        
        PT_SHLIB        = 5,                        
        PT_PHDR         = 6,                        
        PT_TLS          = 7,                        
        // OS- and Processor-specific ranges
        PT_LOOS         = 0x60000000,               
        PT_HIOS         = 0x6fffffff,
        PT_LOPROC       = 0x70000000,               
        PT_HIPROC       = 0x7fffffff,
 
        // OS-specific values for GNU/Linux
        PT_GNU_EH_FRAME = 0x6474e550,               
        PT_GNU_STACK    = 0x6474e551,               
        PT_GNU_RELRO    = 0x6474e552,               
        PT_PAX_FLAGS    = 0x65041580,               
        // OS-specific values for Sun
        PT_SUNWBSS      = 0x6ffffffa,               
        PT_SUNWSTACK    = 0x6ffffffb                
    };
    enum SegmentType {…};
 
    enum SegmentFlags {
        PF_NONE         = 0,                        
        PF_RESERVED     = 0x000ffff8,               
        PF_XPERM        = 0x00000001,               
        PF_WPERM        = 0x00000002,               
        PF_RPERM        = 0x00000004,               
        PF_OS_MASK      = 0x0ff00000,               
        PF_PROC_MASK    = 0xf0000000                
    };
    enum SegmentFlags {…};
 
#ifdef _MSC_VER
# pragma pack (1)
#endif
    struct Elf32SegmentTableEntry_disk {
        uint32_t        p_type;                  
        uint32_t        p_offset;                
        uint32_t        p_vaddr;                 
        uint32_t        p_paddr;                 
        uint32_t        p_filesz;                
        uint32_t        p_memsz;                 
        uint32_t        p_flags;                 
        uint32_t        p_align;                 
    }                                            /* 0x30 */
    struct Elf32SegmentTableEntry_disk {…};
#if !defined(SWIG) && !defined(_MSC_VER)
    __attribute__((packed))
#endif
    ;
 
    struct Elf64SegmentTableEntry_disk {
        uint32_t        p_type;         /* 0x00 */
        uint32_t        p_flags;        /* 0x04 */
        uint64_t        p_offset;       /* 0x08 */
        uint64_t        p_vaddr;        /* 0x10 */
        uint64_t        p_paddr;        /* 0x18 */
        uint64_t        p_filesz;       /* 0x20 */
        uint64_t        p_memsz;        /* 0x28 */
        uint64_t        p_align;        /* 0x30 */
    }                                       /* 0x38 */
    struct Elf64SegmentTableEntry_disk {…};
#if !defined(SWIG) && !defined(_MSC_VER)
    __attribute__((packed))
#endif
    ;
#ifdef _MSC_VER
# pragma pack ()
#endif
 
    // Properties
public:
public:
    size_t const& get_index() const;
    void set_index(size_t const&);
public:
    SgAsmElfSegmentTableEntry::SegmentType const& get_type() const;
    void set_type(SgAsmElfSegmentTableEntry::SegmentType const&);
public:
    SgAsmElfSegmentTableEntry::SegmentFlags const& get_flags() const;
    void set_flags(SgAsmElfSegmentTableEntry::SegmentFlags const&);
public:
    Rose::BinaryAnalysis::Address const& get_offset() const;
    void set_offset(Rose::BinaryAnalysis::Address const&);
public:
    Rose::BinaryAnalysis::Address const& get_vaddr() const;
    void set_vaddr(Rose::BinaryAnalysis::Address const&);
public:
    Rose::BinaryAnalysis::Address const& get_paddr() const;
    void set_paddr(Rose::BinaryAnalysis::Address const&);
public:
    Rose::BinaryAnalysis::Address const& get_filesz() const;
    void set_filesz(Rose::BinaryAnalysis::Address const&);
public:
    Rose::BinaryAnalysis::Address const& get_memsz() const;
    void set_memsz(Rose::BinaryAnalysis::Address const&);
public:
    Rose::BinaryAnalysis::Address const& get_align() const;
    void set_align(Rose::BinaryAnalysis::Address const&);
public:
    SgUnsignedCharList const& get_extra() const;
    SgUnsignedCharList& get_extra();
    void set_extra(SgUnsignedCharList const&);
    // Functions
public:
    SgAsmElfSegmentTableEntry(Rose::BinaryAnalysis::ByteOrder::Endianness sex,
                              const SgAsmElfSegmentTableEntry::Elf32SegmentTableEntry_disk *disk);
 
    SgAsmElfSegmentTableEntry(Rose::BinaryAnalysis::ByteOrder::Endianness sex,
                              const SgAsmElfSegmentTableEntry::Elf64SegmentTableEntry_disk *disk);
 
    void *encode(Rose::BinaryAnalysis::ByteOrder::Endianness, SgAsmElfSegmentTableEntry::Elf32SegmentTableEntry_disk*) const;
    void *encode(Rose::BinaryAnalysis::ByteOrder::Endianness, SgAsmElfSegmentTableEntry::Elf64SegmentTableEntry_disk*) const;
    void updateFromSection(SgAsmElfSection*);
 
    virtual void dump(FILE*, const char *prefix, ssize_t idx) const;
 
    static std::string toString(SgAsmElfSegmentTableEntry::SegmentType);
 
    static std::string toString(SgAsmElfSegmentTableEntry::SegmentFlags);
 
    // Deprecated 2023-11
public:
    void update_from_section(SgAsmElfSection*) ROSE_DEPRECATED("use updateFromSection");
    static std::string to_string(SgAsmElfSegmentTableEntry::SegmentType) ROSE_DEPRECATED("use toString");
    static std::string to_string(SgAsmElfSegmentTableEntry::SegmentFlags) ROSE_DEPRECATED("use toString");
public:
    virtual ~SgAsmElfSegmentTableEntry();
 
public:
    SgAsmElfSegmentTableEntry();
 
protected:
    void initializeProperties();
#endif // SgAsmElfSegmentTableEntry_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmElfSegmentTableEntry: public SgAsmExecutableFileFormat {…};
#endif // DOCUMENTATION
 
 
// SgAsmElfSectionTable           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmElfSectionTable);
IS_SERIALIZABLE(AsmElfSectionTable);
 
#ifndef DOCUMENTATION
AsmElfSectionTable.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmElfSectionTable);
#if defined(SgAsmElfSectionTable_HEADERS) || defined(DOCUMENTATION)
#include <Rose/BinaryAnalysis/Address.h>
#endif // SgAsmElfSectionTable_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmElfSectionTable: public SgAsmGenericSection {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmElfSectionTable);
#if defined(SgAsmElfSectionTable_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmElfSectionTable -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmElfSectionTable");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmGenericSection);
        debugSerializationEnd("SgAsmElfSectionTable");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
    explicit SgAsmElfSectionTable(SgAsmElfFileHeader*);
 
    virtual SgAsmElfSectionTable *parse() override;
 
    SgAsmElfSectionTableEntry *addSection(SgAsmElfSection*);
 
    Rose::BinaryAnalysis::Address calculateSizes(size_t *entsize, size_t *required, size_t *optional, size_t *entcount) const;
 
    virtual bool reallocate() override;
 
    virtual void unparse(std::ostream&) const override;
 
    virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
 
    // Deprecated 2023-11
public:
    SgAsmElfSectionTableEntry *add_section(SgAsmElfSection*) ROSE_DEPRECATED("use addSection");
    Rose::BinaryAnalysis::Address calculate_sizes(size_t*, size_t*, size_t*, size_t*) const ROSE_DEPRECATED("use calculateSizes");
public:
    virtual ~SgAsmElfSectionTable();
 
public:
    SgAsmElfSectionTable();
 
protected:
    void initializeProperties();
#endif // SgAsmElfSectionTable_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmElfSectionTable: public SgAsmGenericSection {…};
#endif // DOCUMENTATION
 
 
// SgAsmElfSectionTableEntry           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmElfSectionTableEntry);
IS_SERIALIZABLE(AsmElfSectionTableEntry);
 
#ifndef DOCUMENTATION
AsmElfSectionTableEntry.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmElfSectionTableEntry);
#if defined(SgAsmElfSectionTableEntry_HEADERS) || defined(DOCUMENTATION)
#include <Rose/BinaryAnalysis/Address.h>
#include <Rose/BinaryAnalysis/ByteOrder.h>
#include <sageContainer.h>
#endif // SgAsmElfSectionTableEntry_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmElfSectionTableEntry: public SgAsmExecutableFileFormat {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfSectionTableEntry.setDataPrototype(
        "unsigned", "sh_name", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfSectionTableEntry.setDataPrototype(
        "SgAsmElfSectionTableEntry::SectionType", "sh_type", "= SHT_PROGBITS",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfSectionTableEntry.setDataPrototype(
        "unsigned long", "sh_link", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfSectionTableEntry.setDataPrototype(
        "unsigned long", "sh_info", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfSectionTableEntry.setDataPrototype(
        "uint64_t", "sh_flags", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfSectionTableEntry.setDataPrototype(
        "Rose::BinaryAnalysis::Address", "sh_addr", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfSectionTableEntry.setDataPrototype(
        "Rose::BinaryAnalysis::Address", "sh_offset", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfSectionTableEntry.setDataPrototype(
        "Rose::BinaryAnalysis::Address", "sh_size", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfSectionTableEntry.setDataPrototype(
        "Rose::BinaryAnalysis::Address", "sh_addralign", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfSectionTableEntry.setDataPrototype(
        "Rose::BinaryAnalysis::Address", "sh_entsize", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfSectionTableEntry.setDataPrototype(
        "SgUnsignedCharList", "extra", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmElfSectionTableEntry);
#if defined(SgAsmElfSectionTableEntry_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmElfSectionTableEntry -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmElfSectionTableEntry");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
        s & BOOST_SERIALIZATION_NVP(p_sh_name);
        s & BOOST_SERIALIZATION_NVP(p_sh_type);
        s & BOOST_SERIALIZATION_NVP(p_sh_link);
        s & BOOST_SERIALIZATION_NVP(p_sh_info);
        s & BOOST_SERIALIZATION_NVP(p_sh_flags);
        s & BOOST_SERIALIZATION_NVP(p_sh_addr);
        s & BOOST_SERIALIZATION_NVP(p_sh_offset);
        s & BOOST_SERIALIZATION_NVP(p_sh_size);
        s & BOOST_SERIALIZATION_NVP(p_sh_addralign);
        s & BOOST_SERIALIZATION_NVP(p_sh_entsize);
        s & BOOST_SERIALIZATION_NVP(p_extra);
        debugSerializationEnd("SgAsmElfSectionTableEntry");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
    // Local types
public:
    enum SectionType {
        SHT_NULL        = 0,                  
        SHT_PROGBITS    = 1,                  
        SHT_SYMTAB      = 2,                  
        SHT_STRTAB      = 3,                  
        SHT_RELA        = 4,                  
        SHT_HASH        = 5,                  
        SHT_DYNAMIC     = 6,                  
        SHT_NOTE        = 7,                  
        SHT_NOBITS      = 8,                  
        SHT_REL         = 9,                  
        SHT_SHLIB       = 10,                 
        SHT_DYNSYM      = 11,                 
        SHT_LOOS        = 0x60000000,         
        SHT_GNU_verdef  = 0x6ffffffd,         
        SHT_GNU_verneed = 0x6ffffffe,         
        SHT_GNU_versym  = 0x6fffffff,         
        SHT_HIOS        = 0x6fffffff,                /*NO_STRINGIFY*/
 
        SHT_LOPROC      = 0x70000000,         /* Processor specific semantics */
        SHT_HIPROC      = 0x7fffffff,
        SHT_LOUSER      = 0x80000000,         /* Application specific semantics */
        SHT_HIUSER      = 0xffffffff
    };
    enum SectionType {…};
 
    enum SectionFlags {
        SHF_NULL=                  0,        
        SHF_WRITE=           (1 << 0),       
        SHF_ALLOC=           (1 << 1),       
        SHF_EXECINSTR=       (1 << 2),       
        SHF_MERGE=           (1 << 4),       
        SHF_STRINGS=         (1 << 5),       
        SHF_INFO_LINK=       (1 << 6),       
        SHF_LINK_ORDER=      (1 << 7),       
        SHF_OS_NONCONFORMING=(1 << 8),       
        SHF_GROUP=           (1 << 9),       
        SHF_TLS=             (1 << 10),      
        SHF_MASKOS=          0x0ff00000,     
        SHF_MASKPROC=        0xf0000000      
    };
    enum SectionFlags {…};
 
#ifdef _MSC_VER
# pragma pack (1)
#endif
    struct Elf32SectionTableEntry_disk {
        uint32_t        sh_name;             /* 0x00 Section name; index into section header string table */
        uint32_t        sh_type;             /* 0x04 Section contents and semantics (see SectionType enum) */
        uint32_t        sh_flags;            /* 0x08 Bit flags */
        uint32_t        sh_addr;             /* 0x0c Desired mapped address */
        uint32_t        sh_offset;           /* 0x10 Section location in file unless sh_type==SHT_NOBITS */
        uint32_t        sh_size;             /* 0x14 Section size in bytes */
        uint32_t        sh_link;             /* 0x18 Section ID of another section; meaning depends on section type */
        uint32_t        sh_info;             /* 0x1c Extra info depending on section type */
        uint32_t        sh_addralign;        /* 0x20 Mapped alignment (0 and 1=>byte aligned); sh_addr must be aligned*/
        uint32_t        sh_entsize;          /* 0x24 If non-zero, size in bytes of each array member in the section */
    }                                        /* 0x28 */
    struct Elf32SectionTableEntry_disk {…};
#if !defined(SWIG) && !defined(_MSC_VER)
    __attribute__((packed))
#endif
    ;
 
    struct Elf64SectionTableEntry_disk {
        uint32_t        sh_name;             /* 0x00 see Elf32SectionTableEntry_disk */
        uint32_t        sh_type;             /* 0x04 */
        uint64_t        sh_flags;            /* 0x08 */
        uint64_t        sh_addr;             /* 0x10 */
        uint64_t        sh_offset;           /* 0x18 */
        uint64_t        sh_size;             /* 0x20 */
        uint32_t        sh_link;             /* 0x28 */
        uint32_t        sh_info;             /* 0x2c */
        uint64_t        sh_addralign;        /* 0x30 */
        uint64_t        sh_entsize;          /* 0x38 */
    }                                        /* 0x40 */
    struct Elf64SectionTableEntry_disk {…};
#if !defined(SWIG) && !defined(_MSC_VER)
    __attribute__((packed))
#endif
    ;
#ifdef _MSC_VER
# pragma pack ()
#endif
 
    // Properties
public:
public:
    unsigned const& get_sh_name() const;
    void set_sh_name(unsigned const&);
public:
    SgAsmElfSectionTableEntry::SectionType const& get_sh_type() const;
    void set_sh_type(SgAsmElfSectionTableEntry::SectionType const&);
public:
    unsigned long const& get_sh_link() const;
    void set_sh_link(unsigned long const&);
public:
    unsigned long const& get_sh_info() const;
    void set_sh_info(unsigned long const&);
public:
    uint64_t const& get_sh_flags() const;
    void set_sh_flags(uint64_t const&);
public:
    Rose::BinaryAnalysis::Address const& get_sh_addr() const;
    void set_sh_addr(Rose::BinaryAnalysis::Address const&);
public:
    Rose::BinaryAnalysis::Address const& get_sh_offset() const;
    void set_sh_offset(Rose::BinaryAnalysis::Address const&);
public:
    Rose::BinaryAnalysis::Address const& get_sh_size() const;
    void set_sh_size(Rose::BinaryAnalysis::Address const&);
public:
    Rose::BinaryAnalysis::Address const& get_sh_addralign() const;
    void set_sh_addralign(Rose::BinaryAnalysis::Address const&);
public:
    Rose::BinaryAnalysis::Address const& get_sh_entsize() const;
    void set_sh_entsize(Rose::BinaryAnalysis::Address const&);
public:
    SgUnsignedCharList const& get_extra() const;
    SgUnsignedCharList& get_extra();
    void set_extra(SgUnsignedCharList const&);
    // Functions
public:
    SgAsmElfSectionTableEntry(Rose::BinaryAnalysis::ByteOrder::Endianness sex,
                              const SgAsmElfSectionTableEntry::Elf32SectionTableEntry_disk *disk);
 
    SgAsmElfSectionTableEntry(Rose::BinaryAnalysis::ByteOrder::Endianness sex,
                              const SgAsmElfSectionTableEntry::Elf64SectionTableEntry_disk *disk);
 
    void *encode(Rose::BinaryAnalysis::ByteOrder::Endianness sex,
                 SgAsmElfSectionTableEntry::Elf32SectionTableEntry_disk *disk) const;
    void *encode(Rose::BinaryAnalysis::ByteOrder::Endianness sex,
                 SgAsmElfSectionTableEntry::Elf64SectionTableEntry_disk *disk) const;
    void updateFromSection(SgAsmElfSection*);
 
    virtual void dump(FILE*, const char *prefix, ssize_t idx) const;
 
    // Use Rose::stringify... function instead.
    static std::string toString(SgAsmElfSectionTableEntry::SectionType);
    static std::string toString(SgAsmElfSectionTableEntry::SectionFlags);
 
    // Deprecated 2023-11
public:
    void update_from_section(SgAsmElfSection*) ROSE_DEPRECATED("use updateFromSection");
    static std::string to_string(SgAsmElfSectionTableEntry::SectionType) ROSE_DEPRECATED("use toString");
    static std::string to_string(SgAsmElfSectionTableEntry::SectionFlags) ROSE_DEPRECATED("use toString");
public:
    virtual ~SgAsmElfSectionTableEntry();
 
public:
    SgAsmElfSectionTableEntry();
 
protected:
    void initializeProperties();
#endif // SgAsmElfSectionTableEntry_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmElfSectionTableEntry: public SgAsmExecutableFileFormat {…};
#endif // DOCUMENTATION
 
 
// SgAsmElfRelocSection           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmElfRelocSection);
IS_SERIALIZABLE(AsmElfRelocSection);
 
#ifndef DOCUMENTATION
AsmElfRelocSection.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmElfRelocSection);
#if defined(SgAsmElfRelocSection_HEADERS) || defined(DOCUMENTATION)
#include <Rose/BinaryAnalysis/Address.h>
 
#ifdef ROSE_SgAsmElfRelocSection_IMPL
#include <SgAsmElfRelocEntryList.h>
#endif
#endif // SgAsmElfRelocSection_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmElfRelocSection: public SgAsmElfSection {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfRelocSection.setDataPrototype(
        "bool", "usesAddend", "= true",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfRelocSection.setDataPrototype(
        "SgAsmElfSection*", "targetSection", "= nullptr",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfRelocSection.setDataPrototype(
        "SgAsmElfRelocEntryList*", "entries", "= createAndParent<SgAsmElfRelocEntryList>(this)",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmElfRelocSection);
#if defined(SgAsmElfRelocSection_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmElfRelocSection -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmElfRelocSection");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmElfSection);
        s & BOOST_SERIALIZATION_NVP(p_usesAddend);
        s & BOOST_SERIALIZATION_NVP(p_targetSection);
        s & BOOST_SERIALIZATION_NVP(p_entries);
        debugSerializationEnd("SgAsmElfRelocSection");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    bool const& get_usesAddend() const;
    void set_usesAddend(bool const&);
public:
    SgAsmElfSection* const& get_targetSection() const;
    void set_targetSection(SgAsmElfSection* const&);
public:
    SgAsmElfRelocEntryList* const& get_entries() const;
    void set_entries(SgAsmElfRelocEntryList* const&);
public:
    SgAsmElfRelocSection(SgAsmElfFileHeader *fhdr, SgAsmElfSymbolSection *symsec,SgAsmElfSection* targetsec);
 
    using SgAsmElfSection::calculateSizes;
    virtual SgAsmElfRelocSection *parse() override;
 
    virtual Rose::BinaryAnalysis::Address
    calculateSizes(size_t *total, size_t *required, size_t *optional, size_t *entcount) const override;
 
    virtual bool reallocate() override;
 
    virtual void unparse(std::ostream&) const override;
 
    virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
 
    // Deprecated 2023-11
public:
    bool get_uses_addend() const ROSE_DEPRECATED("use get_usesAddend");
    void set_uses_addend(bool) ROSE_DEPRECATED("use set_usesAddend");
    SgAsmElfSection* get_target_section() const ROSE_DEPRECATED("use get_targetSection");
    void set_target_section(SgAsmElfSection*) ROSE_DEPRECATED("use set_targetSection");
    using SgAsmElfSection::calculate_sizes;
    virtual Rose::BinaryAnalysis::Address calculate_sizes(size_t*, size_t*, size_t*, size_t*) const override
        ROSE_DEPRECATED("use calculateSizes");
public:
    virtual ~SgAsmElfRelocSection();
 
public:
    SgAsmElfRelocSection();
 
protected:
    void initializeProperties();
#endif // SgAsmElfRelocSection_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmElfRelocSection: public SgAsmElfSection {…};
#endif // DOCUMENTATION
 
 
// SgAsmElfRelocEntryList           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmElfRelocEntryList);
IS_SERIALIZABLE(AsmElfRelocEntryList);
 
#ifndef DOCUMENTATION
AsmElfRelocEntryList.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmElfRelocEntryList);
#if defined(SgAsmElfRelocEntryList_HEADERS) || defined(DOCUMENTATION)
#include <sageContainer.h>
#endif // SgAsmElfRelocEntryList_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmElfRelocEntryList: public SgAsmExecutableFileFormat {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfRelocEntryList.setDataPrototype(
        "SgAsmElfRelocEntryPtrList", "entries", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmElfRelocEntryList);
#if defined(SgAsmElfRelocEntryList_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmElfRelocEntryList -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmElfRelocEntryList");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
        s & BOOST_SERIALIZATION_NVP(p_entries);
        debugSerializationEnd("SgAsmElfRelocEntryList");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgAsmElfRelocEntryPtrList const& get_entries() const;
    SgAsmElfRelocEntryPtrList& get_entries();
    void set_entries(SgAsmElfRelocEntryPtrList const&);
public:
    virtual ~SgAsmElfRelocEntryList();
 
public:
    SgAsmElfRelocEntryList();
 
protected:
    void initializeProperties();
#endif // SgAsmElfRelocEntryList_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmElfRelocEntryList: public SgAsmExecutableFileFormat {…};
#endif // DOCUMENTATION
 
 
// SgAsmElfRelocEntry           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmElfRelocEntry);
IS_SERIALIZABLE(AsmElfRelocEntry);
 
#ifndef DOCUMENTATION
AsmElfRelocEntry.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmElfRelocEntry);
#if defined(SgAsmElfRelocEntry_HEADERS) || defined(DOCUMENTATION)
#include <Rose/BinaryAnalysis/Address.h>
#include <Rose/BinaryAnalysis/ByteOrder.h>
#include <sageContainer.h>
#endif // SgAsmElfRelocEntry_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmElfRelocEntry: public SgAsmExecutableFileFormat {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfRelocEntry.setDataPrototype(
        "Rose::BinaryAnalysis::Address", "r_offset", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfRelocEntry.setDataPrototype(
        "Rose::BinaryAnalysis::Address", "r_addend", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfRelocEntry.setDataPrototype(
        "unsigned long", "sym", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfRelocEntry.setDataPrototype(
        "SgAsmElfRelocEntry::RelocType", "type", "= R_386_NONE",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfRelocEntry.setDataPrototype(
        "SgUnsignedCharList", "extra", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmElfRelocEntry);
#if defined(SgAsmElfRelocEntry_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmElfRelocEntry -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmElfRelocEntry");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
        s & BOOST_SERIALIZATION_NVP(p_r_offset);
        s & BOOST_SERIALIZATION_NVP(p_r_addend);
        s & BOOST_SERIALIZATION_NVP(p_sym);
        s & BOOST_SERIALIZATION_NVP(p_type);
        s & BOOST_SERIALIZATION_NVP(p_extra);
        debugSerializationEnd("SgAsmElfRelocEntry");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
    // Local types
public:
    enum RelocType{
        // Intel 80386 specific definitions.
        R_386_NONE         =0,  
        R_386_32           =1,  
        R_386_PC32         =2,  
        R_386_GOT32        =3,  
        R_386_PLT32        =4,  
        R_386_COPY         =5,  
        R_386_GLOB_DAT     =6,  
        R_386_JMP_SLOT     =7,  
        R_386_RELATIVE     =8,  
        R_386_GOTOFF       =9,  
        R_386_GOTPC        =10, 
        R_386_32PLT        =11,
        R_386_TLS_TPOFF    =14, 
        R_386_TLS_IE       =15, 
        R_386_TLS_GOTIE    =16, 
        R_386_TLS_LE       =17, 
        R_386_TLS_GD       =18, 
        R_386_TLS_LDM      =19, 
        R_386_16           =20,
        R_386_PC16         =21,
        R_386_8            =22,
        R_386_PC8          =23,
        R_386_TLS_GD_32    =24, 
        R_386_TLS_GD_PUSH  =25, 
        R_386_TLS_GD_CALL  =26, 
        R_386_TLS_GD_POP   =27, 
        R_386_TLS_LDM_32   =28, 
        R_386_TLS_LDM_PUSH =29, 
        R_386_TLS_LDM_CALL =30, 
        R_386_TLS_LDM_POP  =31, 
        R_386_TLS_LDO_32   =32, 
        R_386_TLS_IE_32    =33, 
        R_386_TLS_LE_32    =34, 
        R_386_TLS_DTPMOD32 =35, 
        R_386_TLS_DTPOFF32 =36, 
        R_386_TLS_TPOFF32  =37, 
        // First Entry for X86-64
        R_X86_64_NONE     =100, 
        R_X86_64_64       =101, 
        R_X86_64_PC32     =102, 
        R_X86_64_GOT32    =103, 
        R_X86_64_PLT32    =104, 
        R_X86_64_COPY     =105, 
        R_X86_64_GLOB_DAT =106, 
        R_X86_64_JUMP_SLOT=107, 
        R_X86_64_RELATIVE =108, 
        R_X86_64_GOTPCREL =109, 
        R_X86_64_32       =110, 
        R_X86_64_32S      =111, 
        R_X86_64_16       =112, 
        R_X86_64_PC16     =113, 
        R_X86_64_8        =114, 
        R_X86_64_PC8      =115, 
        R_X86_64_DTPMOD64 =116, 
        R_X86_64_DTPOFF64 =117, 
        R_X86_64_TPOFF64  =118, 
        R_X86_64_TLSGD    =119, 
        R_X86_64_TLSLD    =120, 
        R_X86_64_DTPOFF32 =121, 
        R_X86_64_GOTTPOFF =122, 
        R_X86_64_TPOFF32  =123  
    };
    enum RelocType {…};
 
#ifdef _MSC_VER
# pragma pack (1)
#endif
 
    struct Elf32RelaEntry_disk {
        uint32_t        r_offset;
        uint32_t        r_info;
        uint32_t        r_addend;
    }
    struct Elf32RelaEntry_disk {…};
#if !defined(SWIG) && !defined(_MSC_VER)
    __attribute__((packed))
#endif
    ;
 
    struct Elf64RelaEntry_disk {
        uint64_t        r_offset;
        uint64_t        r_info;
        uint64_t        r_addend;
    }
    struct Elf64RelaEntry_disk {…};
#if !defined(SWIG) && !defined(_MSC_VER)
    __attribute__((packed))
#endif
    ;
 
    struct Elf32RelEntry_disk {
        uint32_t        r_offset;
        uint32_t        r_info;
    }
    struct Elf32RelEntry_disk {…};
#if !defined(SWIG) && !defined(_MSC_VER)
    __attribute__((packed))
#endif
    ;
 
    struct Elf64RelEntry_disk {
        uint64_t        r_offset;
        uint64_t        r_info;
    }
    struct Elf64RelEntry_disk {…};
#if !defined(SWIG) && !defined(_MSC_VER)
    __attribute__((packed))
#endif
    ;
 
#ifdef _MSC_VER
# pragma pack ()
#endif
 
    // Properties
public:
public:
    Rose::BinaryAnalysis::Address const& get_r_offset() const;
    void set_r_offset(Rose::BinaryAnalysis::Address const&);
public:
    Rose::BinaryAnalysis::Address const& get_r_addend() const;
    void set_r_addend(Rose::BinaryAnalysis::Address const&);
public:
    unsigned long const& get_sym() const;
    void set_sym(unsigned long const&);
public:
    SgAsmElfRelocEntry::RelocType const& get_type() const;
    void set_type(SgAsmElfRelocEntry::RelocType const&);
public:
    SgUnsignedCharList const& get_extra() const;
    SgUnsignedCharList& get_extra();
    void set_extra(SgUnsignedCharList const&);
    // Functions
public:
    SgAsmElfRelocEntry(SgAsmElfRelocSection*);
 
    void parse(Rose::BinaryAnalysis::ByteOrder::Endianness sex, const SgAsmElfRelocEntry::Elf32RelaEntry_disk *disk);
    void parse(Rose::BinaryAnalysis::ByteOrder::Endianness sex, const SgAsmElfRelocEntry::Elf64RelaEntry_disk *disk);
    void parse(Rose::BinaryAnalysis::ByteOrder::Endianness sex, const SgAsmElfRelocEntry::Elf32RelEntry_disk *disk);
    void parse(Rose::BinaryAnalysis::ByteOrder::Endianness sex, const SgAsmElfRelocEntry::Elf64RelEntry_disk *disk);
    void *encode(Rose::BinaryAnalysis::ByteOrder::Endianness, SgAsmElfRelocEntry::Elf32RelaEntry_disk*) const;
    void *encode(Rose::BinaryAnalysis::ByteOrder::Endianness, SgAsmElfRelocEntry::Elf64RelaEntry_disk*) const;
    void *encode(Rose::BinaryAnalysis::ByteOrder::Endianness, SgAsmElfRelocEntry::Elf32RelEntry_disk*) const;
    void *encode(Rose::BinaryAnalysis::ByteOrder::Endianness, SgAsmElfRelocEntry::Elf64RelEntry_disk*) const;
    void dump(FILE *f, const char *prefix, ssize_t idx, SgAsmElfSymbolSection *symtab) const;
    virtual void dump(FILE *f, const char *prefix, ssize_t idx) const {
        dump(f, prefix, idx, NULL);
    }
    virtual void dump(FILE *f, const char *prefix, ssize_t idx) const  {…}
    std::string toString() const;
 
    // Deprecated 2023-11
public:
    std::string reloc_name() const ROSE_DEPRECATED("use toString");
public:
    virtual ~SgAsmElfRelocEntry();
 
public:
    SgAsmElfRelocEntry();
 
protected:
    void initializeProperties();
#endif // SgAsmElfRelocEntry_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmElfRelocEntry: public SgAsmExecutableFileFormat {…};
#endif // DOCUMENTATION
 
 
// SgAsmElfNoteSection           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmElfNoteSection);
IS_SERIALIZABLE(AsmElfNoteSection);
 
#ifndef DOCUMENTATION
AsmElfNoteSection.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmElfNoteSection);
#if defined(SgAsmElfNoteSection_HEADERS) || defined(DOCUMENTATION)
#ifdef ROSE_SgAsmElfNoteSection_IMPL
#include <SgAsmElfNoteEntryList.h>
#endif
#endif // SgAsmElfNoteSection_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmElfNoteSection: public SgAsmElfSection {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfNoteSection.setDataPrototype(
        "SgAsmElfNoteEntryList*", "entries", "= createAndParent<SgAsmElfNoteEntryList>(this)",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmElfNoteSection);
#if defined(SgAsmElfNoteSection_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmElfNoteSection -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmElfNoteSection");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmElfSection);
        s & BOOST_SERIALIZATION_NVP(p_entries);
        debugSerializationEnd("SgAsmElfNoteSection");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgAsmElfNoteEntryList* const& get_entries() const;
    void set_entries(SgAsmElfNoteEntryList* const&);
public:
    explicit SgAsmElfNoteSection(SgAsmElfFileHeader*);
 
    virtual SgAsmElfNoteSection *parse() override;
 
    virtual bool reallocate() override;
 
    virtual void unparse(std::ostream&) const override;
 
    virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
public:
    virtual ~SgAsmElfNoteSection();
 
public:
    SgAsmElfNoteSection();
 
protected:
    void initializeProperties();
#endif // SgAsmElfNoteSection_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmElfNoteSection: public SgAsmElfSection {…};
#endif // DOCUMENTATION
 
 
// SgAsmElfNoteEntryList           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmElfNoteEntryList);
IS_SERIALIZABLE(AsmElfNoteEntryList);
 
#ifndef DOCUMENTATION
AsmElfNoteEntryList.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmElfNoteEntryList);
#if defined(SgAsmElfNoteEntryList_HEADERS) || defined(DOCUMENTATION)
#include <sageContainer.h>
#endif // SgAsmElfNoteEntryList_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmElfNoteEntryList: public SgAsmExecutableFileFormat {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfNoteEntryList.setDataPrototype(
        "SgAsmElfNoteEntryPtrList", "entries", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmElfNoteEntryList);
#if defined(SgAsmElfNoteEntryList_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmElfNoteEntryList -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmElfNoteEntryList");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
        s & BOOST_SERIALIZATION_NVP(p_entries);
        debugSerializationEnd("SgAsmElfNoteEntryList");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgAsmElfNoteEntryPtrList const& get_entries() const;
    SgAsmElfNoteEntryPtrList& get_entries();
    void set_entries(SgAsmElfNoteEntryPtrList const&);
public:
    virtual ~SgAsmElfNoteEntryList();
 
public:
    SgAsmElfNoteEntryList();
 
protected:
    void initializeProperties();
#endif // SgAsmElfNoteEntryList_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmElfNoteEntryList: public SgAsmExecutableFileFormat {…};
#endif // DOCUMENTATION
 
 
// SgAsmElfNoteEntry           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmElfNoteEntry);
IS_SERIALIZABLE(AsmElfNoteEntry);
 
#ifndef DOCUMENTATION
AsmElfNoteEntry.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmElfNoteEntry);
#if defined(SgAsmElfNoteEntry_HEADERS) || defined(DOCUMENTATION)
#include <Rose/BinaryAnalysis/Address.h>
 
#include <sageContainer.h>
 
#ifdef ROSE_SgAsmElfNoteEntry_IMPL
#include <SgAsmBasicString.h>
#endif
#endif // SgAsmElfNoteEntry_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmElfNoteEntry: public SgAsmExecutableFileFormat {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfNoteEntry.setDataPrototype(
        "unsigned", "type", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfNoteEntry.setDataPrototype(
        "SgAsmGenericString*", "name", "= createAndParent<SgAsmBasicString>(this)",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfNoteEntry.setDataPrototype(
        "SgUnsignedCharList", "payload", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmElfNoteEntry);
#if defined(SgAsmElfNoteEntry_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmElfNoteEntry -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmElfNoteEntry");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
        s & BOOST_SERIALIZATION_NVP(p_type);
        s & BOOST_SERIALIZATION_NVP(p_name);
        s & BOOST_SERIALIZATION_NVP(p_payload);
        debugSerializationEnd("SgAsmElfNoteEntry");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    unsigned const& get_type() const;
    void set_type(unsigned const&);
public:
public:
    SgUnsignedCharList const& get_payload() const;
    SgUnsignedCharList& get_payload();
    void set_payload(SgUnsignedCharList const&);
public:
    SgAsmElfNoteEntry(SgAsmElfNoteSection*);
 
    SgAsmGenericString *get_name() const;
    void set_name(SgAsmGenericString *name);
    Rose::BinaryAnalysis::Address parse(Rose::BinaryAnalysis::Address starting_offset);
 
    Rose::BinaryAnalysis::Address unparse(std::ostream &f, Rose::BinaryAnalysis::Address starting_offset);
 
    virtual void dump(FILE*, const char *prefix, ssize_t idx) const;
 
    void set_payload(const void*, size_t nbytes);
 
    Rose::BinaryAnalysis::Address calculateSize() const;
 
    // Deprecated 2023-11
public:
    Rose::BinaryAnalysis::Address calculate_size() const ROSE_DEPRECATED("use calculateSize");
public:
    virtual ~SgAsmElfNoteEntry();
 
public:
    SgAsmElfNoteEntry();
 
protected:
    void initializeProperties();
#endif // SgAsmElfNoteEntry_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmElfNoteEntry: public SgAsmExecutableFileFormat {…};
#endif // DOCUMENTATION
 
 
// SgAsmElfFileHeader           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmElfFileHeader);
IS_SERIALIZABLE(AsmElfFileHeader);
 
#ifndef DOCUMENTATION
AsmElfFileHeader.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmElfFileHeader);
#if defined(SgAsmElfFileHeader_HEADERS) || defined(DOCUMENTATION)
#include <Rose/BinaryAnalysis/ByteOrder.h>
#endif // SgAsmElfFileHeader_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmElfFileHeader: public SgAsmGenericHeader {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfFileHeader.setDataPrototype(
        "unsigned char", "e_ident_file_class", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfFileHeader.setDataPrototype(
        "unsigned char", "e_ident_data_encoding", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfFileHeader.setDataPrototype(
        "unsigned char", "e_ident_file_version", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfFileHeader.setDataPrototype(
        "SgUnsignedCharList", "e_ident_padding", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfFileHeader.setDataPrototype(
        "unsigned long", "e_type", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfFileHeader.setDataPrototype(
        "unsigned long", "e_machine", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfFileHeader.setDataPrototype(
        "unsigned long", "e_flags", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfFileHeader.setDataPrototype(
        "unsigned long", "e_ehsize", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfFileHeader.setDataPrototype(
        "unsigned long", "phextrasz", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfFileHeader.setDataPrototype(
        "unsigned long", "e_phnum", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfFileHeader.setDataPrototype(
        "unsigned long", "shextrasz", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfFileHeader.setDataPrototype(
        "unsigned long", "e_shnum", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfFileHeader.setDataPrototype(
        "unsigned long", "e_shstrndx", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfFileHeader.setDataPrototype(
        "SgAsmElfSectionTable*", "sectionTable", "= nullptr",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfFileHeader.setDataPrototype(
        "SgAsmElfSegmentTable*", "segmentTable", "= nullptr",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmElfFileHeader);
#if defined(SgAsmElfFileHeader_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmElfFileHeader -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmElfFileHeader");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmGenericHeader);
        s & BOOST_SERIALIZATION_NVP(p_e_ident_file_class);
        s & BOOST_SERIALIZATION_NVP(p_e_ident_data_encoding);
        s & BOOST_SERIALIZATION_NVP(p_e_ident_file_version);
        s & BOOST_SERIALIZATION_NVP(p_e_ident_padding);
        s & BOOST_SERIALIZATION_NVP(p_e_type);
        s & BOOST_SERIALIZATION_NVP(p_e_machine);
        s & BOOST_SERIALIZATION_NVP(p_e_flags);
        s & BOOST_SERIALIZATION_NVP(p_e_ehsize);
        s & BOOST_SERIALIZATION_NVP(p_phextrasz);
        s & BOOST_SERIALIZATION_NVP(p_e_phnum);
        s & BOOST_SERIALIZATION_NVP(p_shextrasz);
        s & BOOST_SERIALIZATION_NVP(p_e_shnum);
        s & BOOST_SERIALIZATION_NVP(p_e_shstrndx);
        s & BOOST_SERIALIZATION_NVP(p_sectionTable);
        s & BOOST_SERIALIZATION_NVP(p_segmentTable);
        debugSerializationEnd("SgAsmElfFileHeader");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
    // Local types
public:
    enum ObjectType {
        ET_NONE         = 0                         
        ,ET_REL          = 1                        
        ,ET_EXEC         = 2                        
        ,ET_DYN          = 3                        
        ,ET_CORE         = 4                        
        ,ET_LOOS         = 0xfe00                   
        ,ET_HIOS         = 0xfeff                   
        ,ET_LOPROC       = 0xff00                   
        ,ET_HIPROC       = 0xffff                   
    };
    enum ObjectType {…};
 
    // Some structures are used to represent certain things whose layout is very precise in binary files, thus we need to
    // make sure the compiler doesn't insert alignment padding between the struct members.  ROSE can be compiled on an
    // architecture that has different alignment constraints than the architecture that these structs describe. GNU
    // compilers have long used the attribute mechanism. Microsoft compilers on the other hand use pragmas. GCC versions
    // 4.0 and earlier do not recognize the Microsoft pragmas and issue compiler errors when one is encountered.
#ifdef _MSC_VER
# pragma pack (1)
#endif
 
    struct Elf32FileHeader_disk {
        unsigned char       e_ident_magic[4];       
        unsigned char       e_ident_file_class;     
        unsigned char       e_ident_data_encoding;  
        unsigned char       e_ident_file_version;   
        unsigned char       e_ident_padding[9];     
        uint16_t            e_type;                 
        uint16_t            e_machine;              
        uint32_t            e_version;              
        uint32_t            e_entry;                
        uint32_t            e_phoff;                
        uint32_t            e_shoff;                
        uint32_t            e_flags;                
        uint16_t            e_ehsize;               
        uint16_t            e_phentsize;            
        uint16_t            e_phnum;                
        uint16_t            e_shentsize;            
        uint16_t            e_shnum;                
        uint16_t            e_shstrndx;             
    }
    struct Elf32FileHeader_disk {…};
#if !defined(SWIG) && !defined(_MSC_VER)
    __attribute__((packed))
#endif
    ;
 
    struct Elf64FileHeader_disk {
        unsigned char       e_ident_magic[4];
        unsigned char       e_ident_file_class;
        unsigned char       e_ident_data_encoding;
        unsigned char       e_ident_file_version;
        unsigned char       e_ident_padding[9];
        uint16_t            e_type;
        uint16_t            e_machine;
        uint32_t            e_version;
        uint64_t            e_entry;
        uint64_t            e_phoff;
        uint64_t            e_shoff;
        uint32_t            e_flags;
        uint16_t            e_ehsize;
        uint16_t            e_phentsize;
        uint16_t            e_phnum;
        uint16_t            e_shentsize;
        uint16_t            e_shnum;
        uint16_t            e_shstrndx;
    }
    struct Elf64FileHeader_disk {…};
#if !defined(SWIG) && !defined(_MSC_VER)
    __attribute__((packed))
#endif
    ;
 
#ifdef _MSC_VER
# pragma pack ()
#endif
 
    // Properties
public:
public:
    unsigned char const& get_e_ident_file_class() const;
    void set_e_ident_file_class(unsigned char const&);
public:
    unsigned char const& get_e_ident_data_encoding() const;
    void set_e_ident_data_encoding(unsigned char const&);
public:
    unsigned char const& get_e_ident_file_version() const;
    void set_e_ident_file_version(unsigned char const&);
public:
    SgUnsignedCharList const& get_e_ident_padding() const;
    void set_e_ident_padding(SgUnsignedCharList const&);
public:
    unsigned long const& get_e_type() const;
    void set_e_type(unsigned long const&);
public:
    unsigned long const& get_e_machine() const;
    void set_e_machine(unsigned long const&);
public:
    unsigned long const& get_e_flags() const;
    void set_e_flags(unsigned long const&);
public:
    unsigned long const& get_e_ehsize() const;
    void set_e_ehsize(unsigned long const&);
public:
    unsigned long const& get_phextrasz() const;
    void set_phextrasz(unsigned long const&);
public:
    unsigned long const& get_e_phnum() const;
    void set_e_phnum(unsigned long const&);
public:
    unsigned long const& get_shextrasz() const;
    void set_shextrasz(unsigned long const&);
public:
    unsigned long const& get_e_shnum() const;
    void set_e_shnum(unsigned long const&);
public:
    unsigned long const& get_e_shstrndx() const;
    void set_e_shstrndx(unsigned long const&);
public:
    SgAsmElfSectionTable* const& get_sectionTable() const;
    void set_sectionTable(SgAsmElfSectionTable* const&);
public:
    SgAsmElfSegmentTable* const& get_segmentTable() const;
    void set_segmentTable(SgAsmElfSegmentTable* const&);
    // Functions
public:
    explicit SgAsmElfFileHeader(SgAsmGenericFile*);
 
    uint64_t maximumPageSize();
 
    static SgAsmExecutableFileFormat::InsSetArchitecture machineToIsa(unsigned machine);
 
    unsigned isaToMachine(SgAsmExecutableFileFormat::InsSetArchitecture isa) const;
 
    virtual SgAsmElfFileHeader *parse() override;
 
    virtual bool reallocate() override;
 
    virtual void unparse(std::ostream&) const override;
 
    virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
 
    static bool isElf(SgAsmGenericFile*);
 
    SgAsmGenericSectionPtrList get_sectionTableSections();
 
    SgAsmGenericSectionPtrList get_segmentTableSections();
 
    // Overrides documented in base class
    virtual const char *formatName() const override;
 
private:
    void *encode(Rose::BinaryAnalysis::ByteOrder::Endianness, SgAsmElfFileHeader::Elf32FileHeader_disk*) const;
    void *encode(Rose::BinaryAnalysis::ByteOrder::Endianness, SgAsmElfFileHeader::Elf64FileHeader_disk*) const;
 
    // Deprecated 2023-11
public:
    SgAsmElfSectionTable* get_section_table() const ROSE_DEPRECATED("use get_sectionTable");
    void set_section_table(SgAsmElfSectionTable*) ROSE_DEPRECATED("use set_sectionTable");
    SgAsmElfSegmentTable* get_segment_table() const ROSE_DEPRECATED("use get_segmentTable");
    void set_segment_table(SgAsmElfSegmentTable*) ROSE_DEPRECATED("use set_segmentTable");
    uint64_t max_page_size() ROSE_DEPRECATED("use maximumPageSize");
    static SgAsmExecutableFileFormat::InsSetArchitecture machine_to_isa(unsigned) ROSE_DEPRECATED("use machineToIsa");
    unsigned isa_to_machine(SgAsmExecutableFileFormat::InsSetArchitecture) const ROSE_DEPRECATED("use isaToMachine");
    static bool is_ELF(SgAsmGenericFile*) ROSE_DEPRECATED("use isElf");
    SgAsmGenericSectionPtrList get_sectab_sections() ROSE_DEPRECATED("use get_sectionTableSections");
    SgAsmGenericSectionPtrList get_segtab_sections() ROSE_DEPRECATED("use get_segmentTableSections");
    virtual const char *format_name() const override ROSE_DEPRECATED("use formatName");
public:
    virtual ~SgAsmElfFileHeader();
 
public:
    SgAsmElfFileHeader();
 
protected:
    void initializeProperties();
#endif // SgAsmElfFileHeader_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmElfFileHeader: public SgAsmGenericHeader {…};
#endif // DOCUMENTATION
 
 
// SgAsmElfEHFrameSection           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmElfEHFrameSection);
IS_SERIALIZABLE(AsmElfEHFrameSection);
 
#ifndef DOCUMENTATION
AsmElfEHFrameSection.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmElfEHFrameSection);
#if defined(SgAsmElfEHFrameSection_HEADERS) || defined(DOCUMENTATION)
#include <Rose/BinaryAnalysis/Address.h>
 
#ifdef ROSE_SgAsmElfEHFrameSection_IMPL
#include <SgAsmElfEHFrameEntryCIList.h>
#endif
#endif // SgAsmElfEHFrameSection_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmElfEHFrameSection: public SgAsmElfSection {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfEHFrameSection.setDataPrototype(
        "SgAsmElfEHFrameEntryCIList*", "ci_entries", "= createAndParent<SgAsmElfEHFrameEntryCIList>(this)",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmElfEHFrameSection);
#if defined(SgAsmElfEHFrameSection_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmElfEHFrameSection -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmElfEHFrameSection");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmElfSection);
        s & BOOST_SERIALIZATION_NVP(p_ci_entries);
        debugSerializationEnd("SgAsmElfEHFrameSection");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgAsmElfEHFrameEntryCIList* const& get_ci_entries() const;
    void set_ci_entries(SgAsmElfEHFrameEntryCIList* const&);
public:
    explicit SgAsmElfEHFrameSection(SgAsmElfFileHeader*);
 
    virtual SgAsmElfEHFrameSection *parse() override;
 
    virtual Rose::BinaryAnalysis::Address
    calculateSizes(size_t *total, size_t *required, size_t *optional, size_t *entcount) const override;
 
    virtual void unparse(std::ostream&) const override;
 
    Rose::BinaryAnalysis::Address unparse(std::ostream*) const;
 
    virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
 
    // Deprecated 2023-11
public:
    virtual Rose::BinaryAnalysis::Address calculate_sizes(size_t*, size_t*, size_t*, size_t*) const override
        ROSE_DEPRECATED("use calculateSizes");
public:
    virtual ~SgAsmElfEHFrameSection();
 
public:
    SgAsmElfEHFrameSection();
 
protected:
    void initializeProperties();
#endif // SgAsmElfEHFrameSection_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmElfEHFrameSection: public SgAsmElfSection {…};
#endif // DOCUMENTATION
 
 
// SgAsmElfEHFrameEntryFDList           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmElfEHFrameEntryFDList);
IS_SERIALIZABLE(AsmElfEHFrameEntryFDList);
 
#ifndef DOCUMENTATION
AsmElfEHFrameEntryFDList.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmElfEHFrameEntryFDList);
#if defined(SgAsmElfEHFrameEntryFDList_HEADERS) || defined(DOCUMENTATION)
#include <sageContainer.h>
#endif // SgAsmElfEHFrameEntryFDList_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmElfEHFrameEntryFDList: public SgAsmExecutableFileFormat {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfEHFrameEntryFDList.setDataPrototype(
        "SgAsmElfEHFrameEntryFDPtrList", "entries", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmElfEHFrameEntryFDList);
#if defined(SgAsmElfEHFrameEntryFDList_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmElfEHFrameEntryFDList -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmElfEHFrameEntryFDList");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
        s & BOOST_SERIALIZATION_NVP(p_entries);
        debugSerializationEnd("SgAsmElfEHFrameEntryFDList");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgAsmElfEHFrameEntryFDPtrList const& get_entries() const;
    SgAsmElfEHFrameEntryFDPtrList& get_entries();
    void set_entries(SgAsmElfEHFrameEntryFDPtrList const&);
public:
    virtual ~SgAsmElfEHFrameEntryFDList();
 
public:
    SgAsmElfEHFrameEntryFDList();
 
protected:
    void initializeProperties();
#endif // SgAsmElfEHFrameEntryFDList_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmElfEHFrameEntryFDList: public SgAsmExecutableFileFormat {…};
#endif // DOCUMENTATION
 
 
// SgAsmElfEHFrameEntryFD           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmElfEHFrameEntryFD);
IS_SERIALIZABLE(AsmElfEHFrameEntryFD);
 
#ifndef DOCUMENTATION
AsmElfEHFrameEntryFD.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmElfEHFrameEntryFD);
#if defined(SgAsmElfEHFrameEntryFD_HEADERS) || defined(DOCUMENTATION)
#include <Rose/BinaryAnalysis/Address.h>
#include <Rose/BinaryAnalysis/RelativeVirtualAddress.h>
#include <sageContainer.h>
#endif // SgAsmElfEHFrameEntryFD_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmElfEHFrameEntryFD: public SgAsmExecutableFileFormat {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfEHFrameEntryFD.setDataPrototype(
        "Rose::BinaryAnalysis::RelativeVirtualAddress", "begin_rva", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfEHFrameEntryFD.setDataPrototype(
        "Rose::BinaryAnalysis::Address", "size", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfEHFrameEntryFD.setDataPrototype(
        "SgUnsignedCharList", "augmentation_data", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfEHFrameEntryFD.setDataPrototype(
        "SgUnsignedCharList", "instructions", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmElfEHFrameEntryFD);
#if defined(SgAsmElfEHFrameEntryFD_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmElfEHFrameEntryFD -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmElfEHFrameEntryFD");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
        s & BOOST_SERIALIZATION_NVP(p_begin_rva);
        s & BOOST_SERIALIZATION_NVP(p_size);
        s & BOOST_SERIALIZATION_NVP(p_augmentation_data);
        s & BOOST_SERIALIZATION_NVP(p_instructions);
        debugSerializationEnd("SgAsmElfEHFrameEntryFD");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    Rose::BinaryAnalysis::RelativeVirtualAddress const& get_begin_rva() const;
    Rose::BinaryAnalysis::RelativeVirtualAddress& get_begin_rva();
    void set_begin_rva(Rose::BinaryAnalysis::RelativeVirtualAddress const&);
public:
    Rose::BinaryAnalysis::Address const& get_size() const;
    void set_size(Rose::BinaryAnalysis::Address const&);
public:
    SgUnsignedCharList const& get_augmentation_data() const;
    SgUnsignedCharList& get_augmentation_data();
    void set_augmentation_data(SgUnsignedCharList const&);
public:
    SgUnsignedCharList const& get_instructions() const;
    SgUnsignedCharList& get_instructions();
    void set_instructions(SgUnsignedCharList const&);
public:
    explicit SgAsmElfEHFrameEntryFD(SgAsmElfEHFrameEntryCI*);
 
    virtual void dump(FILE*, const char *prefix, ssize_t idx) const;
 
    std::string unparse(const SgAsmElfEHFrameSection*, SgAsmElfEHFrameEntryCI*) const;
public:
    virtual ~SgAsmElfEHFrameEntryFD();
 
public:
    SgAsmElfEHFrameEntryFD();
 
protected:
    void initializeProperties();
#endif // SgAsmElfEHFrameEntryFD_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmElfEHFrameEntryFD: public SgAsmExecutableFileFormat {…};
#endif // DOCUMENTATION
 
 
// SgAsmElfEHFrameEntryCIList           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmElfEHFrameEntryCIList);
IS_SERIALIZABLE(AsmElfEHFrameEntryCIList);
 
#ifndef DOCUMENTATION
AsmElfEHFrameEntryCIList.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmElfEHFrameEntryCIList);
#if defined(SgAsmElfEHFrameEntryCIList_HEADERS) || defined(DOCUMENTATION)
#include <sageContainer.h>
#endif // SgAsmElfEHFrameEntryCIList_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmElfEHFrameEntryCIList: public SgAsmExecutableFileFormat {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfEHFrameEntryCIList.setDataPrototype(
        "SgAsmElfEHFrameEntryCIPtrList", "entries", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmElfEHFrameEntryCIList);
#if defined(SgAsmElfEHFrameEntryCIList_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmElfEHFrameEntryCIList -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmElfEHFrameEntryCIList");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
        s & BOOST_SERIALIZATION_NVP(p_entries);
        debugSerializationEnd("SgAsmElfEHFrameEntryCIList");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgAsmElfEHFrameEntryCIPtrList const& get_entries() const;
    SgAsmElfEHFrameEntryCIPtrList& get_entries();
    void set_entries(SgAsmElfEHFrameEntryCIPtrList const&);
public:
    virtual ~SgAsmElfEHFrameEntryCIList();
 
public:
    SgAsmElfEHFrameEntryCIList();
 
protected:
    void initializeProperties();
#endif // SgAsmElfEHFrameEntryCIList_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmElfEHFrameEntryCIList: public SgAsmExecutableFileFormat {…};
#endif // DOCUMENTATION
 
 
// SgAsmElfEHFrameEntryCI           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmElfEHFrameEntryCI);
IS_SERIALIZABLE(AsmElfEHFrameEntryCI);
 
#ifndef DOCUMENTATION
AsmElfEHFrameEntryCI.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmElfEHFrameEntryCI);
#if defined(SgAsmElfEHFrameEntryCI_HEADERS) || defined(DOCUMENTATION)
#include <Rose/BinaryAnalysis/Address.h>
 
#include <sageContainer.h>
 
#ifdef ROSE_SgAsmElfEHFrameEntryCI_IMPL
#include <SgAsmElfEHFrameEntryFDList.h>
#endif
#endif // SgAsmElfEHFrameEntryCI_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmElfEHFrameEntryCI: public SgAsmExecutableFileFormat {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfEHFrameEntryCI.setDataPrototype(
        "int", "version", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfEHFrameEntryCI.setDataPrototype(
        "std::string", "augmentation_string", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfEHFrameEntryCI.setDataPrototype(
        "uint64_t", "eh_data", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfEHFrameEntryCI.setDataPrototype(
        "uint64_t", "code_alignment_factor", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfEHFrameEntryCI.setDataPrototype(
        "int64_t", "data_alignment_factor", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfEHFrameEntryCI.setDataPrototype(
        "uint64_t", "augmentation_data_length", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfEHFrameEntryCI.setDataPrototype(
        "int", "lsda_encoding", "= -1",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfEHFrameEntryCI.setDataPrototype(
        "int", "prh_encoding", "= -1",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfEHFrameEntryCI.setDataPrototype(
        "unsigned", "prh_arg", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfEHFrameEntryCI.setDataPrototype(
        "Rose::BinaryAnalysis::Address", "prh_addr", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfEHFrameEntryCI.setDataPrototype(
        "int", "addr_encoding", "= -1",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfEHFrameEntryCI.setDataPrototype(
        "bool", "sig_frame", "= false",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfEHFrameEntryCI.setDataPrototype(
        "SgUnsignedCharList", "instructions", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfEHFrameEntryCI.setDataPrototype(
        "SgAsmElfEHFrameEntryFDList*", "fd_entries", "= createAndParent<SgAsmElfEHFrameEntryFDList>(this)",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmElfEHFrameEntryCI);
#if defined(SgAsmElfEHFrameEntryCI_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmElfEHFrameEntryCI -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmElfEHFrameEntryCI");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
        s & BOOST_SERIALIZATION_NVP(p_version);
        s & BOOST_SERIALIZATION_NVP(p_augmentation_string);
        s & BOOST_SERIALIZATION_NVP(p_eh_data);
        s & BOOST_SERIALIZATION_NVP(p_code_alignment_factor);
        s & BOOST_SERIALIZATION_NVP(p_data_alignment_factor);
        s & BOOST_SERIALIZATION_NVP(p_augmentation_data_length);
        s & BOOST_SERIALIZATION_NVP(p_lsda_encoding);
        s & BOOST_SERIALIZATION_NVP(p_prh_encoding);
        s & BOOST_SERIALIZATION_NVP(p_prh_arg);
        s & BOOST_SERIALIZATION_NVP(p_prh_addr);
        s & BOOST_SERIALIZATION_NVP(p_addr_encoding);
        s & BOOST_SERIALIZATION_NVP(p_sig_frame);
        s & BOOST_SERIALIZATION_NVP(p_instructions);
        s & BOOST_SERIALIZATION_NVP(p_fd_entries);
        debugSerializationEnd("SgAsmElfEHFrameEntryCI");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    int const& get_version() const;
    void set_version(int const&);
public:
    std::string const& get_augmentation_string() const;
    void set_augmentation_string(std::string const&);
public:
    uint64_t const& get_eh_data() const;
    void set_eh_data(uint64_t const&);
public:
    uint64_t const& get_code_alignment_factor() const;
    void set_code_alignment_factor(uint64_t const&);
public:
    int64_t const& get_data_alignment_factor() const;
    void set_data_alignment_factor(int64_t const&);
public:
    uint64_t const& get_augmentation_data_length() const;
    void set_augmentation_data_length(uint64_t const&);
public:
    int const& get_lsda_encoding() const;
    void set_lsda_encoding(int const&);
public:
    int const& get_prh_encoding() const;
    void set_prh_encoding(int const&);
public:
    unsigned const& get_prh_arg() const;
    void set_prh_arg(unsigned const&);
public:
    Rose::BinaryAnalysis::Address const& get_prh_addr() const;
    void set_prh_addr(Rose::BinaryAnalysis::Address const&);
public:
    int const& get_addr_encoding() const;
    void set_addr_encoding(int const&);
public:
    bool const& get_sig_frame() const;
    void set_sig_frame(bool const&);
public:
    SgUnsignedCharList const& get_instructions() const;
    SgUnsignedCharList& get_instructions();
    void set_instructions(SgUnsignedCharList const&);
public:
    SgAsmElfEHFrameEntryFDList* const& get_fd_entries() const;
    void set_fd_entries(SgAsmElfEHFrameEntryFDList* const&);
public:
    explicit SgAsmElfEHFrameEntryCI(SgAsmElfEHFrameSection *ehframe);
 
    virtual void dump(FILE*, const char *prefix, ssize_t idx) const;
 
    std::string unparse(const SgAsmElfEHFrameSection*) const;
public:
    virtual ~SgAsmElfEHFrameEntryCI();
 
public:
    SgAsmElfEHFrameEntryCI();
 
protected:
    void initializeProperties();
#endif // SgAsmElfEHFrameEntryCI_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmElfEHFrameEntryCI: public SgAsmExecutableFileFormat {…};
#endif // DOCUMENTATION
 
 
// SgAsmElfDynamicSection           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmElfDynamicSection);
IS_SERIALIZABLE(AsmElfDynamicSection);
 
#ifndef DOCUMENTATION
AsmElfDynamicSection.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmElfDynamicSection);
#if defined(SgAsmElfDynamicSection_HEADERS) || defined(DOCUMENTATION)
#include <Rose/BinaryAnalysis/Address.h>
 
#ifdef ROSE_SgAsmElfDynamicSection_IMPL
#include <SgAsmElfDynamicEntryList.h>
#endif
#endif // SgAsmElfDynamicSection_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmElfDynamicSection: public SgAsmElfSection {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfDynamicSection.setDataPrototype(
        "SgAsmElfDynamicEntryList*", "entries", "= createAndParent<SgAsmElfDynamicEntryList>(this)",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmElfDynamicSection);
#if defined(SgAsmElfDynamicSection_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmElfDynamicSection -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmElfDynamicSection");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmElfSection);
        s & BOOST_SERIALIZATION_NVP(p_entries);
        debugSerializationEnd("SgAsmElfDynamicSection");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgAsmElfDynamicEntryList* const& get_entries() const;
    void set_entries(SgAsmElfDynamicEntryList* const&);
public:
    SgAsmElfDynamicSection(SgAsmElfFileHeader *fhdr, SgAsmElfStringSection *strsec);
 
    virtual SgAsmElfDynamicSection* parse() override;
 
    virtual void finishParsing() override;
 
    using SgAsmElfSection::calculateSizes;
    virtual Rose::BinaryAnalysis::Address
    calculateSizes(size_t *total, size_t *required, size_t *optional, size_t *entcount) const override;
 
    virtual bool reallocate() override;
 
    virtual void unparse(std::ostream&) const override;
 
    virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
 
    // Deprecated 2023-11
public:
    virtual void finish_parsing() override ROSE_DEPRECATED("use finishParsing") ROSE_DEPRECATED("use finishParsing");
    using SgAsmElfSection::calculate_sizes;
    virtual Rose::BinaryAnalysis::Address calculate_sizes(size_t*, size_t*, size_t*, size_t*) const override
        ROSE_DEPRECATED("use calculateSizes");
public:
    virtual ~SgAsmElfDynamicSection();
 
public:
    SgAsmElfDynamicSection();
 
protected:
    void initializeProperties();
#endif // SgAsmElfDynamicSection_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmElfDynamicSection: public SgAsmElfSection {…};
#endif // DOCUMENTATION
 
 
// SgAsmElfSection           -- MACHINE GENERATED; DO NOT MODIFY --
 
#ifndef DOCUMENTATION
AstNodeClass& AsmElfSection = nonTerminalConstructor(
    "AsmElfSection",
    *this,
    "AsmElfSection",
    "AsmElfSectionTag",
    SubclassListBuilder()
        | AsmElfDynamicSection
        | AsmElfEHFrameSection
        | AsmElfNoteSection
        | AsmElfRelocSection
        | AsmElfStringSection
        | AsmElfSymbolSection
        | AsmElfSymverDefinedSection
        | AsmElfSymverNeededSection
        | AsmElfSymverSection
    , true);
assert(AsmElfSection.associatedGrammar != nullptr);
AsmElfSection.setCppCondition("!defined(DOCUMENTATION)");
AsmElfSection.isBoostSerializable(true);
AsmElfSection.setAutomaticGenerationOfConstructor(false);
AsmElfSection.setAutomaticGenerationOfDestructor(false);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
AsmElfSection.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmElfSection);
#if defined(SgAsmElfSection_HEADERS) || defined(DOCUMENTATION)
#include <Rose/BinaryAnalysis/Address.h>
 
#ifdef ROSE_SgAsmElfSection_IMPL
#include <SgAsmElfSectionTableEntry.h>
#include <SgAsmElfSegmentTableEntry.h>
#endif
#endif // SgAsmElfSection_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmElfSection: public SgAsmGenericSection {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfSection.setDataPrototype(
        "SgAsmElfSection*", "linkedSection", "= nullptr",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfSection.setDataPrototype(
        "SgAsmElfSectionTableEntry*", "sectionEntry", "= nullptr",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfSection.setDataPrototype(
        "SgAsmElfSegmentTableEntry*", "segmentEntry", "= nullptr",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmElfSection);
#if defined(SgAsmElfSection_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmElfSection -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmElfSection");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmGenericSection);
        s & BOOST_SERIALIZATION_NVP(p_linkedSection);
        s & BOOST_SERIALIZATION_NVP(p_sectionEntry);
        s & BOOST_SERIALIZATION_NVP(p_segmentEntry);
        debugSerializationEnd("SgAsmElfSection");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgAsmElfSection* const& get_linkedSection() const;
    virtual void set_linkedSection(SgAsmElfSection*);
public:
    SgAsmElfSectionTableEntry* const& get_sectionEntry() const;
    void set_sectionEntry(SgAsmElfSectionTableEntry* const&);
public:
    SgAsmElfSegmentTableEntry* const& get_segmentEntry() const;
    void set_segmentEntry(SgAsmElfSegmentTableEntry* const&);
public:
    explicit SgAsmElfSection(SgAsmGenericHeader*);
 
    SgAsmElfSection *initFromSectionTable(SgAsmElfSectionTableEntry*, SgAsmElfStringSection*, int id);
 
    SgAsmElfSection *initFromSegmentTable(SgAsmElfSegmentTableEntry*, bool mmapOnly=false);
 
    Rose::BinaryAnalysis::Address calculateSizes(size_t r32size, size_t r64size, const std::vector<size_t> &optsizes,
                                           size_t *entsize, size_t *required, size_t *optional, size_t *entcount) const;
 
    virtual void finishParsing();
 
    virtual Rose::BinaryAnalysis::Address
    calculateSizes(size_t *entsize, size_t *required, size_t *optional, size_t *entcount) const;
 
    virtual bool reallocate() override;
 
    virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
 
    void allocateNameToStorage(SgAsmElfStringSection*);
 
    SgAsmElfFileHeader *get_elfHeader() const;
 
    // Deprecated 2023-11
public:
    SgAsmElfSection* get_linked_section() const ROSE_DEPRECATED("use get_linkedSection");
    virtual void set_linked_section(SgAsmElfSection*) ROSE_DEPRECATED("use set_linkSection");
    SgAsmElfSectionTableEntry* get_section_entry() const ROSE_DEPRECATED("use get_sectionEntry");
    void set_section_entry(SgAsmElfSectionTableEntry*) ROSE_DEPRECATED("use set_sectionEntry");
    SgAsmElfSegmentTableEntry* get_segment_entry() const ROSE_DEPRECATED("use get_segmentEntry");
    void set_segment_entry(SgAsmElfSegmentTableEntry*) ROSE_DEPRECATED("use set_segmentEntry");
    SgAsmElfSection *init_from_section_table(SgAsmElfSectionTableEntry*, SgAsmElfStringSection*, int)
        ROSE_DEPRECATED("use initFromSectionTable");
    SgAsmElfSection *init_from_segment_table(SgAsmElfSegmentTableEntry*, bool mmap_only=false)
        ROSE_DEPRECATED("use initFromSegmentTable");
    Rose::BinaryAnalysis::Address
    calculate_sizes(size_t, size_t, const std::vector<size_t>&, size_t*, size_t*, size_t*, size_t*) const
        ROSE_DEPRECATED("use calculateSizes");
    virtual void finish_parsing() ROSE_DEPRECATED("use finishParsing");
    virtual Rose::BinaryAnalysis::Address
    calculate_sizes(size_t*, size_t*, size_t*, size_t*) const ROSE_DEPRECATED("use calculateSizes");
    void allocate_name_to_storage(SgAsmElfStringSection*) ROSE_DEPRECATED("use allocateNameToStorage");
    SgAsmElfFileHeader *get_elf_header() const ROSE_DEPRECATED("use get_elfHeader");
public:
    virtual ~SgAsmElfSection();
 
public:
    SgAsmElfSection();
 
protected:
    void initializeProperties();
#endif // SgAsmElfSection_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmElfSection: public SgAsmGenericSection {…};
#endif // DOCUMENTATION
 
 
// SgAsmElfDynamicEntryList           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmElfDynamicEntryList);
IS_SERIALIZABLE(AsmElfDynamicEntryList);
 
#ifndef DOCUMENTATION
AsmElfDynamicEntryList.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmElfDynamicEntryList);
#if defined(SgAsmElfDynamicEntryList_HEADERS) || defined(DOCUMENTATION)
#include <sageContainer.h>
#endif // SgAsmElfDynamicEntryList_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmElfDynamicEntryList: public SgAsmExecutableFileFormat {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfDynamicEntryList.setDataPrototype(
        "SgAsmElfDynamicEntryPtrList", "entries", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmElfDynamicEntryList);
#if defined(SgAsmElfDynamicEntryList_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmElfDynamicEntryList -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmElfDynamicEntryList");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
        s & BOOST_SERIALIZATION_NVP(p_entries);
        debugSerializationEnd("SgAsmElfDynamicEntryList");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgAsmElfDynamicEntryPtrList const& get_entries() const;
    SgAsmElfDynamicEntryPtrList& get_entries();
    void set_entries(SgAsmElfDynamicEntryPtrList const&);
public:
    virtual ~SgAsmElfDynamicEntryList();
 
public:
    SgAsmElfDynamicEntryList();
 
protected:
    void initializeProperties();
#endif // SgAsmElfDynamicEntryList_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmElfDynamicEntryList: public SgAsmExecutableFileFormat {…};
#endif // DOCUMENTATION
 
 
// SgAsmElfDynamicEntry           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmElfDynamicEntry);
IS_SERIALIZABLE(AsmElfDynamicEntry);
 
#ifndef DOCUMENTATION
AsmElfDynamicEntry.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmElfDynamicEntry);
#if defined(SgAsmElfDynamicEntry_HEADERS) || defined(DOCUMENTATION)
#include <Rose/BinaryAnalysis/ByteOrder.h>
#include <Rose/BinaryAnalysis/RelativeVirtualAddress.h>
#include <sageContainer.h>
#endif // SgAsmElfDynamicEntry_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmElfDynamicEntry: public SgAsmExecutableFileFormat {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfDynamicEntry.setDataPrototype(
        "SgAsmElfDynamicEntry::EntryType", "d_tag", "= SgAsmElfDynamicEntry::DT_NULL",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfDynamicEntry.setDataPrototype(
        "Rose::BinaryAnalysis::RelativeVirtualAddress", "d_val", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfDynamicEntry.setDataPrototype(
        "SgAsmGenericString*", "name", "= nullptr",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmElfDynamicEntry.setDataPrototype(
        "SgUnsignedCharList", "extra", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmElfDynamicEntry);
#if defined(SgAsmElfDynamicEntry_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmElfDynamicEntry -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmElfDynamicEntry");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
        s & BOOST_SERIALIZATION_NVP(p_d_tag);
        s & BOOST_SERIALIZATION_NVP(p_d_val);
        s & BOOST_SERIALIZATION_NVP(p_name);
        s & BOOST_SERIALIZATION_NVP(p_extra);
        debugSerializationEnd("SgAsmElfDynamicEntry");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
    // Local types
public:
    enum EntryType {                /* Type    Executable SharedObj Purpose */
        DT_NULL     = 0,        /* ignored mandatory  mandatory Marks end of dynamic array */
        DT_NEEDED   = 1,        /* value   optional   optional  Name of needed library */
        DT_PLTRELSZ = 2,        /* value   optional   optional  Size of reloc entries associated with PLT */
        DT_PLTGOT   = 3,        /* pointer optional   optional  PLT and/or GOT */
        DT_HASH     = 4,        /* pointer mandatory  mandatory Symbol hash table */
        DT_STRTAB   = 5,        /* pointer mandatory  mandatory String table for symbols, lib names, etc. */
        DT_SYMTAB   = 6,        /* pointer mandatory  mandatory Symbol table */
        DT_RELA     = 7,        /* pointer mandatory  optional  Relocation table */
        DT_RELASZ   = 8,        /* value   mandatory  optional  Size of RELA relocation table */
        DT_RELAENT  = 9,        /* value   mandatory  optional  Size of each RELA table entry */
        DT_STRSZ    = 10,       /* value   mandatory  mandatory Size of string table */
        DT_SYMENT   = 11,       /* value   mandatory  mandatory Size of symbol table entry */
        DT_INIT     = 12,       /* pointer optional   optional  Initialization function */
        DT_FINI     = 13,       /* pointer optional   optional  Termination function */
        DT_SONAME   = 14,       /* value   ignored    optional  Name of shared object */
        DT_RPATH    = 15,       /* value   optional   ignored   NUL-term library search path */
        DT_SYMBOLIC = 16,       /* ignored ignored    optional  Bool determines dynamic linker symbol resolution */
        DT_REL      = 17,       /* pointer mandatory  optional  Relocation table */
        DT_RELSZ    = 18,       /* value   mandatory  optional  Size of REL relocation table */
        DT_RELENT   = 19,       /* value   mandatory  optional  Size of each REL table entry */
        DT_PLTREL   = 20,       /* value   optional   optional  Reloc type for PLT; value is DT_RELA or DT_REL */
        DT_DEBUG    = 21,       /* pointer optional   ignored   Contents are not specified at ABI level */
        DT_TEXTREL  = 22,       /* ignored optional   optional  presence => relocs to nonwritable segments OK */
        DT_JMPREL   = 23,       /* pointer optional   optional  Addr of relocation entries for PLT */
        DT_BIND_NOW = 24,       /* ignored optional   optional  Shall dynlinker do relocs before xfering control?*/
        DT_INIT_ARRAY = 25,     /* pointer optional   ?         Array with addresses of init fct */
        DT_FINI_ARRAY = 26,     /* pointer optional   ?         Array with address of fini fct */
        DT_INIT_ARRAYSZ = 27,   /* value   optional   ?         Size in bytes of DT_INIT_ARRAY */
        DT_FINI_ARRAYSZ = 28,   /* value   optional   ?         Size in bytes of DT_FINI_ARRAY */
        DT_RUNPATH  = 29,       /* ?       optional   ?         Library search path (how diff from DT_RPATH?) */
        DT_FLAGS    = 30,       /* value   optional   ?         Bit flags */
        DT_PREINIT_ARRAY = 32,  /* pointer optional   ?         Array with addrs of preinit fct (aka DT_ENCODING)*/
        DT_PREINIT_ARRAYSZ = 33,/* value   optional   ?         size in bytes of DT_PREINIT_ARRAY */
        DT_NUM      = 34,       /* ?       ?          ?         "number used"? */
 
        DT_GNU_PRELINKED =0x6ffffdf5,/*value ?          ?         Prelinking time stamp */
        DT_GNU_CONFLICTSZ=0x6ffffdf6,/*value ?          ?         Size of conflict section */
        DT_GNU_LIBLISTSZ=0x6ffffdf7,/*value  ?          ?         Size of library list */
        DT_CHECKSUM = 0x6ffffdf8, /* value   ?          ?         ? */
        DT_PLTPADSZ = 0x6ffffdf9, /* value   ?          ?         ? */
        DT_MOVEENT  = 0x6ffffdfa, /* value   ?          ?         ? */
        DT_MOVESZ   = 0x6ffffdfb, /* value   ?          ?         ? */
        DT_FEATURE_1= 0x6ffffdfc, /* value   ?          ?         Feature selection (DTF_*) */
        DT_POSFLAG_1= 0x6ffffdfd, /* value   ?          ?         Flag for DT_* entries affecting next entry */
        DT_SYMINSZ  = 0x6ffffdfe, /* value   ?          ?         Size of syminfo table in bytes */
        DT_SYMINENT = 0x6ffffdff, /* value   ?          ?         Size of each syminfo table entry */
 
        DT_GNU_HASH = 0x6ffffef5, /* pointer ?          ?         GNU-style hash table */
        DT_TLSDESC_PLT=0x6ffffef6,/* pointer ?          ?         ? */
        DT_TLSDESC_GOT=0x6ffffef7,/* pointer ?          ?         ? */
        DT_GNU_CONFLICT=0x6ffffef8,/*pointer ?          ?         Start of conflict section */
        DT_GNU_LIBLIST=0x6ffffef9,/* pointer ?          ?         Library list */
        DT_CONFIG   = 0x6ffffefa, /* pointer ?          ?         Configuration information */
        DT_DEPAUDIT = 0x6ffffefb, /* pointer ?          ?         Dependency auditing */
        DT_AUDIT    = 0x6ffffefc, /* pointer ?          ?         Object auditing */
        DT_PLTPAD   = 0x6ffffefd, /* pointer ?          ?         PLT padding */
        DT_MOVETAB  = 0x6ffffefe, /* pointer ?          ?         Move table */
        DT_SYMINFO  = 0x6ffffeff, /* pointer ?          ?         Syminfo table */
 
        DT_VERSYM   = 0x6ffffff0, /* pointer ?          ?         ? */
        DT_RELACOUNT= 0x6ffffff9, /* value   ?          ?         ? */
        DT_RELCOUNT = 0x6ffffffa, /* value   ?          ?         ? */
        DT_FLAGS_1  = 0x6ffffffb, /* value   ?          ?         Sun state flags */
        DT_VERDEF   = 0x6ffffffc, /* pointer ?          ?         Sun version definition table */
        DT_VERDEFNUM= 0x6ffffffd, /* value   ?          ?         Sun number of version definitions */
        DT_VERNEED  = 0x6ffffffe, /* pointer ?          ?         Sun needed versions table */
        DT_VERNEEDNUM=0x6fffffff, /* value   ?          ?         Sun number of needed versions */
 
        DT_AUXILIARY= 0x7ffffffd, /* pointer ?          ?         Sun shared obj to load before self */
        DT_FILTER   = 0x7fffffff  /* pointer ?          ?         Shared object ot get values from */
    };
 
#ifdef _MSC_VER
# pragma pack (1)
#endif
 
    struct Elf32DynamicEntry_disk {
        uint32_t            d_tag;                  
        uint32_t            d_val;                  
    }
    struct Elf32DynamicEntry_disk {…};
#if !defined(SWIG) && !defined(_MSC_VER)
    __attribute__((packed))
#endif
    ;
 
    struct Elf64DynamicEntry_disk {
        uint64_t            d_tag;                  
        uint64_t            d_val;                  
    }
    struct Elf64DynamicEntry_disk {…};
#if !defined(SWIG) && !defined(_MSC_VER)
    __attribute__((packed))
#endif
    ;
 
#ifdef _MSC_VER
# pragma pack ()
#endif
 
    // Properties
public:
public:
    SgAsmElfDynamicEntry::EntryType const& get_d_tag() const;
    void set_d_tag(SgAsmElfDynamicEntry::EntryType const&);
public:
    Rose::BinaryAnalysis::RelativeVirtualAddress const& get_d_val() const;
    Rose::BinaryAnalysis::RelativeVirtualAddress& get_d_val();
    void set_d_val(Rose::BinaryAnalysis::RelativeVirtualAddress const&);
public:
    SgAsmGenericString* const& get_name() const;
    void set_name(SgAsmGenericString*);
public:
    SgUnsignedCharList const& get_extra() const;
    SgUnsignedCharList& get_extra();
    void set_extra(SgUnsignedCharList const&);
    // Functions
public:
    explicit SgAsmElfDynamicEntry(SgAsmElfDynamicSection *dynsec);
 
    void parse(Rose::BinaryAnalysis::ByteOrder::Endianness, const SgAsmElfDynamicEntry::Elf32DynamicEntry_disk*);
    void parse(Rose::BinaryAnalysis::ByteOrder::Endianness, const SgAsmElfDynamicEntry::Elf64DynamicEntry_disk*);
    void *encode(Rose::BinaryAnalysis::ByteOrder::Endianness, SgAsmElfDynamicEntry::Elf32DynamicEntry_disk*) const;
    void *encode(Rose::BinaryAnalysis::ByteOrder::Endianness, SgAsmElfDynamicEntry::Elf64DynamicEntry_disk*) const;
    virtual void dump(FILE*, const char *prefix, ssize_t idx) const;
 
    static std::string toString(SgAsmElfDynamicEntry::EntryType);
 
    // Deprecated 2023-11
public:
    static std::string to_string(SgAsmElfDynamicEntry::EntryType) ROSE_DEPRECATED("use toString");
public:
    virtual ~SgAsmElfDynamicEntry();
 
public:
    SgAsmElfDynamicEntry();
 
protected:
    void initializeProperties();
#endif // SgAsmElfDynamicEntry_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmElfDynamicEntry: public SgAsmExecutableFileFormat {…};
#endif // DOCUMENTATION
 
 
// SgAsmDwarfWithStmt           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmDwarfWithStmt);
IS_SERIALIZABLE(AsmDwarfWithStmt);
 
#ifndef DOCUMENTATION
AsmDwarfWithStmt.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmDwarfWithStmt: public SgAsmDwarfConstruct {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmDwarfWithStmt);
#if defined(SgAsmDwarfWithStmt_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmDwarfWithStmt -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmDwarfWithStmt");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
        debugSerializationEnd("SgAsmDwarfWithStmt");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    virtual ~SgAsmDwarfWithStmt();
 
public:
    SgAsmDwarfWithStmt();
 
public:
    SgAsmDwarfWithStmt(int const& nesting_level,
                       uint64_t const& offset,
                       uint64_t const& overall_offset);
 
protected:
    void initializeProperties();
#endif // SgAsmDwarfWithStmt_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmDwarfWithStmt: public SgAsmDwarfConstruct {…};
#endif // DOCUMENTATION
 
 
// SgAsmDwarfVolatileType           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmDwarfVolatileType);
IS_SERIALIZABLE(AsmDwarfVolatileType);
 
#ifndef DOCUMENTATION
AsmDwarfVolatileType.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmDwarfVolatileType: public SgAsmDwarfConstruct {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmDwarfVolatileType);
#if defined(SgAsmDwarfVolatileType_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmDwarfVolatileType -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmDwarfVolatileType");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
        debugSerializationEnd("SgAsmDwarfVolatileType");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    virtual ~SgAsmDwarfVolatileType();
 
public:
    SgAsmDwarfVolatileType();
 
public:
    SgAsmDwarfVolatileType(int const& nesting_level,
                           uint64_t const& offset,
                           uint64_t const& overall_offset);
 
protected:
    void initializeProperties();
#endif // SgAsmDwarfVolatileType_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmDwarfVolatileType: public SgAsmDwarfConstruct {…};
#endif // DOCUMENTATION
 
 
// SgAsmDwarfVariantPart           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmDwarfVariantPart);
IS_SERIALIZABLE(AsmDwarfVariantPart);
 
#ifndef DOCUMENTATION
AsmDwarfVariantPart.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmDwarfVariantPart: public SgAsmDwarfConstruct {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmDwarfVariantPart);
#if defined(SgAsmDwarfVariantPart_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmDwarfVariantPart -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmDwarfVariantPart");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
        debugSerializationEnd("SgAsmDwarfVariantPart");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    virtual ~SgAsmDwarfVariantPart();
 
public:
    SgAsmDwarfVariantPart();
 
public:
    SgAsmDwarfVariantPart(int const& nesting_level,
                          uint64_t const& offset,
                          uint64_t const& overall_offset);
 
protected:
    void initializeProperties();
#endif // SgAsmDwarfVariantPart_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmDwarfVariantPart: public SgAsmDwarfConstruct {…};
#endif // DOCUMENTATION
 
 
// SgAsmDwarfVariant           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmDwarfVariant);
IS_SERIALIZABLE(AsmDwarfVariant);
 
#ifndef DOCUMENTATION
AsmDwarfVariant.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmDwarfVariant: public SgAsmDwarfConstruct {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmDwarfVariant);
#if defined(SgAsmDwarfVariant_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmDwarfVariant -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmDwarfVariant");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
        debugSerializationEnd("SgAsmDwarfVariant");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    virtual ~SgAsmDwarfVariant();
 
public:
    SgAsmDwarfVariant();
 
public:
    SgAsmDwarfVariant(int const& nesting_level,
                      uint64_t const& offset,
                      uint64_t const& overall_offset);
 
protected:
    void initializeProperties();
#endif // SgAsmDwarfVariant_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmDwarfVariant: public SgAsmDwarfConstruct {…};
#endif // DOCUMENTATION
 
 
// SgAsmDwarfVariable           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmDwarfVariable);
IS_SERIALIZABLE(AsmDwarfVariable);
 
#ifndef DOCUMENTATION
AsmDwarfVariable.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmDwarfVariable: public SgAsmDwarfConstruct {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmDwarfVariable);
#if defined(SgAsmDwarfVariable_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmDwarfVariable -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmDwarfVariable");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
        debugSerializationEnd("SgAsmDwarfVariable");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    virtual ~SgAsmDwarfVariable();
 
public:
    SgAsmDwarfVariable();
 
public:
    SgAsmDwarfVariable(int const& nesting_level,
                       uint64_t const& offset,
                       uint64_t const& overall_offset);
 
protected:
    void initializeProperties();
#endif // SgAsmDwarfVariable_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmDwarfVariable: public SgAsmDwarfConstruct {…};
#endif // DOCUMENTATION
 
 
// SgAsmDwarfUpcStrictType           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmDwarfUpcStrictType);
IS_SERIALIZABLE(AsmDwarfUpcStrictType);
 
#ifndef DOCUMENTATION
AsmDwarfUpcStrictType.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmDwarfUpcStrictType: public SgAsmDwarfConstruct {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmDwarfUpcStrictType);
#if defined(SgAsmDwarfUpcStrictType_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmDwarfUpcStrictType -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmDwarfUpcStrictType");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
        debugSerializationEnd("SgAsmDwarfUpcStrictType");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    virtual ~SgAsmDwarfUpcStrictType();
 
public:
    SgAsmDwarfUpcStrictType();
 
public:
    SgAsmDwarfUpcStrictType(int const& nesting_level,
                            uint64_t const& offset,
                            uint64_t const& overall_offset);
 
protected:
    void initializeProperties();
#endif // SgAsmDwarfUpcStrictType_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmDwarfUpcStrictType: public SgAsmDwarfConstruct {…};
#endif // DOCUMENTATION
 
 
// SgAsmDwarfUpcSharedType           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmDwarfUpcSharedType);
IS_SERIALIZABLE(AsmDwarfUpcSharedType);
 
#ifndef DOCUMENTATION
AsmDwarfUpcSharedType.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmDwarfUpcSharedType: public SgAsmDwarfConstruct {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmDwarfUpcSharedType);
#if defined(SgAsmDwarfUpcSharedType_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmDwarfUpcSharedType -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmDwarfUpcSharedType");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
        debugSerializationEnd("SgAsmDwarfUpcSharedType");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    virtual ~SgAsmDwarfUpcSharedType();
 
public:
    SgAsmDwarfUpcSharedType();
 
public:
    SgAsmDwarfUpcSharedType(int const& nesting_level,
                            uint64_t const& offset,
                            uint64_t const& overall_offset);
 
protected:
    void initializeProperties();
#endif // SgAsmDwarfUpcSharedType_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmDwarfUpcSharedType: public SgAsmDwarfConstruct {…};
#endif // DOCUMENTATION
 
 
// SgAsmDwarfUpcRelaxedType           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmDwarfUpcRelaxedType);
IS_SERIALIZABLE(AsmDwarfUpcRelaxedType);
 
#ifndef DOCUMENTATION
AsmDwarfUpcRelaxedType.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmDwarfUpcRelaxedType: public SgAsmDwarfConstruct {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmDwarfUpcRelaxedType);
#if defined(SgAsmDwarfUpcRelaxedType_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmDwarfUpcRelaxedType -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmDwarfUpcRelaxedType");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
        debugSerializationEnd("SgAsmDwarfUpcRelaxedType");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    virtual ~SgAsmDwarfUpcRelaxedType();
 
public:
    SgAsmDwarfUpcRelaxedType();
 
public:
    SgAsmDwarfUpcRelaxedType(int const& nesting_level,
                             uint64_t const& offset,
                             uint64_t const& overall_offset);
 
protected:
    void initializeProperties();
#endif // SgAsmDwarfUpcRelaxedType_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmDwarfUpcRelaxedType: public SgAsmDwarfConstruct {…};
#endif // DOCUMENTATION
 
 
// SgAsmDwarfUnspecifiedType           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmDwarfUnspecifiedType);
IS_SERIALIZABLE(AsmDwarfUnspecifiedType);
 
#ifndef DOCUMENTATION
AsmDwarfUnspecifiedType.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmDwarfUnspecifiedType: public SgAsmDwarfConstruct {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmDwarfUnspecifiedType);
#if defined(SgAsmDwarfUnspecifiedType_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmDwarfUnspecifiedType -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmDwarfUnspecifiedType");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
        debugSerializationEnd("SgAsmDwarfUnspecifiedType");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    virtual ~SgAsmDwarfUnspecifiedType();
 
public:
    SgAsmDwarfUnspecifiedType();
 
public:
    SgAsmDwarfUnspecifiedType(int const& nesting_level,
                              uint64_t const& offset,
                              uint64_t const& overall_offset);
 
protected:
    void initializeProperties();
#endif // SgAsmDwarfUnspecifiedType_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmDwarfUnspecifiedType: public SgAsmDwarfConstruct {…};
#endif // DOCUMENTATION
 
 
// SgAsmDwarfUnspecifiedParameters           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmDwarfUnspecifiedParameters);
IS_SERIALIZABLE(AsmDwarfUnspecifiedParameters);
 
#ifndef DOCUMENTATION
AsmDwarfUnspecifiedParameters.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmDwarfUnspecifiedParameters: public SgAsmDwarfConstruct {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmDwarfUnspecifiedParameters);
#if defined(SgAsmDwarfUnspecifiedParameters_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmDwarfUnspecifiedParameters -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmDwarfUnspecifiedParameters");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
        debugSerializationEnd("SgAsmDwarfUnspecifiedParameters");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    virtual ~SgAsmDwarfUnspecifiedParameters();
 
public:
    SgAsmDwarfUnspecifiedParameters();
 
public:
    SgAsmDwarfUnspecifiedParameters(int const& nesting_level,
                                    uint64_t const& offset,
                                    uint64_t const& overall_offset);
 
protected:
    void initializeProperties();
#endif // SgAsmDwarfUnspecifiedParameters_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmDwarfUnspecifiedParameters: public SgAsmDwarfConstruct {…};
#endif // DOCUMENTATION
 
 
// SgAsmDwarfUnknownConstruct           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmDwarfUnknownConstruct);
IS_SERIALIZABLE(AsmDwarfUnknownConstruct);
 
#ifndef DOCUMENTATION
AsmDwarfUnknownConstruct.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmDwarfUnknownConstruct: public SgAsmDwarfConstruct {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmDwarfUnknownConstruct);
#if defined(SgAsmDwarfUnknownConstruct_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmDwarfUnknownConstruct -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmDwarfUnknownConstruct");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
        debugSerializationEnd("SgAsmDwarfUnknownConstruct");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    virtual ~SgAsmDwarfUnknownConstruct();
 
public:
    SgAsmDwarfUnknownConstruct();
 
public:
    SgAsmDwarfUnknownConstruct(int const& nesting_level,
                               uint64_t const& offset,
                               uint64_t const& overall_offset);
 
protected:
    void initializeProperties();
#endif // SgAsmDwarfUnknownConstruct_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmDwarfUnknownConstruct: public SgAsmDwarfConstruct {…};
#endif // DOCUMENTATION
 
 
// SgAsmDwarfUnionType           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmDwarfUnionType);
IS_SERIALIZABLE(AsmDwarfUnionType);
 
#ifndef DOCUMENTATION
AsmDwarfUnionType.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmDwarfUnionType);
#if defined(SgAsmDwarfUnionType_HEADERS) || defined(DOCUMENTATION)
#ifdef ROSE_SgAsmDwarfUnionType_IMPL
#include <SgAsmDwarfConstructList.h>
#endif
#endif // SgAsmDwarfUnionType_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmDwarfUnionType: public SgAsmDwarfConstruct {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmDwarfUnionType.setDataPrototype(
        "SgAsmDwarfConstructList*", "body", "= NULL",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmDwarfUnionType);
#if defined(SgAsmDwarfUnionType_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmDwarfUnionType -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmDwarfUnionType");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
        s & BOOST_SERIALIZATION_NVP(p_body);
        debugSerializationEnd("SgAsmDwarfUnionType");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgAsmDwarfConstructList* const& get_body() const;
    void set_body(SgAsmDwarfConstructList* const&);
public:
    SgAsmDwarfConstructList* get_children() override;
public:
    virtual ~SgAsmDwarfUnionType();
 
public:
    SgAsmDwarfUnionType();
 
public:
    SgAsmDwarfUnionType(int const& nesting_level,
                        uint64_t const& offset,
                        uint64_t const& overall_offset);
 
protected:
    void initializeProperties();
#endif // SgAsmDwarfUnionType_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmDwarfUnionType: public SgAsmDwarfConstruct {…};
#endif // DOCUMENTATION
 
 
// SgAsmDwarfTypedef           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmDwarfTypedef);
IS_SERIALIZABLE(AsmDwarfTypedef);
 
#ifndef DOCUMENTATION
AsmDwarfTypedef.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmDwarfTypedef: public SgAsmDwarfConstruct {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmDwarfTypedef);
#if defined(SgAsmDwarfTypedef_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmDwarfTypedef -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmDwarfTypedef");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
        debugSerializationEnd("SgAsmDwarfTypedef");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    virtual ~SgAsmDwarfTypedef();
 
public:
    SgAsmDwarfTypedef();
 
public:
    SgAsmDwarfTypedef(int const& nesting_level,
                      uint64_t const& offset,
                      uint64_t const& overall_offset);
 
protected:
    void initializeProperties();
#endif // SgAsmDwarfTypedef_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmDwarfTypedef: public SgAsmDwarfConstruct {…};
#endif // DOCUMENTATION
 
 
// SgAsmDwarfTryBlock           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmDwarfTryBlock);
IS_SERIALIZABLE(AsmDwarfTryBlock);
 
#ifndef DOCUMENTATION
AsmDwarfTryBlock.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmDwarfTryBlock: public SgAsmDwarfConstruct {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmDwarfTryBlock);
#if defined(SgAsmDwarfTryBlock_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmDwarfTryBlock -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmDwarfTryBlock");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
        debugSerializationEnd("SgAsmDwarfTryBlock");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    virtual ~SgAsmDwarfTryBlock();
 
public:
    SgAsmDwarfTryBlock();
 
public:
    SgAsmDwarfTryBlock(int const& nesting_level,
                       uint64_t const& offset,
                       uint64_t const& overall_offset);
 
protected:
    void initializeProperties();
#endif // SgAsmDwarfTryBlock_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmDwarfTryBlock: public SgAsmDwarfConstruct {…};
#endif // DOCUMENTATION
 
 
// SgAsmDwarfThrownType           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmDwarfThrownType);
IS_SERIALIZABLE(AsmDwarfThrownType);
 
#ifndef DOCUMENTATION
AsmDwarfThrownType.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmDwarfThrownType: public SgAsmDwarfConstruct {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmDwarfThrownType);
#if defined(SgAsmDwarfThrownType_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmDwarfThrownType -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmDwarfThrownType");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
        debugSerializationEnd("SgAsmDwarfThrownType");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    virtual ~SgAsmDwarfThrownType();
 
public:
    SgAsmDwarfThrownType();
 
public:
    SgAsmDwarfThrownType(int const& nesting_level,
                         uint64_t const& offset,
                         uint64_t const& overall_offset);
 
protected:
    void initializeProperties();
#endif // SgAsmDwarfThrownType_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmDwarfThrownType: public SgAsmDwarfConstruct {…};
#endif // DOCUMENTATION
 
 
// SgAsmDwarfTemplateValueParameter           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmDwarfTemplateValueParameter);
IS_SERIALIZABLE(AsmDwarfTemplateValueParameter);
 
#ifndef DOCUMENTATION
AsmDwarfTemplateValueParameter.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmDwarfTemplateValueParameter: public SgAsmDwarfConstruct {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmDwarfTemplateValueParameter);
#if defined(SgAsmDwarfTemplateValueParameter_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmDwarfTemplateValueParameter -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmDwarfTemplateValueParameter");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
        debugSerializationEnd("SgAsmDwarfTemplateValueParameter");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    virtual ~SgAsmDwarfTemplateValueParameter();
 
public:
    SgAsmDwarfTemplateValueParameter();
 
public:
    SgAsmDwarfTemplateValueParameter(int const& nesting_level,
                                     uint64_t const& offset,
                                     uint64_t const& overall_offset);
 
protected:
    void initializeProperties();
#endif // SgAsmDwarfTemplateValueParameter_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmDwarfTemplateValueParameter: public SgAsmDwarfConstruct {…};
#endif // DOCUMENTATION
 
 
// SgAsmDwarfTemplateTypeParameter           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmDwarfTemplateTypeParameter);
IS_SERIALIZABLE(AsmDwarfTemplateTypeParameter);
 
#ifndef DOCUMENTATION
AsmDwarfTemplateTypeParameter.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmDwarfTemplateTypeParameter: public SgAsmDwarfConstruct {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmDwarfTemplateTypeParameter);
#if defined(SgAsmDwarfTemplateTypeParameter_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmDwarfTemplateTypeParameter -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmDwarfTemplateTypeParameter");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
        debugSerializationEnd("SgAsmDwarfTemplateTypeParameter");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    virtual ~SgAsmDwarfTemplateTypeParameter();
 
public:
    SgAsmDwarfTemplateTypeParameter();
 
public:
    SgAsmDwarfTemplateTypeParameter(int const& nesting_level,
                                    uint64_t const& offset,
                                    uint64_t const& overall_offset);
 
protected:
    void initializeProperties();
#endif // SgAsmDwarfTemplateTypeParameter_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmDwarfTemplateTypeParameter: public SgAsmDwarfConstruct {…};
#endif // DOCUMENTATION
 
 
// SgAsmDwarfSubroutineType           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmDwarfSubroutineType);
IS_SERIALIZABLE(AsmDwarfSubroutineType);
 
#ifndef DOCUMENTATION
AsmDwarfSubroutineType.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmDwarfSubroutineType);
#if defined(SgAsmDwarfSubroutineType_HEADERS) || defined(DOCUMENTATION)
#ifdef ROSE_SgAsmDwarfSubroutineType_IMPL
#include <SgAsmDwarfConstructList.h>
#endif
#endif // SgAsmDwarfSubroutineType_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmDwarfSubroutineType: public SgAsmDwarfConstruct {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmDwarfSubroutineType.setDataPrototype(
        "SgAsmDwarfConstructList*", "body", "= nullptr",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmDwarfSubroutineType);
#if defined(SgAsmDwarfSubroutineType_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmDwarfSubroutineType -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmDwarfSubroutineType");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
        s & BOOST_SERIALIZATION_NVP(p_body);
        debugSerializationEnd("SgAsmDwarfSubroutineType");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgAsmDwarfConstructList* const& get_body() const;
    void set_body(SgAsmDwarfConstructList* const&);
public:
    SgAsmDwarfConstructList* get_children() override;
public:
    virtual ~SgAsmDwarfSubroutineType();
 
public:
    SgAsmDwarfSubroutineType();
 
public:
    SgAsmDwarfSubroutineType(int const& nesting_level,
                             uint64_t const& offset,
                             uint64_t const& overall_offset);
 
protected:
    void initializeProperties();
#endif // SgAsmDwarfSubroutineType_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmDwarfSubroutineType: public SgAsmDwarfConstruct {…};
#endif // DOCUMENTATION
 
 
// SgAsmDwarfSubrangeType           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmDwarfSubrangeType);
IS_SERIALIZABLE(AsmDwarfSubrangeType);
 
#ifndef DOCUMENTATION
AsmDwarfSubrangeType.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmDwarfSubrangeType: public SgAsmDwarfConstruct {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmDwarfSubrangeType);
#if defined(SgAsmDwarfSubrangeType_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmDwarfSubrangeType -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmDwarfSubrangeType");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
        debugSerializationEnd("SgAsmDwarfSubrangeType");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    virtual ~SgAsmDwarfSubrangeType();
 
public:
    SgAsmDwarfSubrangeType();
 
public:
    SgAsmDwarfSubrangeType(int const& nesting_level,
                           uint64_t const& offset,
                           uint64_t const& overall_offset);
 
protected:
    void initializeProperties();
#endif // SgAsmDwarfSubrangeType_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmDwarfSubrangeType: public SgAsmDwarfConstruct {…};
#endif // DOCUMENTATION
 
 
// SgAsmDwarfSubprogram           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmDwarfSubprogram);
IS_SERIALIZABLE(AsmDwarfSubprogram);
 
#ifndef DOCUMENTATION
AsmDwarfSubprogram.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmDwarfSubprogram);
#if defined(SgAsmDwarfSubprogram_HEADERS) || defined(DOCUMENTATION)
#ifdef ROSE_SgAsmDwarfSubprogram_IMPL
#include <SgAsmDwarfConstructList.h>
#endif
#endif // SgAsmDwarfSubprogram_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmDwarfSubprogram: public SgAsmDwarfConstruct {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmDwarfSubprogram.setDataPrototype(
        "SgAsmDwarfConstructList*", "body", "= NULL",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmDwarfSubprogram);
#if defined(SgAsmDwarfSubprogram_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmDwarfSubprogram -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmDwarfSubprogram");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
        s & BOOST_SERIALIZATION_NVP(p_body);
        debugSerializationEnd("SgAsmDwarfSubprogram");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgAsmDwarfConstructList* const& get_body() const;
    void set_body(SgAsmDwarfConstructList* const&);
public:
    SgAsmDwarfConstructList* get_children() override;
public:
    virtual ~SgAsmDwarfSubprogram();
 
public:
    SgAsmDwarfSubprogram();
 
public:
    SgAsmDwarfSubprogram(int const& nesting_level,
                         uint64_t const& offset,
                         uint64_t const& overall_offset);
 
protected:
    void initializeProperties();
#endif // SgAsmDwarfSubprogram_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmDwarfSubprogram: public SgAsmDwarfConstruct {…};
#endif // DOCUMENTATION
 
 
// SgAsmDwarfStructureType           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmDwarfStructureType);
IS_SERIALIZABLE(AsmDwarfStructureType);
 
#ifndef DOCUMENTATION
AsmDwarfStructureType.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmDwarfStructureType);
#if defined(SgAsmDwarfStructureType_HEADERS) || defined(DOCUMENTATION)
#ifdef ROSE_SgAsmDwarfStructureType_IMPL
#include <SgAsmDwarfConstructList.h>
#endif
#endif // SgAsmDwarfStructureType_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmDwarfStructureType: public SgAsmDwarfConstruct {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmDwarfStructureType.setDataPrototype(
        "SgAsmDwarfConstructList*", "body", "= nullptr",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmDwarfStructureType);
#if defined(SgAsmDwarfStructureType_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmDwarfStructureType -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmDwarfStructureType");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
        s & BOOST_SERIALIZATION_NVP(p_body);
        debugSerializationEnd("SgAsmDwarfStructureType");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgAsmDwarfConstructList* const& get_body() const;
    void set_body(SgAsmDwarfConstructList* const&);
public:
    SgAsmDwarfConstructList* get_children() override;
public:
    virtual ~SgAsmDwarfStructureType();
 
public:
    SgAsmDwarfStructureType();
 
public:
    SgAsmDwarfStructureType(int const& nesting_level,
                            uint64_t const& offset,
                            uint64_t const& overall_offset);
 
protected:
    void initializeProperties();
#endif // SgAsmDwarfStructureType_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmDwarfStructureType: public SgAsmDwarfConstruct {…};
#endif // DOCUMENTATION
 
 
// SgAsmDwarfStringType           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmDwarfStringType);
IS_SERIALIZABLE(AsmDwarfStringType);
 
#ifndef DOCUMENTATION
AsmDwarfStringType.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmDwarfStringType: public SgAsmDwarfConstruct {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmDwarfStringType);
#if defined(SgAsmDwarfStringType_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmDwarfStringType -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmDwarfStringType");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
        debugSerializationEnd("SgAsmDwarfStringType");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    virtual ~SgAsmDwarfStringType();
 
public:
    SgAsmDwarfStringType();
 
public:
    SgAsmDwarfStringType(int const& nesting_level,
                         uint64_t const& offset,
                         uint64_t const& overall_offset);
 
protected:
    void initializeProperties();
#endif // SgAsmDwarfStringType_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmDwarfStringType: public SgAsmDwarfConstruct {…};
#endif // DOCUMENTATION
 
 
// SgAsmDwarfSharedType           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmDwarfSharedType);
IS_SERIALIZABLE(AsmDwarfSharedType);
 
#ifndef DOCUMENTATION
AsmDwarfSharedType.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmDwarfSharedType: public SgAsmDwarfConstruct {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmDwarfSharedType);
#if defined(SgAsmDwarfSharedType_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmDwarfSharedType -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmDwarfSharedType");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
        debugSerializationEnd("SgAsmDwarfSharedType");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    virtual ~SgAsmDwarfSharedType();
 
public:
    SgAsmDwarfSharedType();
 
public:
    SgAsmDwarfSharedType(int const& nesting_level,
                         uint64_t const& offset,
                         uint64_t const& overall_offset);
 
protected:
    void initializeProperties();
#endif // SgAsmDwarfSharedType_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmDwarfSharedType: public SgAsmDwarfConstruct {…};
#endif // DOCUMENTATION
 
 
// SgAsmDwarfSetType           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmDwarfSetType);
IS_SERIALIZABLE(AsmDwarfSetType);
 
#ifndef DOCUMENTATION
AsmDwarfSetType.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmDwarfSetType: public SgAsmDwarfConstruct {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmDwarfSetType);
#if defined(SgAsmDwarfSetType_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmDwarfSetType -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmDwarfSetType");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
        debugSerializationEnd("SgAsmDwarfSetType");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    virtual ~SgAsmDwarfSetType();
 
public:
    SgAsmDwarfSetType();
 
public:
    SgAsmDwarfSetType(int const& nesting_level,
                      uint64_t const& offset,
                      uint64_t const& overall_offset);
 
protected:
    void initializeProperties();
#endif // SgAsmDwarfSetType_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmDwarfSetType: public SgAsmDwarfConstruct {…};
#endif // DOCUMENTATION
 
 
// SgAsmDwarfRestrictType           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmDwarfRestrictType);
IS_SERIALIZABLE(AsmDwarfRestrictType);
 
#ifndef DOCUMENTATION
AsmDwarfRestrictType.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmDwarfRestrictType: public SgAsmDwarfConstruct {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmDwarfRestrictType);
#if defined(SgAsmDwarfRestrictType_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmDwarfRestrictType -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmDwarfRestrictType");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
        debugSerializationEnd("SgAsmDwarfRestrictType");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    virtual ~SgAsmDwarfRestrictType();
 
public:
    SgAsmDwarfRestrictType();
 
public:
    SgAsmDwarfRestrictType(int const& nesting_level,
                           uint64_t const& offset,
                           uint64_t const& overall_offset);
 
protected:
    void initializeProperties();
#endif // SgAsmDwarfRestrictType_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmDwarfRestrictType: public SgAsmDwarfConstruct {…};
#endif // DOCUMENTATION
 
 
// SgAsmDwarfReferenceType           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmDwarfReferenceType);
IS_SERIALIZABLE(AsmDwarfReferenceType);
 
#ifndef DOCUMENTATION
AsmDwarfReferenceType.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmDwarfReferenceType: public SgAsmDwarfConstruct {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmDwarfReferenceType);
#if defined(SgAsmDwarfReferenceType_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmDwarfReferenceType -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmDwarfReferenceType");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
        debugSerializationEnd("SgAsmDwarfReferenceType");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    virtual ~SgAsmDwarfReferenceType();
 
public:
    SgAsmDwarfReferenceType();
 
public:
    SgAsmDwarfReferenceType(int const& nesting_level,
                            uint64_t const& offset,
                            uint64_t const& overall_offset);
 
protected:
    void initializeProperties();
#endif // SgAsmDwarfReferenceType_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmDwarfReferenceType: public SgAsmDwarfConstruct {…};
#endif // DOCUMENTATION
 
 
// SgAsmDwarfPtrToMemberType           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmDwarfPtrToMemberType);
IS_SERIALIZABLE(AsmDwarfPtrToMemberType);
 
#ifndef DOCUMENTATION
AsmDwarfPtrToMemberType.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmDwarfPtrToMemberType: public SgAsmDwarfConstruct {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmDwarfPtrToMemberType);
#if defined(SgAsmDwarfPtrToMemberType_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmDwarfPtrToMemberType -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmDwarfPtrToMemberType");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
        debugSerializationEnd("SgAsmDwarfPtrToMemberType");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    virtual ~SgAsmDwarfPtrToMemberType();
 
public:
    SgAsmDwarfPtrToMemberType();
 
public:
    SgAsmDwarfPtrToMemberType(int const& nesting_level,
                              uint64_t const& offset,
                              uint64_t const& overall_offset);
 
protected:
    void initializeProperties();
#endif // SgAsmDwarfPtrToMemberType_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmDwarfPtrToMemberType: public SgAsmDwarfConstruct {…};
#endif // DOCUMENTATION
 
 
// SgAsmDwarfPointerType           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmDwarfPointerType);
IS_SERIALIZABLE(AsmDwarfPointerType);
 
#ifndef DOCUMENTATION
AsmDwarfPointerType.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmDwarfPointerType: public SgAsmDwarfConstruct {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmDwarfPointerType);
#if defined(SgAsmDwarfPointerType_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmDwarfPointerType -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmDwarfPointerType");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
        debugSerializationEnd("SgAsmDwarfPointerType");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    virtual ~SgAsmDwarfPointerType();
 
public:
    SgAsmDwarfPointerType();
 
public:
    SgAsmDwarfPointerType(int const& nesting_level,
                          uint64_t const& offset,
                          uint64_t const& overall_offset);
 
protected:
    void initializeProperties();
#endif // SgAsmDwarfPointerType_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmDwarfPointerType: public SgAsmDwarfConstruct {…};
#endif // DOCUMENTATION
 
 
// SgAsmDwarfPartialUnit           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmDwarfPartialUnit);
IS_SERIALIZABLE(AsmDwarfPartialUnit);
 
#ifndef DOCUMENTATION
AsmDwarfPartialUnit.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmDwarfPartialUnit: public SgAsmDwarfConstruct {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmDwarfPartialUnit);
#if defined(SgAsmDwarfPartialUnit_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmDwarfPartialUnit -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmDwarfPartialUnit");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
        debugSerializationEnd("SgAsmDwarfPartialUnit");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    virtual ~SgAsmDwarfPartialUnit();
 
public:
    SgAsmDwarfPartialUnit();
 
public:
    SgAsmDwarfPartialUnit(int const& nesting_level,
                          uint64_t const& offset,
                          uint64_t const& overall_offset);
 
protected:
    void initializeProperties();
#endif // SgAsmDwarfPartialUnit_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmDwarfPartialUnit: public SgAsmDwarfConstruct {…};
#endif // DOCUMENTATION
 
 
// SgAsmDwarfPackedType           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmDwarfPackedType);
IS_SERIALIZABLE(AsmDwarfPackedType);
 
#ifndef DOCUMENTATION
AsmDwarfPackedType.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmDwarfPackedType: public SgAsmDwarfConstruct {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmDwarfPackedType);
#if defined(SgAsmDwarfPackedType_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmDwarfPackedType -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmDwarfPackedType");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
        debugSerializationEnd("SgAsmDwarfPackedType");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    virtual ~SgAsmDwarfPackedType();
 
public:
    SgAsmDwarfPackedType();
 
public:
    SgAsmDwarfPackedType(int const& nesting_level,
                         uint64_t const& offset,
                         uint64_t const& overall_offset);
 
protected:
    void initializeProperties();
#endif // SgAsmDwarfPackedType_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmDwarfPackedType: public SgAsmDwarfConstruct {…};
#endif // DOCUMENTATION
 
 
// SgAsmDwarfNamespace           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmDwarfNamespace);
IS_SERIALIZABLE(AsmDwarfNamespace);
 
#ifndef DOCUMENTATION
AsmDwarfNamespace.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmDwarfNamespace);
#if defined(SgAsmDwarfNamespace_HEADERS) || defined(DOCUMENTATION)
#ifdef ROSE_SgAsmDwarfNamespace_IMPL
#include <SgAsmDwarfConstructList.h>
#endif
#endif // SgAsmDwarfNamespace_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmDwarfNamespace: public SgAsmDwarfConstruct {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmDwarfNamespace.setDataPrototype(
        "SgAsmDwarfConstructList*", "body", "= NULL",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmDwarfNamespace);
#if defined(SgAsmDwarfNamespace_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmDwarfNamespace -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmDwarfNamespace");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
        s & BOOST_SERIALIZATION_NVP(p_body);
        debugSerializationEnd("SgAsmDwarfNamespace");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgAsmDwarfConstructList* const& get_body() const;
    void set_body(SgAsmDwarfConstructList* const&);
public:
    SgAsmDwarfConstructList* get_children() override;
public:
    virtual ~SgAsmDwarfNamespace();
 
public:
    SgAsmDwarfNamespace();
 
public:
    SgAsmDwarfNamespace(int const& nesting_level,
                        uint64_t const& offset,
                        uint64_t const& overall_offset);
 
protected:
    void initializeProperties();
#endif // SgAsmDwarfNamespace_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmDwarfNamespace: public SgAsmDwarfConstruct {…};
#endif // DOCUMENTATION
 
 
// SgAsmDwarfNamelistItem           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmDwarfNamelistItem);
IS_SERIALIZABLE(AsmDwarfNamelistItem);
 
#ifndef DOCUMENTATION
AsmDwarfNamelistItem.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmDwarfNamelistItem: public SgAsmDwarfConstruct {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmDwarfNamelistItem);
#if defined(SgAsmDwarfNamelistItem_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmDwarfNamelistItem -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmDwarfNamelistItem");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
        debugSerializationEnd("SgAsmDwarfNamelistItem");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    virtual ~SgAsmDwarfNamelistItem();
 
public:
    SgAsmDwarfNamelistItem();
 
public:
    SgAsmDwarfNamelistItem(int const& nesting_level,
                           uint64_t const& offset,
                           uint64_t const& overall_offset);
 
protected:
    void initializeProperties();
#endif // SgAsmDwarfNamelistItem_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmDwarfNamelistItem: public SgAsmDwarfConstruct {…};
#endif // DOCUMENTATION
 
 
// SgAsmDwarfNamelist           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmDwarfNamelist);
IS_SERIALIZABLE(AsmDwarfNamelist);
 
#ifndef DOCUMENTATION
AsmDwarfNamelist.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmDwarfNamelist: public SgAsmDwarfConstruct {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmDwarfNamelist);
#if defined(SgAsmDwarfNamelist_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmDwarfNamelist -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmDwarfNamelist");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
        debugSerializationEnd("SgAsmDwarfNamelist");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    virtual ~SgAsmDwarfNamelist();
 
public:
    SgAsmDwarfNamelist();
 
public:
    SgAsmDwarfNamelist(int const& nesting_level,
                       uint64_t const& offset,
                       uint64_t const& overall_offset);
 
protected:
    void initializeProperties();
#endif // SgAsmDwarfNamelist_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmDwarfNamelist: public SgAsmDwarfConstruct {…};
#endif // DOCUMENTATION
 
 
// SgAsmDwarfMutableType           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmDwarfMutableType);
IS_SERIALIZABLE(AsmDwarfMutableType);
 
#ifndef DOCUMENTATION
AsmDwarfMutableType.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmDwarfMutableType: public SgAsmDwarfConstruct {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmDwarfMutableType);
#if defined(SgAsmDwarfMutableType_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmDwarfMutableType -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmDwarfMutableType");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
        debugSerializationEnd("SgAsmDwarfMutableType");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    virtual ~SgAsmDwarfMutableType();
 
public:
    SgAsmDwarfMutableType();
 
public:
    SgAsmDwarfMutableType(int const& nesting_level,
                          uint64_t const& offset,
                          uint64_t const& overall_offset);
 
protected:
    void initializeProperties();
#endif // SgAsmDwarfMutableType_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmDwarfMutableType: public SgAsmDwarfConstruct {…};
#endif // DOCUMENTATION
 
 
// SgAsmDwarfModule           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmDwarfModule);
IS_SERIALIZABLE(AsmDwarfModule);
 
#ifndef DOCUMENTATION
AsmDwarfModule.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmDwarfModule: public SgAsmDwarfConstruct {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmDwarfModule);
#if defined(SgAsmDwarfModule_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmDwarfModule -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmDwarfModule");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
        debugSerializationEnd("SgAsmDwarfModule");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    virtual ~SgAsmDwarfModule();
 
public:
    SgAsmDwarfModule();
 
public:
    SgAsmDwarfModule(int const& nesting_level,
                     uint64_t const& offset,
                     uint64_t const& overall_offset);
 
protected:
    void initializeProperties();
#endif // SgAsmDwarfModule_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmDwarfModule: public SgAsmDwarfConstruct {…};
#endif // DOCUMENTATION
 
 
// SgAsmDwarfMember           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmDwarfMember);
IS_SERIALIZABLE(AsmDwarfMember);
 
#ifndef DOCUMENTATION
AsmDwarfMember.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmDwarfMember: public SgAsmDwarfConstruct {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmDwarfMember);
#if defined(SgAsmDwarfMember_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmDwarfMember -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmDwarfMember");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
        debugSerializationEnd("SgAsmDwarfMember");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    virtual ~SgAsmDwarfMember();
 
public:
    SgAsmDwarfMember();
 
public:
    SgAsmDwarfMember(int const& nesting_level,
                     uint64_t const& offset,
                     uint64_t const& overall_offset);
 
protected:
    void initializeProperties();
#endif // SgAsmDwarfMember_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmDwarfMember: public SgAsmDwarfConstruct {…};
#endif // DOCUMENTATION
 
 
// SgAsmDwarfMacroList           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmDwarfMacroList);
IS_SERIALIZABLE(AsmDwarfMacroList);
 
#ifndef DOCUMENTATION
AsmDwarfMacroList.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmDwarfMacroList);
#if defined(SgAsmDwarfMacroList_HEADERS) || defined(DOCUMENTATION)
#include <sageContainer.h>
#endif // SgAsmDwarfMacroList_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmDwarfMacroList: public SgAsmDwarfInformation {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmDwarfMacroList.setDataPrototype(
        "SgAsmDwarfMacroPtrList", "macro_list", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmDwarfMacroList);
#if defined(SgAsmDwarfMacroList_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmDwarfMacroList -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmDwarfMacroList");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfInformation);
        s & BOOST_SERIALIZATION_NVP(p_macro_list);
        debugSerializationEnd("SgAsmDwarfMacroList");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgAsmDwarfMacroPtrList const& get_macro_list() const;
    void set_macro_list(SgAsmDwarfMacroPtrList const&);
 
public:
    virtual ~SgAsmDwarfMacroList();
 
public:
    SgAsmDwarfMacroList();
 
protected:
    void initializeProperties();
#endif // SgAsmDwarfMacroList_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmDwarfMacroList: public SgAsmDwarfInformation {…};
#endif // DOCUMENTATION
 
 
// SgAsmDwarfMacro           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmDwarfMacro);
IS_SERIALIZABLE(AsmDwarfMacro);
 
#ifndef DOCUMENTATION
AsmDwarfMacro.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmDwarfMacro: public SgAsmDwarfInformation {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmDwarfMacro.setDataPrototype(
        "std::string", "macro_string", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmDwarfMacro);
#if defined(SgAsmDwarfMacro_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmDwarfMacro -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmDwarfMacro");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfInformation);
        s & BOOST_SERIALIZATION_NVP(p_macro_string);
        debugSerializationEnd("SgAsmDwarfMacro");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    std::string const& get_macro_string() const;
    void set_macro_string(std::string const&);
 
public:
    virtual ~SgAsmDwarfMacro();
 
public:
    SgAsmDwarfMacro();
 
protected:
    void initializeProperties();
#endif // SgAsmDwarfMacro_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmDwarfMacro: public SgAsmDwarfInformation {…};
#endif // DOCUMENTATION
 
 
// SgAsmDwarfLineList           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmDwarfLineList);
IS_SERIALIZABLE(AsmDwarfLineList);
 
#ifndef DOCUMENTATION
AsmDwarfLineList.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmDwarfLineList);
#if defined(SgAsmDwarfLineList_HEADERS) || defined(DOCUMENTATION)
#include <sageContainer.h>
#endif // SgAsmDwarfLineList_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmDwarfLineList: public SgAsmDwarfInformation {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmDwarfLineList.setDataPrototype(
        "SgAsmDwarfLinePtrList", "line_list", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmDwarfLineList);
#if defined(SgAsmDwarfLineList_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmDwarfLineList -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmDwarfLineList");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfInformation);
        s & BOOST_SERIALIZATION_NVP(p_line_list);
        debugSerializationEnd("SgAsmDwarfLineList");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgAsmDwarfLinePtrList const& get_line_list() const;
    SgAsmDwarfLinePtrList& get_line_list();
    void set_line_list(SgAsmDwarfLinePtrList const&);
#if 0
    // I [DQ] am having trouble making these proper data members so just use function to return them, so that they are
    // computed dynamically.
    AsmDwarfLineList.setDataPrototype("SgInstructionAddressSourcePositionMapPtrList", "instructionToSourceMap", "",
                                      NO_CONSTRUCTOR_PARAMETER, BUILD_LIST_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
    AsmDwarfLineList.setDataPrototype("SgSourcePositionInstructionAddressMapPtrList", "sourceToInstructionMap", "",
                                      NO_CONSTRUCTOR_PARAMETER, BUILD_LIST_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
#endif
 
public:
    // Once the maps are setup using a valid SgAsmDwarfCompilationUnit, NULL is an acceptable value.
    static DwarfInstructionSourceMapReturnType buildInstructionAddressSourcePositionMaps( SgAsmDwarfCompilationUnit* dwarf_cu = NULL );
 
    void display( const std::string & label );
 
    static std::pair<uint64_t,uint64_t> instructionRange();
    static std::pair<LineColumnFilePosition,LineColumnFilePosition> sourceCodeRange( int file_id );
 
    static uint64_t sourceCodeToAddress ( FileIdLineColumnFilePosition sourcePosition );
    static FileIdLineColumnFilePosition addressToSourceCode ( uint64_t address );
public:
    virtual ~SgAsmDwarfLineList();
 
public:
    SgAsmDwarfLineList();
 
protected:
    void initializeProperties();
#endif // SgAsmDwarfLineList_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmDwarfLineList: public SgAsmDwarfInformation {…};
#endif // DOCUMENTATION
 
 
// SgAsmDwarfLine           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmDwarfLine);
IS_SERIALIZABLE(AsmDwarfLine);
 
#ifndef DOCUMENTATION
AsmDwarfLine.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmDwarfLine: public SgAsmDwarfInformation {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmDwarfLine.setDataPrototype(
        "uint64_t", "address", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmDwarfLine.setDataPrototype(
        "int", "file_id", "= -2",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmDwarfLine.setDataPrototype(
        "int", "line", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmDwarfLine.setDataPrototype(
        "int", "column", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmDwarfLine);
#if defined(SgAsmDwarfLine_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmDwarfLine -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmDwarfLine");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfInformation);
        s & BOOST_SERIALIZATION_NVP(p_address);
        s & BOOST_SERIALIZATION_NVP(p_file_id);
        s & BOOST_SERIALIZATION_NVP(p_line);
        s & BOOST_SERIALIZATION_NVP(p_column);
        debugSerializationEnd("SgAsmDwarfLine");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    uint64_t const& get_address() const;
    void set_address(uint64_t const&);
    // FIXME[Robb Matzke 2024-03-14]: Sg_File_Info::NULL_FILE_ID == -2, but since Sg_File_Info's definition is in the
    // huge Cxx_Grammar.h file we don't want to include it here.
public:
    int const& get_file_id() const;
    void set_file_id(int const&);
 
public:
    int const& get_line() const;
    void set_line(int const&);
 
public:
    int const& get_column() const;
    void set_column(int const&);
 
public:
    virtual ~SgAsmDwarfLine();
 
public:
    SgAsmDwarfLine();
 
public:
    SgAsmDwarfLine(uint64_t const& address,
                   int const& file_id,
                   int const& line,
                   int const& column);
 
protected:
    void initializeProperties();
#endif // SgAsmDwarfLine_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmDwarfLine: public SgAsmDwarfInformation {…};
#endif // DOCUMENTATION
 
 
// SgAsmDwarfLexicalBlock           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmDwarfLexicalBlock);
IS_SERIALIZABLE(AsmDwarfLexicalBlock);
 
#ifndef DOCUMENTATION
AsmDwarfLexicalBlock.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmDwarfLexicalBlock);
#if defined(SgAsmDwarfLexicalBlock_HEADERS) || defined(DOCUMENTATION)
#ifdef ROSE_SgAsmDwarfLexicalBlock_IMPL
#include <SgAsmDwarfConstructList.h>
#endif
#endif // SgAsmDwarfLexicalBlock_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmDwarfLexicalBlock: public SgAsmDwarfConstruct {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmDwarfLexicalBlock.setDataPrototype(
        "SgAsmDwarfConstructList*", "body", "= nullptr",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmDwarfLexicalBlock);
#if defined(SgAsmDwarfLexicalBlock_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmDwarfLexicalBlock -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmDwarfLexicalBlock");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
        s & BOOST_SERIALIZATION_NVP(p_body);
        debugSerializationEnd("SgAsmDwarfLexicalBlock");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgAsmDwarfConstructList* const& get_body() const;
    void set_body(SgAsmDwarfConstructList* const&);
public:
    SgAsmDwarfConstructList* get_children() override;
public:
    virtual ~SgAsmDwarfLexicalBlock();
 
public:
    SgAsmDwarfLexicalBlock();
 
public:
    SgAsmDwarfLexicalBlock(int const& nesting_level,
                           uint64_t const& offset,
                           uint64_t const& overall_offset);
 
protected:
    void initializeProperties();
#endif // SgAsmDwarfLexicalBlock_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmDwarfLexicalBlock: public SgAsmDwarfConstruct {…};
#endif // DOCUMENTATION
 
 
// SgAsmDwarfLabel           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmDwarfLabel);
IS_SERIALIZABLE(AsmDwarfLabel);
 
#ifndef DOCUMENTATION
AsmDwarfLabel.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmDwarfLabel: public SgAsmDwarfConstruct {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmDwarfLabel);
#if defined(SgAsmDwarfLabel_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmDwarfLabel -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmDwarfLabel");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
        debugSerializationEnd("SgAsmDwarfLabel");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    virtual ~SgAsmDwarfLabel();
 
public:
    SgAsmDwarfLabel();
 
public:
    SgAsmDwarfLabel(int const& nesting_level,
                    uint64_t const& offset,
                    uint64_t const& overall_offset);
 
protected:
    void initializeProperties();
#endif // SgAsmDwarfLabel_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmDwarfLabel: public SgAsmDwarfConstruct {…};
#endif // DOCUMENTATION
 
 
// SgAsmDwarfInterfaceType           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmDwarfInterfaceType);
IS_SERIALIZABLE(AsmDwarfInterfaceType);
 
#ifndef DOCUMENTATION
AsmDwarfInterfaceType.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmDwarfInterfaceType: public SgAsmDwarfConstruct {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmDwarfInterfaceType);
#if defined(SgAsmDwarfInterfaceType_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmDwarfInterfaceType -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmDwarfInterfaceType");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
        debugSerializationEnd("SgAsmDwarfInterfaceType");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    virtual ~SgAsmDwarfInterfaceType();
 
public:
    SgAsmDwarfInterfaceType();
 
public:
    SgAsmDwarfInterfaceType(int const& nesting_level,
                            uint64_t const& offset,
                            uint64_t const& overall_offset);
 
protected:
    void initializeProperties();
#endif // SgAsmDwarfInterfaceType_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmDwarfInterfaceType: public SgAsmDwarfConstruct {…};
#endif // DOCUMENTATION
 
 
// SgAsmDwarfInlinedSubroutine           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmDwarfInlinedSubroutine);
IS_SERIALIZABLE(AsmDwarfInlinedSubroutine);
 
#ifndef DOCUMENTATION
AsmDwarfInlinedSubroutine.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmDwarfInlinedSubroutine);
#if defined(SgAsmDwarfInlinedSubroutine_HEADERS) || defined(DOCUMENTATION)
#ifdef ROSE_SgAsmDwarfInlinedSubroutine_IMPL
#include <SgAsmDwarfConstructList.h>
#endif
#endif // SgAsmDwarfInlinedSubroutine_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmDwarfInlinedSubroutine: public SgAsmDwarfConstruct {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmDwarfInlinedSubroutine.setDataPrototype(
        "SgAsmDwarfConstructList*", "body", "= nullptr",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmDwarfInlinedSubroutine);
#if defined(SgAsmDwarfInlinedSubroutine_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmDwarfInlinedSubroutine -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmDwarfInlinedSubroutine");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
        s & BOOST_SERIALIZATION_NVP(p_body);
        debugSerializationEnd("SgAsmDwarfInlinedSubroutine");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgAsmDwarfConstructList* const& get_body() const;
    void set_body(SgAsmDwarfConstructList* const&);
public:
    SgAsmDwarfConstructList* get_children() override;
public:
    virtual ~SgAsmDwarfInlinedSubroutine();
 
public:
    SgAsmDwarfInlinedSubroutine();
 
public:
    SgAsmDwarfInlinedSubroutine(int const& nesting_level,
                                uint64_t const& offset,
                                uint64_t const& overall_offset);
 
protected:
    void initializeProperties();
#endif // SgAsmDwarfInlinedSubroutine_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmDwarfInlinedSubroutine: public SgAsmDwarfConstruct {…};
#endif // DOCUMENTATION
 
 
// SgAsmDwarfInheritance           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmDwarfInheritance);
IS_SERIALIZABLE(AsmDwarfInheritance);
 
#ifndef DOCUMENTATION
AsmDwarfInheritance.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmDwarfInheritance: public SgAsmDwarfConstruct {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmDwarfInheritance);
#if defined(SgAsmDwarfInheritance_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmDwarfInheritance -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmDwarfInheritance");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
        debugSerializationEnd("SgAsmDwarfInheritance");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    virtual ~SgAsmDwarfInheritance();
 
public:
    SgAsmDwarfInheritance();
 
public:
    SgAsmDwarfInheritance(int const& nesting_level,
                          uint64_t const& offset,
                          uint64_t const& overall_offset);
 
protected:
    void initializeProperties();
#endif // SgAsmDwarfInheritance_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmDwarfInheritance: public SgAsmDwarfConstruct {…};
#endif // DOCUMENTATION
 
 
// SgAsmDwarfImportedUnit           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmDwarfImportedUnit);
IS_SERIALIZABLE(AsmDwarfImportedUnit);
 
#ifndef DOCUMENTATION
AsmDwarfImportedUnit.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmDwarfImportedUnit: public SgAsmDwarfConstruct {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmDwarfImportedUnit);
#if defined(SgAsmDwarfImportedUnit_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmDwarfImportedUnit -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmDwarfImportedUnit");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
        debugSerializationEnd("SgAsmDwarfImportedUnit");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    virtual ~SgAsmDwarfImportedUnit();
 
public:
    SgAsmDwarfImportedUnit();
 
public:
    SgAsmDwarfImportedUnit(int const& nesting_level,
                           uint64_t const& offset,
                           uint64_t const& overall_offset);
 
protected:
    void initializeProperties();
#endif // SgAsmDwarfImportedUnit_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmDwarfImportedUnit: public SgAsmDwarfConstruct {…};
#endif // DOCUMENTATION
 
 
// SgAsmDwarfImportedModule           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmDwarfImportedModule);
IS_SERIALIZABLE(AsmDwarfImportedModule);
 
#ifndef DOCUMENTATION
AsmDwarfImportedModule.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmDwarfImportedModule: public SgAsmDwarfConstruct {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmDwarfImportedModule);
#if defined(SgAsmDwarfImportedModule_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmDwarfImportedModule -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmDwarfImportedModule");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
        debugSerializationEnd("SgAsmDwarfImportedModule");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    virtual ~SgAsmDwarfImportedModule();
 
public:
    SgAsmDwarfImportedModule();
 
public:
    SgAsmDwarfImportedModule(int const& nesting_level,
                             uint64_t const& offset,
                             uint64_t const& overall_offset);
 
protected:
    void initializeProperties();
#endif // SgAsmDwarfImportedModule_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmDwarfImportedModule: public SgAsmDwarfConstruct {…};
#endif // DOCUMENTATION
 
 
// SgAsmDwarfImportedDeclaration           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmDwarfImportedDeclaration);
IS_SERIALIZABLE(AsmDwarfImportedDeclaration);
 
#ifndef DOCUMENTATION
AsmDwarfImportedDeclaration.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmDwarfImportedDeclaration: public SgAsmDwarfConstruct {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmDwarfImportedDeclaration);
#if defined(SgAsmDwarfImportedDeclaration_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmDwarfImportedDeclaration -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmDwarfImportedDeclaration");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
        debugSerializationEnd("SgAsmDwarfImportedDeclaration");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    virtual ~SgAsmDwarfImportedDeclaration();
 
public:
    SgAsmDwarfImportedDeclaration();
 
public:
    SgAsmDwarfImportedDeclaration(int const& nesting_level,
                                  uint64_t const& offset,
                                  uint64_t const& overall_offset);
 
protected:
    void initializeProperties();
#endif // SgAsmDwarfImportedDeclaration_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmDwarfImportedDeclaration: public SgAsmDwarfConstruct {…};
#endif // DOCUMENTATION
 
 
// SgAsmDwarfFunctionTemplate           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmDwarfFunctionTemplate);
IS_SERIALIZABLE(AsmDwarfFunctionTemplate);
 
#ifndef DOCUMENTATION
AsmDwarfFunctionTemplate.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmDwarfFunctionTemplate: public SgAsmDwarfConstruct {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmDwarfFunctionTemplate);
#if defined(SgAsmDwarfFunctionTemplate_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmDwarfFunctionTemplate -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmDwarfFunctionTemplate");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
        debugSerializationEnd("SgAsmDwarfFunctionTemplate");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    virtual ~SgAsmDwarfFunctionTemplate();
 
public:
    SgAsmDwarfFunctionTemplate();
 
public:
    SgAsmDwarfFunctionTemplate(int const& nesting_level,
                               uint64_t const& offset,
                               uint64_t const& overall_offset);
 
protected:
    void initializeProperties();
#endif // SgAsmDwarfFunctionTemplate_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmDwarfFunctionTemplate: public SgAsmDwarfConstruct {…};
#endif // DOCUMENTATION
 
 
// SgAsmDwarfFriend           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmDwarfFriend);
IS_SERIALIZABLE(AsmDwarfFriend);
 
#ifndef DOCUMENTATION
AsmDwarfFriend.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmDwarfFriend: public SgAsmDwarfConstruct {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmDwarfFriend);
#if defined(SgAsmDwarfFriend_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmDwarfFriend -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmDwarfFriend");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
        debugSerializationEnd("SgAsmDwarfFriend");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    virtual ~SgAsmDwarfFriend();
 
public:
    SgAsmDwarfFriend();
 
public:
    SgAsmDwarfFriend(int const& nesting_level,
                     uint64_t const& offset,
                     uint64_t const& overall_offset);
 
protected:
    void initializeProperties();
#endif // SgAsmDwarfFriend_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmDwarfFriend: public SgAsmDwarfConstruct {…};
#endif // DOCUMENTATION
 
 
// SgAsmDwarfFormatLabel           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmDwarfFormatLabel);
IS_SERIALIZABLE(AsmDwarfFormatLabel);
 
#ifndef DOCUMENTATION
AsmDwarfFormatLabel.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmDwarfFormatLabel: public SgAsmDwarfConstruct {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmDwarfFormatLabel);
#if defined(SgAsmDwarfFormatLabel_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmDwarfFormatLabel -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmDwarfFormatLabel");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
        debugSerializationEnd("SgAsmDwarfFormatLabel");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    virtual ~SgAsmDwarfFormatLabel();
 
public:
    SgAsmDwarfFormatLabel();
 
public:
    SgAsmDwarfFormatLabel(int const& nesting_level,
                          uint64_t const& offset,
                          uint64_t const& overall_offset);
 
protected:
    void initializeProperties();
#endif // SgAsmDwarfFormatLabel_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmDwarfFormatLabel: public SgAsmDwarfConstruct {…};
#endif // DOCUMENTATION
 
 
// SgAsmDwarfFormalParameter           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmDwarfFormalParameter);
IS_SERIALIZABLE(AsmDwarfFormalParameter);
 
#ifndef DOCUMENTATION
AsmDwarfFormalParameter.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmDwarfFormalParameter: public SgAsmDwarfConstruct {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmDwarfFormalParameter);
#if defined(SgAsmDwarfFormalParameter_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmDwarfFormalParameter -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmDwarfFormalParameter");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
        debugSerializationEnd("SgAsmDwarfFormalParameter");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    virtual ~SgAsmDwarfFormalParameter();
 
public:
    SgAsmDwarfFormalParameter();
 
public:
    SgAsmDwarfFormalParameter(int const& nesting_level,
                              uint64_t const& offset,
                              uint64_t const& overall_offset);
 
protected:
    void initializeProperties();
#endif // SgAsmDwarfFormalParameter_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmDwarfFormalParameter: public SgAsmDwarfConstruct {…};
#endif // DOCUMENTATION
 
 
// SgAsmDwarfFileType           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmDwarfFileType);
IS_SERIALIZABLE(AsmDwarfFileType);
 
#ifndef DOCUMENTATION
AsmDwarfFileType.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmDwarfFileType: public SgAsmDwarfConstruct {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmDwarfFileType);
#if defined(SgAsmDwarfFileType_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmDwarfFileType -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmDwarfFileType");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
        debugSerializationEnd("SgAsmDwarfFileType");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    virtual ~SgAsmDwarfFileType();
 
public:
    SgAsmDwarfFileType();
 
public:
    SgAsmDwarfFileType(int const& nesting_level,
                       uint64_t const& offset,
                       uint64_t const& overall_offset);
 
protected:
    void initializeProperties();
#endif // SgAsmDwarfFileType_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmDwarfFileType: public SgAsmDwarfConstruct {…};
#endif // DOCUMENTATION
 
 
// SgAsmDwarfEnumerator           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmDwarfEnumerator);
IS_SERIALIZABLE(AsmDwarfEnumerator);
 
#ifndef DOCUMENTATION
AsmDwarfEnumerator.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmDwarfEnumerator: public SgAsmDwarfConstruct {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmDwarfEnumerator);
#if defined(SgAsmDwarfEnumerator_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmDwarfEnumerator -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmDwarfEnumerator");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
        debugSerializationEnd("SgAsmDwarfEnumerator");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    virtual ~SgAsmDwarfEnumerator();
 
public:
    SgAsmDwarfEnumerator();
 
public:
    SgAsmDwarfEnumerator(int const& nesting_level,
                         uint64_t const& offset,
                         uint64_t const& overall_offset);
 
protected:
    void initializeProperties();
#endif // SgAsmDwarfEnumerator_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmDwarfEnumerator: public SgAsmDwarfConstruct {…};
#endif // DOCUMENTATION
 
 
// SgAsmDwarfEnumerationType           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmDwarfEnumerationType);
IS_SERIALIZABLE(AsmDwarfEnumerationType);
 
#ifndef DOCUMENTATION
AsmDwarfEnumerationType.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmDwarfEnumerationType);
#if defined(SgAsmDwarfEnumerationType_HEADERS) || defined(DOCUMENTATION)
#ifdef ROSE_SgAsmDwarfEnumerationType_IMPL
#include <SgAsmDwarfConstructList.h>
#endif
#endif // SgAsmDwarfEnumerationType_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmDwarfEnumerationType: public SgAsmDwarfConstruct {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmDwarfEnumerationType.setDataPrototype(
        "SgAsmDwarfConstructList*", "body", "= NULL",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmDwarfEnumerationType);
#if defined(SgAsmDwarfEnumerationType_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmDwarfEnumerationType -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmDwarfEnumerationType");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
        s & BOOST_SERIALIZATION_NVP(p_body);
        debugSerializationEnd("SgAsmDwarfEnumerationType");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgAsmDwarfConstructList* const& get_body() const;
    void set_body(SgAsmDwarfConstructList* const&);
public:
    SgAsmDwarfConstructList* get_children() override;
public:
    virtual ~SgAsmDwarfEnumerationType();
 
public:
    SgAsmDwarfEnumerationType();
 
public:
    SgAsmDwarfEnumerationType(int const& nesting_level,
                              uint64_t const& offset,
                              uint64_t const& overall_offset);
 
protected:
    void initializeProperties();
#endif // SgAsmDwarfEnumerationType_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmDwarfEnumerationType: public SgAsmDwarfConstruct {…};
#endif // DOCUMENTATION
 
 
// SgAsmDwarfEntryPoint           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmDwarfEntryPoint);
IS_SERIALIZABLE(AsmDwarfEntryPoint);
 
#ifndef DOCUMENTATION
AsmDwarfEntryPoint.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmDwarfEntryPoint: public SgAsmDwarfConstruct {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmDwarfEntryPoint);
#if defined(SgAsmDwarfEntryPoint_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmDwarfEntryPoint -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmDwarfEntryPoint");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
        debugSerializationEnd("SgAsmDwarfEntryPoint");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    virtual ~SgAsmDwarfEntryPoint();
 
public:
    SgAsmDwarfEntryPoint();
 
public:
    SgAsmDwarfEntryPoint(int const& nesting_level,
                         uint64_t const& offset,
                         uint64_t const& overall_offset);
 
protected:
    void initializeProperties();
#endif // SgAsmDwarfEntryPoint_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmDwarfEntryPoint: public SgAsmDwarfConstruct {…};
#endif // DOCUMENTATION
 
 
// SgAsmDwarfDwarfProcedure           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmDwarfDwarfProcedure);
IS_SERIALIZABLE(AsmDwarfDwarfProcedure);
 
#ifndef DOCUMENTATION
AsmDwarfDwarfProcedure.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmDwarfDwarfProcedure: public SgAsmDwarfConstruct {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmDwarfDwarfProcedure);
#if defined(SgAsmDwarfDwarfProcedure_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmDwarfDwarfProcedure -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmDwarfDwarfProcedure");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
        debugSerializationEnd("SgAsmDwarfDwarfProcedure");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    virtual ~SgAsmDwarfDwarfProcedure();
 
public:
    SgAsmDwarfDwarfProcedure();
 
public:
    SgAsmDwarfDwarfProcedure(int const& nesting_level,
                             uint64_t const& offset,
                             uint64_t const& overall_offset);
 
protected:
    void initializeProperties();
#endif // SgAsmDwarfDwarfProcedure_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmDwarfDwarfProcedure: public SgAsmDwarfConstruct {…};
#endif // DOCUMENTATION
 
 
// SgAsmDwarfConstType           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmDwarfConstType);
IS_SERIALIZABLE(AsmDwarfConstType);
 
#ifndef DOCUMENTATION
AsmDwarfConstType.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmDwarfConstType: public SgAsmDwarfConstruct {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmDwarfConstType);
#if defined(SgAsmDwarfConstType_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmDwarfConstType -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmDwarfConstType");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
        debugSerializationEnd("SgAsmDwarfConstType");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    virtual ~SgAsmDwarfConstType();
 
public:
    SgAsmDwarfConstType();
 
public:
    SgAsmDwarfConstType(int const& nesting_level,
                        uint64_t const& offset,
                        uint64_t const& overall_offset);
 
protected:
    void initializeProperties();
#endif // SgAsmDwarfConstType_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmDwarfConstType: public SgAsmDwarfConstruct {…};
#endif // DOCUMENTATION
 
 
// SgAsmDwarfConstructList           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmDwarfConstructList);
IS_SERIALIZABLE(AsmDwarfConstructList);
 
#ifndef DOCUMENTATION
AsmDwarfConstructList.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmDwarfConstructList);
#if defined(SgAsmDwarfConstructList_HEADERS) || defined(DOCUMENTATION)
#include <sageContainer.h>
#endif // SgAsmDwarfConstructList_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmDwarfConstructList: public SgAsmDwarfInformation {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmDwarfConstructList.setDataPrototype(
        "SgAsmDwarfConstructPtrList", "list", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmDwarfConstructList);
#if defined(SgAsmDwarfConstructList_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmDwarfConstructList -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmDwarfConstructList");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfInformation);
        s & BOOST_SERIALIZATION_NVP(p_list);
        debugSerializationEnd("SgAsmDwarfConstructList");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgAsmDwarfConstructPtrList const& get_list() const;
    SgAsmDwarfConstructPtrList& get_list();
    void set_list(SgAsmDwarfConstructPtrList const&);
 
public:
    virtual ~SgAsmDwarfConstructList();
 
public:
    SgAsmDwarfConstructList();
 
protected:
    void initializeProperties();
#endif // SgAsmDwarfConstructList_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmDwarfConstructList: public SgAsmDwarfInformation {…};
#endif // DOCUMENTATION
 
 
// SgAsmDwarfConstant           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmDwarfConstant);
IS_SERIALIZABLE(AsmDwarfConstant);
 
#ifndef DOCUMENTATION
AsmDwarfConstant.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmDwarfConstant: public SgAsmDwarfConstruct {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmDwarfConstant);
#if defined(SgAsmDwarfConstant_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmDwarfConstant -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmDwarfConstant");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
        debugSerializationEnd("SgAsmDwarfConstant");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    virtual ~SgAsmDwarfConstant();
 
public:
    SgAsmDwarfConstant();
 
public:
    SgAsmDwarfConstant(int const& nesting_level,
                       uint64_t const& offset,
                       uint64_t const& overall_offset);
 
protected:
    void initializeProperties();
#endif // SgAsmDwarfConstant_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmDwarfConstant: public SgAsmDwarfConstruct {…};
#endif // DOCUMENTATION
 
 
// SgAsmDwarfCondition           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmDwarfCondition);
IS_SERIALIZABLE(AsmDwarfCondition);
 
#ifndef DOCUMENTATION
AsmDwarfCondition.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmDwarfCondition: public SgAsmDwarfConstruct {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmDwarfCondition);
#if defined(SgAsmDwarfCondition_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmDwarfCondition -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmDwarfCondition");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
        debugSerializationEnd("SgAsmDwarfCondition");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    virtual ~SgAsmDwarfCondition();
 
public:
    SgAsmDwarfCondition();
 
public:
    SgAsmDwarfCondition(int const& nesting_level,
                        uint64_t const& offset,
                        uint64_t const& overall_offset);
 
protected:
    void initializeProperties();
#endif // SgAsmDwarfCondition_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmDwarfCondition: public SgAsmDwarfConstruct {…};
#endif // DOCUMENTATION
 
 
// SgAsmDwarfCompilationUnitList           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmDwarfCompilationUnitList);
IS_SERIALIZABLE(AsmDwarfCompilationUnitList);
 
#ifndef DOCUMENTATION
AsmDwarfCompilationUnitList.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmDwarfCompilationUnitList);
#if defined(SgAsmDwarfCompilationUnitList_HEADERS) || defined(DOCUMENTATION)
#include <sageContainer.h>
#endif // SgAsmDwarfCompilationUnitList_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmDwarfCompilationUnitList: public SgAsmDwarfInformation {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmDwarfCompilationUnitList.setDataPrototype(
        "SgAsmDwarfCompilationUnitPtrList", "cu_list", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmDwarfCompilationUnitList);
#if defined(SgAsmDwarfCompilationUnitList_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmDwarfCompilationUnitList -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmDwarfCompilationUnitList");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfInformation);
        s & BOOST_SERIALIZATION_NVP(p_cu_list);
        debugSerializationEnd("SgAsmDwarfCompilationUnitList");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgAsmDwarfCompilationUnitPtrList const& get_cu_list() const;
    SgAsmDwarfCompilationUnitPtrList& get_cu_list();
    void set_cu_list(SgAsmDwarfCompilationUnitPtrList const&);
 
public:
    virtual ~SgAsmDwarfCompilationUnitList();
 
public:
    SgAsmDwarfCompilationUnitList();
 
protected:
    void initializeProperties();
#endif // SgAsmDwarfCompilationUnitList_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmDwarfCompilationUnitList: public SgAsmDwarfInformation {…};
#endif // DOCUMENTATION
 
 
// SgAsmDwarfCompilationUnit           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmDwarfCompilationUnit);
IS_SERIALIZABLE(AsmDwarfCompilationUnit);
 
#ifndef DOCUMENTATION
AsmDwarfCompilationUnit.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmDwarfCompilationUnit);
#if defined(SgAsmDwarfCompilationUnit_HEADERS) || defined(DOCUMENTATION)
#ifdef ROSE_SgAsmDwarfCompilationUnit_IMPL
#include <SgAsmDwarfConstructList.h>
#include <SgAsmDwarfLineList.h>
#include <SgAsmDwarfMacroList.h>
#endif
#endif // SgAsmDwarfCompilationUnit_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmDwarfCompilationUnit: public SgAsmDwarfConstruct {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmDwarfCompilationUnit.setDataPrototype(
        "std::string", "producer", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmDwarfCompilationUnit.setDataPrototype(
        "std::string", "language", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmDwarfCompilationUnit.setDataPrototype(
        "uint64_t", "low_pc", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmDwarfCompilationUnit.setDataPrototype(
        "uint64_t", "hi_pc", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmDwarfCompilationUnit.setDataPrototype(
        "int", "version_stamp", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmDwarfCompilationUnit.setDataPrototype(
        "uint64_t", "abbrev_offset", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmDwarfCompilationUnit.setDataPrototype(
        "uint64_t", "address_size", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmDwarfCompilationUnit.setDataPrototype(
        "uint64_t", "offset_length", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmDwarfCompilationUnit.setDataPrototype(
        "SgAsmDwarfLineList*", "line_info", "= nullptr",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmDwarfCompilationUnit.setDataPrototype(
        "SgAsmDwarfConstructList*", "language_constructs", "= nullptr",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmDwarfCompilationUnit.setDataPrototype(
        "SgAsmDwarfMacroList*", "macro_info", "= nullptr",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmDwarfCompilationUnit);
#if defined(SgAsmDwarfCompilationUnit_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmDwarfCompilationUnit -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmDwarfCompilationUnit");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
        s & BOOST_SERIALIZATION_NVP(p_producer);
        s & BOOST_SERIALIZATION_NVP(p_language);
        s & BOOST_SERIALIZATION_NVP(p_low_pc);
        s & BOOST_SERIALIZATION_NVP(p_hi_pc);
        s & BOOST_SERIALIZATION_NVP(p_version_stamp);
        s & BOOST_SERIALIZATION_NVP(p_abbrev_offset);
        s & BOOST_SERIALIZATION_NVP(p_address_size);
        s & BOOST_SERIALIZATION_NVP(p_offset_length);
        s & BOOST_SERIALIZATION_NVP(p_line_info);
        s & BOOST_SERIALIZATION_NVP(p_language_constructs);
        s & BOOST_SERIALIZATION_NVP(p_macro_info);
        debugSerializationEnd("SgAsmDwarfCompilationUnit");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    std::string const& get_producer() const;
    void set_producer(std::string const&);
 
public:
    std::string const& get_language() const;
    void set_language(std::string const&);
 
public:
    uint64_t const& get_low_pc() const;
    void set_low_pc(uint64_t const&);
 
public:
    uint64_t const& get_hi_pc() const;
    void set_hi_pc(uint64_t const&);
 
public:
    int const& get_version_stamp() const;
    void set_version_stamp(int const&);
 
public:
    uint64_t const& get_abbrev_offset() const;
    void set_abbrev_offset(uint64_t const&);
 
public:
    uint64_t const& get_address_size() const;
    void set_address_size(uint64_t const&);
 
public:
    uint64_t const& get_offset_length() const;
    void set_offset_length(uint64_t const&);
 
public:
    SgAsmDwarfLineList* const& get_line_info() const;
    void set_line_info(SgAsmDwarfLineList* const&);
 
public:
    SgAsmDwarfConstructList* const& get_language_constructs() const;
    void set_language_constructs(SgAsmDwarfConstructList* const&);
 
public:
    SgAsmDwarfMacroList* const& get_macro_info() const;
    void set_macro_info(SgAsmDwarfMacroList* const&);
public:
    SgAsmDwarfConstructList* get_children() override;
public:
    virtual ~SgAsmDwarfCompilationUnit();
 
public:
    SgAsmDwarfCompilationUnit();
 
public:
    SgAsmDwarfCompilationUnit(int const& nesting_level,
                              uint64_t const& offset,
                              uint64_t const& overall_offset);
 
protected:
    void initializeProperties();
#endif // SgAsmDwarfCompilationUnit_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmDwarfCompilationUnit: public SgAsmDwarfConstruct {…};
#endif // DOCUMENTATION
 
 
// SgAsmDwarfCommonInclusion           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmDwarfCommonInclusion);
IS_SERIALIZABLE(AsmDwarfCommonInclusion);
 
#ifndef DOCUMENTATION
AsmDwarfCommonInclusion.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmDwarfCommonInclusion: public SgAsmDwarfConstruct {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmDwarfCommonInclusion);
#if defined(SgAsmDwarfCommonInclusion_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmDwarfCommonInclusion -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmDwarfCommonInclusion");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
        debugSerializationEnd("SgAsmDwarfCommonInclusion");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    virtual ~SgAsmDwarfCommonInclusion();
 
public:
    SgAsmDwarfCommonInclusion();
 
public:
    SgAsmDwarfCommonInclusion(int const& nesting_level,
                              uint64_t const& offset,
                              uint64_t const& overall_offset);
 
protected:
    void initializeProperties();
#endif // SgAsmDwarfCommonInclusion_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmDwarfCommonInclusion: public SgAsmDwarfConstruct {…};
#endif // DOCUMENTATION
 
 
// SgAsmDwarfCommonBlock           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmDwarfCommonBlock);
IS_SERIALIZABLE(AsmDwarfCommonBlock);
 
#ifndef DOCUMENTATION
AsmDwarfCommonBlock.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmDwarfCommonBlock);
#if defined(SgAsmDwarfCommonBlock_HEADERS) || defined(DOCUMENTATION)
#ifdef ROSE_SgAsmDwarfCommonBlock_IMPL
#include <SgAsmDwarfConstructList.h>
#endif
#endif // SgAsmDwarfCommonBlock_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmDwarfCommonBlock: public SgAsmDwarfConstruct {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmDwarfCommonBlock.setDataPrototype(
        "SgAsmDwarfConstructList*", "body", "= NULL",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmDwarfCommonBlock);
#if defined(SgAsmDwarfCommonBlock_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmDwarfCommonBlock -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmDwarfCommonBlock");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
        s & BOOST_SERIALIZATION_NVP(p_body);
        debugSerializationEnd("SgAsmDwarfCommonBlock");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgAsmDwarfConstructList* const& get_body() const;
    void set_body(SgAsmDwarfConstructList* const&);
public:
    SgAsmDwarfConstructList* get_children() override;
public:
    virtual ~SgAsmDwarfCommonBlock();
 
public:
    SgAsmDwarfCommonBlock();
 
public:
    SgAsmDwarfCommonBlock(int const& nesting_level,
                          uint64_t const& offset,
                          uint64_t const& overall_offset);
 
protected:
    void initializeProperties();
#endif // SgAsmDwarfCommonBlock_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmDwarfCommonBlock: public SgAsmDwarfConstruct {…};
#endif // DOCUMENTATION
 
 
// SgAsmDwarfClassType           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmDwarfClassType);
IS_SERIALIZABLE(AsmDwarfClassType);
 
#ifndef DOCUMENTATION
AsmDwarfClassType.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmDwarfClassType);
#if defined(SgAsmDwarfClassType_HEADERS) || defined(DOCUMENTATION)
#ifdef ROSE_SgAsmDwarfClassType_IMPL
#include <SgAsmDwarfConstructList.h>
#endif
#endif // SgAsmDwarfClassType_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmDwarfClassType: public SgAsmDwarfConstruct {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmDwarfClassType.setDataPrototype(
        "SgAsmDwarfConstructList*", "body", "= nullptr",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmDwarfClassType);
#if defined(SgAsmDwarfClassType_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmDwarfClassType -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmDwarfClassType");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
        s & BOOST_SERIALIZATION_NVP(p_body);
        debugSerializationEnd("SgAsmDwarfClassType");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgAsmDwarfConstructList* const& get_body() const;
    void set_body(SgAsmDwarfConstructList* const&);
public:
    SgAsmDwarfConstructList* get_children() override;
public:
    virtual ~SgAsmDwarfClassType();
 
public:
    SgAsmDwarfClassType();
 
public:
    SgAsmDwarfClassType(int const& nesting_level,
                        uint64_t const& offset,
                        uint64_t const& overall_offset);
 
protected:
    void initializeProperties();
#endif // SgAsmDwarfClassType_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmDwarfClassType: public SgAsmDwarfConstruct {…};
#endif // DOCUMENTATION
 
 
// SgAsmDwarfClassTemplate           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmDwarfClassTemplate);
IS_SERIALIZABLE(AsmDwarfClassTemplate);
 
#ifndef DOCUMENTATION
AsmDwarfClassTemplate.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmDwarfClassTemplate: public SgAsmDwarfConstruct {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmDwarfClassTemplate);
#if defined(SgAsmDwarfClassTemplate_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmDwarfClassTemplate -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmDwarfClassTemplate");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
        debugSerializationEnd("SgAsmDwarfClassTemplate");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    virtual ~SgAsmDwarfClassTemplate();
 
public:
    SgAsmDwarfClassTemplate();
 
public:
    SgAsmDwarfClassTemplate(int const& nesting_level,
                            uint64_t const& offset,
                            uint64_t const& overall_offset);
 
protected:
    void initializeProperties();
#endif // SgAsmDwarfClassTemplate_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmDwarfClassTemplate: public SgAsmDwarfConstruct {…};
#endif // DOCUMENTATION
 
 
// SgAsmDwarfCatchBlock           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmDwarfCatchBlock);
IS_SERIALIZABLE(AsmDwarfCatchBlock);
 
#ifndef DOCUMENTATION
AsmDwarfCatchBlock.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmDwarfCatchBlock: public SgAsmDwarfConstruct {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmDwarfCatchBlock);
#if defined(SgAsmDwarfCatchBlock_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmDwarfCatchBlock -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmDwarfCatchBlock");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
        debugSerializationEnd("SgAsmDwarfCatchBlock");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    virtual ~SgAsmDwarfCatchBlock();
 
public:
    SgAsmDwarfCatchBlock();
 
public:
    SgAsmDwarfCatchBlock(int const& nesting_level,
                         uint64_t const& offset,
                         uint64_t const& overall_offset);
 
protected:
    void initializeProperties();
#endif // SgAsmDwarfCatchBlock_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmDwarfCatchBlock: public SgAsmDwarfConstruct {…};
#endif // DOCUMENTATION
 
 
// SgAsmDwarfBaseType           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmDwarfBaseType);
IS_SERIALIZABLE(AsmDwarfBaseType);
 
#ifndef DOCUMENTATION
AsmDwarfBaseType.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmDwarfBaseType: public SgAsmDwarfConstruct {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmDwarfBaseType);
#if defined(SgAsmDwarfBaseType_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmDwarfBaseType -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmDwarfBaseType");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
        debugSerializationEnd("SgAsmDwarfBaseType");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    virtual ~SgAsmDwarfBaseType();
 
public:
    SgAsmDwarfBaseType();
 
public:
    SgAsmDwarfBaseType(int const& nesting_level,
                       uint64_t const& offset,
                       uint64_t const& overall_offset);
 
protected:
    void initializeProperties();
#endif // SgAsmDwarfBaseType_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmDwarfBaseType: public SgAsmDwarfConstruct {…};
#endif // DOCUMENTATION
 
 
// SgAsmDwarfArrayType           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmDwarfArrayType);
IS_SERIALIZABLE(AsmDwarfArrayType);
 
#ifndef DOCUMENTATION
AsmDwarfArrayType.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmDwarfArrayType);
#if defined(SgAsmDwarfArrayType_HEADERS) || defined(DOCUMENTATION)
#ifdef ROSE_SgAsmDwarfArrayType_IMPL
#include <SgAsmDwarfConstructList.h>
#endif
#endif // SgAsmDwarfArrayType_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmDwarfArrayType: public SgAsmDwarfConstruct {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmDwarfArrayType.setDataPrototype(
        "SgAsmDwarfConstructList*", "body", "= nullptr",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmDwarfArrayType);
#if defined(SgAsmDwarfArrayType_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmDwarfArrayType -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmDwarfArrayType");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
        s & BOOST_SERIALIZATION_NVP(p_body);
        debugSerializationEnd("SgAsmDwarfArrayType");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgAsmDwarfConstructList* const& get_body() const;
    void set_body(SgAsmDwarfConstructList* const&);
public:
    SgAsmDwarfConstructList* get_children() override;
public:
    virtual ~SgAsmDwarfArrayType();
 
public:
    SgAsmDwarfArrayType();
 
public:
    SgAsmDwarfArrayType(int const& nesting_level,
                        uint64_t const& offset,
                        uint64_t const& overall_offset);
 
protected:
    void initializeProperties();
#endif // SgAsmDwarfArrayType_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmDwarfArrayType: public SgAsmDwarfConstruct {…};
#endif // DOCUMENTATION
 
 
// SgAsmDwarfAccessDeclaration           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmDwarfAccessDeclaration);
IS_SERIALIZABLE(AsmDwarfAccessDeclaration);
 
#ifndef DOCUMENTATION
AsmDwarfAccessDeclaration.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmDwarfAccessDeclaration: public SgAsmDwarfConstruct {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmDwarfAccessDeclaration);
#if defined(SgAsmDwarfAccessDeclaration_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmDwarfAccessDeclaration -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmDwarfAccessDeclaration");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
        debugSerializationEnd("SgAsmDwarfAccessDeclaration");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    virtual ~SgAsmDwarfAccessDeclaration();
 
public:
    SgAsmDwarfAccessDeclaration();
 
public:
    SgAsmDwarfAccessDeclaration(int const& nesting_level,
                                uint64_t const& offset,
                                uint64_t const& overall_offset);
 
protected:
    void initializeProperties();
#endif // SgAsmDwarfAccessDeclaration_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmDwarfAccessDeclaration: public SgAsmDwarfConstruct {…};
#endif // DOCUMENTATION
 
 
// SgAsmDwarfConstruct           -- MACHINE GENERATED; DO NOT MODIFY --
 
#ifndef DOCUMENTATION
AstNodeClass& AsmDwarfConstruct = nonTerminalConstructor(
    "AsmDwarfConstruct",
    *this,
    "AsmDwarfConstruct",
    "AsmDwarfConstructTag",
    SubclassListBuilder()
        | AsmDwarfAccessDeclaration
        | AsmDwarfArrayType
        | AsmDwarfBaseType
        | AsmDwarfCatchBlock
        | AsmDwarfClassTemplate
        | AsmDwarfClassType
        | AsmDwarfCommonBlock
        | AsmDwarfCommonInclusion
        | AsmDwarfCompilationUnit
        | AsmDwarfCondition
        | AsmDwarfConstant
        | AsmDwarfConstType
        | AsmDwarfDwarfProcedure
        | AsmDwarfEntryPoint
        | AsmDwarfEnumerationType
        | AsmDwarfEnumerator
        | AsmDwarfFileType
        | AsmDwarfFormalParameter
        | AsmDwarfFormatLabel
        | AsmDwarfFriend
        | AsmDwarfFunctionTemplate
        | AsmDwarfImportedDeclaration
        | AsmDwarfImportedModule
        | AsmDwarfImportedUnit
        | AsmDwarfInheritance
        | AsmDwarfInlinedSubroutine
        | AsmDwarfInterfaceType
        | AsmDwarfLabel
        | AsmDwarfLexicalBlock
        | AsmDwarfMember
        | AsmDwarfModule
        | AsmDwarfMutableType
        | AsmDwarfNamelist
        | AsmDwarfNamelistItem
        | AsmDwarfNamespace
        | AsmDwarfPackedType
        | AsmDwarfPartialUnit
        | AsmDwarfPointerType
        | AsmDwarfPtrToMemberType
        | AsmDwarfReferenceType
        | AsmDwarfRestrictType
        | AsmDwarfSetType
        | AsmDwarfSharedType
        | AsmDwarfStringType
        | AsmDwarfStructureType
        | AsmDwarfSubprogram
        | AsmDwarfSubrangeType
        | AsmDwarfSubroutineType
        | AsmDwarfTemplateTypeParameter
        | AsmDwarfTemplateValueParameter
        | AsmDwarfThrownType
        | AsmDwarfTryBlock
        | AsmDwarfTypedef
        | AsmDwarfUnionType
        | AsmDwarfUnknownConstruct
        | AsmDwarfUnspecifiedParameters
        | AsmDwarfUnspecifiedType
        | AsmDwarfUpcRelaxedType
        | AsmDwarfUpcSharedType
        | AsmDwarfUpcStrictType
        | AsmDwarfVariable
        | AsmDwarfVariant
        | AsmDwarfVariantPart
        | AsmDwarfVolatileType
        | AsmDwarfWithStmt
    , false);
assert(AsmDwarfConstruct.associatedGrammar != nullptr);
AsmDwarfConstruct.setCppCondition("!defined(DOCUMENTATION)");
AsmDwarfConstruct.isBoostSerializable(true);
AsmDwarfConstruct.setAutomaticGenerationOfConstructor(false);
AsmDwarfConstruct.setAutomaticGenerationOfDestructor(false);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
AsmDwarfConstruct.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmDwarfConstruct: public SgAsmDwarfInformation {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmDwarfConstruct.setDataPrototype(
        "int", "nesting_level", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmDwarfConstruct.setDataPrototype(
        "uint64_t", "offset", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmDwarfConstruct.setDataPrototype(
        "uint64_t", "overall_offset", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmDwarfConstruct.setDataPrototype(
        "std::string", "name", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmDwarfConstruct.setDataPrototype(
        "SgAsmDwarfLine*", "source_position", "= nullptr",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmDwarfConstruct);
#if defined(SgAsmDwarfConstruct_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmDwarfConstruct -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmDwarfConstruct");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfInformation);
        s & BOOST_SERIALIZATION_NVP(p_nesting_level);
        s & BOOST_SERIALIZATION_NVP(p_offset);
        s & BOOST_SERIALIZATION_NVP(p_overall_offset);
        s & BOOST_SERIALIZATION_NVP(p_name);
        s & BOOST_SERIALIZATION_NVP(p_source_position);
        debugSerializationEnd("SgAsmDwarfConstruct");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
    // For now we will store the nesting level (just to support debugging), then it will be removed.
public:
    int const& get_nesting_level() const;
    void set_nesting_level(int const&);
 
public:
    uint64_t const& get_offset() const;
    void set_offset(uint64_t const&);
 
public:
    uint64_t const& get_overall_offset() const;
    void set_overall_offset(uint64_t const&);
    // A lot of constructs have a name so put the name into the base class
public:
    std::string const& get_name() const;
    void set_name(std::string const&);
    // This is a data member that can be filled in via a separate analysis (we would have to read the line information before
    // hand).
public:
    SgAsmDwarfLine* const& get_source_position() const;
    void set_source_position(SgAsmDwarfLine* const&);
    // [Robb Matzke 2023-03-22]: SgNode already has an attributeMechanism
    // [[using Rosebud: rosetta]]
    // AstAttributeMechanism* attributeMechanism = nullptr;
 
public:
    static SgAsmDwarfConstruct* createDwarfConstruct( int tag, int nesting_level, uint64_t offset, uint64_t overall_offset );
 
    virtual SgAsmDwarfConstructList* get_children();
public:
    virtual ~SgAsmDwarfConstruct();
 
protected:
    SgAsmDwarfConstruct();
 
protected:
    SgAsmDwarfConstruct(int const& nesting_level,
                        uint64_t const& offset,
                        uint64_t const& overall_offset);
 
protected:
    void initializeProperties();
#endif // SgAsmDwarfConstruct_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmDwarfConstruct: public SgAsmDwarfInformation {…};
#endif // DOCUMENTATION
 
 
// SgAsmDwarfInformation           -- MACHINE GENERATED; DO NOT MODIFY --
 
#ifndef DOCUMENTATION
AstNodeClass& AsmDwarfInformation = nonTerminalConstructor(
    "AsmDwarfInformation",
    *this,
    "AsmDwarfInformation",
    "AsmDwarfInformationTag",
    SubclassListBuilder()
        | AsmDwarfCompilationUnitList
        | AsmDwarfConstruct
        | AsmDwarfConstructList
        | AsmDwarfLine
        | AsmDwarfLineList
        | AsmDwarfMacro
        | AsmDwarfMacroList
    , false);
assert(AsmDwarfInformation.associatedGrammar != nullptr);
AsmDwarfInformation.setCppCondition("!defined(DOCUMENTATION)");
AsmDwarfInformation.isBoostSerializable(true);
AsmDwarfInformation.setAutomaticGenerationOfConstructor(false);
AsmDwarfInformation.setAutomaticGenerationOfDestructor(false);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
AsmDwarfInformation.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmDwarfInformation: public SgAsmExecutableFileFormat {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmDwarfInformation);
#if defined(SgAsmDwarfInformation_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmDwarfInformation -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmDwarfInformation");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
        debugSerializationEnd("SgAsmDwarfInformation");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    virtual ~SgAsmDwarfInformation();
 
protected:
    SgAsmDwarfInformation();
 
protected:
    void initializeProperties();
#endif // SgAsmDwarfInformation_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmDwarfInformation: public SgAsmExecutableFileFormat {…};
#endif // DOCUMENTATION
 
 
// SgAsmDOSFileHeader           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmDOSFileHeader);
IS_SERIALIZABLE(AsmDOSFileHeader);
 
#ifndef DOCUMENTATION
AsmDOSFileHeader.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmDOSFileHeader);
#if defined(SgAsmDOSFileHeader_HEADERS) || defined(DOCUMENTATION)
#include <Rose/BinaryAnalysis/Address.h>
#endif // SgAsmDOSFileHeader_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmDOSFileHeader: public SgAsmGenericHeader {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmDOSFileHeader.setDataPrototype(
        "uint16_t", "e_last_page_size", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmDOSFileHeader.setDataPrototype(
        "uint16_t", "e_total_pages", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmDOSFileHeader.setDataPrototype(
        "uint16_t", "e_nrelocs", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmDOSFileHeader.setDataPrototype(
        "uint16_t", "e_header_paragraphs", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmDOSFileHeader.setDataPrototype(
        "uint16_t", "e_minalloc", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmDOSFileHeader.setDataPrototype(
        "uint16_t", "e_maxalloc", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmDOSFileHeader.setDataPrototype(
        "uint16_t", "e_ss", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmDOSFileHeader.setDataPrototype(
        "uint16_t", "e_sp", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmDOSFileHeader.setDataPrototype(
        "uint16_t", "e_cksum", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmDOSFileHeader.setDataPrototype(
        "uint16_t", "e_ip", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmDOSFileHeader.setDataPrototype(
        "uint16_t", "e_cs", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmDOSFileHeader.setDataPrototype(
        "uint16_t", "e_overlay", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmDOSFileHeader.setDataPrototype(
        "Rose::BinaryAnalysis::Address", "e_relocs_offset", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmDOSFileHeader.setDataPrototype(
        "unsigned", "e_res1", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmDOSFileHeader.setDataPrototype(
        "SgAsmGenericSection*", "relocs", "= nullptr",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmDOSFileHeader.setDataPrototype(
        "SgAsmGenericSection*", "rm_section", "= nullptr",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmDOSFileHeader);
#if defined(SgAsmDOSFileHeader_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmDOSFileHeader -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmDOSFileHeader");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmGenericHeader);
        s & BOOST_SERIALIZATION_NVP(p_e_last_page_size);
        s & BOOST_SERIALIZATION_NVP(p_e_total_pages);
        s & BOOST_SERIALIZATION_NVP(p_e_nrelocs);
        s & BOOST_SERIALIZATION_NVP(p_e_header_paragraphs);
        s & BOOST_SERIALIZATION_NVP(p_e_minalloc);
        s & BOOST_SERIALIZATION_NVP(p_e_maxalloc);
        s & BOOST_SERIALIZATION_NVP(p_e_ss);
        s & BOOST_SERIALIZATION_NVP(p_e_sp);
        s & BOOST_SERIALIZATION_NVP(p_e_cksum);
        s & BOOST_SERIALIZATION_NVP(p_e_ip);
        s & BOOST_SERIALIZATION_NVP(p_e_cs);
        s & BOOST_SERIALIZATION_NVP(p_e_overlay);
        s & BOOST_SERIALIZATION_NVP(p_e_relocs_offset);
        s & BOOST_SERIALIZATION_NVP(p_e_res1);
        s & BOOST_SERIALIZATION_NVP(p_relocs);
        s & BOOST_SERIALIZATION_NVP(p_rm_section);
        debugSerializationEnd("SgAsmDOSFileHeader");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
    // Local types
public:
#ifdef _MSC_VER
# pragma pack (1)
#endif
    struct DOSFileHeader_disk {
        unsigned char e_magic[2];                
        uint16_t      e_last_page_size;           //
        uint16_t      e_total_pages;             
        uint16_t      e_nrelocs;                 
        uint16_t      e_header_paragraphs;       
        uint16_t      e_minalloc;                
        uint16_t      e_maxalloc;                
        uint16_t      e_ss;                      
        uint16_t      e_sp;                      
        uint16_t      e_cksum;                   
        uint16_t      e_ip;                      
        uint16_t      e_cs;                      
        uint16_t      e_relocs_offset;           
        uint16_t      e_overlay;                 
        uint32_t      e_res1;                    
    }                                            /* 0x20 */
    struct DOSFileHeader_disk {…};
#if !defined(SWIG) && !defined(_MSC_VER)
    __attribute__((packed))
#endif
    ;
 
    struct DOSRelocEntry_disk {
        uint16_t      offset;                       /* 0x00 */
        uint16_t      segment;                      /* 0x02 */
    }                                               /* 0x04 */
    struct DOSRelocEntry_disk {…};
#if !defined(SWIG) && !defined(_MSC_VER)
    __attribute__((packed))
#endif
    ;
 
#ifdef _MSC_VER
# pragma pack ()
#endif
 
    // Properties
public:
public:
    uint16_t const& get_e_last_page_size() const;
    void set_e_last_page_size(uint16_t const&);
public:
    uint16_t const& get_e_total_pages() const;
    void set_e_total_pages(uint16_t const&);
public:
    uint16_t const& get_e_nrelocs() const;
    void set_e_nrelocs(uint16_t const&);
public:
    uint16_t const& get_e_header_paragraphs() const;
    void set_e_header_paragraphs(uint16_t const&);
public:
    uint16_t const& get_e_minalloc() const;
    void set_e_minalloc(uint16_t const&);
public:
    uint16_t const& get_e_maxalloc() const;
    void set_e_maxalloc(uint16_t const&);
public:
    uint16_t const& get_e_ss() const;
    void set_e_ss(uint16_t const&);
public:
    uint16_t const& get_e_sp() const;
    void set_e_sp(uint16_t const&);
public:
    uint16_t const& get_e_cksum() const;
    void set_e_cksum(uint16_t const&);
public:
    uint16_t const& get_e_ip() const;
    void set_e_ip(uint16_t const&);
public:
    uint16_t const& get_e_cs() const;
    void set_e_cs(uint16_t const&);
public:
    uint16_t const& get_e_overlay() const;
    void set_e_overlay(uint16_t const&);
public:
    Rose::BinaryAnalysis::Address const& get_e_relocs_offset() const;
    void set_e_relocs_offset(Rose::BinaryAnalysis::Address const&);
public:
    unsigned const& get_e_res1() const;
    void set_e_res1(unsigned const&);
public:
    SgAsmGenericSection* const& get_relocs() const;
    void set_relocs(SgAsmGenericSection* const&);
public:
    SgAsmGenericSection* const& get_rm_section() const;
    void set_rm_section(SgAsmGenericSection* const&);
    // Functions
public:
    explicit SgAsmDOSFileHeader(SgAsmGenericFile*);
    virtual SgAsmDOSFileHeader *parse() override {return parse(true);}
    SgAsmDOSFileHeader *parse(bool define_rm_section);
    virtual bool reallocate() override;
    virtual void unparse(std::ostream&) const override;
    virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
    virtual const char *formatName() const override;
 
    SgAsmGenericSection *parseRealModeSection(Rose::BinaryAnalysis::Address max_offset=0);
 
    void updateFromRealModeSection();
 
    static bool isDos(SgAsmGenericFile*);
 
private:
    void *encode(SgAsmDOSFileHeader::DOSFileHeader_disk*) const;
 
    // Deprecated 2023-11
public:
    virtual const char* format_name() const override ROSE_DEPRECATED("use formatName");
    SgAsmGenericSection* parse_rm_section(Rose::BinaryAnalysis::Address max_offset = 0) ROSE_DEPRECATED("use parseRealModeSection");
    void update_from_rm_section() ROSE_DEPRECATED("use updateFromRealModeSection");
    static bool is_DOS(SgAsmGenericFile*) ROSE_DEPRECATED("use isDos");
public:
    virtual ~SgAsmDOSFileHeader();
 
public:
    SgAsmDOSFileHeader();
 
protected:
    void initializeProperties();
#endif // SgAsmDOSFileHeader_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmDOSFileHeader: public SgAsmGenericHeader {…};
#endif // DOCUMENTATION
 
 
// SgAsmGenericHeader           -- MACHINE GENERATED; DO NOT MODIFY --
 
#ifndef DOCUMENTATION
AstNodeClass& AsmGenericHeader = nonTerminalConstructor(
    "AsmGenericHeader",
    *this,
    "AsmGenericHeader",
    "AsmGenericHeaderTag",
    SubclassListBuilder()
        | AsmDOSFileHeader
        | AsmElfFileHeader
        | AsmJvmFileHeader
        | AsmLEFileHeader
        | AsmNEFileHeader
        | AsmPEFileHeader
    , true);
assert(AsmGenericHeader.associatedGrammar != nullptr);
AsmGenericHeader.setCppCondition("!defined(DOCUMENTATION)");
AsmGenericHeader.isBoostSerializable(true);
AsmGenericHeader.setAutomaticGenerationOfConstructor(false);
AsmGenericHeader.setAutomaticGenerationOfDestructor(false);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
AsmGenericHeader.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmGenericHeader);
#if defined(SgAsmGenericHeader_HEADERS) || defined(DOCUMENTATION)
#include <Rose/BinaryAnalysis/Address.h>
#include <Rose/BinaryAnalysis/ByteOrder.h>
#include <Rose/BinaryAnalysis/RelativeVirtualAddress.h>
#include <sageContainer.h>
#include <SgAsmGenericFormat.h>
 
#ifdef ROSE_SgAsmGenericHeader_IMPL
#include <SgAsmGenericDLLList.h>
#include <SgAsmGenericSectionList.h>
#endif
 
class SgAsmGenericDLL;
class SgAsmGenericDLLList;
#endif // SgAsmGenericHeader_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmGenericHeader: public SgAsmGenericSection {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmGenericHeader.setDataPrototype(
        "SgAsmGenericFormat*", "executableFormat", "= createAndParent<SgAsmGenericFormat>(this)",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmGenericHeader.setDataPrototype(
        "SgCharList", "magic", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmGenericHeader.setDataPrototype(
        "SgAsmGenericFormat::InsSetArchitecture", "isa", "= SgAsmGenericFormat::ISA_UNSPECIFIED",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmGenericHeader.setDataPrototype(
        "Rose::BinaryAnalysis::Address", "baseVa", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmGenericHeader.setDataPrototype(
        "SgRVAList", "entryRvas", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmGenericHeader.setDataPrototype(
        "SgAsmGenericDLLList*", "dlls", "= createAndParent<SgAsmGenericDLLList>(this)",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmGenericHeader.setDataPrototype(
        "SgAsmGenericSectionList*", "sections", "= createAndParent<SgAsmGenericSectionList>(this)",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmGenericHeader);
#if defined(SgAsmGenericHeader_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmGenericHeader -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmGenericHeader");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmGenericSection);
        s & BOOST_SERIALIZATION_NVP(p_executableFormat);
        s & BOOST_SERIALIZATION_NVP(p_magic);
        s & BOOST_SERIALIZATION_NVP(p_isa);
        s & BOOST_SERIALIZATION_NVP(p_baseVa);
        s & BOOST_SERIALIZATION_NVP(p_entryRvas);
        s & BOOST_SERIALIZATION_NVP(p_dlls);
        s & BOOST_SERIALIZATION_NVP(p_sections);
        debugSerializationEnd("SgAsmGenericHeader");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgAsmGenericFormat* const& get_executableFormat() const;
    void set_executableFormat(SgAsmGenericFormat* const&);
public:
    SgCharList const& get_magic() const;
    SgCharList& get_magic();
    void set_magic(SgCharList const&);
public:
    SgAsmGenericFormat::InsSetArchitecture const& get_isa() const;
    void set_isa(SgAsmGenericFormat::InsSetArchitecture const&);
public:
    Rose::BinaryAnalysis::Address const& get_baseVa() const;
    void set_baseVa(Rose::BinaryAnalysis::Address const&);
public:
    SgRVAList const& get_entryRvas() const;
    SgRVAList& get_entryRvas();
    void set_entryRvas(SgRVAList const&);
public:
    SgAsmGenericDLLList* const& get_dlls() const;
    void set_dlls(SgAsmGenericDLLList* const&);
public:
    SgAsmGenericSectionList* const& get_sections() const;
    void set_sections(SgAsmGenericSectionList* const&);
public:
    explicit SgAsmGenericHeader(SgAsmGenericFile*);
 
    virtual bool reallocate() override;
 
    virtual void unparse(std::ostream&) const override;
 
    virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
 
    virtual const char *formatName() const;
 
    void addDll(SgAsmGenericDLL *dll);
 
    std::vector<SgAsmGenericDLL*>& get_dlls();
 
    Rose::BinaryAnalysis::Address get_entryRva() const;
 
    void addEntryRva(const Rose::BinaryAnalysis::RelativeVirtualAddress&);
 
    /* Convenience functions */
    Rose::BinaryAnalysis::ByteOrder::Endianness get_sex() const;
    size_t get_wordSize() const;
 
    void addSection(SgAsmGenericSection*);
 
    void removeSection(SgAsmGenericSection*);
 
    SgAsmGenericSectionPtrList get_mappedSections() const;
 
    SgAsmGenericSectionPtrList get_sectionsById(int id) const;
 
    SgAsmGenericSectionPtrList get_sectionsByName(std::string, char sep=0) const;
 
    SgAsmGenericSectionPtrList get_sectionsByOffset(Rose::BinaryAnalysis::Address offset, Rose::BinaryAnalysis::Address size) const;
 
    SgAsmGenericSectionPtrList get_sectionsByRva(Rose::BinaryAnalysis::Address rva) const;
 
    SgAsmGenericSectionPtrList get_sectionsByVa(Rose::BinaryAnalysis::Address va, bool use_preferred) const;
 
    SgAsmGenericSection *get_sectionById(int id, size_t *nfound=0) const;
 
    SgAsmGenericSection *get_sectionByName(const std::string&, char sep=0, size_t *nfound=0) const;
 
    SgAsmGenericSection *get_sectionByOffset(Rose::BinaryAnalysis::Address offset, Rose::BinaryAnalysis::Address size,
                                             size_t *nfound=0) const;
 
    SgAsmGenericSection *get_sectionByRva(Rose::BinaryAnalysis::Address rva, size_t *nfound=0) const;
 
    SgAsmGenericSection *get_sectionByVa(Rose::BinaryAnalysis::Address va, bool use_preferred, size_t *nfound=0) const;
 
    SgAsmGenericSection *get_bestSectionByVa(Rose::BinaryAnalysis::Address va, bool use_preferred, size_t *nfound=0) const;
 
    // Deprecated 2023-11
public:
    SgAsmGenericFormat* get_exec_format() const ROSE_DEPRECATED("use get_executableFormat");
    void set_exec_format(SgAsmGenericFormat*) ROSE_DEPRECATED("use set_executableFormat");
    Rose::BinaryAnalysis::Address get_base_va() const ROSE_DEPRECATED("use get_baseVa");
    void set_base_va(Rose::BinaryAnalysis::Address) ROSE_DEPRECATED("use set_baseVa");
    SgRVAList& get_entry_rvas() ROSE_DEPRECATED("use get_entryRvas");
    const SgRVAList& get_entry_rvas() const ROSE_DEPRECATED("use get_entryRvas");
    void set_entry_rvas(const SgRVAList&) ROSE_DEPRECATED("use set_entryRvas");
    virtual const char *format_name() const ROSE_DEPRECATED("use formatName");
    void add_dll(SgAsmGenericDLL*) ROSE_DEPRECATED("use addDll");
    Rose::BinaryAnalysis::Address get_entry_rva() const ROSE_DEPRECATED("use get_entryRva");
    void add_entry_rva(const Rose::BinaryAnalysis::RelativeVirtualAddress&) ROSE_DEPRECATED("use addEntryRva");
    size_t get_word_size() const ROSE_DEPRECATED("use get_wordSize");
    void add_section(SgAsmGenericSection*) ROSE_DEPRECATED("use addSection");
    void remove_section(SgAsmGenericSection*) ROSE_DEPRECATED("use removeSection");
    SgAsmGenericSectionPtrList get_mapped_sections() const ROSE_DEPRECATED("use get_mappedSections");
    SgAsmGenericSectionPtrList get_sections_by_id(int) const ROSE_DEPRECATED("use get_sectionsById");
    SgAsmGenericSectionPtrList get_sections_by_name(std::string, char=0) const ROSE_DEPRECATED("use get_sectionsByName");
    SgAsmGenericSectionPtrList get_sections_by_offset(Rose::BinaryAnalysis::Address, Rose::BinaryAnalysis::Address) const
        ROSE_DEPRECATED("use get_sectionsByOffset");
    SgAsmGenericSectionPtrList get_sections_by_rva(Rose::BinaryAnalysis::Address) const ROSE_DEPRECATED("use get_sectionsByRva");
    SgAsmGenericSectionPtrList get_sections_by_va(Rose::BinaryAnalysis::Address, bool) const
        ROSE_DEPRECATED("use get_sectionsByVa");
    SgAsmGenericSection *get_section_by_id(int, size_t* = nullptr) const ROSE_DEPRECATED("use get_sectionById");
    SgAsmGenericSection *get_section_by_name(const std::string&, char=0, size_t* = nullptr) const
        ROSE_DEPRECATED("use get_sectionByName");
    SgAsmGenericSection *get_section_by_offset(Rose::BinaryAnalysis::Address, Rose::BinaryAnalysis::Address,
                                               size_t* = nullptr) const ROSE_DEPRECATED("use get_sectionByOffset");
    SgAsmGenericSection *get_section_by_rva(Rose::BinaryAnalysis::Address, size_t* = nullptr) const
        ROSE_DEPRECATED("use get_sectionByRva");
    SgAsmGenericSection *get_section_by_va(Rose::BinaryAnalysis::Address, bool, size_t* = nullptr) const
        ROSE_DEPRECATED("use get_sectionByVa");
    SgAsmGenericSection *get_best_section_by_va(Rose::BinaryAnalysis::Address, bool, size_t* = nullptr) const
        ROSE_DEPRECATED("use get_bestSectionByVa");
public:
    virtual ~SgAsmGenericHeader();
 
public:
    SgAsmGenericHeader();
 
protected:
    void initializeProperties();
#endif // SgAsmGenericHeader_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmGenericHeader: public SgAsmGenericSection {…};
#endif // DOCUMENTATION
 
 
// SgAsmDOSExtendedHeader           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmDOSExtendedHeader);
IS_SERIALIZABLE(AsmDOSExtendedHeader);
 
#ifndef DOCUMENTATION
AsmDOSExtendedHeader.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmDOSExtendedHeader);
#if defined(SgAsmDOSExtendedHeader_HEADERS) || defined(DOCUMENTATION)
#include <Rose/BinaryAnalysis/Address.h>
#endif // SgAsmDOSExtendedHeader_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmDOSExtendedHeader: public SgAsmGenericSection {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmDOSExtendedHeader.setDataPrototype(
        "unsigned", "e_res1", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmDOSExtendedHeader.setDataPrototype(
        "unsigned", "e_oemid", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmDOSExtendedHeader.setDataPrototype(
        "unsigned", "e_oeminfo", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmDOSExtendedHeader.setDataPrototype(
        "unsigned", "e_res2", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmDOSExtendedHeader.setDataPrototype(
        "unsigned", "e_res3", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmDOSExtendedHeader.setDataPrototype(
        "unsigned", "e_res4", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmDOSExtendedHeader.setDataPrototype(
        "unsigned", "e_res5", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmDOSExtendedHeader.setDataPrototype(
        "unsigned", "e_res6", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmDOSExtendedHeader.setDataPrototype(
        "Rose::BinaryAnalysis::Address", "e_lfanew", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmDOSExtendedHeader);
#if defined(SgAsmDOSExtendedHeader_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmDOSExtendedHeader -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmDOSExtendedHeader");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmGenericSection);
        s & BOOST_SERIALIZATION_NVP(p_e_res1);
        s & BOOST_SERIALIZATION_NVP(p_e_oemid);
        s & BOOST_SERIALIZATION_NVP(p_e_oeminfo);
        s & BOOST_SERIALIZATION_NVP(p_e_res2);
        s & BOOST_SERIALIZATION_NVP(p_e_res3);
        s & BOOST_SERIALIZATION_NVP(p_e_res4);
        s & BOOST_SERIALIZATION_NVP(p_e_res5);
        s & BOOST_SERIALIZATION_NVP(p_e_res6);
        s & BOOST_SERIALIZATION_NVP(p_e_lfanew);
        debugSerializationEnd("SgAsmDOSExtendedHeader");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
    // Local types
public:
#ifdef _MSC_VER
# pragma pack (1)
#endif
    struct DOSExtendedHeader_disk {
        uint32_t      e_res1;     /* 0x00 reserved */
        uint16_t      e_oemid;    /* 0x04 OEM Identifier */
        uint16_t      e_oeminfo;  /* 0x06 other OEM information; oemid specific */
        uint32_t      e_res2;     /* 0x08 reserved */
        uint32_t      e_res3;     /* 0x0c reserved */
        uint32_t      e_res4;     /* 0x10 reserved */
        uint32_t      e_res5;     /* 0x14 reserved */
        uint32_t      e_res6;     /* 0x18 reserved */
        uint32_t      e_lfanew;   /* 0x1c file offset of new exe (PE) header */
    }                                 /* 0x20 */
    struct DOSExtendedHeader_disk {…};
#if !defined(SWIG) && !defined(_MSC_VER)
    __attribute__((packed))
#endif
    ;
#ifdef _MSC_VER
# pragma pack ()
#endif
 
    // Properties
public:
public:
    unsigned const& get_e_res1() const;
    void set_e_res1(unsigned const&);
public:
    unsigned const& get_e_oemid() const;
    void set_e_oemid(unsigned const&);
public:
    unsigned const& get_e_oeminfo() const;
    void set_e_oeminfo(unsigned const&);
public:
    unsigned const& get_e_res2() const;
    void set_e_res2(unsigned const&);
public:
    unsigned const& get_e_res3() const;
    void set_e_res3(unsigned const&);
public:
    unsigned const& get_e_res4() const;
    void set_e_res4(unsigned const&);
public:
    unsigned const& get_e_res5() const;
    void set_e_res5(unsigned const&);
public:
    unsigned const& get_e_res6() const;
    void set_e_res6(unsigned const&);
public:
    Rose::BinaryAnalysis::Address const& get_e_lfanew() const;
    void set_e_lfanew(Rose::BinaryAnalysis::Address const&);
    // Functions
public:
    explicit SgAsmDOSExtendedHeader(SgAsmDOSFileHeader*);
    virtual SgAsmDOSExtendedHeader *parse() override;
    void *encode(SgAsmDOSExtendedHeader::DOSExtendedHeader_disk*) const;
    virtual void unparse(std::ostream&) const override;
    virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
public:
    virtual ~SgAsmDOSExtendedHeader();
 
public:
    SgAsmDOSExtendedHeader();
 
protected:
    void initializeProperties();
#endif // SgAsmDOSExtendedHeader_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmDOSExtendedHeader: public SgAsmGenericSection {…};
#endif // DOCUMENTATION
 
 
// SgAsmDirectRegisterExpression           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmDirectRegisterExpression);
IS_SERIALIZABLE(AsmDirectRegisterExpression);
 
#ifndef DOCUMENTATION
AsmDirectRegisterExpression.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmDirectRegisterExpression: public SgAsmRegisterReferenceExpression {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmDirectRegisterExpression);
#if defined(SgAsmDirectRegisterExpression_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmDirectRegisterExpression -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmDirectRegisterExpression");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmRegisterReferenceExpression);
        debugSerializationEnd("SgAsmDirectRegisterExpression");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    virtual ~SgAsmDirectRegisterExpression();
 
public:
    SgAsmDirectRegisterExpression();
 
public:
    explicit SgAsmDirectRegisterExpression(Rose::BinaryAnalysis::RegisterDescriptor const& descriptor);
 
protected:
    void initializeProperties();
#endif // SgAsmDirectRegisterExpression_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmDirectRegisterExpression: public SgAsmRegisterReferenceExpression {…};
#endif // DOCUMENTATION
 
 
// SgAsmRegisterReferenceExpression           -- MACHINE GENERATED; DO NOT MODIFY --
 
#ifndef DOCUMENTATION
AstNodeClass& AsmRegisterReferenceExpression = nonTerminalConstructor(
    "AsmRegisterReferenceExpression",
    *this,
    "AsmRegisterReferenceExpression",
    "AsmRegisterReferenceExpressionTag",
    SubclassListBuilder()
        | AsmDirectRegisterExpression
        | AsmIndirectRegisterExpression
    , false);
assert(AsmRegisterReferenceExpression.associatedGrammar != nullptr);
AsmRegisterReferenceExpression.setCppCondition("!defined(DOCUMENTATION)");
AsmRegisterReferenceExpression.isBoostSerializable(true);
AsmRegisterReferenceExpression.setAutomaticGenerationOfConstructor(false);
AsmRegisterReferenceExpression.setAutomaticGenerationOfDestructor(false);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
AsmRegisterReferenceExpression.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmRegisterReferenceExpression: public SgAsmExpression {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmRegisterReferenceExpression.setDataPrototype(
        "Rose::BinaryAnalysis::RegisterDescriptor", "descriptor", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmRegisterReferenceExpression.setDataPrototype(
        "int", "adjustment", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmRegisterReferenceExpression);
#if defined(SgAsmRegisterReferenceExpression_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmRegisterReferenceExpression -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmRegisterReferenceExpression");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExpression);
        s & BOOST_SERIALIZATION_NVP(p_descriptor);
        s & BOOST_SERIALIZATION_NVP(p_adjustment);
        debugSerializationEnd("SgAsmRegisterReferenceExpression");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    Rose::BinaryAnalysis::RegisterDescriptor const& get_descriptor() const;
    void set_descriptor(Rose::BinaryAnalysis::RegisterDescriptor const&);
public:
    int const& get_adjustment() const;
    void set_adjustment(int const&);
public:
    virtual ~SgAsmRegisterReferenceExpression();
 
protected:
    SgAsmRegisterReferenceExpression();
 
protected:
    explicit SgAsmRegisterReferenceExpression(Rose::BinaryAnalysis::RegisterDescriptor const& descriptor);
 
protected:
    void initializeProperties();
#endif // SgAsmRegisterReferenceExpression_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmRegisterReferenceExpression: public SgAsmExpression {…};
#endif // DOCUMENTATION
 
 
// SgAsmControlFlagsExpression           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmControlFlagsExpression);
IS_SERIALIZABLE(AsmControlFlagsExpression);
 
#ifndef DOCUMENTATION
AsmControlFlagsExpression.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmControlFlagsExpression);
#if defined(SgAsmControlFlagsExpression_HEADERS) || defined(DOCUMENTATION)
// FIXME[Robb P Matzke 2016-10-31]: no idea what this is
#endif // SgAsmControlFlagsExpression_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmControlFlagsExpression: public SgAsmExpression {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmControlFlagsExpression.setDataPrototype(
        "unsigned long", "bitFlags", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmControlFlagsExpression);
#if defined(SgAsmControlFlagsExpression_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmControlFlagsExpression -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmControlFlagsExpression");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExpression);
        s & BOOST_SERIALIZATION_NVP(p_bitFlags);
        debugSerializationEnd("SgAsmControlFlagsExpression");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    unsigned long const& get_bitFlags() const;
    void set_bitFlags(unsigned long const&);
    // [Robb Matzke 2023-11-06] deprecated 2023-11
    unsigned long get_bit_flags() const ROSE_DEPRECATED("use get_bitFlags");
    void set_bit_flags(unsigned long) ROSE_DEPRECATED("use set_bitFlags");
public:
    virtual ~SgAsmControlFlagsExpression();
 
public:
    SgAsmControlFlagsExpression();
 
protected:
    void initializeProperties();
#endif // SgAsmControlFlagsExpression_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmControlFlagsExpression: public SgAsmExpression {…};
#endif // DOCUMENTATION
 
 
// SgAsmConstantExpression           -- MACHINE GENERATED; DO NOT MODIFY --
 
#ifndef DOCUMENTATION
AstNodeClass& AsmConstantExpression = nonTerminalConstructor(
    "AsmConstantExpression",
    *this,
    "AsmConstantExpression",
    "AsmConstantExpressionTag",
    SubclassListBuilder()
        | AsmFloatValueExpression
        | AsmIntegerValueExpression
    , false);
assert(AsmConstantExpression.associatedGrammar != nullptr);
AsmConstantExpression.setCppCondition("!defined(DOCUMENTATION)");
AsmConstantExpression.isBoostSerializable(true);
AsmConstantExpression.setAutomaticGenerationOfConstructor(false);
AsmConstantExpression.setAutomaticGenerationOfDestructor(false);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
AsmConstantExpression.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmConstantExpression);
#if defined(SgAsmConstantExpression_HEADERS) || defined(DOCUMENTATION)
#include <Sawyer/BitVector.h>
#endif // SgAsmConstantExpression_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmConstantExpression: public SgAsmValueExpression {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmConstantExpression.setDataPrototype(
        "Sawyer::Container::BitVector", "bitVector", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmConstantExpression);
#if defined(SgAsmConstantExpression_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmConstantExpression -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmConstantExpression");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmValueExpression);
        s & BOOST_SERIALIZATION_NVP(p_bitVector);
        debugSerializationEnd("SgAsmConstantExpression");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    Sawyer::Container::BitVector const& get_bitVector() const;
    Sawyer::Container::BitVector& get_bitVector();
    void set_bitVector(Sawyer::Container::BitVector const&);
public:
    virtual ~SgAsmConstantExpression();
 
protected:
    SgAsmConstantExpression();
 
protected:
    void initializeProperties();
#endif // SgAsmConstantExpression_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmConstantExpression: public SgAsmValueExpression {…};
#endif // DOCUMENTATION
 
 
// SgAsmValueExpression           -- MACHINE GENERATED; DO NOT MODIFY --
 
#ifndef DOCUMENTATION
AstNodeClass& AsmValueExpression = nonTerminalConstructor(
    "AsmValueExpression",
    *this,
    "AsmValueExpression",
    "AsmValueExpressionTag",
    SubclassListBuilder()
        | AsmConstantExpression
    , false);
assert(AsmValueExpression.associatedGrammar != nullptr);
AsmValueExpression.setCppCondition("!defined(DOCUMENTATION)");
AsmValueExpression.isBoostSerializable(true);
AsmValueExpression.setAutomaticGenerationOfConstructor(false);
AsmValueExpression.setAutomaticGenerationOfDestructor(false);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
AsmValueExpression.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmValueExpression: public SgAsmExpression {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmValueExpression.setDataPrototype(
        "SgAsmValueExpression*", "unfoldedExpression", "= nullptr",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmValueExpression.setDataPrototype(
        "unsigned short", "bitOffset", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmValueExpression.setDataPrototype(
        "unsigned short", "bitSize", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmValueExpression.setDataPrototype(
        "SgSymbol*", "symbol", "= nullptr",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmValueExpression);
#if defined(SgAsmValueExpression_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmValueExpression -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmValueExpression");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExpression);
        s & BOOST_SERIALIZATION_NVP(p_unfoldedExpression);
        s & BOOST_SERIALIZATION_NVP(p_bitOffset);
        s & BOOST_SERIALIZATION_NVP(p_bitSize);
        debugSerializationEnd("SgAsmValueExpression");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgAsmValueExpression* const& get_unfoldedExpression() const;
    void set_unfoldedExpression(SgAsmValueExpression* const&);
public:
    unsigned short const& get_bitOffset() const;
    void set_bitOffset(unsigned short const&);
public:
    unsigned short const& get_bitSize() const;
    void set_bitSize(unsigned short const&);
public:
    SgSymbol* const& get_symbol() const;
    void set_symbol(SgSymbol* const&);
    // Deprecated 2023-11
public:
    SgAsmValueExpression* get_unfolded_expression_tree() const ROSE_DEPRECATED("use get_unfoldedExpression");
    void set_unfolded_expression_tree(SgAsmValueExpression*) ROSE_DEPRECATED("use set_unfoldedExpression");
    unsigned short get_bit_offset() const ROSE_DEPRECATED("use get_bitOffset");
    void set_bit_offset(unsigned short) ROSE_DEPRECATED("use set_bitOffset");
    unsigned short get_bit_size() const ROSE_DEPRECATED("use get_bitSize");
    void set_bit_size(unsigned short) ROSE_DEPRECATED("use set_bitSize");
public:
    virtual ~SgAsmValueExpression();
 
protected:
    SgAsmValueExpression();
 
protected:
    void initializeProperties();
#endif // SgAsmValueExpression_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmValueExpression: public SgAsmExpression {…};
#endif // DOCUMENTATION
 
 
// SgAsmCommonSubExpression           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmCommonSubExpression);
IS_SERIALIZABLE(AsmCommonSubExpression);
 
#ifndef DOCUMENTATION
AsmCommonSubExpression.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmCommonSubExpression);
#if defined(SgAsmCommonSubExpression_HEADERS) || defined(DOCUMENTATION)
// FIXME[Robb P Matzke 2016-10-31]: no idea what this is
#endif // SgAsmCommonSubExpression_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmCommonSubExpression: public SgAsmExpression {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCommonSubExpression.setDataPrototype(
        "SgAsmExpression*", "subexpression", "= nullptr",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmCommonSubExpression);
#if defined(SgAsmCommonSubExpression_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmCommonSubExpression -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmCommonSubExpression");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExpression);
        s & BOOST_SERIALIZATION_NVP(p_subexpression);
        debugSerializationEnd("SgAsmCommonSubExpression");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgAsmExpression* const& get_subexpression() const;
    void set_subexpression(SgAsmExpression* const&);
 
public:
    virtual ~SgAsmCommonSubExpression();
 
public:
    SgAsmCommonSubExpression();
 
protected:
    void initializeProperties();
#endif // SgAsmCommonSubExpression_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmCommonSubExpression: public SgAsmExpression {…};
#endif // DOCUMENTATION
 
 
// SgAsmCoffSymbolTable           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmCoffSymbolTable);
IS_SERIALIZABLE(AsmCoffSymbolTable);
 
#ifndef DOCUMENTATION
AsmCoffSymbolTable.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmCoffSymbolTable);
#if defined(SgAsmCoffSymbolTable_HEADERS) || defined(DOCUMENTATION)
#ifdef ROSE_SgAsmCoffSymbolTable_IMPL
#include <SgAsmCoffSymbolList.h>
#endif
#endif // SgAsmCoffSymbolTable_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmCoffSymbolTable: public SgAsmGenericSection {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCoffSymbolTable.setDataPrototype(
        "SgAsmGenericSection*", "strtab", "= nullptr",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCoffSymbolTable.setDataPrototype(
        "SgAsmCoffSymbolList*", "symbols", "= createAndParent<SgAsmCoffSymbolList>(this)",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmCoffSymbolTable);
#if defined(SgAsmCoffSymbolTable_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmCoffSymbolTable -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmCoffSymbolTable");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmGenericSection);
        s & BOOST_SERIALIZATION_NVP(p_strtab);
        s & BOOST_SERIALIZATION_NVP(p_symbols);
        debugSerializationEnd("SgAsmCoffSymbolTable");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgAsmGenericSection* const& get_strtab() const;
    void set_strtab(SgAsmGenericSection* const&);
public:
    SgAsmCoffSymbolList* const& get_symbols() const;
    void set_symbols(SgAsmCoffSymbolList* const&);
public:
    explicit SgAsmCoffSymbolTable(SgAsmPEFileHeader*);
    size_t get_nslots() const;
    virtual SgAsmCoffSymbolTable *parse() override;
    virtual void unparse(std::ostream&) const override;
    virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
public:
    virtual ~SgAsmCoffSymbolTable();
 
public:
    SgAsmCoffSymbolTable();
 
protected:
    void initializeProperties();
#endif // SgAsmCoffSymbolTable_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmCoffSymbolTable: public SgAsmGenericSection {…};
#endif // DOCUMENTATION
 
 
// SgAsmCoffSymbolList           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmCoffSymbolList);
IS_SERIALIZABLE(AsmCoffSymbolList);
 
#ifndef DOCUMENTATION
AsmCoffSymbolList.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmCoffSymbolList);
#if defined(SgAsmCoffSymbolList_HEADERS) || defined(DOCUMENTATION)
#include <sageContainer.h>
#endif // SgAsmCoffSymbolList_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmCoffSymbolList: public SgAsmExecutableFileFormat {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCoffSymbolList.setDataPrototype(
        "SgAsmCoffSymbolPtrList", "symbols", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmCoffSymbolList);
#if defined(SgAsmCoffSymbolList_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmCoffSymbolList -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmCoffSymbolList");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
        s & BOOST_SERIALIZATION_NVP(p_symbols);
        debugSerializationEnd("SgAsmCoffSymbolList");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgAsmCoffSymbolPtrList const& get_symbols() const;
    SgAsmCoffSymbolPtrList& get_symbols();
    void set_symbols(SgAsmCoffSymbolPtrList const&);
public:
    virtual ~SgAsmCoffSymbolList();
 
public:
    SgAsmCoffSymbolList();
 
protected:
    void initializeProperties();
#endif // SgAsmCoffSymbolList_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmCoffSymbolList: public SgAsmExecutableFileFormat {…};
#endif // DOCUMENTATION
 
 
// SgAsmCoffSymbol           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmCoffSymbol);
IS_SERIALIZABLE(AsmCoffSymbol);
 
#ifndef DOCUMENTATION
AsmCoffSymbol.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmCoffSymbol);
#if defined(SgAsmCoffSymbol_HEADERS) || defined(DOCUMENTATION)
#include <Rose/BinaryAnalysis/Address.h>
 
#include <sageContainer.h>
#endif // SgAsmCoffSymbol_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmCoffSymbol: public SgAsmGenericSymbol {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCoffSymbol.setDataPrototype(
        "std::string", "st_name", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCoffSymbol.setDataPrototype(
        "Rose::BinaryAnalysis::Address", "st_name_offset", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCoffSymbol.setDataPrototype(
        "int", "st_section_num", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCoffSymbol.setDataPrototype(
        "unsigned", "st_type", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCoffSymbol.setDataPrototype(
        "unsigned", "st_storage_class", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCoffSymbol.setDataPrototype(
        "unsigned", "st_num_aux_entries", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCoffSymbol.setDataPrototype(
        "SgUnsignedCharList", "auxiliaryData", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmCoffSymbol);
#if defined(SgAsmCoffSymbol_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmCoffSymbol -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmCoffSymbol");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmGenericSymbol);
        s & BOOST_SERIALIZATION_NVP(p_st_name);
        s & BOOST_SERIALIZATION_NVP(p_st_name_offset);
        s & BOOST_SERIALIZATION_NVP(p_st_section_num);
        s & BOOST_SERIALIZATION_NVP(p_st_type);
        s & BOOST_SERIALIZATION_NVP(p_st_storage_class);
        s & BOOST_SERIALIZATION_NVP(p_st_num_aux_entries);
        s & BOOST_SERIALIZATION_NVP(p_auxiliaryData);
        debugSerializationEnd("SgAsmCoffSymbol");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
    // Local types
public:
#ifdef _MSC_VER
# pragma pack (1)
#endif
    struct COFFSymbol_disk {
        union {
            char            st_name[8];
            struct {
                uint32_t    st_zero;
                uint32_t    st_offset;
            };
        };
        uint32_t            st_value;
        int16_t             st_section_num;
        uint16_t            st_type;
        unsigned char       st_storage_class;
        unsigned char       st_num_aux_entries;
    }
    struct COFFSymbol_disk {…};
// DQ (3/7/2013): Adding support to restrict visability to SWIG.
#if !defined(SWIG) && !defined(_MSC_VER)
    __attribute__((packed))
#endif
    ;
#ifdef _MSC_VER
# pragma pack ()
#endif
 
    // Properties and data members
public:
public:
    std::string const& get_st_name() const;
    void set_st_name(std::string const&);
public:
    Rose::BinaryAnalysis::Address const& get_st_name_offset() const;
    void set_st_name_offset(Rose::BinaryAnalysis::Address const&);
public:
    int const& get_st_section_num() const;
    void set_st_section_num(int const&);
public:
    unsigned const& get_st_type() const;
    void set_st_type(unsigned const&);
public:
    unsigned const& get_st_storage_class() const;
    void set_st_storage_class(unsigned const&);
public:
    unsigned const& get_st_num_aux_entries() const;
    void set_st_num_aux_entries(unsigned const&);
public:
    SgUnsignedCharList const& get_auxiliaryData() const;
    SgUnsignedCharList& get_auxiliaryData();
    void set_auxiliaryData(SgUnsignedCharList const&);
public:
    static const unsigned int COFFSymbol_disk_size = 18;
 
    // Functions
public:
    SgAsmCoffSymbol(SgAsmPEFileHeader *fhdr, SgAsmGenericSection *symtab, SgAsmGenericSection *strtab, size_t idx);
    void *encode(SgAsmCoffSymbol::COFFSymbol_disk*) const;
    virtual void dump(FILE *f, const char *prefix, ssize_t idx) const override;
 
    // Deprecated
public:
    const SgUnsignedCharList& get_aux_data() const ROSE_DEPRECATED("use get_auxiliaryData");
    void set_aux_data(const SgUnsignedCharList&) ROSE_DEPRECATED("use set_auxiliaryData");
public:
    virtual ~SgAsmCoffSymbol();
 
public:
    SgAsmCoffSymbol();
 
protected:
    void initializeProperties();
#endif // SgAsmCoffSymbol_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmCoffSymbol: public SgAsmGenericSymbol {…};
#endif // DOCUMENTATION
 
 
// SgAsmGenericSymbol           -- MACHINE GENERATED; DO NOT MODIFY --
 
#ifndef DOCUMENTATION
AstNodeClass& AsmGenericSymbol = nonTerminalConstructor(
    "AsmGenericSymbol",
    *this,
    "AsmGenericSymbol",
    "AsmGenericSymbolTag",
    SubclassListBuilder()
        | AsmCoffSymbol
        | AsmElfSymbol
    , false);
assert(AsmGenericSymbol.associatedGrammar != nullptr);
AsmGenericSymbol.setCppCondition("!defined(DOCUMENTATION)");
AsmGenericSymbol.isBoostSerializable(true);
AsmGenericSymbol.setAutomaticGenerationOfConstructor(false);
AsmGenericSymbol.setAutomaticGenerationOfDestructor(false);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
AsmGenericSymbol.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmGenericSymbol);
#if defined(SgAsmGenericSymbol_HEADERS) || defined(DOCUMENTATION)
#include <Rose/BinaryAnalysis/Address.h>
 
/* Base class for symbol tables. */
#endif // SgAsmGenericSymbol_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmGenericSymbol: public SgAsmExecutableFileFormat {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmGenericSymbol.setDataPrototype(
        "SgAsmGenericSymbol::SymbolDefState", "definitionState", "= SgAsmGenericSymbol::SYM_UNDEFINED",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmGenericSymbol.setDataPrototype(
        "SgAsmGenericSymbol::SymbolBinding", "binding", "= SgAsmGenericSymbol::SYM_NO_BINDING",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmGenericSymbol.setDataPrototype(
        "SgAsmGenericSymbol::SymbolType", "type", "= SgAsmGenericSymbol::SYM_NO_TYPE",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmGenericSymbol.setDataPrototype(
        "Rose::BinaryAnalysis::Address", "value", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmGenericSymbol.setDataPrototype(
        "Rose::BinaryAnalysis::Address", "size", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmGenericSymbol.setDataPrototype(
        "SgAsmGenericSection*", "bound", "= nullptr",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmGenericSymbol.setDataPrototype(
        "SgAsmGenericString*", "name", "= nullptr",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmGenericSymbol);
#if defined(SgAsmGenericSymbol_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmGenericSymbol -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmGenericSymbol");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
        s & BOOST_SERIALIZATION_NVP(p_definitionState);
        s & BOOST_SERIALIZATION_NVP(p_binding);
        s & BOOST_SERIALIZATION_NVP(p_type);
        s & BOOST_SERIALIZATION_NVP(p_value);
        s & BOOST_SERIALIZATION_NVP(p_size);
        s & BOOST_SERIALIZATION_NVP(p_bound);
        s & BOOST_SERIALIZATION_NVP(p_name);
        debugSerializationEnd("SgAsmGenericSymbol");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
    // Local types
public:
    enum SymbolDefState {
        SYM_UNDEFINED,          
        SYM_TENTATIVE,          
        SYM_DEFINED             
    };
    enum SymbolDefState {…};
 
    enum SymbolType {
        SYM_NO_TYPE,            
        SYM_DATA,               
        SYM_FUNC,               
        SYM_SECTION,            
        SYM_FILE,               
        SYM_ARRAY,              
        SYM_TLS,                
        SYM_REGISTER,           
        SYM_COMMON,             
        SYM_IFUNC               
    };
    enum SymbolType {…};
 
    enum SymbolBinding {
        SYM_NO_BINDING,         
        SYM_LOCAL,              
        SYM_GLOBAL,             
        SYM_WEAK                
    };
    enum SymbolBinding {…};
 
    // Properties
public:
public:
    SgAsmGenericSymbol::SymbolDefState const& get_definitionState() const;
    void set_definitionState(SgAsmGenericSymbol::SymbolDefState const&);
public:
    SgAsmGenericSymbol::SymbolBinding const& get_binding() const;
    void set_binding(SgAsmGenericSymbol::SymbolBinding const&);
public:
    SgAsmGenericSymbol::SymbolType const& get_type() const;
    void set_type(SgAsmGenericSymbol::SymbolType const&);
public:
    Rose::BinaryAnalysis::Address const& get_value() const;
    void set_value(Rose::BinaryAnalysis::Address const&);
public:
    Rose::BinaryAnalysis::Address const& get_size() const;
    void set_size(Rose::BinaryAnalysis::Address const&);
public:
    SgAsmGenericSection* const& get_bound() const;
    void set_bound(SgAsmGenericSection* const&);
public:
    SgAsmGenericString* get_name() const;
    void set_name(SgAsmGenericString*);
    // Functions
public:
    virtual void dump(FILE*, const char *prefix, ssize_t idx) const;
 
    // Deprecated 2023-11
public:
    SymbolDefState get_def_state() const ROSE_DEPRECATED("use get_definitionState");
    void set_def_state(SymbolDefState) ROSE_DEPRECATED("use set_definitionState");
public:
    virtual ~SgAsmGenericSymbol();
 
protected:
    SgAsmGenericSymbol();
 
protected:
    void initializeProperties();
#endif // SgAsmGenericSymbol_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmGenericSymbol: public SgAsmExecutableFileFormat {…};
#endif // DOCUMENTATION
 
 
// SgAsmCoffStrtab           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmCoffStrtab);
IS_SERIALIZABLE(AsmCoffStrtab);
 
#ifndef DOCUMENTATION
AsmCoffStrtab.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmCoffStrtab);
#if defined(SgAsmCoffStrtab_HEADERS) || defined(DOCUMENTATION)
#include <Rose/BinaryAnalysis/Address.h>
#endif // SgAsmCoffStrtab_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmCoffStrtab: public SgAsmGenericStrtab {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmCoffStrtab);
#if defined(SgAsmCoffStrtab_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmCoffStrtab -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmCoffStrtab");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmGenericStrtab);
        debugSerializationEnd("SgAsmCoffStrtab");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
    explicit SgAsmCoffStrtab(class SgAsmPESection *containing_section);
    void destructorHelper() override;
    virtual void unparse(std::ostream&) const;
    virtual SgAsmStringStorage *createStorage(Rose::BinaryAnalysis::Address offset, bool shared) override;
    virtual Rose::BinaryAnalysis::Address get_storageSize(const SgAsmStringStorage*) override;
 
    // Deprecated 2023-11
    virtual SgAsmStringStorage *create_storage(Rose::BinaryAnalysis::Address, bool) override ROSE_DEPRECATED("use createStorage");
    virtual Rose::BinaryAnalysis::Address get_storage_size(const SgAsmStringStorage*) override
        ROSE_DEPRECATED("use get_storageSize");
public:
    virtual ~SgAsmCoffStrtab();
 
public:
    SgAsmCoffStrtab();
 
protected:
    void initializeProperties();
#endif // SgAsmCoffStrtab_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmCoffStrtab: public SgAsmGenericStrtab {…};
#endif // DOCUMENTATION
 
 
// SgAsmGenericStrtab           -- MACHINE GENERATED; DO NOT MODIFY --
 
#ifndef DOCUMENTATION
AstNodeClass& AsmGenericStrtab = nonTerminalConstructor(
    "AsmGenericStrtab",
    *this,
    "AsmGenericStrtab",
    "AsmGenericStrtabTag",
    SubclassListBuilder()
        | AsmCoffStrtab
        | AsmElfStrtab
    , false);
assert(AsmGenericStrtab.associatedGrammar != nullptr);
AsmGenericStrtab.setCppCondition("!defined(DOCUMENTATION)");
AsmGenericStrtab.isBoostSerializable(true);
AsmGenericStrtab.setAutomaticGenerationOfConstructor(false);
AsmGenericStrtab.setAutomaticGenerationOfDestructor(false);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
AsmGenericStrtab.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmGenericStrtab);
#if defined(SgAsmGenericStrtab_HEADERS) || defined(DOCUMENTATION)
#include <Rose/BinaryAnalysis/Address.h>
#include <Rose/BinaryAnalysis/AddressIntervalSet.h>
#endif // SgAsmGenericStrtab_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmGenericStrtab: public SgAsmExecutableFileFormat {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmGenericStrtab.setDataPrototype(
        "SgAsmGenericSection*", "container", "= nullptr",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmGenericStrtab.setDataPrototype(
        "SgAsmGenericStrtab::referenced_t", "storageList", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmGenericStrtab.setDataPrototype(
        "Rose::BinaryAnalysis::AddressIntervalSet", "freeList", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmGenericStrtab.setDataPrototype(
        "SgAsmStringStorage*", "dontFree", "= nullptr",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmGenericStrtab.setDataPrototype(
        "size_t", "numberFreed", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmGenericStrtab);
#if defined(SgAsmGenericStrtab_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmGenericStrtab -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmGenericStrtab");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
        s & BOOST_SERIALIZATION_NVP(p_container);
        s & BOOST_SERIALIZATION_NVP(p_storageList);
        s & BOOST_SERIALIZATION_NVP(p_freeList);
        s & BOOST_SERIALIZATION_NVP(p_dontFree);
        s & BOOST_SERIALIZATION_NVP(p_numberFreed);
        debugSerializationEnd("SgAsmGenericStrtab");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
    // Local types
public:
    typedef std::vector<class SgAsmStringStorage*> referenced_t;
 
    // Properties
public:
public:
    SgAsmGenericSection* const& get_container() const;
    void set_container(SgAsmGenericSection* const&);
public:
    SgAsmGenericStrtab::referenced_t const& get_storageList() const;
    void set_storageList(SgAsmGenericStrtab::referenced_t const&);
public:
    Rose::BinaryAnalysis::AddressIntervalSet const& get_freeList() const;
    Rose::BinaryAnalysis::AddressIntervalSet& get_freeList();
public:
    SgAsmStringStorage* const& get_dontFree() const;
    void set_dontFree(SgAsmStringStorage* const&);
public:
    size_t const& get_numberFreed() const;
    void set_numberFreed(size_t const&);
    // Functions
public:
    explicit SgAsmGenericStrtab(SgAsmGenericSection *container);
 
    virtual SgAsmGenericStrtab* parse() {return this;}
 
    virtual void dump(FILE*, const char *prefix, ssize_t idx) const;
 
    SgAsmStoredString *createString(Rose::BinaryAnalysis::Address offset, bool shared);
 
    void free(SgAsmStringStorage*);
 
    void free(Rose::BinaryAnalysis::Address offset, Rose::BinaryAnalysis::Address size); /*mark part of table as free*/
 
    void freeAllStrings(bool blow_away_holes=false);
 
    virtual void allocateOverlap(SgAsmStringStorage*);
 
    bool reallocate(bool shrink);
 
    //These should be pure virtual but ROSETTA apparently doesn't support that (RPM 2008-10-03)
    virtual SgAsmStringStorage *createStorage(Rose::BinaryAnalysis::Address /*offset*/, bool /*shared*/);
    virtual Rose::BinaryAnalysis::Address get_storageSize(const SgAsmStringStorage*);
    virtual void rebind(SgAsmStringStorage*, Rose::BinaryAnalysis::Address);
 
    // Deprecated 2023-11
public:
    const referenced_t& get_storage_list() const ROSE_DEPRECATED("use get_storageList");
    void set_storage_list(const referenced_t&) ROSE_DEPRECATED("use set_storageList");
    const Rose::BinaryAnalysis::AddressIntervalSet& get_freelist() const ROSE_DEPRECATED("use get_freeList");
    Rose::BinaryAnalysis::AddressIntervalSet& get_freelist() ROSE_DEPRECATED("use set_freeList");
    SgAsmStringStorage* get_dont_free() const ROSE_DEPRECATED("use get_dontFree");
    void set_dont_free(SgAsmStringStorage*) ROSE_DEPRECATED("use set_dontFree");
    size_t get_num_freed() const ROSE_DEPRECATED("use get_numberFreed");
    void set_num_freed(size_t) ROSE_DEPRECATED("use set_numberFreed");
    SgAsmStoredString *create_string(Rose::BinaryAnalysis::Address, bool) ROSE_DEPRECATED("use createString");
    void free_all_strings(bool=false) ROSE_DEPRECATED("use freeAllStrings");
    virtual void allocate_overlap(SgAsmStringStorage*) ROSE_DEPRECATED("use allocateOverlap");
    virtual SgAsmStringStorage *create_storage(Rose::BinaryAnalysis::Address, bool) ROSE_DEPRECATED("use createStorage");
    virtual Rose::BinaryAnalysis::Address get_storage_size(const SgAsmStringStorage*) ROSE_DEPRECATED("use get_storageSize");
public:
    virtual ~SgAsmGenericStrtab();
 
protected:
    SgAsmGenericStrtab();
 
protected:
    void initializeProperties();
#endif // SgAsmGenericStrtab_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmGenericStrtab: public SgAsmExecutableFileFormat {…};
#endif // DOCUMENTATION
 
 
// SgAsmCliHeader           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmCliHeader);
IS_SERIALIZABLE(AsmCliHeader);
 
#ifndef DOCUMENTATION
AsmCliHeader.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmCliHeader);
#if defined(SgAsmCliHeader_HEADERS) || defined(DOCUMENTATION)
#ifdef ROSE_SgAsmCliHeader_IMPL
#include <SgAsmCilMetadataRoot.h>
#endif
#endif // SgAsmCliHeader_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmCliHeader: public SgAsmGenericSection {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCliHeader.setDataPrototype(
        "uint32_t", "cb", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCliHeader.setDataPrototype(
        "uint16_t", "majorRuntimeVersion", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCliHeader.setDataPrototype(
        "uint16_t", "minorRuntimeVersion", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCliHeader.setDataPrototype(
        "uint64_t", "metaData", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCliHeader.setDataPrototype(
        "uint32_t", "flags", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCliHeader.setDataPrototype(
        "uint32_t", "entryPointToken", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCliHeader.setDataPrototype(
        "uint64_t", "resources", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCliHeader.setDataPrototype(
        "uint64_t", "strongNameSignature", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCliHeader.setDataPrototype(
        "uint64_t", "codeManagerTable", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCliHeader.setDataPrototype(
        "uint64_t", "vTableFixups", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCliHeader.setDataPrototype(
        "uint64_t", "exportAddressTableJumps", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCliHeader.setDataPrototype(
        "uint64_t", "managedNativeHeader", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCliHeader.setDataPrototype(
        "SgAsmCilMetadataRoot*", "metadataRoot", "= nullptr",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmCliHeader);
#if defined(SgAsmCliHeader_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmCliHeader -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmCliHeader");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmGenericSection);
        s & BOOST_SERIALIZATION_NVP(p_cb);
        s & BOOST_SERIALIZATION_NVP(p_majorRuntimeVersion);
        s & BOOST_SERIALIZATION_NVP(p_minorRuntimeVersion);
        s & BOOST_SERIALIZATION_NVP(p_metaData);
        s & BOOST_SERIALIZATION_NVP(p_flags);
        s & BOOST_SERIALIZATION_NVP(p_entryPointToken);
        s & BOOST_SERIALIZATION_NVP(p_resources);
        s & BOOST_SERIALIZATION_NVP(p_strongNameSignature);
        s & BOOST_SERIALIZATION_NVP(p_codeManagerTable);
        s & BOOST_SERIALIZATION_NVP(p_vTableFixups);
        s & BOOST_SERIALIZATION_NVP(p_exportAddressTableJumps);
        s & BOOST_SERIALIZATION_NVP(p_managedNativeHeader);
        debugSerializationEnd("SgAsmCliHeader");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    uint32_t const& get_cb() const;
    void set_cb(uint32_t const&);
public:
    uint16_t const& get_majorRuntimeVersion() const;
    void set_majorRuntimeVersion(uint16_t const&);
public:
    uint16_t const& get_minorRuntimeVersion() const;
    void set_minorRuntimeVersion(uint16_t const&);
public:
    uint64_t const& get_metaData() const;
    void set_metaData(uint64_t const&);
public:
    uint32_t const& get_flags() const;
    void set_flags(uint32_t const&);
public:
    uint32_t const& get_entryPointToken() const;
    void set_entryPointToken(uint32_t const&);
public:
    uint64_t const& get_resources() const;
    void set_resources(uint64_t const&);
public:
    uint64_t const& get_strongNameSignature() const;
    void set_strongNameSignature(uint64_t const&);
public:
    uint64_t const& get_codeManagerTable() const;
    void set_codeManagerTable(uint64_t const&);
public:
    uint64_t const& get_vTableFixups() const;
    void set_vTableFixups(uint64_t const&);
public:
    uint64_t const& get_exportAddressTableJumps() const;
    void set_exportAddressTableJumps(uint64_t const&);
public:
    uint64_t const& get_managedNativeHeader() const;
    void set_managedNativeHeader(uint64_t const&);
    // FIXME[Robb Matzke 2023-03-20]: is the lack of serialization a bug?
public:
    SgAsmCilMetadataRoot* const& get_metadataRoot() const;
    void set_metadataRoot(SgAsmCilMetadataRoot* const&);
 public:
    explicit SgAsmCliHeader(SgAsmPEFileHeader*);
 
    virtual SgAsmCliHeader* parse() override;
 
    virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
public:
    virtual ~SgAsmCliHeader();
 
public:
    SgAsmCliHeader();
 
protected:
    void initializeProperties();
#endif // SgAsmCliHeader_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmCliHeader: public SgAsmGenericSection {…};
#endif // DOCUMENTATION
 
 
// SgAsmGenericSection           -- MACHINE GENERATED; DO NOT MODIFY --
 
#ifndef DOCUMENTATION
AstNodeClass& AsmGenericSection = nonTerminalConstructor(
    "AsmGenericSection",
    *this,
    "AsmGenericSection",
    "AsmGenericSectionTag",
    SubclassListBuilder()
        | AsmCliHeader
        | AsmCoffSymbolTable
        | AsmDOSExtendedHeader
        | AsmElfSection
        | AsmElfSectionTable
        | AsmElfSegmentTable
        | AsmGenericHeader
        | AsmJvmAttributeTable
        | AsmJvmConstantPool
        | AsmJvmFieldTable
        | AsmJvmMethodTable
        | AsmLEEntryTable
        | AsmLENameTable
        | AsmLEPageTable
        | AsmLERelocTable
        | AsmLESection
        | AsmLESectionTable
        | AsmNEEntryTable
        | AsmNEModuleTable
        | AsmNENameTable
        | AsmNERelocTable
        | AsmNESection
        | AsmNESectionTable
        | AsmNEStringTable
        | AsmPESection
        | AsmPESectionTable
    , true);
assert(AsmGenericSection.associatedGrammar != nullptr);
AsmGenericSection.setCppCondition("!defined(DOCUMENTATION)");
AsmGenericSection.isBoostSerializable(true);
AsmGenericSection.setAutomaticGenerationOfConstructor(false);
AsmGenericSection.setAutomaticGenerationOfDestructor(false);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
AsmGenericSection.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmGenericSection);
#if defined(SgAsmGenericSection_HEADERS) || defined(DOCUMENTATION)
#include <Rose/BinaryAnalysis/Address.h>
#include <Rose/BinaryAnalysis/AddressIntervalSet.h>
#include <Rose/BinaryAnalysis/MemoryMap.h>
#include <Rose/BinaryAnalysis/RelativeVirtualAddress.h>
#include <sageContainer.h>
 
#ifdef ROSE_SgAsmGenericSection_IMPL
#include <SgAsmBasicString.h>
#endif
#endif // SgAsmGenericSection_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmGenericSection: public SgAsmExecutableFileFormat {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmGenericSection.setDataPrototype(
        "SgAsmGenericFile*", "file", "= nullptr",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmGenericSection.setDataPrototype(
        "SgAsmGenericHeader*", "header", "= nullptr",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmGenericSection.setDataPrototype(
        "Rose::BinaryAnalysis::Address", "size", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmGenericSection.setDataPrototype(
        "Rose::BinaryAnalysis::Address", "offset", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmGenericSection.setDataPrototype(
        "Rose::BinaryAnalysis::Address", "fileAlignment", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmGenericSection.setDataPrototype(
        "SgFileContentList", "data", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmGenericSection.setDataPrototype(
        "SgAsmGenericSection::SectionPurpose", "purpose", "= SgAsmGenericSection::SP_UNSPECIFIED",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmGenericSection.setDataPrototype(
        "bool", "synthesized", "= false",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmGenericSection.setDataPrototype(
        "int", "id", "= -1",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmGenericSection.setDataPrototype(
        "SgAsmGenericString*", "name", "= createAndParent<SgAsmBasicString>(this)",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmGenericSection.setDataPrototype(
        "std::string", "shortName", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmGenericSection.setDataPrototype(
        "Rose::BinaryAnalysis::Address", "mappedPreferredRva", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmGenericSection.setDataPrototype(
        "Rose::BinaryAnalysis::Address", "mappedSize", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmGenericSection.setDataPrototype(
        "Rose::BinaryAnalysis::Address", "mappedAlignment", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmGenericSection.setDataPrototype(
        "bool", "mappedReadPermission", "= false",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmGenericSection.setDataPrototype(
        "bool", "mappedWritePermission", "= false",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmGenericSection.setDataPrototype(
        "bool", "mappedExecutePermission", "= false",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmGenericSection.setDataPrototype(
        "bool", "containsCode", "= false",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmGenericSection.setDataPrototype(
        "Rose::BinaryAnalysis::Address", "mappedActualVa", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmGenericSection);
#if defined(SgAsmGenericSection_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmGenericSection -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmGenericSection");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
        s & BOOST_SERIALIZATION_NVP(p_file);
        s & BOOST_SERIALIZATION_NVP(p_header);
        s & BOOST_SERIALIZATION_NVP(p_size);
        s & BOOST_SERIALIZATION_NVP(p_offset);
        s & BOOST_SERIALIZATION_NVP(p_fileAlignment);
        s & BOOST_SERIALIZATION_NVP(p_data);
        s & BOOST_SERIALIZATION_NVP(p_purpose);
        s & BOOST_SERIALIZATION_NVP(p_synthesized);
        s & BOOST_SERIALIZATION_NVP(p_id);
        s & BOOST_SERIALIZATION_NVP(p_name);
        s & BOOST_SERIALIZATION_NVP(p_shortName);
        s & BOOST_SERIALIZATION_NVP(p_mappedPreferredRva);
        s & BOOST_SERIALIZATION_NVP(p_mappedSize);
        s & BOOST_SERIALIZATION_NVP(p_mappedAlignment);
        s & BOOST_SERIALIZATION_NVP(p_mappedReadPermission);
        s & BOOST_SERIALIZATION_NVP(p_mappedWritePermission);
        s & BOOST_SERIALIZATION_NVP(p_mappedExecutePermission);
        s & BOOST_SERIALIZATION_NVP(p_containsCode);
        s & BOOST_SERIALIZATION_NVP(p_mappedActualVa);
        debugSerializationEnd("SgAsmGenericSection");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
    // Local types
public:
    enum SectionPurpose {
        SP_UNSPECIFIED,                 
        SP_PROGRAM,                     
        SP_HEADER,                      
        SP_SYMTAB,                      
        SP_OTHER                        
    };
    enum SectionPurpose {…};
 
    // Properties
public:
public:
    SgAsmGenericFile* const& get_file() const;
    void set_file(SgAsmGenericFile* const&);
public:
    SgAsmGenericHeader* const& get_header() const;
    void set_header(SgAsmGenericHeader* const&);
public:
    Rose::BinaryAnalysis::Address get_size() const;
    virtual void set_size(Rose::BinaryAnalysis::Address);
public:
 // Starting file offset of the section
 
    Rose::BinaryAnalysis::Address get_offset() const;
    virtual void set_offset(Rose::BinaryAnalysis::Address);
public:
    Rose::BinaryAnalysis::Address const& get_fileAlignment() const;
    void set_fileAlignment(Rose::BinaryAnalysis::Address const&);
public:
    SgFileContentList const& get_data() const;
    void set_data(SgFileContentList const&);
public:
    SgAsmGenericSection::SectionPurpose const& get_purpose() const;
    void set_purpose(SgAsmGenericSection::SectionPurpose const&);
public:
    bool const& get_synthesized() const;
    void set_synthesized(bool const&);
public:
    int const& get_id() const;
    void set_id(int const&);
public:
    SgAsmGenericString* const& get_name() const;
    void set_name(SgAsmGenericString *s);
public:
    void set_shortName(std::string const&);
    std::string get_shortName() const;
public:
    Rose::BinaryAnalysis::Address const& get_mappedPreferredRva() const;
    virtual void set_mappedPreferredRva(Rose::BinaryAnalysis::Address);
public:
    Rose::BinaryAnalysis::Address const& get_mappedSize() const;
    virtual void set_mappedSize(Rose::BinaryAnalysis::Address);
public:
    Rose::BinaryAnalysis::Address const& get_mappedAlignment() const;
    void set_mappedAlignment(Rose::BinaryAnalysis::Address const&);
public:
    bool const& get_mappedReadPermission() const;
    void set_mappedReadPermission(bool const&);
public:
    bool const& get_mappedWritePermission() const;
    void set_mappedWritePermission(bool const&);
public:
    bool const& get_mappedExecutePermission() const;
    void set_mappedExecutePermission(bool const&);
public:
    bool const& get_containsCode() const;
    void set_containsCode(bool const&);
public:
    Rose::BinaryAnalysis::Address const& get_mappedActualVa() const;
    void set_mappedActualVa(Rose::BinaryAnalysis::Address const&);
    // Non-property data members
private:
protected: // Allows local_data_pool to be initialized by subclasses. Note, destruction is problematic, freeing non-allocated ptr.
           // Set breakpoint in malloc_error_break to debug [Rasmussen, 2024.03.02]
    /* This is an optional local, writable pool for the p_data member. Normally a section will point into the pool
     * for its SgAsmGenericFile which is memory-mapped (read-only) from the actual file being parsed. The default
     * unparsing action is to write the original data back to the file. By allowing a section to allocate its own
     * pool for `data` we create a very easy way to get data into the unparsed file (the alternative is to derive
     * a new class and override the unparse() method). */
    unsigned char *local_data_pool;
 
    // Functions
public:
    SgAsmGenericSection(SgAsmGenericFile*, SgAsmGenericHeader*);
 
    static void dumpContainingSections(FILE*, const std::string &prefix, Rose::BinaryAnalysis::RelativeVirtualAddress,
                                       const SgAsmGenericSectionPtrList&);
 
    void grabContent();
 
    virtual SgAsmGenericSection* parse();
 
    virtual void dump(FILE*, const char *prefix, ssize_t idx) const;
 
    virtual bool reallocate() { return false; }
 
    virtual void unparse(std::ostream&) const;
 
    void unparse(std::ostream&, const ExtentMap&) const;
 
    void unparseHoles(std::ostream&) const;
 
    SgAsmGenericHeader *isFileHeader();
 
    Rose::BinaryAnalysis::Address get_endOffset() const;
 
    void extend(Rose::BinaryAnalysis::Address nbytes);
 
    Rose::BinaryAnalysis::Address write(std::ostream&, Rose::BinaryAnalysis::Address offset, size_t bufsize, const void *buf) const;
    Rose::BinaryAnalysis::Address write(std::ostream&, Rose::BinaryAnalysis::Address offset, const std::string &str) const;
    Rose::BinaryAnalysis::Address write(std::ostream&, Rose::BinaryAnalysis::Address offset, char c) const;
    Rose::BinaryAnalysis::Address write(std::ostream&, Rose::BinaryAnalysis::Address offset, const SgFileContentList &buf) const;
    Rose::BinaryAnalysis::Address write(std::ostream&, Rose::BinaryAnalysis::Address offset, const SgUnsignedCharList &buf) const;
    Rose::BinaryAnalysis::Address writeUleb128(unsigned char*, Rose::BinaryAnalysis::Address offset, uint64_t) const;
 
    Rose::BinaryAnalysis::Address writeSleb128(unsigned char*, Rose::BinaryAnalysis::Address offset, int64_t) const;
 
    size_t readContent(Rose::BinaryAnalysis::Address abs_offset, void *dst_buf, Rose::BinaryAnalysis::Address size, bool strict=true);
 
    size_t readContent(const Rose::BinaryAnalysis::MemoryMap::Ptr&, Rose::BinaryAnalysis::Address start,  void *dst_buf,
                       Rose::BinaryAnalysis::Address size, bool strict=true);
    size_t readContent(const Rose::BinaryAnalysis::MemoryMap::Ptr&, const Rose::BinaryAnalysis::RelativeVirtualAddress &start,
                       void *dst_buf, Rose::BinaryAnalysis::Address size, bool strict=true);
    size_t readContentLocal(Rose::BinaryAnalysis::Address rel_offset, void *dst_buf, Rose::BinaryAnalysis::Address size,
                            bool strict=true);
 
    std::string readContentString(const Rose::BinaryAnalysis::MemoryMap::Ptr&, Rose::BinaryAnalysis::Address va, bool strict=true);
 
    std::string readContentString(Rose::BinaryAnalysis::Address abs_offset, bool strict=true);
    std::string readContentString(const Rose::BinaryAnalysis::MemoryMap::Ptr &map, Rose::BinaryAnalysis::RelativeVirtualAddress rva,
                                  bool strict=true);
    std::string readContentLocalString(Rose::BinaryAnalysis::Address rel_offset, bool strict=true);
 
    SgUnsignedCharList readContentLocalUcl(Rose::BinaryAnalysis::Address rel_offset, Rose::BinaryAnalysis::Address size);
 
    int64_t readContentLocalSleb128(Rose::BinaryAnalysis::Address *rel_offset, bool strict=true);
 
    uint64_t readContentLocalUleb128(Rose::BinaryAnalysis::Address *rel_offset, bool strict=true);
 
    unsigned char *writableContent(size_t nbytes);
 
    Rose::BinaryAnalysis::AddressIntervalSet get_referencedExtents() const;
 
    Rose::BinaryAnalysis::AddressIntervalSet get_unreferencedExtents() const;
 
    bool isMapped() const;
 
    void clearMapped();
 
    Rose::BinaryAnalysis::Address get_baseVa() const;
 
    Rose::BinaryAnalysis::Address get_mappedPreferredVa() const;
 
    Rose::BinaryAnalysis::Address get_vaOffset(Rose::BinaryAnalysis::Address va) const;
 
    Rose::BinaryAnalysis::Address get_rvaOffset(Rose::BinaryAnalysis::Address rva) const;
 
    Extent get_fileExtent() const;
 
    Extent get_mappedPreferredExtent() const;
 
    bool align();
 
protected:
    virtual void destructorHelper() override;
 
    // Deprecated 2023-11
public:
    Rose::BinaryAnalysis::Address get_file_alignment() const ROSE_DEPRECATED("use get_fileAlignment");
    void set_file_alignment(Rose::BinaryAnalysis::Address) ROSE_DEPRECATED("use set_fileAlignment");
    std::string get_short_name() const ROSE_DEPRECATED("use get_shortName");
    void set_short_name(const std::string&) ROSE_DEPRECATED("use set_shortName");
    Rose::BinaryAnalysis::Address get_mapped_preferred_rva() const ROSE_DEPRECATED("use get_mappedPreferredRva");
    void set_mapped_preferred_rva(Rose::BinaryAnalysis::Address) ROSE_DEPRECATED("use set_mappedPreferredRva");
    Rose::BinaryAnalysis::Address get_mapped_size() const ROSE_DEPRECATED("use get_mappedSize");
    void set_mapped_size(Rose::BinaryAnalysis::Address) ROSE_DEPRECATED("use set_mappedSize");
    Rose::BinaryAnalysis::Address get_mapped_alignment() const ROSE_DEPRECATED("use get_mappedAlignment");
    void set_mapped_alignment(Rose::BinaryAnalysis::Address) ROSE_DEPRECATED("use set_mappedAlignment");
    bool get_mapped_rperm() const ROSE_DEPRECATED("use get_mappedReadPermission");
    void set_mapped_rperm(bool) ROSE_DEPRECATED("use set_mappedReadPermission");
    bool get_mapped_wperm() const ROSE_DEPRECATED("use get_mappedWritePermission");
    void set_mapped_wperm(bool) ROSE_DEPRECATED("use set_mappedWritePermission");
    bool get_mapped_xperm() const ROSE_DEPRECATED("use get_mappedExecutePermission");
    void set_mapped_xperm(bool) ROSE_DEPRECATED("use set_mappedExecutePermission");
    bool get_contains_code() const ROSE_DEPRECATED("use get_containsCode");
    void set_contains_code(bool) ROSE_DEPRECATED("use set_containsCode");
    Rose::BinaryAnalysis::Address get_mapped_actual_va() const ROSE_DEPRECATED("use get_mappedActualVa");
    void set_mapped_actual_va(Rose::BinaryAnalysis::Address) ROSE_DEPRECATED("use set_mappedActualVa");
    static void dump_containing_sections(FILE*, const std::string&, Rose::BinaryAnalysis::RelativeVirtualAddress,
                                         const SgAsmGenericSectionPtrList&)
        ROSE_DEPRECATED("use dumpContainingSections");
    void grab_content() ROSE_DEPRECATED("use grabContent");
    void unparse_holes(std::ostream&) const ROSE_DEPRECATED("use unparseHoles");
    SgAsmGenericHeader *is_file_header() ROSE_DEPRECATED("use isFileHeader");
    Rose::BinaryAnalysis::Address get_end_offset() const ROSE_DEPRECATED("use get_endOffset");
    Rose::BinaryAnalysis::Address write_uleb128(unsigned char*, Rose::BinaryAnalysis::Address, uint64_t) const
        ROSE_DEPRECATED("use writeUleb128");
    Rose::BinaryAnalysis::Address write_sleb128(unsigned char*, Rose::BinaryAnalysis::Address, int64_t) const
        ROSE_DEPRECATED("use writeSleb128");
    size_t read_content(Rose::BinaryAnalysis::Address, void*, Rose::BinaryAnalysis::Address, bool=true)
        ROSE_DEPRECATED("use readContent");
    size_t read_content(const Rose::BinaryAnalysis::MemoryMap::Ptr&, Rose::BinaryAnalysis::Address,  void*,
                        Rose::BinaryAnalysis::Address, bool=true) ROSE_DEPRECATED("use readContent");
    size_t read_content(const Rose::BinaryAnalysis::MemoryMap::Ptr&, const Rose::BinaryAnalysis::RelativeVirtualAddress&, void*,
                        Rose::BinaryAnalysis::Address, bool=true)
        ROSE_DEPRECATED("use readContent");
    size_t read_content_local(Rose::BinaryAnalysis::Address, void*, Rose::BinaryAnalysis::Address, bool=true)
        ROSE_DEPRECATED("use readContentLocal");
    std::string read_content_str(const Rose::BinaryAnalysis::MemoryMap::Ptr&, Rose::BinaryAnalysis::Address, bool=true)
        ROSE_DEPRECATED("use readContentString");
    std::string read_content_str(Rose::BinaryAnalysis::Address, bool=true) ROSE_DEPRECATED("use readContentString");
    std::string read_content_str(const Rose::BinaryAnalysis::MemoryMap::Ptr&, Rose::BinaryAnalysis::RelativeVirtualAddress,
                                 bool=true)
        ROSE_DEPRECATED("use readContentString");
    std::string read_content_local_str(Rose::BinaryAnalysis::Address, bool=true) ROSE_DEPRECATED("use readContentLocalString");
    SgUnsignedCharList read_content_local_ucl(Rose::BinaryAnalysis::Address, Rose::BinaryAnalysis::Address)
        ROSE_DEPRECATED("use readContentLocalUcl");
    int64_t read_content_local_sleb128(Rose::BinaryAnalysis::Address*, bool=true) ROSE_DEPRECATED("use readContentLocalSleb128");
    uint64_t read_content_local_uleb128(Rose::BinaryAnalysis::Address*, bool=true) ROSE_DEPRECATED("use readContentLocalUleb128");
    unsigned char *writable_content(size_t) ROSE_DEPRECATED("use writableContent");
    Rose::BinaryAnalysis::AddressIntervalSet get_referenced_extents() const ROSE_DEPRECATED("use get_referencedExtents");
    Rose::BinaryAnalysis::AddressIntervalSet get_unreferenced_extents() const ROSE_DEPRECATED("use get_unreferencedExtents");
    bool is_mapped() const ROSE_DEPRECATED("use isMapped");
    void clear_mapped() ROSE_DEPRECATED("use clearMapped");
    Rose::BinaryAnalysis::Address get_base_va() const ROSE_DEPRECATED("use get_baseVa");
    Rose::BinaryAnalysis::Address get_mapped_preferred_va() const ROSE_DEPRECATED("use get_mappedPreferredVa");
    Rose::BinaryAnalysis::Address get_va_offset(Rose::BinaryAnalysis::Address) const ROSE_DEPRECATED("use get_vaOffset");
    Rose::BinaryAnalysis::Address get_rva_offset(Rose::BinaryAnalysis::Address) const ROSE_DEPRECATED("use get_rvaOffset");
    Extent get_file_extent() const ROSE_DEPRECATED("use get_fileExtent");
    Extent get_mapped_preferred_extent() const ROSE_DEPRECATED("use get_mappedPreferredExtent");
public:
    virtual ~SgAsmGenericSection();
 
public:
    SgAsmGenericSection();
 
protected:
    void initializeProperties();
#endif // SgAsmGenericSection_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmGenericSection: public SgAsmExecutableFileFormat {…};
#endif // DOCUMENTATION
 
 
// SgAsmCilUint8Heap           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmCilUint8Heap);
IS_SERIALIZABLE(AsmCilUint8Heap);
 
#ifndef DOCUMENTATION
AsmCilUint8Heap.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmCilUint8Heap: public SgAsmCilDataStream {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilUint8Heap.setDataPrototype(
        "std::vector<uint8_t>", "Stream", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmCilUint8Heap);
#if defined(SgAsmCilUint8Heap_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmCilUint8Heap -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmCilUint8Heap");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilDataStream);
        s & BOOST_SERIALIZATION_NVP(p_Stream);
        debugSerializationEnd("SgAsmCilUint8Heap");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    std::vector<uint8_t> const& get_Stream() const;
    std::vector<uint8_t>& get_Stream();
public:
    void parse(const std::vector<uint8_t>& buf, size_t startOfMetaData) override;
    void unparse(std::vector<uint8_t>& buf, size_t startOfMetaData) const override;
    void dump(std::ostream& os) const override;
public:
    virtual ~SgAsmCilUint8Heap();
 
public:
    SgAsmCilUint8Heap();
 
public:
    SgAsmCilUint8Heap(uint32_t const& Offset,
                      uint32_t const& Size,
                      std::string const& Name,
                      uint32_t const& NamePadding);
 
protected:
    void initializeProperties();
#endif // SgAsmCilUint8Heap_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmCilUint8Heap: public SgAsmCilDataStream {…};
#endif // DOCUMENTATION
 
 
// SgAsmCilUint32Heap           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmCilUint32Heap);
IS_SERIALIZABLE(AsmCilUint32Heap);
 
#ifndef DOCUMENTATION
AsmCilUint32Heap.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmCilUint32Heap: public SgAsmCilDataStream {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilUint32Heap.setDataPrototype(
        "std::vector<uint32_t>", "Stream", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmCilUint32Heap);
#if defined(SgAsmCilUint32Heap_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmCilUint32Heap -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmCilUint32Heap");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilDataStream);
        s & BOOST_SERIALIZATION_NVP(p_Stream);
        debugSerializationEnd("SgAsmCilUint32Heap");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    std::vector<uint32_t> const& get_Stream() const;
    std::vector<uint32_t>& get_Stream();
public:
    void parse(const std::vector<uint8_t>& buf, size_t startOfMetaData) override;
    void unparse(std::vector<uint8_t>& buf, size_t startOfMetaData) const override;
    void dump(std::ostream& os) const override;
public:
    virtual ~SgAsmCilUint32Heap();
 
public:
    SgAsmCilUint32Heap();
 
public:
    SgAsmCilUint32Heap(uint32_t const& Offset,
                       uint32_t const& Size,
                       std::string const& Name,
                       uint32_t const& NamePadding);
 
protected:
    void initializeProperties();
#endif // SgAsmCilUint32Heap_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmCilUint32Heap: public SgAsmCilDataStream {…};
#endif // DOCUMENTATION
 
 
// SgAsmCilTypeSpecTable           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmCilTypeSpecTable);
IS_SERIALIZABLE(AsmCilTypeSpecTable);
 
#ifndef DOCUMENTATION
AsmCilTypeSpecTable.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmCilTypeSpecTable: public SgAsmCilMetadata {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilTypeSpecTable.setDataPrototype(
        "std::vector<SgAsmCilTypeSpec*>", "elements", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmCilTypeSpecTable);
#if defined(SgAsmCilTypeSpecTable_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmCilTypeSpecTable -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmCilTypeSpecTable");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
        s & BOOST_SERIALIZATION_NVP(p_elements);
        debugSerializationEnd("SgAsmCilTypeSpecTable");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    std::vector<SgAsmCilTypeSpec*> const& get_elements() const;
    std::vector<SgAsmCilTypeSpec*>& get_elements();
public:
    using CilMetadataType = SgAsmCilTypeSpec;
public:
    virtual ~SgAsmCilTypeSpecTable();
 
public:
    SgAsmCilTypeSpecTable();
 
protected:
    void initializeProperties();
#endif // SgAsmCilTypeSpecTable_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmCilTypeSpecTable: public SgAsmCilMetadata {…};
#endif // DOCUMENTATION
 
 
// SgAsmCilTypeSpec           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmCilTypeSpec);
IS_SERIALIZABLE(AsmCilTypeSpec);
 
#ifndef DOCUMENTATION
AsmCilTypeSpec.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmCilTypeSpec: public SgAsmCilMetadata {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilTypeSpec.setDataPrototype(
        "uint32_t", "Signature", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmCilTypeSpec);
#if defined(SgAsmCilTypeSpec_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmCilTypeSpec -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmCilTypeSpec");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
        s & BOOST_SERIALIZATION_NVP(p_Signature);
        debugSerializationEnd("SgAsmCilTypeSpec");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    uint32_t const& get_Signature() const;
    void set_Signature(uint32_t const&);
public:
    void parse(const std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing);
    void unparse(std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing) const;
    void dump(std::ostream&) const;
 
    const std::uint8_t* get_Signature_blob() const;
public:
    virtual ~SgAsmCilTypeSpec();
 
public:
    SgAsmCilTypeSpec();
 
protected:
    void initializeProperties();
#endif // SgAsmCilTypeSpec_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmCilTypeSpec: public SgAsmCilMetadata {…};
#endif // DOCUMENTATION
 
 
// SgAsmCilTypeRefTable           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmCilTypeRefTable);
IS_SERIALIZABLE(AsmCilTypeRefTable);
 
#ifndef DOCUMENTATION
AsmCilTypeRefTable.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmCilTypeRefTable: public SgAsmCilMetadata {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilTypeRefTable.setDataPrototype(
        "std::vector<SgAsmCilTypeRef*>", "elements", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmCilTypeRefTable);
#if defined(SgAsmCilTypeRefTable_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmCilTypeRefTable -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmCilTypeRefTable");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
        s & BOOST_SERIALIZATION_NVP(p_elements);
        debugSerializationEnd("SgAsmCilTypeRefTable");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    std::vector<SgAsmCilTypeRef*> const& get_elements() const;
    std::vector<SgAsmCilTypeRef*>& get_elements();
public:
    using CilMetadataType = SgAsmCilTypeRef;
public:
    virtual ~SgAsmCilTypeRefTable();
 
public:
    SgAsmCilTypeRefTable();
 
protected:
    void initializeProperties();
#endif // SgAsmCilTypeRefTable_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmCilTypeRefTable: public SgAsmCilMetadata {…};
#endif // DOCUMENTATION
 
 
// SgAsmCilTypeRef           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmCilTypeRef);
IS_SERIALIZABLE(AsmCilTypeRef);
 
#ifndef DOCUMENTATION
AsmCilTypeRef.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmCilTypeRef: public SgAsmCilMetadata {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilTypeRef.setDataPrototype(
        "uint16_t", "ResolutionScope", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilTypeRef.setDataPrototype(
        "uint32_t", "TypeName", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilTypeRef.setDataPrototype(
        "uint32_t", "TypeNamespace", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmCilTypeRef);
#if defined(SgAsmCilTypeRef_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmCilTypeRef -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmCilTypeRef");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
        s & BOOST_SERIALIZATION_NVP(p_ResolutionScope);
        s & BOOST_SERIALIZATION_NVP(p_TypeName);
        s & BOOST_SERIALIZATION_NVP(p_TypeNamespace);
        debugSerializationEnd("SgAsmCilTypeRef");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    uint16_t const& get_ResolutionScope() const;
    void set_ResolutionScope(uint16_t const&);
public:
    uint32_t const& get_TypeName() const;
    void set_TypeName(uint32_t const&);
public:
    uint32_t const& get_TypeNamespace() const;
    void set_TypeNamespace(uint32_t const&);
public:
    void parse(const std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing);
    void unparse(std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing) const;
    void dump(std::ostream&) const;
 
    const SgAsmCilMetadata* get_ResolutionScope_object() const;
    const std::uint8_t* get_TypeName_string() const;
    const std::uint8_t* get_TypeNamespace_string() const;
public:
    virtual ~SgAsmCilTypeRef();
 
public:
    SgAsmCilTypeRef();
 
protected:
    void initializeProperties();
#endif // SgAsmCilTypeRef_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmCilTypeRef: public SgAsmCilMetadata {…};
#endif // DOCUMENTATION
 
 
// SgAsmCilTypeDefTable           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmCilTypeDefTable);
IS_SERIALIZABLE(AsmCilTypeDefTable);
 
#ifndef DOCUMENTATION
AsmCilTypeDefTable.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmCilTypeDefTable: public SgAsmCilMetadata {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilTypeDefTable.setDataPrototype(
        "std::vector<SgAsmCilTypeDef*>", "elements", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmCilTypeDefTable);
#if defined(SgAsmCilTypeDefTable_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmCilTypeDefTable -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmCilTypeDefTable");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
        s & BOOST_SERIALIZATION_NVP(p_elements);
        debugSerializationEnd("SgAsmCilTypeDefTable");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    std::vector<SgAsmCilTypeDef*> const& get_elements() const;
    std::vector<SgAsmCilTypeDef*>& get_elements();
public:
    using CilMetadataType = SgAsmCilTypeDef;
public:
    virtual ~SgAsmCilTypeDefTable();
 
public:
    SgAsmCilTypeDefTable();
 
protected:
    void initializeProperties();
#endif // SgAsmCilTypeDefTable_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmCilTypeDefTable: public SgAsmCilMetadata {…};
#endif // DOCUMENTATION
 
 
// SgAsmCilTypeDef           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmCilTypeDef);
IS_SERIALIZABLE(AsmCilTypeDef);
 
#ifndef DOCUMENTATION
AsmCilTypeDef.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmCilTypeDef: public SgAsmCilMetadata {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilTypeDef.setDataPrototype(
        "uint32_t", "Flags", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilTypeDef.setDataPrototype(
        "uint32_t", "TypeName", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilTypeDef.setDataPrototype(
        "uint32_t", "TypeNamespace", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilTypeDef.setDataPrototype(
        "uint32_t", "Extends", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilTypeDef.setDataPrototype(
        "uint32_t", "FieldList", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilTypeDef.setDataPrototype(
        "uint32_t", "MethodList", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmCilTypeDef);
#if defined(SgAsmCilTypeDef_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmCilTypeDef -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmCilTypeDef");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
        s & BOOST_SERIALIZATION_NVP(p_Flags);
        s & BOOST_SERIALIZATION_NVP(p_TypeName);
        s & BOOST_SERIALIZATION_NVP(p_TypeNamespace);
        s & BOOST_SERIALIZATION_NVP(p_Extends);
        s & BOOST_SERIALIZATION_NVP(p_FieldList);
        s & BOOST_SERIALIZATION_NVP(p_MethodList);
        debugSerializationEnd("SgAsmCilTypeDef");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    uint32_t const& get_Flags() const;
    void set_Flags(uint32_t const&);
public:
    uint32_t const& get_TypeName() const;
    void set_TypeName(uint32_t const&);
public:
    uint32_t const& get_TypeNamespace() const;
    void set_TypeNamespace(uint32_t const&);
public:
    uint32_t const& get_Extends() const;
    void set_Extends(uint32_t const&);
public:
    uint32_t const& get_FieldList() const;
    void set_FieldList(uint32_t const&);
public:
    uint32_t const& get_MethodList() const;
    void set_MethodList(uint32_t const&);
public:
    void parse(const std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing);
    void unparse(std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing) const;
    void dump(std::ostream&) const;
 
    const std::uint8_t* get_TypeName_string() const;
    const std::uint8_t* get_TypeNamespace_string() const;
    const SgAsmCilMetadata* get_Extends_object() const;
    const SgAsmCilMetadata* get_FieldList_object() const;
    const SgAsmCilMetadata* get_MethodList_object() const;
    const SgAsmCilMetadata* get_MethodList_object(const SgAsmCilMethodDef*) const;
public:
    virtual ~SgAsmCilTypeDef();
 
public:
    SgAsmCilTypeDef();
 
protected:
    void initializeProperties();
#endif // SgAsmCilTypeDef_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmCilTypeDef: public SgAsmCilMetadata {…};
#endif // DOCUMENTATION
 
 
// SgAsmCilStandAloneSigTable           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmCilStandAloneSigTable);
IS_SERIALIZABLE(AsmCilStandAloneSigTable);
 
#ifndef DOCUMENTATION
AsmCilStandAloneSigTable.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmCilStandAloneSigTable: public SgAsmCilMetadata {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilStandAloneSigTable.setDataPrototype(
        "std::vector<SgAsmCilStandAloneSig*>", "elements", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmCilStandAloneSigTable);
#if defined(SgAsmCilStandAloneSigTable_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmCilStandAloneSigTable -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmCilStandAloneSigTable");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
        s & BOOST_SERIALIZATION_NVP(p_elements);
        debugSerializationEnd("SgAsmCilStandAloneSigTable");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    std::vector<SgAsmCilStandAloneSig*> const& get_elements() const;
    std::vector<SgAsmCilStandAloneSig*>& get_elements();
public:
    using CilMetadataType = SgAsmCilStandAloneSig;
public:
    virtual ~SgAsmCilStandAloneSigTable();
 
public:
    SgAsmCilStandAloneSigTable();
 
protected:
    void initializeProperties();
#endif // SgAsmCilStandAloneSigTable_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmCilStandAloneSigTable: public SgAsmCilMetadata {…};
#endif // DOCUMENTATION
 
 
// SgAsmCilStandAloneSig           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmCilStandAloneSig);
IS_SERIALIZABLE(AsmCilStandAloneSig);
 
#ifndef DOCUMENTATION
AsmCilStandAloneSig.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmCilStandAloneSig: public SgAsmCilMetadata {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilStandAloneSig.setDataPrototype(
        "uint32_t", "Signature", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmCilStandAloneSig);
#if defined(SgAsmCilStandAloneSig_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmCilStandAloneSig -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmCilStandAloneSig");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
        s & BOOST_SERIALIZATION_NVP(p_Signature);
        debugSerializationEnd("SgAsmCilStandAloneSig");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    uint32_t const& get_Signature() const;
    void set_Signature(uint32_t const&);
public:
    void parse(const std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing);
    void unparse(std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing) const;
    void dump(std::ostream&) const;
 
    const std::uint8_t* get_Signature_blob() const;
public:
    virtual ~SgAsmCilStandAloneSig();
 
public:
    SgAsmCilStandAloneSig();
 
protected:
    void initializeProperties();
#endif // SgAsmCilStandAloneSig_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmCilStandAloneSig: public SgAsmCilMetadata {…};
#endif // DOCUMENTATION
 
 
// SgAsmCilPropertyTable           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmCilPropertyTable);
IS_SERIALIZABLE(AsmCilPropertyTable);
 
#ifndef DOCUMENTATION
AsmCilPropertyTable.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmCilPropertyTable: public SgAsmCilMetadata {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilPropertyTable.setDataPrototype(
        "std::vector<SgAsmCilProperty*>", "elements", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmCilPropertyTable);
#if defined(SgAsmCilPropertyTable_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmCilPropertyTable -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmCilPropertyTable");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
        s & BOOST_SERIALIZATION_NVP(p_elements);
        debugSerializationEnd("SgAsmCilPropertyTable");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    std::vector<SgAsmCilProperty*> const& get_elements() const;
    std::vector<SgAsmCilProperty*>& get_elements();
public:
    using CilMetadataType = SgAsmCilProperty;
public:
    virtual ~SgAsmCilPropertyTable();
 
public:
    SgAsmCilPropertyTable();
 
protected:
    void initializeProperties();
#endif // SgAsmCilPropertyTable_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmCilPropertyTable: public SgAsmCilMetadata {…};
#endif // DOCUMENTATION
 
 
// SgAsmCilPropertyMapTable           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmCilPropertyMapTable);
IS_SERIALIZABLE(AsmCilPropertyMapTable);
 
#ifndef DOCUMENTATION
AsmCilPropertyMapTable.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmCilPropertyMapTable: public SgAsmCilMetadata {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilPropertyMapTable.setDataPrototype(
        "std::vector<SgAsmCilPropertyMap*>", "elements", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmCilPropertyMapTable);
#if defined(SgAsmCilPropertyMapTable_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmCilPropertyMapTable -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmCilPropertyMapTable");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
        s & BOOST_SERIALIZATION_NVP(p_elements);
        debugSerializationEnd("SgAsmCilPropertyMapTable");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    std::vector<SgAsmCilPropertyMap*> const& get_elements() const;
    std::vector<SgAsmCilPropertyMap*>& get_elements();
public:
    using CilMetadataType = SgAsmCilPropertyMap;
public:
    virtual ~SgAsmCilPropertyMapTable();
 
public:
    SgAsmCilPropertyMapTable();
 
protected:
    void initializeProperties();
#endif // SgAsmCilPropertyMapTable_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmCilPropertyMapTable: public SgAsmCilMetadata {…};
#endif // DOCUMENTATION
 
 
// SgAsmCilPropertyMap           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmCilPropertyMap);
IS_SERIALIZABLE(AsmCilPropertyMap);
 
#ifndef DOCUMENTATION
AsmCilPropertyMap.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmCilPropertyMap: public SgAsmCilMetadata {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilPropertyMap.setDataPrototype(
        "uint32_t", "Parent", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilPropertyMap.setDataPrototype(
        "uint32_t", "PropertyList", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmCilPropertyMap);
#if defined(SgAsmCilPropertyMap_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmCilPropertyMap -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmCilPropertyMap");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
        s & BOOST_SERIALIZATION_NVP(p_Parent);
        s & BOOST_SERIALIZATION_NVP(p_PropertyList);
        debugSerializationEnd("SgAsmCilPropertyMap");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    uint32_t const& get_Parent() const;
    void set_Parent(uint32_t const&);
public:
    uint32_t const& get_PropertyList() const;
    void set_PropertyList(uint32_t const&);
public:
    void parse(const std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing);
    void unparse(std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing) const;
    void dump(std::ostream&) const;
 
    const SgAsmCilMetadata* get_Parent_object() const;
    const SgAsmCilMetadata* get_PropertyList_object() const;
public:
    virtual ~SgAsmCilPropertyMap();
 
public:
    SgAsmCilPropertyMap();
 
protected:
    void initializeProperties();
#endif // SgAsmCilPropertyMap_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmCilPropertyMap: public SgAsmCilMetadata {…};
#endif // DOCUMENTATION
 
 
// SgAsmCilProperty           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmCilProperty);
IS_SERIALIZABLE(AsmCilProperty);
 
#ifndef DOCUMENTATION
AsmCilProperty.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmCilProperty: public SgAsmCilMetadata {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilProperty.setDataPrototype(
        "uint16_t", "Flags", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilProperty.setDataPrototype(
        "uint32_t", "Name", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilProperty.setDataPrototype(
        "uint32_t", "Type", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmCilProperty);
#if defined(SgAsmCilProperty_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmCilProperty -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmCilProperty");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
        s & BOOST_SERIALIZATION_NVP(p_Flags);
        s & BOOST_SERIALIZATION_NVP(p_Name);
        s & BOOST_SERIALIZATION_NVP(p_Type);
        debugSerializationEnd("SgAsmCilProperty");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    uint16_t const& get_Flags() const;
    void set_Flags(uint16_t const&);
public:
    uint32_t const& get_Name() const;
    void set_Name(uint32_t const&);
public:
    uint32_t const& get_Type() const;
    void set_Type(uint32_t const&);
public:
    void parse(const std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing);
    void unparse(std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing) const;
    void dump(std::ostream&) const;
 
    const std::uint8_t* get_Name_string() const;
    const std::uint8_t* get_Type_blob() const;
public:
    virtual ~SgAsmCilProperty();
 
public:
    SgAsmCilProperty();
 
protected:
    void initializeProperties();
#endif // SgAsmCilProperty_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmCilProperty: public SgAsmCilMetadata {…};
#endif // DOCUMENTATION
 
 
// SgAsmCilParamTable           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmCilParamTable);
IS_SERIALIZABLE(AsmCilParamTable);
 
#ifndef DOCUMENTATION
AsmCilParamTable.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmCilParamTable: public SgAsmCilMetadata {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilParamTable.setDataPrototype(
        "std::vector<SgAsmCilParam*>", "elements", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmCilParamTable);
#if defined(SgAsmCilParamTable_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmCilParamTable -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmCilParamTable");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
        s & BOOST_SERIALIZATION_NVP(p_elements);
        debugSerializationEnd("SgAsmCilParamTable");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    std::vector<SgAsmCilParam*> const& get_elements() const;
    std::vector<SgAsmCilParam*>& get_elements();
public:
    using CilMetadataType = SgAsmCilParam;
public:
    virtual ~SgAsmCilParamTable();
 
public:
    SgAsmCilParamTable();
 
protected:
    void initializeProperties();
#endif // SgAsmCilParamTable_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmCilParamTable: public SgAsmCilMetadata {…};
#endif // DOCUMENTATION
 
 
// SgAsmCilParam           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmCilParam);
IS_SERIALIZABLE(AsmCilParam);
 
#ifndef DOCUMENTATION
AsmCilParam.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmCilParam: public SgAsmCilMetadata {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilParam.setDataPrototype(
        "uint16_t", "Flags", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilParam.setDataPrototype(
        "uint16_t", "Sequence", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilParam.setDataPrototype(
        "uint32_t", "Name", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmCilParam);
#if defined(SgAsmCilParam_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmCilParam -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmCilParam");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
        s & BOOST_SERIALIZATION_NVP(p_Flags);
        s & BOOST_SERIALIZATION_NVP(p_Sequence);
        s & BOOST_SERIALIZATION_NVP(p_Name);
        debugSerializationEnd("SgAsmCilParam");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    uint16_t const& get_Flags() const;
    void set_Flags(uint16_t const&);
public:
    uint16_t const& get_Sequence() const;
    void set_Sequence(uint16_t const&);
public:
    uint32_t const& get_Name() const;
    void set_Name(uint32_t const&);
public:
    void parse(const std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing);
    void unparse(std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing) const;
    void dump(std::ostream&) const;
 
    const std::uint8_t* get_Name_string() const;
public:
    virtual ~SgAsmCilParam();
 
public:
    SgAsmCilParam();
 
protected:
    void initializeProperties();
#endif // SgAsmCilParam_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmCilParam: public SgAsmCilMetadata {…};
#endif // DOCUMENTATION
 
 
// SgAsmCilNestedClassTable           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmCilNestedClassTable);
IS_SERIALIZABLE(AsmCilNestedClassTable);
 
#ifndef DOCUMENTATION
AsmCilNestedClassTable.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmCilNestedClassTable: public SgAsmCilMetadata {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilNestedClassTable.setDataPrototype(
        "std::vector<SgAsmCilNestedClass*>", "elements", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmCilNestedClassTable);
#if defined(SgAsmCilNestedClassTable_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmCilNestedClassTable -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmCilNestedClassTable");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
        s & BOOST_SERIALIZATION_NVP(p_elements);
        debugSerializationEnd("SgAsmCilNestedClassTable");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    std::vector<SgAsmCilNestedClass*> const& get_elements() const;
    std::vector<SgAsmCilNestedClass*>& get_elements();
public:
    using CilMetadataType = SgAsmCilNestedClass;
public:
    virtual ~SgAsmCilNestedClassTable();
 
public:
    SgAsmCilNestedClassTable();
 
protected:
    void initializeProperties();
#endif // SgAsmCilNestedClassTable_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmCilNestedClassTable: public SgAsmCilMetadata {…};
#endif // DOCUMENTATION
 
 
// SgAsmCilNestedClass           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmCilNestedClass);
IS_SERIALIZABLE(AsmCilNestedClass);
 
#ifndef DOCUMENTATION
AsmCilNestedClass.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmCilNestedClass: public SgAsmCilMetadata {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilNestedClass.setDataPrototype(
        "uint32_t", "NestedClass", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilNestedClass.setDataPrototype(
        "uint32_t", "EnclosingClass", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmCilNestedClass);
#if defined(SgAsmCilNestedClass_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmCilNestedClass -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmCilNestedClass");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
        s & BOOST_SERIALIZATION_NVP(p_NestedClass);
        s & BOOST_SERIALIZATION_NVP(p_EnclosingClass);
        debugSerializationEnd("SgAsmCilNestedClass");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    uint32_t const& get_NestedClass() const;
    void set_NestedClass(uint32_t const&);
public:
    uint32_t const& get_EnclosingClass() const;
    void set_EnclosingClass(uint32_t const&);
public:
    void parse(const std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing);
    void unparse(std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing) const;
    void dump(std::ostream&) const;
 
    const SgAsmCilMetadata* get_NestedClass_object() const;
    const SgAsmCilMetadata* get_EnclosingClass_object() const;
public:
    virtual ~SgAsmCilNestedClass();
 
public:
    SgAsmCilNestedClass();
 
protected:
    void initializeProperties();
#endif // SgAsmCilNestedClass_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmCilNestedClass: public SgAsmCilMetadata {…};
#endif // DOCUMENTATION
 
 
// SgAsmCilModuleTable           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmCilModuleTable);
IS_SERIALIZABLE(AsmCilModuleTable);
 
#ifndef DOCUMENTATION
AsmCilModuleTable.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmCilModuleTable: public SgAsmCilMetadata {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilModuleTable.setDataPrototype(
        "std::vector<SgAsmCilModule*>", "elements", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmCilModuleTable);
#if defined(SgAsmCilModuleTable_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmCilModuleTable -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmCilModuleTable");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
        s & BOOST_SERIALIZATION_NVP(p_elements);
        debugSerializationEnd("SgAsmCilModuleTable");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    std::vector<SgAsmCilModule*> const& get_elements() const;
    std::vector<SgAsmCilModule*>& get_elements();
public:
    using CilMetadataType = SgAsmCilModule;
public:
    virtual ~SgAsmCilModuleTable();
 
public:
    SgAsmCilModuleTable();
 
protected:
    void initializeProperties();
#endif // SgAsmCilModuleTable_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmCilModuleTable: public SgAsmCilMetadata {…};
#endif // DOCUMENTATION
 
 
// SgAsmCilModuleRefTable           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmCilModuleRefTable);
IS_SERIALIZABLE(AsmCilModuleRefTable);
 
#ifndef DOCUMENTATION
AsmCilModuleRefTable.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmCilModuleRefTable: public SgAsmCilMetadata {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilModuleRefTable.setDataPrototype(
        "std::vector<SgAsmCilModuleRef*>", "elements", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmCilModuleRefTable);
#if defined(SgAsmCilModuleRefTable_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmCilModuleRefTable -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmCilModuleRefTable");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
        s & BOOST_SERIALIZATION_NVP(p_elements);
        debugSerializationEnd("SgAsmCilModuleRefTable");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    std::vector<SgAsmCilModuleRef*> const& get_elements() const;
    std::vector<SgAsmCilModuleRef*>& get_elements();
public:
    using CilMetadataType = SgAsmCilModuleRef;
public:
    virtual ~SgAsmCilModuleRefTable();
 
public:
    SgAsmCilModuleRefTable();
 
protected:
    void initializeProperties();
#endif // SgAsmCilModuleRefTable_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmCilModuleRefTable: public SgAsmCilMetadata {…};
#endif // DOCUMENTATION
 
 
// SgAsmCilModuleRef           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmCilModuleRef);
IS_SERIALIZABLE(AsmCilModuleRef);
 
#ifndef DOCUMENTATION
AsmCilModuleRef.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmCilModuleRef: public SgAsmCilMetadata {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilModuleRef.setDataPrototype(
        "uint32_t", "Name", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmCilModuleRef);
#if defined(SgAsmCilModuleRef_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmCilModuleRef -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmCilModuleRef");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
        s & BOOST_SERIALIZATION_NVP(p_Name);
        debugSerializationEnd("SgAsmCilModuleRef");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    uint32_t const& get_Name() const;
    void set_Name(uint32_t const&);
public:
    void parse(const std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing);
    void unparse(std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing) const;
    void dump(std::ostream&) const;
 
    const std::uint8_t* get_Name_string() const;
public:
    virtual ~SgAsmCilModuleRef();
 
public:
    SgAsmCilModuleRef();
 
protected:
    void initializeProperties();
#endif // SgAsmCilModuleRef_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmCilModuleRef: public SgAsmCilMetadata {…};
#endif // DOCUMENTATION
 
 
// SgAsmCilModule           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmCilModule);
IS_SERIALIZABLE(AsmCilModule);
 
#ifndef DOCUMENTATION
AsmCilModule.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmCilModule: public SgAsmCilMetadata {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilModule.setDataPrototype(
        "uint16_t", "Generation", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilModule.setDataPrototype(
        "uint32_t", "Name", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilModule.setDataPrototype(
        "uint32_t", "Mvid", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilModule.setDataPrototype(
        "uint32_t", "Encld", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilModule.setDataPrototype(
        "uint32_t", "EncBaseId", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmCilModule);
#if defined(SgAsmCilModule_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmCilModule -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmCilModule");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
        s & BOOST_SERIALIZATION_NVP(p_Generation);
        s & BOOST_SERIALIZATION_NVP(p_Name);
        s & BOOST_SERIALIZATION_NVP(p_Mvid);
        s & BOOST_SERIALIZATION_NVP(p_Encld);
        s & BOOST_SERIALIZATION_NVP(p_EncBaseId);
        debugSerializationEnd("SgAsmCilModule");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    uint16_t const& get_Generation() const;
    void set_Generation(uint16_t const&);
public:
    uint32_t const& get_Name() const;
    void set_Name(uint32_t const&);
public:
    uint32_t const& get_Mvid() const;
    void set_Mvid(uint32_t const&);
public:
    uint32_t const& get_Encld() const;
    void set_Encld(uint32_t const&);
public:
    uint32_t const& get_EncBaseId() const;
    void set_EncBaseId(uint32_t const&);
public:
    void parse(const std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing);
    void unparse(std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing) const;
    void dump(std::ostream&) const;
 
    const std::uint8_t* get_Name_string() const;
    const std::uint32_t* get_Mvid_guid() const;
    const std::uint32_t* get_Encld_guid() const;
    const std::uint32_t* get_EncBaseId_guid() const;
public:
    virtual ~SgAsmCilModule();
 
public:
    SgAsmCilModule();
 
protected:
    void initializeProperties();
#endif // SgAsmCilModule_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmCilModule: public SgAsmCilMetadata {…};
#endif // DOCUMENTATION
 
 
// SgAsmCilMethodSpecTable           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmCilMethodSpecTable);
IS_SERIALIZABLE(AsmCilMethodSpecTable);
 
#ifndef DOCUMENTATION
AsmCilMethodSpecTable.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmCilMethodSpecTable: public SgAsmCilMetadata {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilMethodSpecTable.setDataPrototype(
        "std::vector<SgAsmCilMethodSpec*>", "elements", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmCilMethodSpecTable);
#if defined(SgAsmCilMethodSpecTable_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmCilMethodSpecTable -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmCilMethodSpecTable");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
        s & BOOST_SERIALIZATION_NVP(p_elements);
        debugSerializationEnd("SgAsmCilMethodSpecTable");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    std::vector<SgAsmCilMethodSpec*> const& get_elements() const;
    std::vector<SgAsmCilMethodSpec*>& get_elements();
public:
    using CilMetadataType = SgAsmCilMethodSpec;
public:
    virtual ~SgAsmCilMethodSpecTable();
 
public:
    SgAsmCilMethodSpecTable();
 
protected:
    void initializeProperties();
#endif // SgAsmCilMethodSpecTable_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmCilMethodSpecTable: public SgAsmCilMetadata {…};
#endif // DOCUMENTATION
 
 
// SgAsmCilMethodSpec           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmCilMethodSpec);
IS_SERIALIZABLE(AsmCilMethodSpec);
 
#ifndef DOCUMENTATION
AsmCilMethodSpec.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmCilMethodSpec: public SgAsmCilMetadata {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilMethodSpec.setDataPrototype(
        "uint32_t", "Method", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilMethodSpec.setDataPrototype(
        "uint32_t", "Instantiation", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmCilMethodSpec);
#if defined(SgAsmCilMethodSpec_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmCilMethodSpec -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmCilMethodSpec");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
        s & BOOST_SERIALIZATION_NVP(p_Method);
        s & BOOST_SERIALIZATION_NVP(p_Instantiation);
        debugSerializationEnd("SgAsmCilMethodSpec");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    uint32_t const& get_Method() const;
    void set_Method(uint32_t const&);
public:
    uint32_t const& get_Instantiation() const;
    void set_Instantiation(uint32_t const&);
public:
    void parse(const std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing);
    void unparse(std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing) const;
    void dump(std::ostream&) const;
 
    const SgAsmCilMetadata* get_Method_object() const;
    const std::uint8_t* get_Instantiation_blob() const;
public:
    virtual ~SgAsmCilMethodSpec();
 
public:
    SgAsmCilMethodSpec();
 
protected:
    void initializeProperties();
#endif // SgAsmCilMethodSpec_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmCilMethodSpec: public SgAsmCilMetadata {…};
#endif // DOCUMENTATION
 
 
// SgAsmCilMethodSemanticsTable           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmCilMethodSemanticsTable);
IS_SERIALIZABLE(AsmCilMethodSemanticsTable);
 
#ifndef DOCUMENTATION
AsmCilMethodSemanticsTable.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmCilMethodSemanticsTable: public SgAsmCilMetadata {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilMethodSemanticsTable.setDataPrototype(
        "std::vector<SgAsmCilMethodSemantics*>", "elements", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmCilMethodSemanticsTable);
#if defined(SgAsmCilMethodSemanticsTable_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmCilMethodSemanticsTable -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmCilMethodSemanticsTable");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
        s & BOOST_SERIALIZATION_NVP(p_elements);
        debugSerializationEnd("SgAsmCilMethodSemanticsTable");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    std::vector<SgAsmCilMethodSemantics*> const& get_elements() const;
    std::vector<SgAsmCilMethodSemantics*>& get_elements();
public:
    using CilMetadataType = SgAsmCilMethodSemantics;
public:
    virtual ~SgAsmCilMethodSemanticsTable();
 
public:
    SgAsmCilMethodSemanticsTable();
 
protected:
    void initializeProperties();
#endif // SgAsmCilMethodSemanticsTable_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmCilMethodSemanticsTable: public SgAsmCilMetadata {…};
#endif // DOCUMENTATION
 
 
// SgAsmCilMethodSemantics           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmCilMethodSemantics);
IS_SERIALIZABLE(AsmCilMethodSemantics);
 
#ifndef DOCUMENTATION
AsmCilMethodSemantics.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmCilMethodSemantics: public SgAsmCilMetadata {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilMethodSemantics.setDataPrototype(
        "uint16_t", "Semantics", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilMethodSemantics.setDataPrototype(
        "uint32_t", "Method", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilMethodSemantics.setDataPrototype(
        "uint32_t", "Association", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmCilMethodSemantics);
#if defined(SgAsmCilMethodSemantics_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmCilMethodSemantics -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmCilMethodSemantics");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
        s & BOOST_SERIALIZATION_NVP(p_Semantics);
        s & BOOST_SERIALIZATION_NVP(p_Method);
        s & BOOST_SERIALIZATION_NVP(p_Association);
        debugSerializationEnd("SgAsmCilMethodSemantics");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    uint16_t const& get_Semantics() const;
    void set_Semantics(uint16_t const&);
public:
    uint32_t const& get_Method() const;
    void set_Method(uint32_t const&);
public:
    uint32_t const& get_Association() const;
    void set_Association(uint32_t const&);
public:
    void parse(const std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing);
    void unparse(std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing) const;
    void dump(std::ostream&) const;
 
    const SgAsmCilMetadata* get_Method_object() const;
    const SgAsmCilMetadata* get_Association_object() const;
public:
    virtual ~SgAsmCilMethodSemantics();
 
public:
    SgAsmCilMethodSemantics();
 
protected:
    void initializeProperties();
#endif // SgAsmCilMethodSemantics_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmCilMethodSemantics: public SgAsmCilMetadata {…};
#endif // DOCUMENTATION
 
 
// SgAsmCilMethodImplTable           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmCilMethodImplTable);
IS_SERIALIZABLE(AsmCilMethodImplTable);
 
#ifndef DOCUMENTATION
AsmCilMethodImplTable.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmCilMethodImplTable: public SgAsmCilMetadata {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilMethodImplTable.setDataPrototype(
        "std::vector<SgAsmCilMethodImpl*>", "elements", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmCilMethodImplTable);
#if defined(SgAsmCilMethodImplTable_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmCilMethodImplTable -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmCilMethodImplTable");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
        s & BOOST_SERIALIZATION_NVP(p_elements);
        debugSerializationEnd("SgAsmCilMethodImplTable");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    std::vector<SgAsmCilMethodImpl*> const& get_elements() const;
    std::vector<SgAsmCilMethodImpl*>& get_elements();
public:
    using CilMetadataType = SgAsmCilMethodImpl;
public:
    virtual ~SgAsmCilMethodImplTable();
 
public:
    SgAsmCilMethodImplTable();
 
protected:
    void initializeProperties();
#endif // SgAsmCilMethodImplTable_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmCilMethodImplTable: public SgAsmCilMetadata {…};
#endif // DOCUMENTATION
 
 
// SgAsmCilMethodImpl           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmCilMethodImpl);
IS_SERIALIZABLE(AsmCilMethodImpl);
 
#ifndef DOCUMENTATION
AsmCilMethodImpl.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmCilMethodImpl: public SgAsmCilMetadata {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilMethodImpl.setDataPrototype(
        "uint32_t", "Class", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilMethodImpl.setDataPrototype(
        "uint32_t", "MethodBody", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilMethodImpl.setDataPrototype(
        "uint32_t", "MethodDeclaration", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmCilMethodImpl);
#if defined(SgAsmCilMethodImpl_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmCilMethodImpl -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmCilMethodImpl");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
        s & BOOST_SERIALIZATION_NVP(p_Class);
        s & BOOST_SERIALIZATION_NVP(p_MethodBody);
        s & BOOST_SERIALIZATION_NVP(p_MethodDeclaration);
        debugSerializationEnd("SgAsmCilMethodImpl");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    uint32_t const& get_Class() const;
    void set_Class(uint32_t const&);
public:
    uint32_t const& get_MethodBody() const;
    void set_MethodBody(uint32_t const&);
public:
    uint32_t const& get_MethodDeclaration() const;
    void set_MethodDeclaration(uint32_t const&);
public:
    void parse(const std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing);
    void unparse(std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing) const;
    void dump(std::ostream&) const;
 
    const SgAsmCilMetadata* get_Class_object() const;
    const SgAsmCilMetadata* get_MethodBody_object() const;
    const SgAsmCilMetadata* get_MethodDeclaration_object() const;
public:
    virtual ~SgAsmCilMethodImpl();
 
public:
    SgAsmCilMethodImpl();
 
protected:
    void initializeProperties();
#endif // SgAsmCilMethodImpl_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmCilMethodImpl: public SgAsmCilMetadata {…};
#endif // DOCUMENTATION
 
 
// SgAsmCilMethodDefTable           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmCilMethodDefTable);
IS_SERIALIZABLE(AsmCilMethodDefTable);
 
#ifndef DOCUMENTATION
AsmCilMethodDefTable.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmCilMethodDefTable: public SgAsmCilMetadata {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilMethodDefTable.setDataPrototype(
        "std::vector<SgAsmCilMethodDef*>", "elements", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmCilMethodDefTable);
#if defined(SgAsmCilMethodDefTable_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmCilMethodDefTable -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmCilMethodDefTable");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
        s & BOOST_SERIALIZATION_NVP(p_elements);
        debugSerializationEnd("SgAsmCilMethodDefTable");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    std::vector<SgAsmCilMethodDef*> const& get_elements() const;
    std::vector<SgAsmCilMethodDef*>& get_elements();
public:
    using CilMetadataType = SgAsmCilMethodDef;
public:
    virtual ~SgAsmCilMethodDefTable();
 
public:
    SgAsmCilMethodDefTable();
 
protected:
    void initializeProperties();
#endif // SgAsmCilMethodDefTable_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmCilMethodDefTable: public SgAsmCilMetadata {…};
#endif // DOCUMENTATION
 
 
// SgAsmCilMethodDef           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmCilMethodDef);
IS_SERIALIZABLE(AsmCilMethodDef);
 
#ifndef DOCUMENTATION
AsmCilMethodDef.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmCilMethodDef: public SgAsmCilMetadata {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilMethodDef.setDataPrototype(
        "uint32_t", "RVA", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilMethodDef.setDataPrototype(
        "uint16_t", "ImplFlags", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilMethodDef.setDataPrototype(
        "uint16_t", "Flags", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilMethodDef.setDataPrototype(
        "uint32_t", "Name", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilMethodDef.setDataPrototype(
        "uint32_t", "Signature", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilMethodDef.setDataPrototype(
        "uint32_t", "ParamList", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilMethodDef.setDataPrototype(
        "SgAsmBlock*", "body", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilMethodDef.setDataPrototype(
        "bool", "initLocals", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilMethodDef.setDataPrototype(
        "uint32_t", "stackSize", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilMethodDef.setDataPrototype(
        "bool", "hasMoreSections", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilMethodDef.setDataPrototype(
        "uint32_t", "localVarSigTok", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilMethodDef.setDataPrototype(
        "std::vector<SgAsmCilMethodData*>", "methodData", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilMethodDef.setDataPrototype(
        "int", "bodyState", "= BDY_NOT_PROCESSED",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmCilMethodDef);
#if defined(SgAsmCilMethodDef_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmCilMethodDef -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmCilMethodDef");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
        s & BOOST_SERIALIZATION_NVP(p_RVA);
        s & BOOST_SERIALIZATION_NVP(p_ImplFlags);
        s & BOOST_SERIALIZATION_NVP(p_Flags);
        s & BOOST_SERIALIZATION_NVP(p_Name);
        s & BOOST_SERIALIZATION_NVP(p_Signature);
        s & BOOST_SERIALIZATION_NVP(p_ParamList);
        s & BOOST_SERIALIZATION_NVP(p_body);
        s & BOOST_SERIALIZATION_NVP(p_initLocals);
        s & BOOST_SERIALIZATION_NVP(p_stackSize);
        s & BOOST_SERIALIZATION_NVP(p_hasMoreSections);
        s & BOOST_SERIALIZATION_NVP(p_localVarSigTok);
        s & BOOST_SERIALIZATION_NVP(p_methodData);
        s & BOOST_SERIALIZATION_NVP(p_bodyState);
        debugSerializationEnd("SgAsmCilMethodDef");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
  public:
    using BodyState = int;
 
    enum : BodyState {
      // good states > 0
      BDY_NOT_AVAILABLE               = 3, 
      BDY_FULLY_DECODED               = 2, 
      BDY_RUNTIME_SUPPORTED           = 1, 
 
      // default == 0
      BDY_NOT_PROCESSED               = 0, 
 
      // fail states < 0
      BDY_INVALID_HEADER_BYTE         = -1,  
      BDY_INVALID_HEADER_KIND         = -2,  
      BDY_INVALID_HEADER_ALIGN        = -3,  
      BDY_INVALID_CODE_LENGTH         = -4,  
      BDY_INVALID_INSTRUCTION_LENGTH  = -5,  
      BDY_INVALID_INSTRUCTION         = -6,  
      BDY_INVALID_SECTION_ALIGN       = -7,  
      BDY_INVALID_SECTION_HEADER      = -8,  
      BDY_INVALID_CLAUSE_KIND         = -9,  
      BDY_INVALID_CLAUSE_LENGTH       = -10, 
    };
 
  private:
public:
    uint32_t const& get_RVA() const;
    void set_RVA(uint32_t const&);
public:
    uint16_t const& get_ImplFlags() const;
    void set_ImplFlags(uint16_t const&);
public:
    uint16_t const& get_Flags() const;
    void set_Flags(uint16_t const&);
public:
    uint32_t const& get_Name() const;
    void set_Name(uint32_t const&);
public:
    uint32_t const& get_Signature() const;
    void set_Signature(uint32_t const&);
public:
    uint32_t const& get_ParamList() const;
    void set_ParamList(uint32_t const&);
public:
    SgAsmBlock* const& get_body() const;
    void set_body(SgAsmBlock* const&);
public:
    bool const& get_initLocals() const;
    void set_initLocals(bool const&);
public:
    uint32_t const& get_stackSize() const;
    void set_stackSize(uint32_t const&);
public:
    bool const& get_hasMoreSections() const;
    void set_hasMoreSections(bool const&);
    //
    // additional fields
public:
    uint32_t const& get_localVarSigTok() const;
    void set_localVarSigTok(uint32_t const&);
public:
    std::vector<SgAsmCilMethodData*> const& get_methodData() const;
    std::vector<SgAsmCilMethodData*>& get_methodData();
public:
    int const& get_bodyState() const;
    void set_bodyState(int const&);
public:
    void parse(const std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing);
    void unparse(std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing) const;
    void dump(std::ostream&) const;
 
    const std::uint8_t* get_Name_string() const;
    const std::uint8_t* get_Signature_blob() const;
    const SgAsmCilMetadata* get_ParamList_object() const;
public:
    virtual ~SgAsmCilMethodDef();
 
public:
    SgAsmCilMethodDef();
 
protected:
    void initializeProperties();
#endif // SgAsmCilMethodDef_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmCilMethodDef: public SgAsmCilMetadata {…};
#endif // DOCUMENTATION
 
 
// SgAsmCilMethodData           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmCilMethodData);
IS_SERIALIZABLE(AsmCilMethodData);
 
#ifndef DOCUMENTATION
AsmCilMethodData.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmCilMethodData);
#if defined(SgAsmCilMethodData_HEADERS) || defined(DOCUMENTATION)
#include <vector>
#endif // SgAsmCilMethodData_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmCilMethodData: public SgAsmCilNode {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilMethodData.setDataPrototype(
        "uint64_t", "kind", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilMethodData.setDataPrototype(
        "std::uint32_t", "dataSize", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilMethodData.setDataPrototype(
        "std::vector<SgAsmCilExceptionData*>", "clauses", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmCilMethodData);
#if defined(SgAsmCilMethodData_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmCilMethodData -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmCilMethodData");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilNode);
        s & BOOST_SERIALIZATION_NVP(p_kind);
        s & BOOST_SERIALIZATION_NVP(p_dataSize);
        s & BOOST_SERIALIZATION_NVP(p_clauses);
        debugSerializationEnd("SgAsmCilMethodData");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
  enum
  {
    CorILMethod_Sect_EHTable    = 0x01,
    CorILMethod_Sect_OptILTable = 0x02,
    CorILMethod_Sect_FatFormat  = 0x40,
    CorILMethod_Sect_MoreSects  = 0x80,
  };
 
private:
public:
    uint64_t const& get_kind() const;
    void set_kind(uint64_t const&);
 
public:
    std::uint32_t const& get_dataSize() const;
    void set_dataSize(std::uint32_t const&);
 
public:
    std::vector<SgAsmCilExceptionData*> const& get_Clauses() const;
    std::vector<SgAsmCilExceptionData*>& get_Clauses();
public:
  bool isEHTable() const
  {
    return (p_kind & CorILMethod_Sect_EHTable) == CorILMethod_Sect_EHTable;
  }
 
  bool isOptILTable() const
  {
    const bool res = (p_kind & CorILMethod_Sect_OptILTable) == CorILMethod_Sect_OptILTable;
 
    ASSERT_require(!res);
    return res;
  }
 
  bool usesFatFormat() const
  {
    return (p_kind & CorILMethod_Sect_FatFormat) == CorILMethod_Sect_FatFormat;
  }
 
  bool hasMoreSections() const
  {
    return (p_kind & CorILMethod_Sect_MoreSects) == CorILMethod_Sect_MoreSects;
  }
public:
    virtual ~SgAsmCilMethodData();
 
public:
    SgAsmCilMethodData();
 
protected:
    void initializeProperties();
#endif // SgAsmCilMethodData_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmCilMethodData: public SgAsmCilNode {…};
#endif // DOCUMENTATION
 
 
// SgAsmCilMetadataRoot           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmCilMetadataRoot);
IS_SERIALIZABLE(AsmCilMetadataRoot);
 
#ifndef DOCUMENTATION
AsmCilMetadataRoot.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmCilMetadataRoot: public SgAsmCilNode {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilMetadataRoot.setDataPrototype(
        "uint32_t", "Signature", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilMetadataRoot.setDataPrototype(
        "uint16_t", "MajorVersion", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilMetadataRoot.setDataPrototype(
        "uint16_t", "MinorVersion", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilMetadataRoot.setDataPrototype(
        "uint32_t", "Reserved0", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilMetadataRoot.setDataPrototype(
        "uint32_t", "Length", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilMetadataRoot.setDataPrototype(
        "std::string", "Version", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilMetadataRoot.setDataPrototype(
        "uint32_t", "VersionPadding", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilMetadataRoot.setDataPrototype(
        "uint16_t", "Flags", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilMetadataRoot.setDataPrototype(
        "uint16_t", "NumberOfStreams", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilMetadataRoot.setDataPrototype(
        "std::vector<SgAsmCilDataStream*>", "Streams", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmCilMetadataRoot);
#if defined(SgAsmCilMetadataRoot_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmCilMetadataRoot -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmCilMetadataRoot");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilNode);
        s & BOOST_SERIALIZATION_NVP(p_Signature);
        s & BOOST_SERIALIZATION_NVP(p_MajorVersion);
        s & BOOST_SERIALIZATION_NVP(p_MinorVersion);
        s & BOOST_SERIALIZATION_NVP(p_Reserved0);
        s & BOOST_SERIALIZATION_NVP(p_Length);
        s & BOOST_SERIALIZATION_NVP(p_Version);
        s & BOOST_SERIALIZATION_NVP(p_VersionPadding);
        s & BOOST_SERIALIZATION_NVP(p_Flags);
        s & BOOST_SERIALIZATION_NVP(p_NumberOfStreams);
        s & BOOST_SERIALIZATION_NVP(p_Streams);
        debugSerializationEnd("SgAsmCilMetadataRoot");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    uint32_t const& get_Signature() const;
    void set_Signature(uint32_t const&);
public:
    uint16_t const& get_MajorVersion() const;
    void set_MajorVersion(uint16_t const&);
public:
    uint16_t const& get_MinorVersion() const;
    void set_MinorVersion(uint16_t const&);
public:
    uint32_t const& get_Reserved0() const;
    void set_Reserved0(uint32_t const&);
public:
    uint32_t const& get_Length() const;
    void set_Length(uint32_t const&);
public:
    std::string const& get_Version() const;
    void set_Version(std::string const&);
public:
    uint32_t const& get_VersionPadding() const;
    void set_VersionPadding(uint32_t const&);
public:
    uint16_t const& get_Flags() const;
    void set_Flags(uint16_t const&);
public:
    uint16_t const& get_NumberOfStreams() const;
    void set_NumberOfStreams(uint16_t const&);
    // FIXME[Robb Matzke 2023-03-22]: these were implemented elsewhere, but could be auto generated
public:
    std::vector<SgAsmCilDataStream*> const& get_Streams() const;
    std::vector<SgAsmCilDataStream*>& get_Streams();
    //const std::vector<SgAsmCilDataStream*>& get_Streams() const;
    //std::vector<SgAsmCilDataStream*>& get_Streams();
private:
    mutable int8_t idxStringHeap = -1;
    mutable int8_t idxBlobHeap = -1;
    mutable int8_t idxUsHeap = -1;
    mutable int8_t idxGuidHeap = -1;
    mutable int8_t idxMetadataHeap = -1;
public:
    static constexpr uint32_t MAGIC_SIGNATURE = 0x424A5342;
 
    void parse();
 
    void parse(const std::vector<uint8_t>& buf, size_t index);
 
    void unparse(std::ostream& f) const;
 
    void unparse(std::vector<uint8_t>&, std::size_t) const;
 
    void dump(std::ostream& os) const;
 
    SgAsmCilUint8Heap*    get_StringHeap() const;
    SgAsmCilUint8Heap*    get_BlobHeap() const;
    SgAsmCilUint8Heap*    get_UsHeap() const;
    SgAsmCilUint32Heap*   get_GuidHeap() const;
    SgAsmCilMetadataHeap* get_MetadataHeap() const;
public:
    virtual ~SgAsmCilMetadataRoot();
 
public:
    SgAsmCilMetadataRoot();
 
protected:
    void initializeProperties();
#endif // SgAsmCilMetadataRoot_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmCilMetadataRoot: public SgAsmCilNode {…};
#endif // DOCUMENTATION
 
 
// SgAsmCilMetadataHeap           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmCilMetadataHeap);
IS_SERIALIZABLE(AsmCilMetadataHeap);
 
#ifndef DOCUMENTATION
AsmCilMetadataHeap.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmCilMetadataHeap);
#if defined(SgAsmCilMetadataHeap_HEADERS) || defined(DOCUMENTATION)
#ifdef ROSE_SgAsmCilMetadataHeap_IMPL
#include <SgAsmCilAssemblyTable.h>
#include <SgAsmCilAssemblyOSTable.h>
#include <SgAsmCilAssemblyProcessorTable.h>
#include <SgAsmCilAssemblyRefTable.h>
#include <SgAsmCilAssemblyRefOSTable.h>
#include <SgAsmCilAssemblyRefProcessorTable.h>
#include <SgAsmCilClassLayoutTable.h>
#include <SgAsmCilConstantTable.h>
#include <SgAsmCilCustomAttributeTable.h>
#include <SgAsmCilDeclSecurityTable.h>
#include <SgAsmCilEventTable.h>
#include <SgAsmCilEventMapTable.h>
#include <SgAsmCilExportedTypeTable.h>
#include <SgAsmCilFieldTable.h>
#include <SgAsmCilFieldLayoutTable.h>
#include <SgAsmCilFieldMarshalTable.h>
#include <SgAsmCilFieldRVATable.h>
#include <SgAsmCilFileTable.h>
#include <SgAsmCilGenericParamTable.h>
#include <SgAsmCilGenericParamConstraintTable.h>
#include <SgAsmCilImplMapTable.h>
#include <SgAsmCilInterfaceImplTable.h>
#include <SgAsmCilManifestResourceTable.h>
#include <SgAsmCilMemberRefTable.h>
#include <SgAsmCilMethodDefTable.h>
#include <SgAsmCilMethodImplTable.h>
#include <SgAsmCilMethodSemanticsTable.h>
#include <SgAsmCilMethodSpecTable.h>
#include <SgAsmCilModuleTable.h>
#include <SgAsmCilModuleRefTable.h>
#include <SgAsmCilNestedClassTable.h>
#include <SgAsmCilParamTable.h>
#include <SgAsmCilPropertyTable.h>
#include <SgAsmCilPropertyMapTable.h>
#include <SgAsmCilStandAloneSigTable.h>
#include <SgAsmCilTypeDefTable.h>
#include <SgAsmCilTypeRefTable.h>
#include <SgAsmCilTypeSpecTable.h>
#endif
#endif // SgAsmCilMetadataHeap_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmCilMetadataHeap: public SgAsmCilDataStream {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilMetadataHeap.setDataPrototype(
        "uint32_t", "ReservedAlwaysZero", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilMetadataHeap.setDataPrototype(
        "uint8_t", "MajorVersion", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilMetadataHeap.setDataPrototype(
        "uint8_t", "MinorVersion", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilMetadataHeap.setDataPrototype(
        "uint8_t", "HeapSizes", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilMetadataHeap.setDataPrototype(
        "uint8_t", "ReservedAlwaysOne", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilMetadataHeap.setDataPrototype(
        "uint64_t", "Valid", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilMetadataHeap.setDataPrototype(
        "uint64_t", "Sorted", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilMetadataHeap.setDataPrototype(
        "std::vector<uint32_t>", "NumberOfRows", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilMetadataHeap.setDataPrototype(
        "uint64_t", "DataSizeFlags", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilMetadataHeap.setDataPrototype(
        "SgAsmCilAssemblyTable*", "AssemblyTable", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilMetadataHeap.setDataPrototype(
        "SgAsmCilAssemblyOSTable*", "AssemblyOSTable", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilMetadataHeap.setDataPrototype(
        "SgAsmCilAssemblyProcessorTable*", "AssemblyProcessorTable", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilMetadataHeap.setDataPrototype(
        "SgAsmCilAssemblyRefTable*", "AssemblyRefTable", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilMetadataHeap.setDataPrototype(
        "SgAsmCilAssemblyRefOSTable*", "AssemblyRefOSTable", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilMetadataHeap.setDataPrototype(
        "SgAsmCilAssemblyRefProcessorTable*", "AssemblyRefProcessorTable", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilMetadataHeap.setDataPrototype(
        "SgAsmCilClassLayoutTable*", "ClassLayoutTable", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilMetadataHeap.setDataPrototype(
        "SgAsmCilConstantTable*", "ConstantTable", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilMetadataHeap.setDataPrototype(
        "SgAsmCilCustomAttributeTable*", "CustomAttributeTable", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilMetadataHeap.setDataPrototype(
        "SgAsmCilDeclSecurityTable*", "DeclSecurityTable", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilMetadataHeap.setDataPrototype(
        "SgAsmCilEventTable*", "EventTable", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilMetadataHeap.setDataPrototype(
        "SgAsmCilEventMapTable*", "EventMapTable", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilMetadataHeap.setDataPrototype(
        "SgAsmCilExportedTypeTable*", "ExportedTypeTable", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilMetadataHeap.setDataPrototype(
        "SgAsmCilFieldTable*", "FieldTable", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilMetadataHeap.setDataPrototype(
        "SgAsmCilFieldLayoutTable*", "FieldLayoutTable", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilMetadataHeap.setDataPrototype(
        "SgAsmCilFieldMarshalTable*", "FieldMarshalTable", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilMetadataHeap.setDataPrototype(
        "SgAsmCilFieldRVATable*", "FieldRVATable", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilMetadataHeap.setDataPrototype(
        "SgAsmCilFileTable*", "FileTable", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilMetadataHeap.setDataPrototype(
        "SgAsmCilGenericParamTable*", "GenericParamTable", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilMetadataHeap.setDataPrototype(
        "SgAsmCilGenericParamConstraintTable*", "GenericParamConstraintTable", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilMetadataHeap.setDataPrototype(
        "SgAsmCilImplMapTable*", "ImplMapTable", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilMetadataHeap.setDataPrototype(
        "SgAsmCilInterfaceImplTable*", "InterfaceImplTable", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilMetadataHeap.setDataPrototype(
        "SgAsmCilManifestResourceTable*", "ManifestResourceTable", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilMetadataHeap.setDataPrototype(
        "SgAsmCilMemberRefTable*", "MemberRefTable", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilMetadataHeap.setDataPrototype(
        "SgAsmCilMethodDefTable*", "MethodDefTable", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilMetadataHeap.setDataPrototype(
        "SgAsmCilMethodImplTable*", "MethodImplTable", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilMetadataHeap.setDataPrototype(
        "SgAsmCilMethodSemanticsTable*", "MethodSemanticsTable", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilMetadataHeap.setDataPrototype(
        "SgAsmCilMethodSpecTable*", "MethodSpecTable", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilMetadataHeap.setDataPrototype(
        "SgAsmCilModuleTable*", "ModuleTable", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilMetadataHeap.setDataPrototype(
        "SgAsmCilModuleRefTable*", "ModuleRefTable", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilMetadataHeap.setDataPrototype(
        "SgAsmCilNestedClassTable*", "NestedClassTable", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilMetadataHeap.setDataPrototype(
        "SgAsmCilParamTable*", "ParamTable", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilMetadataHeap.setDataPrototype(
        "SgAsmCilPropertyTable*", "PropertyTable", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilMetadataHeap.setDataPrototype(
        "SgAsmCilPropertyMapTable*", "PropertyMapTable", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilMetadataHeap.setDataPrototype(
        "SgAsmCilStandAloneSigTable*", "StandAloneSigTable", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilMetadataHeap.setDataPrototype(
        "SgAsmCilTypeDefTable*", "TypeDefTable", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilMetadataHeap.setDataPrototype(
        "SgAsmCilTypeRefTable*", "TypeRefTable", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilMetadataHeap.setDataPrototype(
        "SgAsmCilTypeSpecTable*", "TypeSpecTable", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmCilMetadataHeap);
#if defined(SgAsmCilMetadataHeap_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmCilMetadataHeap -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmCilMetadataHeap");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilDataStream);
        s & BOOST_SERIALIZATION_NVP(p_ReservedAlwaysZero);
        s & BOOST_SERIALIZATION_NVP(p_MajorVersion);
        s & BOOST_SERIALIZATION_NVP(p_MinorVersion);
        s & BOOST_SERIALIZATION_NVP(p_HeapSizes);
        s & BOOST_SERIALIZATION_NVP(p_ReservedAlwaysOne);
        s & BOOST_SERIALIZATION_NVP(p_Valid);
        s & BOOST_SERIALIZATION_NVP(p_Sorted);
        s & BOOST_SERIALIZATION_NVP(p_NumberOfRows);
        s & BOOST_SERIALIZATION_NVP(p_DataSizeFlags);
        s & BOOST_SERIALIZATION_NVP(p_AssemblyTable);
        s & BOOST_SERIALIZATION_NVP(p_AssemblyOSTable);
        s & BOOST_SERIALIZATION_NVP(p_AssemblyProcessorTable);
        s & BOOST_SERIALIZATION_NVP(p_AssemblyRefTable);
        s & BOOST_SERIALIZATION_NVP(p_AssemblyRefOSTable);
        s & BOOST_SERIALIZATION_NVP(p_AssemblyRefProcessorTable);
        s & BOOST_SERIALIZATION_NVP(p_ClassLayoutTable);
        s & BOOST_SERIALIZATION_NVP(p_ConstantTable);
        s & BOOST_SERIALIZATION_NVP(p_CustomAttributeTable);
        s & BOOST_SERIALIZATION_NVP(p_DeclSecurityTable);
        s & BOOST_SERIALIZATION_NVP(p_EventTable);
        s & BOOST_SERIALIZATION_NVP(p_EventMapTable);
        s & BOOST_SERIALIZATION_NVP(p_ExportedTypeTable);
        s & BOOST_SERIALIZATION_NVP(p_FieldTable);
        s & BOOST_SERIALIZATION_NVP(p_FieldLayoutTable);
        s & BOOST_SERIALIZATION_NVP(p_FieldMarshalTable);
        s & BOOST_SERIALIZATION_NVP(p_FieldRVATable);
        s & BOOST_SERIALIZATION_NVP(p_FileTable);
        s & BOOST_SERIALIZATION_NVP(p_GenericParamTable);
        s & BOOST_SERIALIZATION_NVP(p_GenericParamConstraintTable);
        s & BOOST_SERIALIZATION_NVP(p_ImplMapTable);
        s & BOOST_SERIALIZATION_NVP(p_InterfaceImplTable);
        s & BOOST_SERIALIZATION_NVP(p_ManifestResourceTable);
        s & BOOST_SERIALIZATION_NVP(p_MemberRefTable);
        s & BOOST_SERIALIZATION_NVP(p_MethodDefTable);
        s & BOOST_SERIALIZATION_NVP(p_MethodImplTable);
        s & BOOST_SERIALIZATION_NVP(p_MethodSemanticsTable);
        s & BOOST_SERIALIZATION_NVP(p_MethodSpecTable);
        s & BOOST_SERIALIZATION_NVP(p_ModuleTable);
        s & BOOST_SERIALIZATION_NVP(p_ModuleRefTable);
        s & BOOST_SERIALIZATION_NVP(p_NestedClassTable);
        s & BOOST_SERIALIZATION_NVP(p_ParamTable);
        s & BOOST_SERIALIZATION_NVP(p_PropertyTable);
        s & BOOST_SERIALIZATION_NVP(p_PropertyMapTable);
        s & BOOST_SERIALIZATION_NVP(p_StandAloneSigTable);
        s & BOOST_SERIALIZATION_NVP(p_TypeDefTable);
        s & BOOST_SERIALIZATION_NVP(p_TypeRefTable);
        s & BOOST_SERIALIZATION_NVP(p_TypeSpecTable);
        debugSerializationEnd("SgAsmCilMetadataHeap");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    uint32_t const& get_ReservedAlwaysZero() const;
    void set_ReservedAlwaysZero(uint32_t const&);
public:
    uint8_t const& get_MajorVersion() const;
    void set_MajorVersion(uint8_t const&);
public:
    uint8_t const& get_MinorVersion() const;
    void set_MinorVersion(uint8_t const&);
public:
    uint8_t const& get_HeapSizes() const;
    void set_HeapSizes(uint8_t const&);
public:
    uint8_t const& get_ReservedAlwaysOne() const;
    void set_ReservedAlwaysOne(uint8_t const&);
public:
    uint64_t const& get_Valid() const;
    void set_Valid(uint64_t const&);
public:
    uint64_t const& get_Sorted() const;
    void set_Sorted(uint64_t const&);
public:
    std::vector<uint32_t> const& get_NumberOfRows() const;
    void set_NumberOfRows(std::vector<uint32_t> const&);
public:
    uint64_t const& get_DataSizeFlags() const;
    void set_DataSizeFlags(uint64_t const&);
public:
    SgAsmCilAssemblyTable* const& get_AssemblyTable() const;
    void set_AssemblyTable(SgAsmCilAssemblyTable* const&);
public:
    SgAsmCilAssemblyOSTable* const& get_AssemblyOSTable() const;
    void set_AssemblyOSTable(SgAsmCilAssemblyOSTable* const&);
public:
    SgAsmCilAssemblyProcessorTable* const& get_AssemblyProcessorTable() const;
    void set_AssemblyProcessorTable(SgAsmCilAssemblyProcessorTable* const&);
public:
    SgAsmCilAssemblyRefTable* const& get_AssemblyRefTable() const;
    void set_AssemblyRefTable(SgAsmCilAssemblyRefTable* const&);
public:
    SgAsmCilAssemblyRefOSTable* const& get_AssemblyRefOSTable() const;
    void set_AssemblyRefOSTable(SgAsmCilAssemblyRefOSTable* const&);
public:
    SgAsmCilAssemblyRefProcessorTable* const& get_AssemblyRefProcessorTable() const;
    void set_AssemblyRefProcessorTable(SgAsmCilAssemblyRefProcessorTable* const&);
public:
    SgAsmCilClassLayoutTable* const& get_ClassLayoutTable() const;
    void set_ClassLayoutTable(SgAsmCilClassLayoutTable* const&);
public:
    SgAsmCilConstantTable* const& get_ConstantTable() const;
    void set_ConstantTable(SgAsmCilConstantTable* const&);
public:
    SgAsmCilCustomAttributeTable* const& get_CustomAttributeTable() const;
    void set_CustomAttributeTable(SgAsmCilCustomAttributeTable* const&);
public:
    SgAsmCilDeclSecurityTable* const& get_DeclSecurityTable() const;
    void set_DeclSecurityTable(SgAsmCilDeclSecurityTable* const&);
public:
    SgAsmCilEventTable* const& get_EventTable() const;
    void set_EventTable(SgAsmCilEventTable* const&);
public:
    SgAsmCilEventMapTable* const& get_EventMapTable() const;
    void set_EventMapTable(SgAsmCilEventMapTable* const&);
public:
    SgAsmCilExportedTypeTable* const& get_ExportedTypeTable() const;
    void set_ExportedTypeTable(SgAsmCilExportedTypeTable* const&);
public:
    SgAsmCilFieldTable* const& get_FieldTable() const;
    void set_FieldTable(SgAsmCilFieldTable* const&);
public:
    SgAsmCilFieldLayoutTable* const& get_FieldLayoutTable() const;
    void set_FieldLayoutTable(SgAsmCilFieldLayoutTable* const&);
public:
    SgAsmCilFieldMarshalTable* const& get_FieldMarshalTable() const;
    void set_FieldMarshalTable(SgAsmCilFieldMarshalTable* const&);
public:
    SgAsmCilFieldRVATable* const& get_FieldRVATable() const;
    void set_FieldRVATable(SgAsmCilFieldRVATable* const&);
public:
    SgAsmCilFileTable* const& get_FileTable() const;
    void set_FileTable(SgAsmCilFileTable* const&);
public:
    SgAsmCilGenericParamTable* const& get_GenericParamTable() const;
    void set_GenericParamTable(SgAsmCilGenericParamTable* const&);
public:
    SgAsmCilGenericParamConstraintTable* const& get_GenericParamConstraintTable() const;
    void set_GenericParamConstraintTable(SgAsmCilGenericParamConstraintTable* const&);
public:
    SgAsmCilImplMapTable* const& get_ImplMapTable() const;
    void set_ImplMapTable(SgAsmCilImplMapTable* const&);
public:
    SgAsmCilInterfaceImplTable* const& get_InterfaceImplTable() const;
    void set_InterfaceImplTable(SgAsmCilInterfaceImplTable* const&);
public:
    SgAsmCilManifestResourceTable* const& get_ManifestResourceTable() const;
    void set_ManifestResourceTable(SgAsmCilManifestResourceTable* const&);
public:
    SgAsmCilMemberRefTable* const& get_MemberRefTable() const;
    void set_MemberRefTable(SgAsmCilMemberRefTable* const&);
public:
    SgAsmCilMethodDefTable* const& get_MethodDefTable() const;
    void set_MethodDefTable(SgAsmCilMethodDefTable* const&);
public:
    SgAsmCilMethodImplTable* const& get_MethodImplTable() const;
    void set_MethodImplTable(SgAsmCilMethodImplTable* const&);
public:
    SgAsmCilMethodSemanticsTable* const& get_MethodSemanticsTable() const;
    void set_MethodSemanticsTable(SgAsmCilMethodSemanticsTable* const&);
public:
    SgAsmCilMethodSpecTable* const& get_MethodSpecTable() const;
    void set_MethodSpecTable(SgAsmCilMethodSpecTable* const&);
public:
    SgAsmCilModuleTable* const& get_ModuleTable() const;
    void set_ModuleTable(SgAsmCilModuleTable* const&);
public:
    SgAsmCilModuleRefTable* const& get_ModuleRefTable() const;
    void set_ModuleRefTable(SgAsmCilModuleRefTable* const&);
public:
    SgAsmCilNestedClassTable* const& get_NestedClassTable() const;
    void set_NestedClassTable(SgAsmCilNestedClassTable* const&);
public:
    SgAsmCilParamTable* const& get_ParamTable() const;
    void set_ParamTable(SgAsmCilParamTable* const&);
public:
    SgAsmCilPropertyTable* const& get_PropertyTable() const;
    void set_PropertyTable(SgAsmCilPropertyTable* const&);
public:
    SgAsmCilPropertyMapTable* const& get_PropertyMapTable() const;
    void set_PropertyMapTable(SgAsmCilPropertyMapTable* const&);
public:
    SgAsmCilStandAloneSigTable* const& get_StandAloneSigTable() const;
    void set_StandAloneSigTable(SgAsmCilStandAloneSigTable* const&);
public:
    SgAsmCilTypeDefTable* const& get_TypeDefTable() const;
    void set_TypeDefTable(SgAsmCilTypeDefTable* const&);
public:
    SgAsmCilTypeRefTable* const& get_TypeRefTable() const;
    void set_TypeRefTable(SgAsmCilTypeRefTable* const&);
public:
    SgAsmCilTypeSpecTable* const& get_TypeSpecTable() const;
    void set_TypeSpecTable(SgAsmCilTypeSpecTable* const&);
public:
    enum ReferenceKind
    {
      // heaps
      e_ref_string_heap           = 1 << 0,
      e_ref_guid_heap             = 1 << 1,
      e_ref_blob_heap             = 1 << 2,
      // single-table references
      e_ref_assembly_ref          = 1 << 3,
      e_ref_type_def              = 1 << 4,
      e_ref_event                 = 1 << 5,
      e_ref_field                 = 1 << 6,
      e_ref_generic_param         = 1 << 7,
      e_ref_module_ref            = 1 << 8,
      e_ref_method_def            = 1 << 9,
      e_ref_param                 = 1 << 10,
      e_ref_property              = 1 << 11,
      // multi-table references
      e_ref_has_constant          = 1 << 12,
      e_ref_has_custom_attribute  = 1 << 13,
      e_ref_has_decl_security     = 1 << 14,
      e_ref_has_field_marshall    = 1 << 15,
      e_ref_has_semantics         = 1 << 16,
      e_ref_method_def_or_ref     = 1 << 17,
      e_ref_type_def_or_ref       = 1 << 18,
      e_ref_implementation        = 1 << 19,
      e_ref_member_forwarded      = 1 << 20,
      e_ref_member_ref_parent     = 1 << 21,
      e_ref_type_or_method_def    = 1 << 22,
      e_ref_custom_attribute_type = 1 << 23,
      e_ref_resolution_scope      = 1 << 24,
      e_ref_last                  = 1 << 25,
    };
    enum ReferenceKind {…};
 
    enum TableKind : std::uint8_t
    {
 
      e_Assembly = 0x20,
      e_AssemblyOS = 0x22,
      e_AssemblyProcessor = 0x21,
      e_AssemblyRef = 0x23,
      e_AssemblyRefOS = 0x25,
      e_AssemblyRefProcessor = 0x24,
      e_ClassLayout = 0x0F,
      e_Constant = 0x0B,
      e_CustomAttribute = 0x0C,
      e_DeclSecurity = 0x0E,
      e_Event = 0x14,
      e_EventMap = 0x12,
      e_ExportedType = 0x27,
      e_Field = 0x04,
      e_FieldLayout = 0x10,
      e_FieldMarshal = 0x0D,
      e_FieldRVA = 0x1D,
      e_File = 0x26,
      e_GenericParam = 0x2A,
      e_GenericParamConstraint = 0x2C,
      e_ImplMap = 0x1C,
      e_InterfaceImpl = 0x09,
      e_ManifestResource = 0x28,
      e_MemberRef = 0x0A,
      e_MethodDef = 0x06,
      e_MethodImpl = 0x19,
      e_MethodSemantics = 0x18,
      e_MethodSpec = 0x2B,
      e_Module = 0x00,
      e_ModuleRef = 0x1A,
      e_NestedClass = 0x29,
      e_Param = 0x08,
      e_Property = 0x17,
      e_PropertyMap = 0x15,
      e_StandAloneSig = 0x11,
      e_TypeDef = 0x02,
      e_TypeRef = 0x01,
      e_TypeSpec = 0x1B,
      e_Unknown_table_kind = 0xFF
    };
 
    void parse(const std::vector<uint8_t>& buf, size_t startOfMetaData) override;
 
    void unparse(std::vector<uint8_t>& buf, size_t startOfMetaData) const override;
 
    void dump(std::ostream& os) const override;
 
    SgAsmCilMetadata* get_MetadataNode(std::uint32_t idx, TableKind tblcode) const;
 
    SgAsmCilMetadata* get_CodedMetadataNode(std::uint32_t refcode, ReferenceKind knd) const;
 
    SgAsmCilMetadata* get_MetadataNode(std::uint32_t refcode, ReferenceKind knd) const;
public:
    virtual ~SgAsmCilMetadataHeap();
 
public:
    SgAsmCilMetadataHeap();
 
public:
    SgAsmCilMetadataHeap(uint32_t const& Offset,
                         uint32_t const& Size,
                         std::string const& Name,
                         uint32_t const& NamePadding);
 
protected:
    void initializeProperties();
#endif // SgAsmCilMetadataHeap_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmCilMetadataHeap: public SgAsmCilDataStream {…};
#endif // DOCUMENTATION
 
 
// SgAsmCilMemberRefTable           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmCilMemberRefTable);
IS_SERIALIZABLE(AsmCilMemberRefTable);
 
#ifndef DOCUMENTATION
AsmCilMemberRefTable.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmCilMemberRefTable: public SgAsmCilMetadata {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilMemberRefTable.setDataPrototype(
        "std::vector<SgAsmCilMemberRef*>", "elements", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmCilMemberRefTable);
#if defined(SgAsmCilMemberRefTable_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmCilMemberRefTable -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmCilMemberRefTable");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
        s & BOOST_SERIALIZATION_NVP(p_elements);
        debugSerializationEnd("SgAsmCilMemberRefTable");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    std::vector<SgAsmCilMemberRef*> const& get_elements() const;
    std::vector<SgAsmCilMemberRef*>& get_elements();
public:
    using CilMetadataType = SgAsmCilMemberRef;
public:
    virtual ~SgAsmCilMemberRefTable();
 
public:
    SgAsmCilMemberRefTable();
 
protected:
    void initializeProperties();
#endif // SgAsmCilMemberRefTable_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmCilMemberRefTable: public SgAsmCilMetadata {…};
#endif // DOCUMENTATION
 
 
// SgAsmCilMemberRef           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmCilMemberRef);
IS_SERIALIZABLE(AsmCilMemberRef);
 
#ifndef DOCUMENTATION
AsmCilMemberRef.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmCilMemberRef: public SgAsmCilMetadata {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilMemberRef.setDataPrototype(
        "uint32_t", "Class", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilMemberRef.setDataPrototype(
        "uint32_t", "Name", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilMemberRef.setDataPrototype(
        "uint32_t", "Signature", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmCilMemberRef);
#if defined(SgAsmCilMemberRef_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmCilMemberRef -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmCilMemberRef");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
        s & BOOST_SERIALIZATION_NVP(p_Class);
        s & BOOST_SERIALIZATION_NVP(p_Name);
        s & BOOST_SERIALIZATION_NVP(p_Signature);
        debugSerializationEnd("SgAsmCilMemberRef");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    uint32_t const& get_Class() const;
    void set_Class(uint32_t const&);
public:
    uint32_t const& get_Name() const;
    void set_Name(uint32_t const&);
public:
    uint32_t const& get_Signature() const;
    void set_Signature(uint32_t const&);
public:
    void parse(const std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing);
    void unparse(std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing) const;
    void dump(std::ostream&) const;
 
    const SgAsmCilMetadata* get_Class_object() const;
    const std::uint8_t* get_Name_string() const;
    const std::uint8_t* get_Signature_blob() const;
public:
    virtual ~SgAsmCilMemberRef();
 
public:
    SgAsmCilMemberRef();
 
protected:
    void initializeProperties();
#endif // SgAsmCilMemberRef_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmCilMemberRef: public SgAsmCilMetadata {…};
#endif // DOCUMENTATION
 
 
// SgAsmCilManifestResourceTable           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmCilManifestResourceTable);
IS_SERIALIZABLE(AsmCilManifestResourceTable);
 
#ifndef DOCUMENTATION
AsmCilManifestResourceTable.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmCilManifestResourceTable: public SgAsmCilMetadata {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilManifestResourceTable.setDataPrototype(
        "std::vector<SgAsmCilManifestResource*>", "elements", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmCilManifestResourceTable);
#if defined(SgAsmCilManifestResourceTable_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmCilManifestResourceTable -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmCilManifestResourceTable");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
        s & BOOST_SERIALIZATION_NVP(p_elements);
        debugSerializationEnd("SgAsmCilManifestResourceTable");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    std::vector<SgAsmCilManifestResource*> const& get_elements() const;
    std::vector<SgAsmCilManifestResource*>& get_elements();
public:
    using CilMetadataType = SgAsmCilManifestResource;
public:
    virtual ~SgAsmCilManifestResourceTable();
 
public:
    SgAsmCilManifestResourceTable();
 
protected:
    void initializeProperties();
#endif // SgAsmCilManifestResourceTable_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmCilManifestResourceTable: public SgAsmCilMetadata {…};
#endif // DOCUMENTATION
 
 
// SgAsmCilManifestResource           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmCilManifestResource);
IS_SERIALIZABLE(AsmCilManifestResource);
 
#ifndef DOCUMENTATION
AsmCilManifestResource.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmCilManifestResource: public SgAsmCilMetadata {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilManifestResource.setDataPrototype(
        "uint32_t", "Offset", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilManifestResource.setDataPrototype(
        "uint32_t", "Flags", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilManifestResource.setDataPrototype(
        "uint32_t", "Name", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilManifestResource.setDataPrototype(
        "uint32_t", "Implementation", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmCilManifestResource);
#if defined(SgAsmCilManifestResource_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmCilManifestResource -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmCilManifestResource");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
        s & BOOST_SERIALIZATION_NVP(p_Offset);
        s & BOOST_SERIALIZATION_NVP(p_Flags);
        s & BOOST_SERIALIZATION_NVP(p_Name);
        s & BOOST_SERIALIZATION_NVP(p_Implementation);
        debugSerializationEnd("SgAsmCilManifestResource");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    uint32_t const& get_Offset() const;
    void set_Offset(uint32_t const&);
public:
    uint32_t const& get_Flags() const;
    void set_Flags(uint32_t const&);
public:
    uint32_t const& get_Name() const;
    void set_Name(uint32_t const&);
public:
    uint32_t const& get_Implementation() const;
    void set_Implementation(uint32_t const&);
public:
    void parse(const std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing);
    void unparse(std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing) const;
    void dump(std::ostream&) const;
 
    const std::uint8_t* get_Name_string() const;
    const SgAsmCilMetadata* get_Implementation_object() const;
public:
    virtual ~SgAsmCilManifestResource();
 
public:
    SgAsmCilManifestResource();
 
protected:
    void initializeProperties();
#endif // SgAsmCilManifestResource_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmCilManifestResource: public SgAsmCilMetadata {…};
#endif // DOCUMENTATION
 
 
// SgAsmCilInterfaceImplTable           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmCilInterfaceImplTable);
IS_SERIALIZABLE(AsmCilInterfaceImplTable);
 
#ifndef DOCUMENTATION
AsmCilInterfaceImplTable.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmCilInterfaceImplTable: public SgAsmCilMetadata {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilInterfaceImplTable.setDataPrototype(
        "std::vector<SgAsmCilInterfaceImpl*>", "elements", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmCilInterfaceImplTable);
#if defined(SgAsmCilInterfaceImplTable_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmCilInterfaceImplTable -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmCilInterfaceImplTable");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
        s & BOOST_SERIALIZATION_NVP(p_elements);
        debugSerializationEnd("SgAsmCilInterfaceImplTable");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    std::vector<SgAsmCilInterfaceImpl*> const& get_elements() const;
    std::vector<SgAsmCilInterfaceImpl*>& get_elements();
public:
    using CilMetadataType = SgAsmCilInterfaceImpl;
public:
    virtual ~SgAsmCilInterfaceImplTable();
 
public:
    SgAsmCilInterfaceImplTable();
 
protected:
    void initializeProperties();
#endif // SgAsmCilInterfaceImplTable_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmCilInterfaceImplTable: public SgAsmCilMetadata {…};
#endif // DOCUMENTATION
 
 
// SgAsmCilInterfaceImpl           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmCilInterfaceImpl);
IS_SERIALIZABLE(AsmCilInterfaceImpl);
 
#ifndef DOCUMENTATION
AsmCilInterfaceImpl.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmCilInterfaceImpl: public SgAsmCilMetadata {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilInterfaceImpl.setDataPrototype(
        "uint32_t", "Class", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilInterfaceImpl.setDataPrototype(
        "uint32_t", "Interface", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmCilInterfaceImpl);
#if defined(SgAsmCilInterfaceImpl_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmCilInterfaceImpl -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmCilInterfaceImpl");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
        s & BOOST_SERIALIZATION_NVP(p_Class);
        s & BOOST_SERIALIZATION_NVP(p_Interface);
        debugSerializationEnd("SgAsmCilInterfaceImpl");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    uint32_t const& get_Class() const;
    void set_Class(uint32_t const&);
public:
    uint32_t const& get_Interface() const;
    void set_Interface(uint32_t const&);
public:
    void parse(const std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing);
    void unparse(std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing) const;
    void dump(std::ostream&) const;
 
    const SgAsmCilMetadata* get_Class_object() const;
    const SgAsmCilMetadata* get_Interface_object() const;
public:
    virtual ~SgAsmCilInterfaceImpl();
 
public:
    SgAsmCilInterfaceImpl();
 
protected:
    void initializeProperties();
#endif // SgAsmCilInterfaceImpl_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmCilInterfaceImpl: public SgAsmCilMetadata {…};
#endif // DOCUMENTATION
 
 
// SgAsmCilInstruction           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmCilInstruction);
IS_SERIALIZABLE(AsmCilInstruction);
 
#ifndef DOCUMENTATION
AsmCilInstruction.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmCilInstruction);
#if defined(SgAsmCilInstruction_HEADERS) || defined(DOCUMENTATION)
#include <Rose/BinaryAnalysis/InstructionEnumsCil.h>
#endif // SgAsmCilInstruction_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmCilInstruction: public SgAsmInstruction {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilInstruction.setDataPrototype(
        "Rose::BinaryAnalysis::CilInstructionKind", "kind", "= Rose::BinaryAnalysis::Cil_unknown_instruction",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmCilInstruction);
#if defined(SgAsmCilInstruction_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmCilInstruction -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmCilInstruction");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmInstruction);
        s & BOOST_SERIALIZATION_NVP(p_kind);
        debugSerializationEnd("SgAsmCilInstruction");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    Rose::BinaryAnalysis::CilInstructionKind const& get_kind() const;
    void set_kind(Rose::BinaryAnalysis::CilInstructionKind const&);
public:
    // Overrides are documented in the base classa
    virtual unsigned get_anyKind() const override;
public:
    virtual ~SgAsmCilInstruction();
 
public:
    SgAsmCilInstruction();
 
public:
    SgAsmCilInstruction(Rose::BinaryAnalysis::Address const& address,
                        uint8_t const& architectureId,
                        Rose::BinaryAnalysis::CilInstructionKind const& kind);
 
protected:
    void initializeProperties();
#endif // SgAsmCilInstruction_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmCilInstruction: public SgAsmInstruction {…};
#endif // DOCUMENTATION
 
 
// SgAsmCilImplMapTable           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmCilImplMapTable);
IS_SERIALIZABLE(AsmCilImplMapTable);
 
#ifndef DOCUMENTATION
AsmCilImplMapTable.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmCilImplMapTable: public SgAsmCilMetadata {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilImplMapTable.setDataPrototype(
        "std::vector<SgAsmCilImplMap*>", "elements", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmCilImplMapTable);
#if defined(SgAsmCilImplMapTable_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmCilImplMapTable -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmCilImplMapTable");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
        s & BOOST_SERIALIZATION_NVP(p_elements);
        debugSerializationEnd("SgAsmCilImplMapTable");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    std::vector<SgAsmCilImplMap*> const& get_elements() const;
    std::vector<SgAsmCilImplMap*>& get_elements();
public:
    using CilMetadataType = SgAsmCilImplMap;
public:
    virtual ~SgAsmCilImplMapTable();
 
public:
    SgAsmCilImplMapTable();
 
protected:
    void initializeProperties();
#endif // SgAsmCilImplMapTable_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmCilImplMapTable: public SgAsmCilMetadata {…};
#endif // DOCUMENTATION
 
 
// SgAsmCilImplMap           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmCilImplMap);
IS_SERIALIZABLE(AsmCilImplMap);
 
#ifndef DOCUMENTATION
AsmCilImplMap.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmCilImplMap: public SgAsmCilMetadata {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilImplMap.setDataPrototype(
        "uint16_t", "MappingFlags", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilImplMap.setDataPrototype(
        "uint32_t", "MemberForwarded", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilImplMap.setDataPrototype(
        "uint32_t", "ImportName", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilImplMap.setDataPrototype(
        "uint32_t", "ImportScope", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmCilImplMap);
#if defined(SgAsmCilImplMap_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmCilImplMap -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmCilImplMap");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
        s & BOOST_SERIALIZATION_NVP(p_MappingFlags);
        s & BOOST_SERIALIZATION_NVP(p_MemberForwarded);
        s & BOOST_SERIALIZATION_NVP(p_ImportName);
        s & BOOST_SERIALIZATION_NVP(p_ImportScope);
        debugSerializationEnd("SgAsmCilImplMap");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    uint16_t const& get_MappingFlags() const;
    void set_MappingFlags(uint16_t const&);
public:
    uint32_t const& get_MemberForwarded() const;
    void set_MemberForwarded(uint32_t const&);
public:
    uint32_t const& get_ImportName() const;
    void set_ImportName(uint32_t const&);
public:
    uint32_t const& get_ImportScope() const;
    void set_ImportScope(uint32_t const&);
public:
    void parse(const std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing);
    void unparse(std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing) const;
    void dump(std::ostream&) const;
 
    const SgAsmCilMetadata* get_MemberForwarded_object() const;
    const std::uint8_t* get_ImportName_string() const;
    const SgAsmCilMetadata* get_ImportScope_object() const;
public:
    virtual ~SgAsmCilImplMap();
 
public:
    SgAsmCilImplMap();
 
protected:
    void initializeProperties();
#endif // SgAsmCilImplMap_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmCilImplMap: public SgAsmCilMetadata {…};
#endif // DOCUMENTATION
 
 
// SgAsmCilGenericParamTable           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmCilGenericParamTable);
IS_SERIALIZABLE(AsmCilGenericParamTable);
 
#ifndef DOCUMENTATION
AsmCilGenericParamTable.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmCilGenericParamTable: public SgAsmCilMetadata {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilGenericParamTable.setDataPrototype(
        "std::vector<SgAsmCilGenericParam*>", "elements", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmCilGenericParamTable);
#if defined(SgAsmCilGenericParamTable_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmCilGenericParamTable -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmCilGenericParamTable");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
        s & BOOST_SERIALIZATION_NVP(p_elements);
        debugSerializationEnd("SgAsmCilGenericParamTable");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    std::vector<SgAsmCilGenericParam*> const& get_elements() const;
    std::vector<SgAsmCilGenericParam*>& get_elements();
public:
    using CilMetadataType = SgAsmCilGenericParam;
public:
    virtual ~SgAsmCilGenericParamTable();
 
public:
    SgAsmCilGenericParamTable();
 
protected:
    void initializeProperties();
#endif // SgAsmCilGenericParamTable_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmCilGenericParamTable: public SgAsmCilMetadata {…};
#endif // DOCUMENTATION
 
 
// SgAsmCilGenericParam           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmCilGenericParam);
IS_SERIALIZABLE(AsmCilGenericParam);
 
#ifndef DOCUMENTATION
AsmCilGenericParam.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmCilGenericParam: public SgAsmCilMetadata {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilGenericParam.setDataPrototype(
        "uint16_t", "Number", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilGenericParam.setDataPrototype(
        "uint16_t", "Flags", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilGenericParam.setDataPrototype(
        "uint32_t", "Owner", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilGenericParam.setDataPrototype(
        "uint32_t", "Name", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmCilGenericParam);
#if defined(SgAsmCilGenericParam_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmCilGenericParam -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmCilGenericParam");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
        s & BOOST_SERIALIZATION_NVP(p_Number);
        s & BOOST_SERIALIZATION_NVP(p_Flags);
        s & BOOST_SERIALIZATION_NVP(p_Owner);
        s & BOOST_SERIALIZATION_NVP(p_Name);
        debugSerializationEnd("SgAsmCilGenericParam");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    uint16_t const& get_Number() const;
    void set_Number(uint16_t const&);
public:
    uint16_t const& get_Flags() const;
    void set_Flags(uint16_t const&);
public:
    uint32_t const& get_Owner() const;
    void set_Owner(uint32_t const&);
public:
    uint32_t const& get_Name() const;
    void set_Name(uint32_t const&);
public:
    void parse(const std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing);
    void unparse(std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing) const;
    void dump(std::ostream&) const;
 
    const SgAsmCilMetadata* get_Owner_object() const;
    const std::uint8_t* get_Name_string() const;
public:
    virtual ~SgAsmCilGenericParam();
 
public:
    SgAsmCilGenericParam();
 
protected:
    void initializeProperties();
#endif // SgAsmCilGenericParam_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmCilGenericParam: public SgAsmCilMetadata {…};
#endif // DOCUMENTATION
 
 
// SgAsmCilGenericParamConstraintTable           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmCilGenericParamConstraintTable);
IS_SERIALIZABLE(AsmCilGenericParamConstraintTable);
 
#ifndef DOCUMENTATION
AsmCilGenericParamConstraintTable.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmCilGenericParamConstraintTable: public SgAsmCilMetadata {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilGenericParamConstraintTable.setDataPrototype(
        "std::vector<SgAsmCilGenericParamConstraint*>", "elements", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmCilGenericParamConstraintTable);
#if defined(SgAsmCilGenericParamConstraintTable_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmCilGenericParamConstraintTable -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmCilGenericParamConstraintTable");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
        s & BOOST_SERIALIZATION_NVP(p_elements);
        debugSerializationEnd("SgAsmCilGenericParamConstraintTable");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    std::vector<SgAsmCilGenericParamConstraint*> const& get_elements() const;
    std::vector<SgAsmCilGenericParamConstraint*>& get_elements();
public:
    using CilMetadataType = SgAsmCilGenericParamConstraint;
public:
    virtual ~SgAsmCilGenericParamConstraintTable();
 
public:
    SgAsmCilGenericParamConstraintTable();
 
protected:
    void initializeProperties();
#endif // SgAsmCilGenericParamConstraintTable_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmCilGenericParamConstraintTable: public SgAsmCilMetadata {…};
#endif // DOCUMENTATION
 
 
// SgAsmCilGenericParamConstraint           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmCilGenericParamConstraint);
IS_SERIALIZABLE(AsmCilGenericParamConstraint);
 
#ifndef DOCUMENTATION
AsmCilGenericParamConstraint.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmCilGenericParamConstraint: public SgAsmCilMetadata {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilGenericParamConstraint.setDataPrototype(
        "uint32_t", "Owner", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilGenericParamConstraint.setDataPrototype(
        "uint32_t", "Constraint", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmCilGenericParamConstraint);
#if defined(SgAsmCilGenericParamConstraint_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmCilGenericParamConstraint -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmCilGenericParamConstraint");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
        s & BOOST_SERIALIZATION_NVP(p_Owner);
        s & BOOST_SERIALIZATION_NVP(p_Constraint);
        debugSerializationEnd("SgAsmCilGenericParamConstraint");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    uint32_t const& get_Owner() const;
    void set_Owner(uint32_t const&);
public:
    uint32_t const& get_Constraint() const;
    void set_Constraint(uint32_t const&);
public:
    void parse(const std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing);
    void unparse(std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing) const;
    void dump(std::ostream&) const;
 
    const SgAsmCilMetadata* get_Owner_object() const;
    const SgAsmCilMetadata* get_Constraint_object() const;
public:
    virtual ~SgAsmCilGenericParamConstraint();
 
public:
    SgAsmCilGenericParamConstraint();
 
protected:
    void initializeProperties();
#endif // SgAsmCilGenericParamConstraint_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmCilGenericParamConstraint: public SgAsmCilMetadata {…};
#endif // DOCUMENTATION
 
 
// SgAsmCilFileTable           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmCilFileTable);
IS_SERIALIZABLE(AsmCilFileTable);
 
#ifndef DOCUMENTATION
AsmCilFileTable.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmCilFileTable: public SgAsmCilMetadata {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilFileTable.setDataPrototype(
        "std::vector<SgAsmCilFile*>", "elements", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmCilFileTable);
#if defined(SgAsmCilFileTable_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmCilFileTable -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmCilFileTable");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
        s & BOOST_SERIALIZATION_NVP(p_elements);
        debugSerializationEnd("SgAsmCilFileTable");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    std::vector<SgAsmCilFile*> const& get_elements() const;
    std::vector<SgAsmCilFile*>& get_elements();
public:
    using CilMetadataType = SgAsmCilFile;
public:
    virtual ~SgAsmCilFileTable();
 
public:
    SgAsmCilFileTable();
 
protected:
    void initializeProperties();
#endif // SgAsmCilFileTable_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmCilFileTable: public SgAsmCilMetadata {…};
#endif // DOCUMENTATION
 
 
// SgAsmCilFile           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmCilFile);
IS_SERIALIZABLE(AsmCilFile);
 
#ifndef DOCUMENTATION
AsmCilFile.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmCilFile: public SgAsmCilMetadata {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilFile.setDataPrototype(
        "uint32_t", "Flags", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilFile.setDataPrototype(
        "uint32_t", "Name", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilFile.setDataPrototype(
        "uint32_t", "HashValue", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmCilFile);
#if defined(SgAsmCilFile_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmCilFile -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmCilFile");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
        s & BOOST_SERIALIZATION_NVP(p_Flags);
        s & BOOST_SERIALIZATION_NVP(p_Name);
        s & BOOST_SERIALIZATION_NVP(p_HashValue);
        debugSerializationEnd("SgAsmCilFile");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    uint32_t const& get_Flags() const;
    void set_Flags(uint32_t const&);
public:
    uint32_t const& get_Name() const;
    void set_Name(uint32_t const&);
public:
    uint32_t const& get_HashValue() const;
    void set_HashValue(uint32_t const&);
public:
    void parse(const std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing);
    void unparse(std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing) const;
    void dump(std::ostream&) const;
 
    const std::uint8_t* get_Name_string() const;
    const std::uint8_t* get_HashValue_blob() const;
public:
    virtual ~SgAsmCilFile();
 
public:
    SgAsmCilFile();
 
protected:
    void initializeProperties();
#endif // SgAsmCilFile_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmCilFile: public SgAsmCilMetadata {…};
#endif // DOCUMENTATION
 
 
// SgAsmCilFieldTable           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmCilFieldTable);
IS_SERIALIZABLE(AsmCilFieldTable);
 
#ifndef DOCUMENTATION
AsmCilFieldTable.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmCilFieldTable: public SgAsmCilMetadata {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilFieldTable.setDataPrototype(
        "std::vector<SgAsmCilField*>", "elements", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmCilFieldTable);
#if defined(SgAsmCilFieldTable_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmCilFieldTable -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmCilFieldTable");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
        s & BOOST_SERIALIZATION_NVP(p_elements);
        debugSerializationEnd("SgAsmCilFieldTable");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    std::vector<SgAsmCilField*> const& get_elements() const;
    std::vector<SgAsmCilField*>& get_elements();
public:
    using CilMetadataType = SgAsmCilField;
public:
    virtual ~SgAsmCilFieldTable();
 
public:
    SgAsmCilFieldTable();
 
protected:
    void initializeProperties();
#endif // SgAsmCilFieldTable_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmCilFieldTable: public SgAsmCilMetadata {…};
#endif // DOCUMENTATION
 
 
// SgAsmCilFieldRVATable           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmCilFieldRVATable);
IS_SERIALIZABLE(AsmCilFieldRVATable);
 
#ifndef DOCUMENTATION
AsmCilFieldRVATable.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmCilFieldRVATable: public SgAsmCilMetadata {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilFieldRVATable.setDataPrototype(
        "std::vector<SgAsmCilFieldRVA*>", "elements", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmCilFieldRVATable);
#if defined(SgAsmCilFieldRVATable_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmCilFieldRVATable -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmCilFieldRVATable");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
        s & BOOST_SERIALIZATION_NVP(p_elements);
        debugSerializationEnd("SgAsmCilFieldRVATable");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    std::vector<SgAsmCilFieldRVA*> const& get_elements() const;
    std::vector<SgAsmCilFieldRVA*>& get_elements();
public:
    using CilMetadataType = SgAsmCilFieldRVA;
public:
    virtual ~SgAsmCilFieldRVATable();
 
public:
    SgAsmCilFieldRVATable();
 
protected:
    void initializeProperties();
#endif // SgAsmCilFieldRVATable_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmCilFieldRVATable: public SgAsmCilMetadata {…};
#endif // DOCUMENTATION
 
 
// SgAsmCilFieldRVA           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmCilFieldRVA);
IS_SERIALIZABLE(AsmCilFieldRVA);
 
#ifndef DOCUMENTATION
AsmCilFieldRVA.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmCilFieldRVA: public SgAsmCilMetadata {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilFieldRVA.setDataPrototype(
        "uint32_t", "RVA", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilFieldRVA.setDataPrototype(
        "uint32_t", "Field", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmCilFieldRVA);
#if defined(SgAsmCilFieldRVA_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmCilFieldRVA -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmCilFieldRVA");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
        s & BOOST_SERIALIZATION_NVP(p_RVA);
        s & BOOST_SERIALIZATION_NVP(p_Field);
        debugSerializationEnd("SgAsmCilFieldRVA");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    uint32_t const& get_RVA() const;
    void set_RVA(uint32_t const&);
public:
    uint32_t const& get_Field() const;
    void set_Field(uint32_t const&);
public:
    void parse(const std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing);
    void unparse(std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing) const;
    void dump(std::ostream&) const;
 
    const SgAsmCilMetadata* get_Field_object() const;
public:
    virtual ~SgAsmCilFieldRVA();
 
public:
    SgAsmCilFieldRVA();
 
protected:
    void initializeProperties();
#endif // SgAsmCilFieldRVA_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmCilFieldRVA: public SgAsmCilMetadata {…};
#endif // DOCUMENTATION
 
 
// SgAsmCilFieldMarshalTable           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmCilFieldMarshalTable);
IS_SERIALIZABLE(AsmCilFieldMarshalTable);
 
#ifndef DOCUMENTATION
AsmCilFieldMarshalTable.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmCilFieldMarshalTable: public SgAsmCilMetadata {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilFieldMarshalTable.setDataPrototype(
        "std::vector<SgAsmCilFieldMarshal*>", "elements", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmCilFieldMarshalTable);
#if defined(SgAsmCilFieldMarshalTable_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmCilFieldMarshalTable -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmCilFieldMarshalTable");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
        s & BOOST_SERIALIZATION_NVP(p_elements);
        debugSerializationEnd("SgAsmCilFieldMarshalTable");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    std::vector<SgAsmCilFieldMarshal*> const& get_elements() const;
    std::vector<SgAsmCilFieldMarshal*>& get_elements();
public:
    using CilMetadataType = SgAsmCilFieldMarshal;
public:
    virtual ~SgAsmCilFieldMarshalTable();
 
public:
    SgAsmCilFieldMarshalTable();
 
protected:
    void initializeProperties();
#endif // SgAsmCilFieldMarshalTable_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmCilFieldMarshalTable: public SgAsmCilMetadata {…};
#endif // DOCUMENTATION
 
 
// SgAsmCilFieldMarshal           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmCilFieldMarshal);
IS_SERIALIZABLE(AsmCilFieldMarshal);
 
#ifndef DOCUMENTATION
AsmCilFieldMarshal.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmCilFieldMarshal: public SgAsmCilMetadata {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilFieldMarshal.setDataPrototype(
        "uint32_t", "Parent", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilFieldMarshal.setDataPrototype(
        "uint32_t", "NativeType", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmCilFieldMarshal);
#if defined(SgAsmCilFieldMarshal_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmCilFieldMarshal -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmCilFieldMarshal");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
        s & BOOST_SERIALIZATION_NVP(p_Parent);
        s & BOOST_SERIALIZATION_NVP(p_NativeType);
        debugSerializationEnd("SgAsmCilFieldMarshal");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    uint32_t const& get_Parent() const;
    void set_Parent(uint32_t const&);
public:
    uint32_t const& get_NativeType() const;
    void set_NativeType(uint32_t const&);
public:
    void parse(const std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing);
    void unparse(std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing) const;
    void dump(std::ostream&) const;
 
    const SgAsmCilMetadata* get_Parent_object() const;
    const std::uint8_t* get_NativeType_blob() const;
public:
    virtual ~SgAsmCilFieldMarshal();
 
public:
    SgAsmCilFieldMarshal();
 
protected:
    void initializeProperties();
#endif // SgAsmCilFieldMarshal_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmCilFieldMarshal: public SgAsmCilMetadata {…};
#endif // DOCUMENTATION
 
 
// SgAsmCilFieldLayoutTable           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmCilFieldLayoutTable);
IS_SERIALIZABLE(AsmCilFieldLayoutTable);
 
#ifndef DOCUMENTATION
AsmCilFieldLayoutTable.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmCilFieldLayoutTable: public SgAsmCilMetadata {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilFieldLayoutTable.setDataPrototype(
        "std::vector<SgAsmCilFieldLayout*>", "elements", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmCilFieldLayoutTable);
#if defined(SgAsmCilFieldLayoutTable_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmCilFieldLayoutTable -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmCilFieldLayoutTable");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
        s & BOOST_SERIALIZATION_NVP(p_elements);
        debugSerializationEnd("SgAsmCilFieldLayoutTable");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    std::vector<SgAsmCilFieldLayout*> const& get_elements() const;
    std::vector<SgAsmCilFieldLayout*>& get_elements();
public:
    using CilMetadataType = SgAsmCilFieldLayout;
public:
    virtual ~SgAsmCilFieldLayoutTable();
 
public:
    SgAsmCilFieldLayoutTable();
 
protected:
    void initializeProperties();
#endif // SgAsmCilFieldLayoutTable_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmCilFieldLayoutTable: public SgAsmCilMetadata {…};
#endif // DOCUMENTATION
 
 
// SgAsmCilFieldLayout           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmCilFieldLayout);
IS_SERIALIZABLE(AsmCilFieldLayout);
 
#ifndef DOCUMENTATION
AsmCilFieldLayout.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmCilFieldLayout: public SgAsmCilMetadata {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilFieldLayout.setDataPrototype(
        "uint32_t", "Offset", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilFieldLayout.setDataPrototype(
        "uint32_t", "Field", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmCilFieldLayout);
#if defined(SgAsmCilFieldLayout_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmCilFieldLayout -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmCilFieldLayout");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
        s & BOOST_SERIALIZATION_NVP(p_Offset);
        s & BOOST_SERIALIZATION_NVP(p_Field);
        debugSerializationEnd("SgAsmCilFieldLayout");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    uint32_t const& get_Offset() const;
    void set_Offset(uint32_t const&);
public:
    uint32_t const& get_Field() const;
    void set_Field(uint32_t const&);
public:
    void parse(const std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing);
    void unparse(std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing) const;
    void dump(std::ostream&) const;
 
    const SgAsmCilMetadata* get_Field_object() const;
public:
    virtual ~SgAsmCilFieldLayout();
 
public:
    SgAsmCilFieldLayout();
 
protected:
    void initializeProperties();
#endif // SgAsmCilFieldLayout_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmCilFieldLayout: public SgAsmCilMetadata {…};
#endif // DOCUMENTATION
 
 
// SgAsmCilField           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmCilField);
IS_SERIALIZABLE(AsmCilField);
 
#ifndef DOCUMENTATION
AsmCilField.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmCilField: public SgAsmCilMetadata {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilField.setDataPrototype(
        "uint16_t", "Flags", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilField.setDataPrototype(
        "uint32_t", "Name", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilField.setDataPrototype(
        "uint32_t", "Signature", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmCilField);
#if defined(SgAsmCilField_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmCilField -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmCilField");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
        s & BOOST_SERIALIZATION_NVP(p_Flags);
        s & BOOST_SERIALIZATION_NVP(p_Name);
        s & BOOST_SERIALIZATION_NVP(p_Signature);
        debugSerializationEnd("SgAsmCilField");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    uint16_t const& get_Flags() const;
    void set_Flags(uint16_t const&);
public:
    uint32_t const& get_Name() const;
    void set_Name(uint32_t const&);
public:
    uint32_t const& get_Signature() const;
    void set_Signature(uint32_t const&);
public:
    void parse(const std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing);
    void unparse(std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing) const;
    void dump(std::ostream&) const;
 
    const std::uint8_t* get_Name_string() const;
    const std::uint8_t* get_Signature_blob() const;
public:
    virtual ~SgAsmCilField();
 
public:
    SgAsmCilField();
 
protected:
    void initializeProperties();
#endif // SgAsmCilField_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmCilField: public SgAsmCilMetadata {…};
#endif // DOCUMENTATION
 
 
// SgAsmCilExportedTypeTable           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmCilExportedTypeTable);
IS_SERIALIZABLE(AsmCilExportedTypeTable);
 
#ifndef DOCUMENTATION
AsmCilExportedTypeTable.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmCilExportedTypeTable: public SgAsmCilMetadata {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilExportedTypeTable.setDataPrototype(
        "std::vector<SgAsmCilExportedType*>", "elements", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmCilExportedTypeTable);
#if defined(SgAsmCilExportedTypeTable_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmCilExportedTypeTable -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmCilExportedTypeTable");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
        s & BOOST_SERIALIZATION_NVP(p_elements);
        debugSerializationEnd("SgAsmCilExportedTypeTable");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    std::vector<SgAsmCilExportedType*> const& get_elements() const;
    std::vector<SgAsmCilExportedType*>& get_elements();
public:
    using CilMetadataType = SgAsmCilExportedType;
public:
    virtual ~SgAsmCilExportedTypeTable();
 
public:
    SgAsmCilExportedTypeTable();
 
protected:
    void initializeProperties();
#endif // SgAsmCilExportedTypeTable_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmCilExportedTypeTable: public SgAsmCilMetadata {…};
#endif // DOCUMENTATION
 
 
// SgAsmCilExportedType           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmCilExportedType);
IS_SERIALIZABLE(AsmCilExportedType);
 
#ifndef DOCUMENTATION
AsmCilExportedType.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmCilExportedType: public SgAsmCilMetadata {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilExportedType.setDataPrototype(
        "uint32_t", "EventFlags", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilExportedType.setDataPrototype(
        "uint32_t", "TypeDefIdName", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilExportedType.setDataPrototype(
        "uint32_t", "TypeName", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilExportedType.setDataPrototype(
        "uint32_t", "TypeNamespace", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilExportedType.setDataPrototype(
        "uint32_t", "Implementation", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmCilExportedType);
#if defined(SgAsmCilExportedType_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmCilExportedType -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmCilExportedType");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
        s & BOOST_SERIALIZATION_NVP(p_EventFlags);
        s & BOOST_SERIALIZATION_NVP(p_TypeDefIdName);
        s & BOOST_SERIALIZATION_NVP(p_TypeName);
        s & BOOST_SERIALIZATION_NVP(p_TypeNamespace);
        s & BOOST_SERIALIZATION_NVP(p_Implementation);
        debugSerializationEnd("SgAsmCilExportedType");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    uint32_t const& get_EventFlags() const;
    void set_EventFlags(uint32_t const&);
public:
    uint32_t const& get_TypeDefIdName() const;
    void set_TypeDefIdName(uint32_t const&);
public:
    uint32_t const& get_TypeName() const;
    void set_TypeName(uint32_t const&);
public:
    uint32_t const& get_TypeNamespace() const;
    void set_TypeNamespace(uint32_t const&);
public:
    uint32_t const& get_Implementation() const;
    void set_Implementation(uint32_t const&);
public:
    void parse(const std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing);
    void unparse(std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing) const;
    void dump(std::ostream&) const;
 
    const std::uint8_t* get_TypeName_string() const;
    const std::uint8_t* get_TypeNamespace_string() const;
    const SgAsmCilMetadata* get_Implementation_object() const;
public:
    virtual ~SgAsmCilExportedType();
 
public:
    SgAsmCilExportedType();
 
protected:
    void initializeProperties();
#endif // SgAsmCilExportedType_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmCilExportedType: public SgAsmCilMetadata {…};
#endif // DOCUMENTATION
 
 
// SgAsmCilExceptionData           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmCilExceptionData);
IS_SERIALIZABLE(AsmCilExceptionData);
 
#ifndef DOCUMENTATION
AsmCilExceptionData.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmCilExceptionData: public SgAsmCilNode {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilExceptionData.setDataPrototype(
        "std::uint32_t", "flags", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilExceptionData.setDataPrototype(
        "std::uint32_t", "tryOffset", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilExceptionData.setDataPrototype(
        "std::uint32_t", "tryLength", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilExceptionData.setDataPrototype(
        "std::uint32_t", "handlerOffset", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilExceptionData.setDataPrototype(
        "std::uint32_t", "handlerLength", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilExceptionData.setDataPrototype(
        "std::uint32_t", "classTokenOrFilterOffset", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmCilExceptionData);
#if defined(SgAsmCilExceptionData_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmCilExceptionData -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmCilExceptionData");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilNode);
        s & BOOST_SERIALIZATION_NVP(p_flags);
        s & BOOST_SERIALIZATION_NVP(p_tryOffset);
        s & BOOST_SERIALIZATION_NVP(p_tryLength);
        s & BOOST_SERIALIZATION_NVP(p_handlerOffset);
        s & BOOST_SERIALIZATION_NVP(p_handlerLength);
        s & BOOST_SERIALIZATION_NVP(p_classTokenOrFilterOffset);
        debugSerializationEnd("SgAsmCilExceptionData");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
  enum
  {
    COR_ILEXCEPTION_CLAUSE_EXCEPTION = 0x0000,
    COR_ILEXCEPTION_CLAUSE_FILTER    = 0x0001,
    COR_ILEXCEPTION_CLAUSE_FINALLY   = 0x0002,
    COR_ILEXCEPTION_CLAUSE_FAULT     = 0x0004,
    COR_ILEXCEPTION_CLAUSE_MASK      = ( COR_ILEXCEPTION_CLAUSE_EXCEPTION
                                       | COR_ILEXCEPTION_CLAUSE_FILTER
                                       | COR_ILEXCEPTION_CLAUSE_FINALLY
                                       | COR_ILEXCEPTION_CLAUSE_FAULT
                                       ),
  };
 
private:
public:
    std::uint32_t const& get_flags() const;
    void set_flags(std::uint32_t const&);
 
public:
    std::uint32_t const& get_tryOffset() const;
    void set_tryOffset(std::uint32_t const&);
 
public:
    std::uint32_t const& get_tryLength() const;
    void set_tryLength(std::uint32_t const&);
 
public:
    std::uint32_t const& get_handlerOffset() const;
    void set_handlerOffset(std::uint32_t const&);
 
public:
    std::uint32_t const& get_handlerLength() const;
    void set_handlerLength(std::uint32_t const&);
 
public:
    std::uint32_t const& get_classTokenOrFilterOffset() const;
    void set_classTokenOrFilterOffset(std::uint32_t const&);
public:
  bool isException() const { return (get_flags() & COR_ILEXCEPTION_CLAUSE_MASK) == COR_ILEXCEPTION_CLAUSE_EXCEPTION; }
  bool isFilter()    const { return (get_flags() & COR_ILEXCEPTION_CLAUSE_MASK) == COR_ILEXCEPTION_CLAUSE_FILTER; }
  bool isFinally()   const { return (get_flags() & COR_ILEXCEPTION_CLAUSE_MASK) == COR_ILEXCEPTION_CLAUSE_FINALLY; }
  bool isFault()     const { return (get_flags() & COR_ILEXCEPTION_CLAUSE_MASK) == COR_ILEXCEPTION_CLAUSE_FAULT; }
public:
    virtual ~SgAsmCilExceptionData();
 
public:
    SgAsmCilExceptionData();
 
protected:
    void initializeProperties();
#endif // SgAsmCilExceptionData_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmCilExceptionData: public SgAsmCilNode {…};
#endif // DOCUMENTATION
 
 
// SgAsmCilEventTable           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmCilEventTable);
IS_SERIALIZABLE(AsmCilEventTable);
 
#ifndef DOCUMENTATION
AsmCilEventTable.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmCilEventTable: public SgAsmCilMetadata {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilEventTable.setDataPrototype(
        "std::vector<SgAsmCilEvent*>", "elements", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmCilEventTable);
#if defined(SgAsmCilEventTable_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmCilEventTable -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmCilEventTable");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
        s & BOOST_SERIALIZATION_NVP(p_elements);
        debugSerializationEnd("SgAsmCilEventTable");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    std::vector<SgAsmCilEvent*> const& get_elements() const;
    std::vector<SgAsmCilEvent*>& get_elements();
public:
    using CilMetadataType = SgAsmCilEvent;
public:
    virtual ~SgAsmCilEventTable();
 
public:
    SgAsmCilEventTable();
 
protected:
    void initializeProperties();
#endif // SgAsmCilEventTable_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmCilEventTable: public SgAsmCilMetadata {…};
#endif // DOCUMENTATION
 
 
// SgAsmCilEventMapTable           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmCilEventMapTable);
IS_SERIALIZABLE(AsmCilEventMapTable);
 
#ifndef DOCUMENTATION
AsmCilEventMapTable.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmCilEventMapTable: public SgAsmCilMetadata {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilEventMapTable.setDataPrototype(
        "std::vector<SgAsmCilEventMap*>", "elements", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmCilEventMapTable);
#if defined(SgAsmCilEventMapTable_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmCilEventMapTable -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmCilEventMapTable");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
        s & BOOST_SERIALIZATION_NVP(p_elements);
        debugSerializationEnd("SgAsmCilEventMapTable");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    std::vector<SgAsmCilEventMap*> const& get_elements() const;
    std::vector<SgAsmCilEventMap*>& get_elements();
public:
    using CilMetadataType = SgAsmCilEventMap;
public:
    virtual ~SgAsmCilEventMapTable();
 
public:
    SgAsmCilEventMapTable();
 
protected:
    void initializeProperties();
#endif // SgAsmCilEventMapTable_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmCilEventMapTable: public SgAsmCilMetadata {…};
#endif // DOCUMENTATION
 
 
// SgAsmCilEventMap           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmCilEventMap);
IS_SERIALIZABLE(AsmCilEventMap);
 
#ifndef DOCUMENTATION
AsmCilEventMap.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmCilEventMap: public SgAsmCilMetadata {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilEventMap.setDataPrototype(
        "uint32_t", "Parent", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilEventMap.setDataPrototype(
        "uint32_t", "EventList", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmCilEventMap);
#if defined(SgAsmCilEventMap_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmCilEventMap -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmCilEventMap");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
        s & BOOST_SERIALIZATION_NVP(p_Parent);
        s & BOOST_SERIALIZATION_NVP(p_EventList);
        debugSerializationEnd("SgAsmCilEventMap");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    uint32_t const& get_Parent() const;
    void set_Parent(uint32_t const&);
public:
    uint32_t const& get_EventList() const;
    void set_EventList(uint32_t const&);
public:
    void parse(const std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing);
    void unparse(std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing) const;
    void dump(std::ostream&) const;
 
    const SgAsmCilMetadata* get_Parent_object() const;
    const SgAsmCilMetadata* get_EventList_object() const;
public:
    virtual ~SgAsmCilEventMap();
 
public:
    SgAsmCilEventMap();
 
protected:
    void initializeProperties();
#endif // SgAsmCilEventMap_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmCilEventMap: public SgAsmCilMetadata {…};
#endif // DOCUMENTATION
 
 
// SgAsmCilEvent           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmCilEvent);
IS_SERIALIZABLE(AsmCilEvent);
 
#ifndef DOCUMENTATION
AsmCilEvent.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmCilEvent: public SgAsmCilMetadata {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilEvent.setDataPrototype(
        "uint16_t", "EventFlags", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilEvent.setDataPrototype(
        "uint32_t", "Name", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilEvent.setDataPrototype(
        "uint32_t", "EventType", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmCilEvent);
#if defined(SgAsmCilEvent_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmCilEvent -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmCilEvent");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
        s & BOOST_SERIALIZATION_NVP(p_EventFlags);
        s & BOOST_SERIALIZATION_NVP(p_Name);
        s & BOOST_SERIALIZATION_NVP(p_EventType);
        debugSerializationEnd("SgAsmCilEvent");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    uint16_t const& get_EventFlags() const;
    void set_EventFlags(uint16_t const&);
public:
    uint32_t const& get_Name() const;
    void set_Name(uint32_t const&);
public:
    uint32_t const& get_EventType() const;
    void set_EventType(uint32_t const&);
public:
    void parse(const std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing);
    void unparse(std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing) const;
    void dump(std::ostream&) const;
 
    const std::uint8_t* get_Name_string() const;
    const SgAsmCilMetadata* get_EventType_object() const;
public:
    virtual ~SgAsmCilEvent();
 
public:
    SgAsmCilEvent();
 
protected:
    void initializeProperties();
#endif // SgAsmCilEvent_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmCilEvent: public SgAsmCilMetadata {…};
#endif // DOCUMENTATION
 
 
// SgAsmCilDeclSecurityTable           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmCilDeclSecurityTable);
IS_SERIALIZABLE(AsmCilDeclSecurityTable);
 
#ifndef DOCUMENTATION
AsmCilDeclSecurityTable.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmCilDeclSecurityTable: public SgAsmCilMetadata {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilDeclSecurityTable.setDataPrototype(
        "std::vector<SgAsmCilDeclSecurity*>", "elements", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmCilDeclSecurityTable);
#if defined(SgAsmCilDeclSecurityTable_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmCilDeclSecurityTable -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmCilDeclSecurityTable");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
        s & BOOST_SERIALIZATION_NVP(p_elements);
        debugSerializationEnd("SgAsmCilDeclSecurityTable");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    std::vector<SgAsmCilDeclSecurity*> const& get_elements() const;
    std::vector<SgAsmCilDeclSecurity*>& get_elements();
public:
    using CilMetadataType = SgAsmCilDeclSecurity;
public:
    virtual ~SgAsmCilDeclSecurityTable();
 
public:
    SgAsmCilDeclSecurityTable();
 
protected:
    void initializeProperties();
#endif // SgAsmCilDeclSecurityTable_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmCilDeclSecurityTable: public SgAsmCilMetadata {…};
#endif // DOCUMENTATION
 
 
// SgAsmCilDeclSecurity           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmCilDeclSecurity);
IS_SERIALIZABLE(AsmCilDeclSecurity);
 
#ifndef DOCUMENTATION
AsmCilDeclSecurity.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmCilDeclSecurity: public SgAsmCilMetadata {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilDeclSecurity.setDataPrototype(
        "uint16_t", "Action", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilDeclSecurity.setDataPrototype(
        "uint32_t", "Parent", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilDeclSecurity.setDataPrototype(
        "uint32_t", "PermissionSet", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmCilDeclSecurity);
#if defined(SgAsmCilDeclSecurity_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmCilDeclSecurity -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmCilDeclSecurity");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
        s & BOOST_SERIALIZATION_NVP(p_Action);
        s & BOOST_SERIALIZATION_NVP(p_Parent);
        s & BOOST_SERIALIZATION_NVP(p_PermissionSet);
        debugSerializationEnd("SgAsmCilDeclSecurity");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    uint16_t const& get_Action() const;
    void set_Action(uint16_t const&);
public:
    uint32_t const& get_Parent() const;
    void set_Parent(uint32_t const&);
public:
    uint32_t const& get_PermissionSet() const;
    void set_PermissionSet(uint32_t const&);
public:
    void parse(const std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing);
    void unparse(std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing) const;
    void dump(std::ostream&) const;
 
    const SgAsmCilMetadata* get_Parent_object() const;
    const std::uint8_t* get_PermissionSet_blob() const;
public:
    virtual ~SgAsmCilDeclSecurity();
 
public:
    SgAsmCilDeclSecurity();
 
protected:
    void initializeProperties();
#endif // SgAsmCilDeclSecurity_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmCilDeclSecurity: public SgAsmCilMetadata {…};
#endif // DOCUMENTATION
 
 
// SgAsmCilDataStream           -- MACHINE GENERATED; DO NOT MODIFY --
 
#ifndef DOCUMENTATION
AstNodeClass& AsmCilDataStream = nonTerminalConstructor(
    "AsmCilDataStream",
    *this,
    "AsmCilDataStream",
    "AsmCilDataStreamTag",
    SubclassListBuilder()
        | AsmCilMetadataHeap
        | AsmCilUint32Heap
        | AsmCilUint8Heap
    , false);
assert(AsmCilDataStream.associatedGrammar != nullptr);
AsmCilDataStream.setCppCondition("!defined(DOCUMENTATION)");
AsmCilDataStream.isBoostSerializable(true);
AsmCilDataStream.setAutomaticGenerationOfConstructor(false);
AsmCilDataStream.setAutomaticGenerationOfDestructor(false);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
AsmCilDataStream.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmCilDataStream: public SgAsmCilNode {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilDataStream.setDataPrototype(
        "uint32_t", "Offset", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilDataStream.setDataPrototype(
        "uint32_t", "Size", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilDataStream.setDataPrototype(
        "std::string", "Name", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilDataStream.setDataPrototype(
        "uint32_t", "NamePadding", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmCilDataStream);
#if defined(SgAsmCilDataStream_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmCilDataStream -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmCilDataStream");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilNode);
        s & BOOST_SERIALIZATION_NVP(p_Offset);
        s & BOOST_SERIALIZATION_NVP(p_Size);
        s & BOOST_SERIALIZATION_NVP(p_Name);
        s & BOOST_SERIALIZATION_NVP(p_NamePadding);
        debugSerializationEnd("SgAsmCilDataStream");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    uint32_t const& get_Offset() const;
    void set_Offset(uint32_t const&);
public:
    uint32_t const& get_Size() const;
    void set_Size(uint32_t const&);
public:
    std::string const& get_Name() const;
    void set_Name(std::string const&);
public:
    uint32_t const& get_NamePadding() const;
    void set_NamePadding(uint32_t const&);
public:
    static const std::string ID_STRING_HEAP;
    static const std::string ID_BLOB_HEAP;
    static const std::string ID_US_HEAP;
    static const std::string ID_GUID_HEAP;
    static const std::string ID_METADATA_HEAP;
    virtual void parse(const std::vector<uint8_t>& buf, size_t startOfMetaData); /* FIXME: should be abstract */
 
    virtual void unparse(std::vector<uint8_t>& buf, size_t startOfMetaData) const; /* FIXME: should be abstract */
 
    virtual void dump(std::ostream& os) const; /* FIXME: should be abstract */
public:
    virtual ~SgAsmCilDataStream();
 
protected:
    SgAsmCilDataStream();
 
protected:
    SgAsmCilDataStream(uint32_t const& Offset,
                       uint32_t const& Size,
                       std::string const& Name,
                       uint32_t const& NamePadding);
 
protected:
    void initializeProperties();
#endif // SgAsmCilDataStream_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmCilDataStream: public SgAsmCilNode {…};
#endif // DOCUMENTATION
 
 
// SgAsmCilCustomAttributeTable           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmCilCustomAttributeTable);
IS_SERIALIZABLE(AsmCilCustomAttributeTable);
 
#ifndef DOCUMENTATION
AsmCilCustomAttributeTable.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmCilCustomAttributeTable: public SgAsmCilMetadata {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilCustomAttributeTable.setDataPrototype(
        "std::vector<SgAsmCilCustomAttribute*>", "elements", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmCilCustomAttributeTable);
#if defined(SgAsmCilCustomAttributeTable_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmCilCustomAttributeTable -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmCilCustomAttributeTable");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
        s & BOOST_SERIALIZATION_NVP(p_elements);
        debugSerializationEnd("SgAsmCilCustomAttributeTable");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    std::vector<SgAsmCilCustomAttribute*> const& get_elements() const;
    std::vector<SgAsmCilCustomAttribute*>& get_elements();
public:
    using CilMetadataType = SgAsmCilCustomAttribute;
public:
    virtual ~SgAsmCilCustomAttributeTable();
 
public:
    SgAsmCilCustomAttributeTable();
 
protected:
    void initializeProperties();
#endif // SgAsmCilCustomAttributeTable_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmCilCustomAttributeTable: public SgAsmCilMetadata {…};
#endif // DOCUMENTATION
 
 
// SgAsmCilCustomAttribute           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmCilCustomAttribute);
IS_SERIALIZABLE(AsmCilCustomAttribute);
 
#ifndef DOCUMENTATION
AsmCilCustomAttribute.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmCilCustomAttribute: public SgAsmCilMetadata {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilCustomAttribute.setDataPrototype(
        "uint32_t", "Parent", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilCustomAttribute.setDataPrototype(
        "uint32_t", "Type", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilCustomAttribute.setDataPrototype(
        "uint32_t", "Value", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmCilCustomAttribute);
#if defined(SgAsmCilCustomAttribute_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmCilCustomAttribute -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmCilCustomAttribute");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
        s & BOOST_SERIALIZATION_NVP(p_Parent);
        s & BOOST_SERIALIZATION_NVP(p_Type);
        s & BOOST_SERIALIZATION_NVP(p_Value);
        debugSerializationEnd("SgAsmCilCustomAttribute");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    uint32_t const& get_Parent() const;
    void set_Parent(uint32_t const&);
public:
    uint32_t const& get_Type() const;
    void set_Type(uint32_t const&);
public:
    uint32_t const& get_Value() const;
    void set_Value(uint32_t const&);
public:
    void parse(const std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing);
    void unparse(std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing) const;
    void dump(std::ostream&) const;
 
    const SgAsmCilMetadata* get_Parent_object() const;
    const SgAsmCilMetadata* get_Type_object() const;
    const std::uint8_t* get_Value_blob() const;
public:
    virtual ~SgAsmCilCustomAttribute();
 
public:
    SgAsmCilCustomAttribute();
 
protected:
    void initializeProperties();
#endif // SgAsmCilCustomAttribute_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmCilCustomAttribute: public SgAsmCilMetadata {…};
#endif // DOCUMENTATION
 
 
// SgAsmCilConstantTable           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmCilConstantTable);
IS_SERIALIZABLE(AsmCilConstantTable);
 
#ifndef DOCUMENTATION
AsmCilConstantTable.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmCilConstantTable: public SgAsmCilMetadata {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilConstantTable.setDataPrototype(
        "std::vector<SgAsmCilConstant*>", "elements", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmCilConstantTable);
#if defined(SgAsmCilConstantTable_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmCilConstantTable -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmCilConstantTable");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
        s & BOOST_SERIALIZATION_NVP(p_elements);
        debugSerializationEnd("SgAsmCilConstantTable");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    std::vector<SgAsmCilConstant*> const& get_elements() const;
    std::vector<SgAsmCilConstant*>& get_elements();
public:
    using CilMetadataType = SgAsmCilConstant;
public:
    virtual ~SgAsmCilConstantTable();
 
public:
    SgAsmCilConstantTable();
 
protected:
    void initializeProperties();
#endif // SgAsmCilConstantTable_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmCilConstantTable: public SgAsmCilMetadata {…};
#endif // DOCUMENTATION
 
 
// SgAsmCilConstant           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmCilConstant);
IS_SERIALIZABLE(AsmCilConstant);
 
#ifndef DOCUMENTATION
AsmCilConstant.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmCilConstant: public SgAsmCilMetadata {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilConstant.setDataPrototype(
        "uint8_t", "Type", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilConstant.setDataPrototype(
        "uint8_t", "Padding", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilConstant.setDataPrototype(
        "uint32_t", "Parent", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilConstant.setDataPrototype(
        "uint32_t", "Value", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmCilConstant);
#if defined(SgAsmCilConstant_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmCilConstant -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmCilConstant");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
        s & BOOST_SERIALIZATION_NVP(p_Type);
        s & BOOST_SERIALIZATION_NVP(p_Padding);
        s & BOOST_SERIALIZATION_NVP(p_Parent);
        s & BOOST_SERIALIZATION_NVP(p_Value);
        debugSerializationEnd("SgAsmCilConstant");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    uint8_t const& get_Type() const;
    void set_Type(uint8_t const&);
public:
    uint8_t const& get_Padding() const;
    void set_Padding(uint8_t const&);
public:
    uint32_t const& get_Parent() const;
    void set_Parent(uint32_t const&);
public:
    uint32_t const& get_Value() const;
    void set_Value(uint32_t const&);
public:
    void parse(const std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing);
    void unparse(std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing) const;
    void dump(std::ostream&) const;
 
    const SgAsmCilMetadata* get_Parent_object() const;
    const std::uint8_t* get_Value_blob() const;
public:
    virtual ~SgAsmCilConstant();
 
public:
    SgAsmCilConstant();
 
protected:
    void initializeProperties();
#endif // SgAsmCilConstant_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmCilConstant: public SgAsmCilMetadata {…};
#endif // DOCUMENTATION
 
 
// SgAsmCilClassLayoutTable           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmCilClassLayoutTable);
IS_SERIALIZABLE(AsmCilClassLayoutTable);
 
#ifndef DOCUMENTATION
AsmCilClassLayoutTable.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmCilClassLayoutTable: public SgAsmCilMetadata {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilClassLayoutTable.setDataPrototype(
        "std::vector<SgAsmCilClassLayout*>", "elements", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmCilClassLayoutTable);
#if defined(SgAsmCilClassLayoutTable_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmCilClassLayoutTable -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmCilClassLayoutTable");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
        s & BOOST_SERIALIZATION_NVP(p_elements);
        debugSerializationEnd("SgAsmCilClassLayoutTable");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    std::vector<SgAsmCilClassLayout*> const& get_elements() const;
    std::vector<SgAsmCilClassLayout*>& get_elements();
public:
    using CilMetadataType = SgAsmCilClassLayout;
public:
    virtual ~SgAsmCilClassLayoutTable();
 
public:
    SgAsmCilClassLayoutTable();
 
protected:
    void initializeProperties();
#endif // SgAsmCilClassLayoutTable_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmCilClassLayoutTable: public SgAsmCilMetadata {…};
#endif // DOCUMENTATION
 
 
// SgAsmCilClassLayout           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmCilClassLayout);
IS_SERIALIZABLE(AsmCilClassLayout);
 
#ifndef DOCUMENTATION
AsmCilClassLayout.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmCilClassLayout: public SgAsmCilMetadata {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilClassLayout.setDataPrototype(
        "uint16_t", "PackingSize", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilClassLayout.setDataPrototype(
        "uint32_t", "ClassSize", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilClassLayout.setDataPrototype(
        "uint32_t", "Parent", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmCilClassLayout);
#if defined(SgAsmCilClassLayout_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmCilClassLayout -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmCilClassLayout");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
        s & BOOST_SERIALIZATION_NVP(p_PackingSize);
        s & BOOST_SERIALIZATION_NVP(p_ClassSize);
        s & BOOST_SERIALIZATION_NVP(p_Parent);
        debugSerializationEnd("SgAsmCilClassLayout");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    uint16_t const& get_PackingSize() const;
    void set_PackingSize(uint16_t const&);
public:
    uint32_t const& get_ClassSize() const;
    void set_ClassSize(uint32_t const&);
public:
    uint32_t const& get_Parent() const;
    void set_Parent(uint32_t const&);
public:
    void parse(const std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing);
    void unparse(std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing) const;
    void dump(std::ostream&) const;
 
    const SgAsmCilMetadata* get_Parent_object() const;
public:
    virtual ~SgAsmCilClassLayout();
 
public:
    SgAsmCilClassLayout();
 
protected:
    void initializeProperties();
#endif // SgAsmCilClassLayout_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmCilClassLayout: public SgAsmCilMetadata {…};
#endif // DOCUMENTATION
 
 
// SgAsmCilAssemblyTable           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmCilAssemblyTable);
IS_SERIALIZABLE(AsmCilAssemblyTable);
 
#ifndef DOCUMENTATION
AsmCilAssemblyTable.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmCilAssemblyTable: public SgAsmCilMetadata {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilAssemblyTable.setDataPrototype(
        "std::vector<SgAsmCilAssembly*>", "elements", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmCilAssemblyTable);
#if defined(SgAsmCilAssemblyTable_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmCilAssemblyTable -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmCilAssemblyTable");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
        s & BOOST_SERIALIZATION_NVP(p_elements);
        debugSerializationEnd("SgAsmCilAssemblyTable");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    std::vector<SgAsmCilAssembly*> const& get_elements() const;
    std::vector<SgAsmCilAssembly*>& get_elements();
public:
    using CilMetadataType = SgAsmCilAssembly;
public:
    virtual ~SgAsmCilAssemblyTable();
 
public:
    SgAsmCilAssemblyTable();
 
protected:
    void initializeProperties();
#endif // SgAsmCilAssemblyTable_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmCilAssemblyTable: public SgAsmCilMetadata {…};
#endif // DOCUMENTATION
 
 
// SgAsmCilAssemblyRefTable           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmCilAssemblyRefTable);
IS_SERIALIZABLE(AsmCilAssemblyRefTable);
 
#ifndef DOCUMENTATION
AsmCilAssemblyRefTable.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmCilAssemblyRefTable: public SgAsmCilMetadata {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilAssemblyRefTable.setDataPrototype(
        "std::vector<SgAsmCilAssemblyRef*>", "elements", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmCilAssemblyRefTable);
#if defined(SgAsmCilAssemblyRefTable_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmCilAssemblyRefTable -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmCilAssemblyRefTable");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
        s & BOOST_SERIALIZATION_NVP(p_elements);
        debugSerializationEnd("SgAsmCilAssemblyRefTable");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    std::vector<SgAsmCilAssemblyRef*> const& get_elements() const;
    std::vector<SgAsmCilAssemblyRef*>& get_elements();
public:
    using CilMetadataType = SgAsmCilAssemblyRef;
public:
    virtual ~SgAsmCilAssemblyRefTable();
 
public:
    SgAsmCilAssemblyRefTable();
 
protected:
    void initializeProperties();
#endif // SgAsmCilAssemblyRefTable_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmCilAssemblyRefTable: public SgAsmCilMetadata {…};
#endif // DOCUMENTATION
 
 
// SgAsmCilAssemblyRefProcessorTable           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmCilAssemblyRefProcessorTable);
IS_SERIALIZABLE(AsmCilAssemblyRefProcessorTable);
 
#ifndef DOCUMENTATION
AsmCilAssemblyRefProcessorTable.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmCilAssemblyRefProcessorTable: public SgAsmCilMetadata {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilAssemblyRefProcessorTable.setDataPrototype(
        "std::vector<SgAsmCilAssemblyRefProcessor*>", "elements", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmCilAssemblyRefProcessorTable);
#if defined(SgAsmCilAssemblyRefProcessorTable_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmCilAssemblyRefProcessorTable -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmCilAssemblyRefProcessorTable");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
        s & BOOST_SERIALIZATION_NVP(p_elements);
        debugSerializationEnd("SgAsmCilAssemblyRefProcessorTable");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    std::vector<SgAsmCilAssemblyRefProcessor*> const& get_elements() const;
    std::vector<SgAsmCilAssemblyRefProcessor*>& get_elements();
public:
    using CilMetadataType = SgAsmCilAssemblyRefProcessor;
public:
    virtual ~SgAsmCilAssemblyRefProcessorTable();
 
public:
    SgAsmCilAssemblyRefProcessorTable();
 
protected:
    void initializeProperties();
#endif // SgAsmCilAssemblyRefProcessorTable_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmCilAssemblyRefProcessorTable: public SgAsmCilMetadata {…};
#endif // DOCUMENTATION
 
 
// SgAsmCilAssemblyRefProcessor           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmCilAssemblyRefProcessor);
IS_SERIALIZABLE(AsmCilAssemblyRefProcessor);
 
#ifndef DOCUMENTATION
AsmCilAssemblyRefProcessor.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmCilAssemblyRefProcessor: public SgAsmCilMetadata {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilAssemblyRefProcessor.setDataPrototype(
        "uint32_t", "Processor", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilAssemblyRefProcessor.setDataPrototype(
        "uint32_t", "AssemblyRef", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmCilAssemblyRefProcessor);
#if defined(SgAsmCilAssemblyRefProcessor_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmCilAssemblyRefProcessor -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmCilAssemblyRefProcessor");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
        s & BOOST_SERIALIZATION_NVP(p_Processor);
        s & BOOST_SERIALIZATION_NVP(p_AssemblyRef);
        debugSerializationEnd("SgAsmCilAssemblyRefProcessor");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    uint32_t const& get_Processor() const;
    void set_Processor(uint32_t const&);
public:
    uint32_t const& get_AssemblyRef() const;
    void set_AssemblyRef(uint32_t const&);
public:
    void parse(const std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing);
    void unparse(std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing) const;
    void dump(std::ostream&) const;
 
    const SgAsmCilMetadata* get_AssemblyRef_object() const;
public:
    virtual ~SgAsmCilAssemblyRefProcessor();
 
public:
    SgAsmCilAssemblyRefProcessor();
 
protected:
    void initializeProperties();
#endif // SgAsmCilAssemblyRefProcessor_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmCilAssemblyRefProcessor: public SgAsmCilMetadata {…};
#endif // DOCUMENTATION
 
 
// SgAsmCilAssemblyRefOSTable           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmCilAssemblyRefOSTable);
IS_SERIALIZABLE(AsmCilAssemblyRefOSTable);
 
#ifndef DOCUMENTATION
AsmCilAssemblyRefOSTable.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmCilAssemblyRefOSTable: public SgAsmCilMetadata {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilAssemblyRefOSTable.setDataPrototype(
        "std::vector<SgAsmCilAssemblyRefOS*>", "elements", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmCilAssemblyRefOSTable);
#if defined(SgAsmCilAssemblyRefOSTable_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmCilAssemblyRefOSTable -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmCilAssemblyRefOSTable");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
        s & BOOST_SERIALIZATION_NVP(p_elements);
        debugSerializationEnd("SgAsmCilAssemblyRefOSTable");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    std::vector<SgAsmCilAssemblyRefOS*> const& get_elements() const;
    std::vector<SgAsmCilAssemblyRefOS*>& get_elements();
public:
    using CilMetadataType = SgAsmCilAssemblyRefOS;
public:
    virtual ~SgAsmCilAssemblyRefOSTable();
 
public:
    SgAsmCilAssemblyRefOSTable();
 
protected:
    void initializeProperties();
#endif // SgAsmCilAssemblyRefOSTable_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmCilAssemblyRefOSTable: public SgAsmCilMetadata {…};
#endif // DOCUMENTATION
 
 
// SgAsmCilAssemblyRefOS           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmCilAssemblyRefOS);
IS_SERIALIZABLE(AsmCilAssemblyRefOS);
 
#ifndef DOCUMENTATION
AsmCilAssemblyRefOS.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmCilAssemblyRefOS: public SgAsmCilMetadata {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilAssemblyRefOS.setDataPrototype(
        "uint32_t", "OSPlatformID", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilAssemblyRefOS.setDataPrototype(
        "uint32_t", "OSMajorVersion", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilAssemblyRefOS.setDataPrototype(
        "uint32_t", "OSMinorVersion", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilAssemblyRefOS.setDataPrototype(
        "uint32_t", "AssemblyRefOS", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmCilAssemblyRefOS);
#if defined(SgAsmCilAssemblyRefOS_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmCilAssemblyRefOS -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmCilAssemblyRefOS");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
        s & BOOST_SERIALIZATION_NVP(p_OSPlatformID);
        s & BOOST_SERIALIZATION_NVP(p_OSMajorVersion);
        s & BOOST_SERIALIZATION_NVP(p_OSMinorVersion);
        s & BOOST_SERIALIZATION_NVP(p_AssemblyRefOS);
        debugSerializationEnd("SgAsmCilAssemblyRefOS");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    uint32_t const& get_OSPlatformID() const;
    void set_OSPlatformID(uint32_t const&);
public:
    uint32_t const& get_OSMajorVersion() const;
    void set_OSMajorVersion(uint32_t const&);
public:
    uint32_t const& get_OSMinorVersion() const;
    void set_OSMinorVersion(uint32_t const&);
public:
    uint32_t const& get_AssemblyRefOS() const;
    void set_AssemblyRefOS(uint32_t const&);
public:
    void parse(const std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing);
    void unparse(std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing) const;
    void dump(std::ostream&) const;
 
    const SgAsmCilMetadata* get_AssemblyRefOS_object() const;
public:
    virtual ~SgAsmCilAssemblyRefOS();
 
public:
    SgAsmCilAssemblyRefOS();
 
protected:
    void initializeProperties();
#endif // SgAsmCilAssemblyRefOS_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmCilAssemblyRefOS: public SgAsmCilMetadata {…};
#endif // DOCUMENTATION
 
 
// SgAsmCilAssemblyRef           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmCilAssemblyRef);
IS_SERIALIZABLE(AsmCilAssemblyRef);
 
#ifndef DOCUMENTATION
AsmCilAssemblyRef.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmCilAssemblyRef: public SgAsmCilMetadata {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilAssemblyRef.setDataPrototype(
        "uint16_t", "MajorVersion", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilAssemblyRef.setDataPrototype(
        "uint16_t", "MinorVersion", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilAssemblyRef.setDataPrototype(
        "uint16_t", "BuildNumber", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilAssemblyRef.setDataPrototype(
        "uint16_t", "RevisionNumber", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilAssemblyRef.setDataPrototype(
        "uint32_t", "Flags", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilAssemblyRef.setDataPrototype(
        "uint32_t", "PublicKeyOrToken", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilAssemblyRef.setDataPrototype(
        "uint32_t", "Name", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilAssemblyRef.setDataPrototype(
        "uint32_t", "Culture", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilAssemblyRef.setDataPrototype(
        "uint32_t", "HashValue", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmCilAssemblyRef);
#if defined(SgAsmCilAssemblyRef_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmCilAssemblyRef -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmCilAssemblyRef");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
        s & BOOST_SERIALIZATION_NVP(p_MajorVersion);
        s & BOOST_SERIALIZATION_NVP(p_MinorVersion);
        s & BOOST_SERIALIZATION_NVP(p_BuildNumber);
        s & BOOST_SERIALIZATION_NVP(p_RevisionNumber);
        s & BOOST_SERIALIZATION_NVP(p_Flags);
        s & BOOST_SERIALIZATION_NVP(p_PublicKeyOrToken);
        s & BOOST_SERIALIZATION_NVP(p_Name);
        s & BOOST_SERIALIZATION_NVP(p_Culture);
        s & BOOST_SERIALIZATION_NVP(p_HashValue);
        debugSerializationEnd("SgAsmCilAssemblyRef");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    uint16_t const& get_MajorVersion() const;
    void set_MajorVersion(uint16_t const&);
public:
    uint16_t const& get_MinorVersion() const;
    void set_MinorVersion(uint16_t const&);
public:
    uint16_t const& get_BuildNumber() const;
    void set_BuildNumber(uint16_t const&);
public:
    uint16_t const& get_RevisionNumber() const;
    void set_RevisionNumber(uint16_t const&);
public:
    uint32_t const& get_Flags() const;
    void set_Flags(uint32_t const&);
public:
    uint32_t const& get_PublicKeyOrToken() const;
    void set_PublicKeyOrToken(uint32_t const&);
public:
    uint32_t const& get_Name() const;
    void set_Name(uint32_t const&);
public:
    uint32_t const& get_Culture() const;
    void set_Culture(uint32_t const&);
public:
    uint32_t const& get_HashValue() const;
    void set_HashValue(uint32_t const&);
public:
    void parse(const std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing);
    void unparse(std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing) const;
    void dump(std::ostream&) const;
 
    const std::uint8_t* get_PublicKeyOrToken_blob() const;
    const std::uint8_t* get_Name_string() const;
    const std::uint8_t* get_Culture_string() const;
    const std::uint8_t* get_HashValue_blob() const;
public:
    virtual ~SgAsmCilAssemblyRef();
 
public:
    SgAsmCilAssemblyRef();
 
protected:
    void initializeProperties();
#endif // SgAsmCilAssemblyRef_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmCilAssemblyRef: public SgAsmCilMetadata {…};
#endif // DOCUMENTATION
 
 
// SgAsmCilAssemblyProcessorTable           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmCilAssemblyProcessorTable);
IS_SERIALIZABLE(AsmCilAssemblyProcessorTable);
 
#ifndef DOCUMENTATION
AsmCilAssemblyProcessorTable.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmCilAssemblyProcessorTable: public SgAsmCilMetadata {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilAssemblyProcessorTable.setDataPrototype(
        "std::vector<SgAsmCilAssemblyProcessor*>", "elements", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmCilAssemblyProcessorTable);
#if defined(SgAsmCilAssemblyProcessorTable_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmCilAssemblyProcessorTable -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmCilAssemblyProcessorTable");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
        s & BOOST_SERIALIZATION_NVP(p_elements);
        debugSerializationEnd("SgAsmCilAssemblyProcessorTable");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    std::vector<SgAsmCilAssemblyProcessor*> const& get_elements() const;
    std::vector<SgAsmCilAssemblyProcessor*>& get_elements();
public:
    using CilMetadataType = SgAsmCilAssemblyProcessor;
public:
    virtual ~SgAsmCilAssemblyProcessorTable();
 
public:
    SgAsmCilAssemblyProcessorTable();
 
protected:
    void initializeProperties();
#endif // SgAsmCilAssemblyProcessorTable_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmCilAssemblyProcessorTable: public SgAsmCilMetadata {…};
#endif // DOCUMENTATION
 
 
// SgAsmCilAssemblyProcessor           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmCilAssemblyProcessor);
IS_SERIALIZABLE(AsmCilAssemblyProcessor);
 
#ifndef DOCUMENTATION
AsmCilAssemblyProcessor.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmCilAssemblyProcessor: public SgAsmCilMetadata {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilAssemblyProcessor.setDataPrototype(
        "uint32_t", "Processor", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmCilAssemblyProcessor);
#if defined(SgAsmCilAssemblyProcessor_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmCilAssemblyProcessor -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmCilAssemblyProcessor");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
        s & BOOST_SERIALIZATION_NVP(p_Processor);
        debugSerializationEnd("SgAsmCilAssemblyProcessor");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    uint32_t const& get_Processor() const;
    void set_Processor(uint32_t const&);
public:
    void parse(const std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing);
    void unparse(std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing) const;
    void dump(std::ostream&) const;
public:
    virtual ~SgAsmCilAssemblyProcessor();
 
public:
    SgAsmCilAssemblyProcessor();
 
protected:
    void initializeProperties();
#endif // SgAsmCilAssemblyProcessor_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmCilAssemblyProcessor: public SgAsmCilMetadata {…};
#endif // DOCUMENTATION
 
 
// SgAsmCilAssemblyOSTable           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmCilAssemblyOSTable);
IS_SERIALIZABLE(AsmCilAssemblyOSTable);
 
#ifndef DOCUMENTATION
AsmCilAssemblyOSTable.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmCilAssemblyOSTable: public SgAsmCilMetadata {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilAssemblyOSTable.setDataPrototype(
        "std::vector<SgAsmCilAssemblyOS*>", "elements", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmCilAssemblyOSTable);
#if defined(SgAsmCilAssemblyOSTable_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmCilAssemblyOSTable -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmCilAssemblyOSTable");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
        s & BOOST_SERIALIZATION_NVP(p_elements);
        debugSerializationEnd("SgAsmCilAssemblyOSTable");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    std::vector<SgAsmCilAssemblyOS*> const& get_elements() const;
    std::vector<SgAsmCilAssemblyOS*>& get_elements();
public:
    using CilMetadataType = SgAsmCilAssemblyOS;
public:
    virtual ~SgAsmCilAssemblyOSTable();
 
public:
    SgAsmCilAssemblyOSTable();
 
protected:
    void initializeProperties();
#endif // SgAsmCilAssemblyOSTable_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmCilAssemblyOSTable: public SgAsmCilMetadata {…};
#endif // DOCUMENTATION
 
 
// SgAsmCilAssemblyOS           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmCilAssemblyOS);
IS_SERIALIZABLE(AsmCilAssemblyOS);
 
#ifndef DOCUMENTATION
AsmCilAssemblyOS.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmCilAssemblyOS: public SgAsmCilMetadata {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilAssemblyOS.setDataPrototype(
        "uint32_t", "OSPlatformID", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilAssemblyOS.setDataPrototype(
        "uint32_t", "OSMajorVersion", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilAssemblyOS.setDataPrototype(
        "uint32_t", "OSMinorVersion", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmCilAssemblyOS);
#if defined(SgAsmCilAssemblyOS_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmCilAssemblyOS -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmCilAssemblyOS");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
        s & BOOST_SERIALIZATION_NVP(p_OSPlatformID);
        s & BOOST_SERIALIZATION_NVP(p_OSMajorVersion);
        s & BOOST_SERIALIZATION_NVP(p_OSMinorVersion);
        debugSerializationEnd("SgAsmCilAssemblyOS");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    uint32_t const& get_OSPlatformID() const;
    void set_OSPlatformID(uint32_t const&);
public:
    uint32_t const& get_OSMajorVersion() const;
    void set_OSMajorVersion(uint32_t const&);
public:
    uint32_t const& get_OSMinorVersion() const;
    void set_OSMinorVersion(uint32_t const&);
public:
    void parse(const std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing);
    void unparse(std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing) const;
    void dump(std::ostream&) const;
public:
    virtual ~SgAsmCilAssemblyOS();
 
public:
    SgAsmCilAssemblyOS();
 
protected:
    void initializeProperties();
#endif // SgAsmCilAssemblyOS_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmCilAssemblyOS: public SgAsmCilMetadata {…};
#endif // DOCUMENTATION
 
 
// SgAsmCilAssembly           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmCilAssembly);
IS_SERIALIZABLE(AsmCilAssembly);
 
#ifndef DOCUMENTATION
AsmCilAssembly.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmCilAssembly: public SgAsmCilMetadata {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilAssembly.setDataPrototype(
        "uint32_t", "HashAlgId", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilAssembly.setDataPrototype(
        "uint16_t", "MajorVersion", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilAssembly.setDataPrototype(
        "uint16_t", "MinorVersion", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilAssembly.setDataPrototype(
        "uint16_t", "BuildNumber", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilAssembly.setDataPrototype(
        "uint16_t", "RevisionNumber", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilAssembly.setDataPrototype(
        "uint32_t", "Flags", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilAssembly.setDataPrototype(
        "uint32_t", "PublicKey", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilAssembly.setDataPrototype(
        "uint32_t", "Name", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmCilAssembly.setDataPrototype(
        "uint32_t", "Culture", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmCilAssembly);
#if defined(SgAsmCilAssembly_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmCilAssembly -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmCilAssembly");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
        s & BOOST_SERIALIZATION_NVP(p_HashAlgId);
        s & BOOST_SERIALIZATION_NVP(p_MajorVersion);
        s & BOOST_SERIALIZATION_NVP(p_MinorVersion);
        s & BOOST_SERIALIZATION_NVP(p_BuildNumber);
        s & BOOST_SERIALIZATION_NVP(p_RevisionNumber);
        s & BOOST_SERIALIZATION_NVP(p_Flags);
        s & BOOST_SERIALIZATION_NVP(p_PublicKey);
        s & BOOST_SERIALIZATION_NVP(p_Name);
        s & BOOST_SERIALIZATION_NVP(p_Culture);
        debugSerializationEnd("SgAsmCilAssembly");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    uint32_t const& get_HashAlgId() const;
    void set_HashAlgId(uint32_t const&);
public:
    uint16_t const& get_MajorVersion() const;
    void set_MajorVersion(uint16_t const&);
public:
    uint16_t const& get_MinorVersion() const;
    void set_MinorVersion(uint16_t const&);
public:
    uint16_t const& get_BuildNumber() const;
    void set_BuildNumber(uint16_t const&);
public:
    uint16_t const& get_RevisionNumber() const;
    void set_RevisionNumber(uint16_t const&);
public:
    uint32_t const& get_Flags() const;
    void set_Flags(uint32_t const&);
public:
    uint32_t const& get_PublicKey() const;
    void set_PublicKey(uint32_t const&);
public:
    uint32_t const& get_Name() const;
    void set_Name(uint32_t const&);
public:
    uint32_t const& get_Culture() const;
    void set_Culture(uint32_t const&);
public:
    void parse(const std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing);
    void unparse(std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing) const;
    void dump(std::ostream&) const;
 
    const std::uint8_t* get_PublicKey_blob() const;
    const std::uint8_t* get_Name_string() const;
    const std::uint8_t* get_Culture_string() const;
public:
    virtual ~SgAsmCilAssembly();
 
public:
    SgAsmCilAssembly();
 
protected:
    void initializeProperties();
#endif // SgAsmCilAssembly_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmCilAssembly: public SgAsmCilMetadata {…};
#endif // DOCUMENTATION
 
 
// SgAsmCilMetadata           -- MACHINE GENERATED; DO NOT MODIFY --
 
#ifndef DOCUMENTATION
AstNodeClass& AsmCilMetadata = nonTerminalConstructor(
    "AsmCilMetadata",
    *this,
    "AsmCilMetadata",
    "AsmCilMetadataTag",
    SubclassListBuilder()
        | AsmCilAssembly
        | AsmCilAssemblyOS
        | AsmCilAssemblyOSTable
        | AsmCilAssemblyProcessor
        | AsmCilAssemblyProcessorTable
        | AsmCilAssemblyRef
        | AsmCilAssemblyRefOS
        | AsmCilAssemblyRefOSTable
        | AsmCilAssemblyRefProcessor
        | AsmCilAssemblyRefProcessorTable
        | AsmCilAssemblyRefTable
        | AsmCilAssemblyTable
        | AsmCilClassLayout
        | AsmCilClassLayoutTable
        | AsmCilConstant
        | AsmCilConstantTable
        | AsmCilCustomAttribute
        | AsmCilCustomAttributeTable
        | AsmCilDeclSecurity
        | AsmCilDeclSecurityTable
        | AsmCilEvent
        | AsmCilEventMap
        | AsmCilEventMapTable
        | AsmCilEventTable
        | AsmCilExportedType
        | AsmCilExportedTypeTable
        | AsmCilField
        | AsmCilFieldLayout
        | AsmCilFieldLayoutTable
        | AsmCilFieldMarshal
        | AsmCilFieldMarshalTable
        | AsmCilFieldRVA
        | AsmCilFieldRVATable
        | AsmCilFieldTable
        | AsmCilFile
        | AsmCilFileTable
        | AsmCilGenericParamConstraint
        | AsmCilGenericParamConstraintTable
        | AsmCilGenericParam
        | AsmCilGenericParamTable
        | AsmCilImplMap
        | AsmCilImplMapTable
        | AsmCilInterfaceImpl
        | AsmCilInterfaceImplTable
        | AsmCilManifestResource
        | AsmCilManifestResourceTable
        | AsmCilMemberRef
        | AsmCilMemberRefTable
        | AsmCilMethodDef
        | AsmCilMethodDefTable
        | AsmCilMethodImpl
        | AsmCilMethodImplTable
        | AsmCilMethodSemantics
        | AsmCilMethodSemanticsTable
        | AsmCilMethodSpec
        | AsmCilMethodSpecTable
        | AsmCilModule
        | AsmCilModuleRef
        | AsmCilModuleRefTable
        | AsmCilModuleTable
        | AsmCilNestedClass
        | AsmCilNestedClassTable
        | AsmCilParam
        | AsmCilParamTable
        | AsmCilProperty
        | AsmCilPropertyMap
        | AsmCilPropertyMapTable
        | AsmCilPropertyTable
        | AsmCilStandAloneSig
        | AsmCilStandAloneSigTable
        | AsmCilTypeDef
        | AsmCilTypeDefTable
        | AsmCilTypeRef
        | AsmCilTypeRefTable
        | AsmCilTypeSpec
        | AsmCilTypeSpecTable
    , false);
assert(AsmCilMetadata.associatedGrammar != nullptr);
AsmCilMetadata.setCppCondition("!defined(DOCUMENTATION)");
AsmCilMetadata.isBoostSerializable(true);
AsmCilMetadata.setAutomaticGenerationOfConstructor(false);
AsmCilMetadata.setAutomaticGenerationOfDestructor(false);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
AsmCilMetadata.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmCilMetadata: public SgAsmCilNode {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmCilMetadata);
#if defined(SgAsmCilMetadata_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmCilMetadata -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmCilMetadata");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilNode);
        debugSerializationEnd("SgAsmCilMetadata");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    virtual ~SgAsmCilMetadata();
 
protected:
    SgAsmCilMetadata();
 
protected:
    void initializeProperties();
#endif // SgAsmCilMetadata_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmCilMetadata: public SgAsmCilNode {…};
#endif // DOCUMENTATION
 
 
// SgAsmCilNode           -- MACHINE GENERATED; DO NOT MODIFY --
 
#ifndef DOCUMENTATION
AstNodeClass& AsmCilNode = nonTerminalConstructor(
    "AsmCilNode",
    *this,
    "AsmCilNode",
    "AsmCilNodeTag",
    SubclassListBuilder()
        | AsmCilDataStream
        | AsmCilExceptionData
        | AsmCilMetadata
        | AsmCilMetadataRoot
        | AsmCilMethodData
    , false);
assert(AsmCilNode.associatedGrammar != nullptr);
AsmCilNode.setCppCondition("!defined(DOCUMENTATION)");
AsmCilNode.isBoostSerializable(true);
AsmCilNode.setAutomaticGenerationOfConstructor(false);
AsmCilNode.setAutomaticGenerationOfDestructor(false);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
AsmCilNode.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmCilNode: public SgAsmNode {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmCilNode);
#if defined(SgAsmCilNode_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmCilNode -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmCilNode");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmNode);
        debugSerializationEnd("SgAsmCilNode");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    virtual ~SgAsmCilNode();
 
protected:
    SgAsmCilNode();
 
protected:
    void initializeProperties();
#endif // SgAsmCilNode_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmCilNode: public SgAsmNode {…};
#endif // DOCUMENTATION
 
 
// SgAsmByteOrder           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmByteOrder);
IS_SERIALIZABLE(AsmByteOrder);
 
#ifndef DOCUMENTATION
AsmByteOrder.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmByteOrder);
#if defined(SgAsmByteOrder_HEADERS) || defined(DOCUMENTATION)
#include <Rose/BinaryAnalysis/ByteOrder.h>
#endif // SgAsmByteOrder_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmByteOrder: public SgAsmExpression {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmByteOrder);
#if defined(SgAsmByteOrder_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmByteOrder -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmByteOrder");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExpression);
        s & BOOST_SERIALIZATION_NVP(byteOrder_);
        debugSerializationEnd("SgAsmByteOrder");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
private:
    Rose::BinaryAnalysis::ByteOrder::Endianness byteOrder_;
 
public:
    Rose::BinaryAnalysis::ByteOrder::Endianness const& byteOrder() const;
    void byteOrder(Rose::BinaryAnalysis::ByteOrder::Endianness const&);
public:
    virtual ~SgAsmByteOrder();
 
public:
    SgAsmByteOrder();
 
public:
    explicit SgAsmByteOrder(Rose::BinaryAnalysis::ByteOrder::Endianness const& byteOrder);
 
protected:
    void initializeProperties();
#endif // SgAsmByteOrder_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmByteOrder: public SgAsmExpression {…};
#endif // DOCUMENTATION
 
 
// SgAsmBlock           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmBlock);
IS_SERIALIZABLE(AsmBlock);
 
#ifndef DOCUMENTATION
AsmBlock.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmBlock);
#if defined(SgAsmBlock_HEADERS) || defined(DOCUMENTATION)
#include <Rose/BinaryAnalysis/Address.h>
 
#include <sageContainer.h>
 
#ifdef ROSE_SgAsmBlock_IMPL
#include <SgAsmInstruction.h>                           // for SgAsmInstruction::INVALID_STACK_DELTA
#endif
#endif // SgAsmBlock_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmBlock: public SgAsmStatement {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmBlock.setDataPrototype(
        "Rose::BinaryAnalysis::Address", "id", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmBlock.setDataPrototype(
        "unsigned", "reason", "= SgAsmBlock::BLK_NONE",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmBlock.setDataPrototype(
        "SgAsmStatementPtrList", "statementList", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmBlock.setDataPrototype(
        "SgAsmIntegerValuePtrList", "successors", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmBlock.setDataPrototype(
        "bool", "successorsComplete", "= false",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmBlock.setDataPrototype(
        "SgAsmBlock*", "immediateDominator", "= nullptr",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmBlock.setDataPrototype(
        "size_t", "cachedVertex", "= (size_t)(-1)",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmBlock.setDataPrototype(
        "double", "codeLikelihood", "= 0.0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmBlock.setDataPrototype(
        "int64_t", "stackDeltaOut", "= SgAsmInstruction::INVALID_STACK_DELTA",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmBlock);
#if defined(SgAsmBlock_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmBlock -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmBlock");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmStatement);
        s & BOOST_SERIALIZATION_NVP(p_reason);
        s & BOOST_SERIALIZATION_NVP(p_statementList);
        s & BOOST_SERIALIZATION_NVP(p_successors);
        s & BOOST_SERIALIZATION_NVP(p_successorsComplete);
        s & BOOST_SERIALIZATION_NVP(p_immediateDominator);
        s & BOOST_SERIALIZATION_NVP(p_cachedVertex);
        s & BOOST_SERIALIZATION_NVP(p_codeLikelihood);
        s & BOOST_SERIALIZATION_NVP(p_stackDeltaOut);
        debugSerializationEnd("SgAsmBlock");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
    // Local types
public:
    enum Reason {
        // Please update SgAsmBlock::reasonString() if you change this enum!
        BLK_NONE        = 0x00000000,           
        BLK_ENTRY_POINT = 0x00010000,           
        BLK_PADDING     = 0x00020000,           
        BLK_FRAGMENT    = 0x00080000,           
        BLK_CFGHEAD     = 0x00100000,           
        BLK_USERDEF     = 0x00200000,           
        BLK_LEFTOVERS   = 0x00400000,           
        BLK_JUMPTABLE   = 0x00800000,           
        BLK_GRAPH1      = 0x01000000,           
        BLK_GRAPH2      = 0x02000000,           
        BLK_GRAPH3      = 0x04000000,           
        BLK_DEFAULT     = BLK_NONE,             //NO_STRINGIFY
 
        // ========= Miscellaneous Reasons ===========================================================================
        // The first half of the range (1-127, inclusive) is used for algorithms defined by ROSE.  The second half is
        // availalble for users to use as they see fit.
        BLK_MISCMASK    = 0x000000ff,           
        BLK_FINDDATA    = 0x00000001,           
        BLK_POSTFUNC    = 0x00000002            
    };
    enum Reason {…};
 
    // Properties
public:
 
    // FIXME[Robb Matzke 2023-03-18]: is the lack of serialization a bug?
public:
    Rose::BinaryAnalysis::Address const& get_id() const;
    void set_id(Rose::BinaryAnalysis::Address const&);
public:
    unsigned const& get_reason() const;
    void set_reason(unsigned const&);
    // statementList and successors should have been pointers to nodes that contain the list rather than being the lists
    // themselves because ROSETTA doesn't allow traversals on multiple list data members--we can traverse either one list or
    // the other, but not both.  It's too late to change how this part of the AST is structured because so much user code
    // already depends on it, therefore we can only traverse statementList and not successors. [Robb Matzke 2016-02-25]
public:
    SgAsmStatementPtrList const& get_statementList() const;
    SgAsmStatementPtrList& get_statementList();
    void set_statementList(SgAsmStatementPtrList const&);
    // statementList and successors should have been pointers to nodes that contain the list rather than being the lists
    // themselves because ROSETTA doesn't allow traversals on multiple list data members--we can traverse either one list or
    // the other, but not both.  It's too late to change how this part of the AST is structured because so much user code
    // already depends on it, therefore we can only traverse statementList and not successors. [Robb Matzke 2016-02-25]
public:
    SgAsmIntegerValuePtrList const& get_successors() const;
    SgAsmIntegerValuePtrList& get_successors();
    void set_successors(SgAsmIntegerValuePtrList const&);
public:
    bool const& get_successorsComplete() const;
    void set_successorsComplete(bool const&);
public:
    SgAsmBlock* const& get_immediateDominator() const;
    void set_immediateDominator(SgAsmBlock* const&);
public:
    size_t const& get_cachedVertex() const;
    void set_cachedVertex(size_t const&);
 // see BinaryAnalysis::ControlFlow
public:
    double const& get_codeLikelihood() const;
    void set_codeLikelihood(double const&);
public:
    int64_t const& get_stackDeltaOut() const;
    void set_stackDeltaOut(int64_t const&);
    // Functions
public:
    void appendStatement(SgAsmStatement*);
 
    void removeStatement(SgAsmStatement*);
 
    // FIXME[Robb P Matzke 2017-02-13]: wrong name -- erases only statements, not all children
    void removeChildren();
 
    Rose::BinaryAnalysis::Address get_fallthroughVa();
 
    SgAsmFunction *get_enclosingFunction() const;
 
    bool hasInstructions() const;
 
    bool isBasicBlock() const;
 
    bool isFunctionCall(Rose::BinaryAnalysis::Address &target_va/*out*/, Rose::BinaryAnalysis::Address &return_va/*out*/);
 
    static std::string reasonKey(const std::string &prefix = "");
 
    std::string reasonString(bool pad) const;
 
    static std::string reasonString(bool pad, unsigned reason);
 
    // Deprecated
 
    // [Robb Matzke 2023-11-06]: deprecated 2023-11
    bool get_successors_complete() const ROSE_DEPRECATED("use get_successorsComplete");
    void set_successors_complete(bool) ROSE_DEPRECATED("use get_successorsComplete");
    SgAsmBlock* get_immediate_dominator() const ROSE_DEPRECATED("use get_immediateDominator");
    void set_immediate_dominator(SgAsmBlock*) ROSE_DEPRECATED("use set_immediateDominator");
    size_t get_cached_vertex() const ROSE_DEPRECATED("use get_cachedVertex");
    void set_cached_vertex(size_t) ROSE_DEPRECATED("use set_cachedVertex");
    double get_code_likelihood() const ROSE_DEPRECATED("use get_codeLikelihood");
    void set_code_likelihood(double) ROSE_DEPRECATED("use set_codeLikelihood");
    void append_statement(SgAsmStatement*) ROSE_DEPRECATED("use appendStatement");
    void remove_statement(SgAsmStatement*) ROSE_DEPRECATED("use removeStatement");
    void remove_children() ROSE_DEPRECATED("use removeChildren");
    Rose::BinaryAnalysis::Address get_fallthrough_va() ROSE_DEPRECATED("use getFallthroughVa");
    SgAsmFunction* get_enclosing_function() const ROSE_DEPRECATED("use get_enclosingFunction");
    bool has_instructions() const ROSE_DEPRECATED("use hasInstructions");
    bool is_basic_block() const ROSE_DEPRECATED("use isBasicBlock");
    bool is_function_call(Rose::BinaryAnalysis::Address&, Rose::BinaryAnalysis::Address&) ROSE_DEPRECATED("use isFunctionCall");
    static std::string reason_key(const std::string& = "") ROSE_DEPRECATED("use reasonKey");
    std::string reason_str(bool) const ROSE_DEPRECATED("use reasonString");
    static std::string reason_str(bool, unsigned) ROSE_DEPRECATED("use reasonString");
public:
    virtual ~SgAsmBlock();
 
public:
    SgAsmBlock();
 
public:
    explicit SgAsmBlock(Rose::BinaryAnalysis::Address const& address);
 
protected:
    void initializeProperties();
#endif // SgAsmBlock_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmBlock: public SgAsmStatement {…};
#endif // DOCUMENTATION
 
 
// SgAsmBinarySubtract           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmBinarySubtract);
IS_SERIALIZABLE(AsmBinarySubtract);
 
#ifndef DOCUMENTATION
AsmBinarySubtract.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmBinarySubtract: public SgAsmBinaryExpression {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmBinarySubtract);
#if defined(SgAsmBinarySubtract_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmBinarySubtract -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmBinarySubtract");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmBinaryExpression);
        debugSerializationEnd("SgAsmBinarySubtract");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    virtual ~SgAsmBinarySubtract();
 
public:
    SgAsmBinarySubtract();
 
public:
    SgAsmBinarySubtract(SgAsmExpression* const& lhs,
                        SgAsmExpression* const& rhs);
 
protected:
    void initializeProperties();
#endif // SgAsmBinarySubtract_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmBinarySubtract: public SgAsmBinaryExpression {…};
#endif // DOCUMENTATION
 
 
// SgAsmBinaryRor           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmBinaryRor);
IS_SERIALIZABLE(AsmBinaryRor);
 
#ifndef DOCUMENTATION
AsmBinaryRor.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmBinaryRor: public SgAsmBinaryExpression {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmBinaryRor);
#if defined(SgAsmBinaryRor_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmBinaryRor -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmBinaryRor");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmBinaryExpression);
        debugSerializationEnd("SgAsmBinaryRor");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    virtual ~SgAsmBinaryRor();
 
public:
    SgAsmBinaryRor();
 
public:
    SgAsmBinaryRor(SgAsmExpression* const& lhs,
                   SgAsmExpression* const& rhs);
 
protected:
    void initializeProperties();
#endif // SgAsmBinaryRor_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmBinaryRor: public SgAsmBinaryExpression {…};
#endif // DOCUMENTATION
 
 
// SgAsmBinaryPreupdate           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmBinaryPreupdate);
IS_SERIALIZABLE(AsmBinaryPreupdate);
 
#ifndef DOCUMENTATION
AsmBinaryPreupdate.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmBinaryPreupdate: public SgAsmBinaryExpression {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmBinaryPreupdate);
#if defined(SgAsmBinaryPreupdate_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmBinaryPreupdate -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmBinaryPreupdate");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmBinaryExpression);
        debugSerializationEnd("SgAsmBinaryPreupdate");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    virtual ~SgAsmBinaryPreupdate();
 
public:
    SgAsmBinaryPreupdate();
 
public:
    SgAsmBinaryPreupdate(SgAsmExpression* const& lhs,
                         SgAsmExpression* const& rhs);
 
protected:
    void initializeProperties();
#endif // SgAsmBinaryPreupdate_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmBinaryPreupdate: public SgAsmBinaryExpression {…};
#endif // DOCUMENTATION
 
 
// SgAsmBinaryPostupdate           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmBinaryPostupdate);
IS_SERIALIZABLE(AsmBinaryPostupdate);
 
#ifndef DOCUMENTATION
AsmBinaryPostupdate.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmBinaryPostupdate: public SgAsmBinaryExpression {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmBinaryPostupdate);
#if defined(SgAsmBinaryPostupdate_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmBinaryPostupdate -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmBinaryPostupdate");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmBinaryExpression);
        debugSerializationEnd("SgAsmBinaryPostupdate");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    virtual ~SgAsmBinaryPostupdate();
 
public:
    SgAsmBinaryPostupdate();
 
public:
    SgAsmBinaryPostupdate(SgAsmExpression* const& lhs,
                          SgAsmExpression* const& rhs);
 
protected:
    void initializeProperties();
#endif // SgAsmBinaryPostupdate_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmBinaryPostupdate: public SgAsmBinaryExpression {…};
#endif // DOCUMENTATION
 
 
// SgAsmBinaryMultiply           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmBinaryMultiply);
IS_SERIALIZABLE(AsmBinaryMultiply);
 
#ifndef DOCUMENTATION
AsmBinaryMultiply.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmBinaryMultiply: public SgAsmBinaryExpression {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmBinaryMultiply);
#if defined(SgAsmBinaryMultiply_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmBinaryMultiply -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmBinaryMultiply");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmBinaryExpression);
        debugSerializationEnd("SgAsmBinaryMultiply");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    virtual ~SgAsmBinaryMultiply();
 
public:
    SgAsmBinaryMultiply();
 
public:
    SgAsmBinaryMultiply(SgAsmExpression* const& lhs,
                        SgAsmExpression* const& rhs);
 
protected:
    void initializeProperties();
#endif // SgAsmBinaryMultiply_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmBinaryMultiply: public SgAsmBinaryExpression {…};
#endif // DOCUMENTATION
 
 
// SgAsmBinaryMsl           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmBinaryMsl);
IS_SERIALIZABLE(AsmBinaryMsl);
 
#ifndef DOCUMENTATION
AsmBinaryMsl.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmBinaryMsl: public SgAsmBinaryExpression {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmBinaryMsl);
#if defined(SgAsmBinaryMsl_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmBinaryMsl -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmBinaryMsl");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmBinaryExpression);
        debugSerializationEnd("SgAsmBinaryMsl");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    virtual ~SgAsmBinaryMsl();
 
public:
    SgAsmBinaryMsl();
 
public:
    SgAsmBinaryMsl(SgAsmExpression* const& lhs,
                   SgAsmExpression* const& rhs);
 
protected:
    void initializeProperties();
#endif // SgAsmBinaryMsl_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmBinaryMsl: public SgAsmBinaryExpression {…};
#endif // DOCUMENTATION
 
 
// SgAsmBinaryMod           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmBinaryMod);
IS_SERIALIZABLE(AsmBinaryMod);
 
#ifndef DOCUMENTATION
AsmBinaryMod.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmBinaryMod: public SgAsmBinaryExpression {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmBinaryMod);
#if defined(SgAsmBinaryMod_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmBinaryMod -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmBinaryMod");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmBinaryExpression);
        debugSerializationEnd("SgAsmBinaryMod");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    virtual ~SgAsmBinaryMod();
 
public:
    SgAsmBinaryMod();
 
public:
    SgAsmBinaryMod(SgAsmExpression* const& lhs,
                   SgAsmExpression* const& rhs);
 
protected:
    void initializeProperties();
#endif // SgAsmBinaryMod_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmBinaryMod: public SgAsmBinaryExpression {…};
#endif // DOCUMENTATION
 
 
// SgAsmBinaryLsr           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmBinaryLsr);
IS_SERIALIZABLE(AsmBinaryLsr);
 
#ifndef DOCUMENTATION
AsmBinaryLsr.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmBinaryLsr: public SgAsmBinaryExpression {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmBinaryLsr);
#if defined(SgAsmBinaryLsr_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmBinaryLsr -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmBinaryLsr");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmBinaryExpression);
        debugSerializationEnd("SgAsmBinaryLsr");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    virtual ~SgAsmBinaryLsr();
 
public:
    SgAsmBinaryLsr();
 
public:
    SgAsmBinaryLsr(SgAsmExpression* const& lhs,
                   SgAsmExpression* const& rhs);
 
protected:
    void initializeProperties();
#endif // SgAsmBinaryLsr_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmBinaryLsr: public SgAsmBinaryExpression {…};
#endif // DOCUMENTATION
 
 
// SgAsmBinaryLsl           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmBinaryLsl);
IS_SERIALIZABLE(AsmBinaryLsl);
 
#ifndef DOCUMENTATION
AsmBinaryLsl.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmBinaryLsl: public SgAsmBinaryExpression {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmBinaryLsl);
#if defined(SgAsmBinaryLsl_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmBinaryLsl -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmBinaryLsl");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmBinaryExpression);
        debugSerializationEnd("SgAsmBinaryLsl");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    virtual ~SgAsmBinaryLsl();
 
public:
    SgAsmBinaryLsl();
 
public:
    SgAsmBinaryLsl(SgAsmExpression* const& lhs,
                   SgAsmExpression* const& rhs);
 
protected:
    void initializeProperties();
#endif // SgAsmBinaryLsl_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmBinaryLsl: public SgAsmBinaryExpression {…};
#endif // DOCUMENTATION
 
 
// SgAsmBinaryDivide           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmBinaryDivide);
IS_SERIALIZABLE(AsmBinaryDivide);
 
#ifndef DOCUMENTATION
AsmBinaryDivide.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmBinaryDivide: public SgAsmBinaryExpression {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmBinaryDivide);
#if defined(SgAsmBinaryDivide_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmBinaryDivide -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmBinaryDivide");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmBinaryExpression);
        debugSerializationEnd("SgAsmBinaryDivide");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    virtual ~SgAsmBinaryDivide();
 
public:
    SgAsmBinaryDivide();
 
public:
    SgAsmBinaryDivide(SgAsmExpression* const& lhs,
                      SgAsmExpression* const& rhs);
 
protected:
    void initializeProperties();
#endif // SgAsmBinaryDivide_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmBinaryDivide: public SgAsmBinaryExpression {…};
#endif // DOCUMENTATION
 
 
// SgAsmBinaryConcat           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmBinaryConcat);
IS_SERIALIZABLE(AsmBinaryConcat);
 
#ifndef DOCUMENTATION
AsmBinaryConcat.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmBinaryConcat: public SgAsmBinaryExpression {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmBinaryConcat);
#if defined(SgAsmBinaryConcat_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmBinaryConcat -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmBinaryConcat");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmBinaryExpression);
        debugSerializationEnd("SgAsmBinaryConcat");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    virtual ~SgAsmBinaryConcat();
 
public:
    SgAsmBinaryConcat();
 
public:
    SgAsmBinaryConcat(SgAsmExpression* const& lhs,
                      SgAsmExpression* const& rhs);
 
protected:
    void initializeProperties();
#endif // SgAsmBinaryConcat_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmBinaryConcat: public SgAsmBinaryExpression {…};
#endif // DOCUMENTATION
 
 
// SgAsmBinaryAsr           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmBinaryAsr);
IS_SERIALIZABLE(AsmBinaryAsr);
 
#ifndef DOCUMENTATION
AsmBinaryAsr.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmBinaryAsr: public SgAsmBinaryExpression {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmBinaryAsr);
#if defined(SgAsmBinaryAsr_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmBinaryAsr -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmBinaryAsr");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmBinaryExpression);
        debugSerializationEnd("SgAsmBinaryAsr");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    virtual ~SgAsmBinaryAsr();
 
public:
    SgAsmBinaryAsr();
 
public:
    SgAsmBinaryAsr(SgAsmExpression* const& lhs,
                   SgAsmExpression* const& rhs);
 
protected:
    void initializeProperties();
#endif // SgAsmBinaryAsr_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmBinaryAsr: public SgAsmBinaryExpression {…};
#endif // DOCUMENTATION
 
 
// SgAsmBinaryAdd           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmBinaryAdd);
IS_SERIALIZABLE(AsmBinaryAdd);
 
#ifndef DOCUMENTATION
AsmBinaryAdd.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmBinaryAdd: public SgAsmBinaryExpression {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmBinaryAdd);
#if defined(SgAsmBinaryAdd_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmBinaryAdd -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmBinaryAdd");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmBinaryExpression);
        debugSerializationEnd("SgAsmBinaryAdd");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
 
public:
    virtual ~SgAsmBinaryAdd();
 
public:
    SgAsmBinaryAdd();
 
public:
    SgAsmBinaryAdd(SgAsmExpression* const& lhs,
                   SgAsmExpression* const& rhs);
 
protected:
    void initializeProperties();
#endif // SgAsmBinaryAdd_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmBinaryAdd: public SgAsmBinaryExpression {…};
#endif // DOCUMENTATION
 
 
// SgAsmBinaryExpression           -- MACHINE GENERATED; DO NOT MODIFY --
 
#ifndef DOCUMENTATION
AstNodeClass& AsmBinaryExpression = nonTerminalConstructor(
    "AsmBinaryExpression",
    *this,
    "AsmBinaryExpression",
    "AsmBinaryExpressionTag",
    SubclassListBuilder()
        | AsmBinaryAdd
        | AsmBinaryAsr
        | AsmBinaryConcat
        | AsmBinaryDivide
        | AsmBinaryLsl
        | AsmBinaryLsr
        | AsmBinaryMod
        | AsmBinaryMsl
        | AsmBinaryMultiply
        | AsmBinaryPostupdate
        | AsmBinaryPreupdate
        | AsmBinaryRor
        | AsmBinarySubtract
    , false);
assert(AsmBinaryExpression.associatedGrammar != nullptr);
AsmBinaryExpression.setCppCondition("!defined(DOCUMENTATION)");
AsmBinaryExpression.isBoostSerializable(true);
AsmBinaryExpression.setAutomaticGenerationOfConstructor(false);
AsmBinaryExpression.setAutomaticGenerationOfDestructor(false);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
AsmBinaryExpression.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmBinaryExpression: public SgAsmExpression {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmBinaryExpression.setDataPrototype(
        "SgAsmExpression*", "lhs", "= nullptr",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmBinaryExpression.setDataPrototype(
        "SgAsmExpression*", "rhs", "= nullptr",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmBinaryExpression);
#if defined(SgAsmBinaryExpression_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmBinaryExpression -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmBinaryExpression");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExpression);
        s & BOOST_SERIALIZATION_NVP(p_lhs);
        s & BOOST_SERIALIZATION_NVP(p_rhs);
        debugSerializationEnd("SgAsmBinaryExpression");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgAsmExpression* const& get_lhs() const;
    void set_lhs(SgAsmExpression* const&);
public:
    SgAsmExpression* const& get_rhs() const;
    void set_rhs(SgAsmExpression* const&);
public:
    virtual ~SgAsmBinaryExpression();
 
protected:
    SgAsmBinaryExpression();
 
protected:
    SgAsmBinaryExpression(SgAsmExpression* const& lhs,
                          SgAsmExpression* const& rhs);
 
protected:
    void initializeProperties();
#endif // SgAsmBinaryExpression_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmBinaryExpression: public SgAsmExpression {…};
#endif // DOCUMENTATION
 
 
// SgAsmBasicString           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmBasicString);
IS_SERIALIZABLE(AsmBasicString);
 
#ifndef DOCUMENTATION
AsmBasicString.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmBasicString);
#if defined(SgAsmBasicString_HEADERS) || defined(DOCUMENTATION)
#include <Rose/BinaryAnalysis/Address.h>
#endif // SgAsmBasicString_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmBasicString: public SgAsmGenericString {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmBasicString.setDataPrototype(
        "std::string", "string", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmBasicString);
#if defined(SgAsmBasicString_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmBasicString -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmBasicString");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmGenericString);
        s & BOOST_SERIALIZATION_NVP(p_string);
        debugSerializationEnd("SgAsmBasicString");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    virtual std::string get_string(bool escape=false) const override;
    virtual void set_string(const std::string&) override;
    virtual void set_string(Rose::BinaryAnalysis::Address) override;
 
public:
    explicit SgAsmBasicString(const std::string&);
    explicit SgAsmBasicString(const char*);
    // Overrides documented in base class
    virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
public:
    virtual ~SgAsmBasicString();
 
public:
    SgAsmBasicString();
 
protected:
    void initializeProperties();
#endif // SgAsmBasicString_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmBasicString: public SgAsmGenericString {…};
#endif // DOCUMENTATION
 
 
// SgAsmGenericString           -- MACHINE GENERATED; DO NOT MODIFY --
 
#ifndef DOCUMENTATION
AstNodeClass& AsmGenericString = nonTerminalConstructor(
    "AsmGenericString",
    *this,
    "AsmGenericString",
    "AsmGenericStringTag",
    SubclassListBuilder()
        | AsmBasicString
        | AsmStoredString
    , false);
assert(AsmGenericString.associatedGrammar != nullptr);
AsmGenericString.setCppCondition("!defined(DOCUMENTATION)");
AsmGenericString.isBoostSerializable(true);
AsmGenericString.setAutomaticGenerationOfConstructor(false);
AsmGenericString.setAutomaticGenerationOfDestructor(false);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
AsmGenericString.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmGenericString);
#if defined(SgAsmGenericString_HEADERS) || defined(DOCUMENTATION)
#include <Rose/BinaryAnalysis/Address.h>
#endif // SgAsmGenericString_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmGenericString: public SgAsmExecutableFileFormat {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmGenericString);
#if defined(SgAsmGenericString_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmGenericString -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmGenericString");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
        debugSerializationEnd("SgAsmGenericString");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
    static const Rose::BinaryAnalysis::Address unallocated;
 
    virtual std::string get_string(bool escape=false) const;
    virtual void set_string(const std::string &s);
    virtual void set_string(Rose::BinaryAnalysis::Address);
    virtual Rose::BinaryAnalysis::Address get_offset() const {return unallocated;}
 
    virtual void dump(FILE*, const char *prefix, ssize_t idx) const;
public:
    virtual ~SgAsmGenericString();
 
protected:
    SgAsmGenericString();
 
protected:
    void initializeProperties();
#endif // SgAsmGenericString_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmGenericString: public SgAsmExecutableFileFormat {…};
#endif // DOCUMENTATION
 
 
// SgAsmExecutableFileFormat           -- MACHINE GENERATED; DO NOT MODIFY --
 
#ifndef DOCUMENTATION
AstNodeClass& AsmExecutableFileFormat = nonTerminalConstructor(
    "AsmExecutableFileFormat",
    *this,
    "AsmExecutableFileFormat",
    "AsmExecutableFileFormatTag",
    SubclassListBuilder()
        | AsmCoffSymbolList
        | AsmDwarfInformation
        | AsmElfDynamicEntry
        | AsmElfDynamicEntryList
        | AsmElfEHFrameEntryCI
        | AsmElfEHFrameEntryCIList
        | AsmElfEHFrameEntryFD
        | AsmElfEHFrameEntryFDList
        | AsmElfNoteEntry
        | AsmElfNoteEntryList
        | AsmElfRelocEntry
        | AsmElfRelocEntryList
        | AsmElfSectionTableEntry
        | AsmElfSegmentTableEntry
        | AsmElfSegmentTableEntryList
        | AsmElfSymbolList
        | AsmElfSymverDefinedAux
        | AsmElfSymverDefinedAuxList
        | AsmElfSymverDefinedEntry
        | AsmElfSymverDefinedEntryList
        | AsmElfSymverEntry
        | AsmElfSymverEntryList
        | AsmElfSymverNeededAux
        | AsmElfSymverNeededAuxList
        | AsmElfSymverNeededEntry
        | AsmElfSymverNeededEntryList
        | AsmGenericDLL
        | AsmGenericDLLList
        | AsmGenericFile
        | AsmGenericFormat
        | AsmGenericHeaderList
        | AsmGenericSection
        | AsmGenericSectionList
        | AsmGenericString
        | AsmGenericStrtab
        | AsmGenericSymbol
        | AsmGenericSymbolList
        | AsmLEEntryPoint
        | AsmLEPageTableEntry
        | AsmLESectionTableEntry
        | AsmNEEntryPoint
        | AsmNERelocEntry
        | AsmNESectionTableEntry
        | AsmPEExportDirectory
        | AsmPEExportEntry
        | AsmPEExportEntryList
        | AsmPEImportDirectory
        | AsmPEImportDirectoryList
        | AsmPEImportItem
        | AsmPEImportItemList
        | AsmPERVASizePair
        | AsmPERVASizePairList
        | AsmPESectionTableEntry
        | AsmStringStorage
    , false);
assert(AsmExecutableFileFormat.associatedGrammar != nullptr);
AsmExecutableFileFormat.setCppCondition("!defined(DOCUMENTATION)");
AsmExecutableFileFormat.isBoostSerializable(true);
AsmExecutableFileFormat.setAutomaticGenerationOfConstructor(false);
AsmExecutableFileFormat.setAutomaticGenerationOfDestructor(false);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
AsmExecutableFileFormat.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmExecutableFileFormat);
#if defined(SgAsmExecutableFileFormat_HEADERS) || defined(DOCUMENTATION)
#include <Rose/BinaryAnalysis/Address.h>
#include <Rose/Exception.h>
#endif // SgAsmExecutableFileFormat_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmExecutableFileFormat: public SgAsmNode {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmExecutableFileFormat);
#if defined(SgAsmExecutableFileFormat_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmExecutableFileFormat -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmExecutableFileFormat");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmNode);
        debugSerializationEnd("SgAsmExecutableFileFormat");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
    // Local types
public:
    class ShortRead: public Rose::Exception {
    public:
        const SgAsmGenericSection *section;         
        Rose::BinaryAnalysis::Address offset;       
        Rose::BinaryAnalysis::Address size;         
        ShortRead(const class SgAsmGenericSection *section, size_t offset, size_t size)
            : Rose::Exception("short read"), section(section), offset(offset), size(size) {}
        ShortRead(const class SgAsmGenericSection *section, size_t offset, size_t size, const std::string &mesg)
            : Rose::Exception(mesg), section(section), offset(offset), size(size) {}
        ShortRead(const class SgAsmGenericSection *section, size_t offset, size_t size, const char *mesg)
            : Rose::Exception(mesg), section(section), offset(offset), size(size) {}
        ~ShortRead() throw () {}
    };
    class ShortRead: public Rose::Exception {…};
 
    class ShortWrite: public Rose::Exception {
    public:
        const SgAsmGenericSection *section;         
        Rose::BinaryAnalysis::Address offset;       
        Rose::BinaryAnalysis::Address size;         
        ShortWrite(const class SgAsmGenericSection *section, size_t offset, size_t size)
            : Rose::Exception(""), section(section), offset(offset), size(size) {}
        ShortWrite(const class SgAsmGenericSection *section, size_t offset, size_t size, const std::string &mesg)
            : Rose::Exception(mesg), section(section), offset(offset), size(size) {}
        ShortWrite(const class SgAsmGenericSection *section, size_t offset, size_t size, const char *mesg)
            : Rose::Exception(mesg), section(section), offset(offset), size(size) {}
    };
    class ShortWrite: public Rose::Exception {…};
 
    class FormatError: public Rose::Exception {
    public:
        FormatError(const std::string &mesg)
            : Rose::Exception(mesg) {}
        FormatError(const char *mesg)
            : Rose::Exception(mesg) {}
        ~FormatError() throw () {}
    };
    class FormatError: public Rose::Exception {…};
 
    typedef struct stat fileDetails;
 
    enum ExecFamily {
        FAMILY_UNSPECIFIED,                         
        FAMILY_DOS,                                 
        FAMILY_ELF,                                 
        FAMILY_JVM,                                 
        FAMILY_LE,                                  
        FAMILY_LX,                                  
        FAMILY_NE,                                  
        FAMILY_PE                                   
    };
    enum ExecFamily {…};
 
    enum ExecABI {
        ABI_UNSPECIFIED,                            
        ABI_OTHER,                                  
        ABI_86OPEN,                                 
        ABI_AIX,                                    
        ABI_ARM,                                    
        ABI_FREEBSD,                                
        ABI_HPUX,                                   
        ABI_IRIX,                                   
        ABI_HURD,                                   
        ABI_JVM,                                    
        ABI_LINUX,                                  
        ABI_MODESTO,                                
        ABI_MONTEREY,                               
        ABI_MSDOS,                                  
        ABI_NT,                                     
        ABI_NETBSD,                                 
        ABI_OS2,                                    
        ABI_SOLARIS,                                
        ABI_SYSV,                                   
        ABI_TRU64,                                  
        ABI_WIN386                                  
    };
    enum ExecABI {…};
 
    enum InsSetArchitecture {
        ISA_UNSPECIFIED             = 0x0000,       
        ISA_OTHER                   = 0xffff,       
        ISA_FAMILY_MASK             = 0xff00,       
        ISA_IA32_Family             = 0x0100,       
        ISA_IA32_286                = 0x0101,       
        ISA_IA32_386                = 0x0102,       
        ISA_IA32_486                = 0x0103,       
        ISA_IA32_Pentium            = 0x0104,       
        ISA_IA32_Cyrix6x86          = 0x0105,       
        ISA_IA32_AMDK5              = 0x0106,       
        ISA_IA32_PentiumPro         = 0x0107,       
        ISA_IA32_PentiumII          = 0x0108,       
        ISA_IA32_Athlon             = 0x0109,       
        ISA_IA32_Pentium4           = 0x010a,       
        ISA_IA32_PentiumM           = 0x010b,       
        ISA_X8664_Family            = 0x0200,       
        ISA_X8664_Athlon64          = 0x0201,       
        ISA_X8664_Prescott          = 0x0202,       
        ISA_X8664_IntelCore         = 0x0203,       
        ISA_X8664_AMDPhenom         = 0x0204,       
        ISA_SPARC_Family            = 0x0300,       
        ISA_SPARC_V7                = 0x0301,
        ISA_SPARC_V8                = 0x0302,
        ISA_SPARC_V8E               = 0x0303,
        ISA_SPARC_V9                = 0x0304,
        ISA_SPARC_V9JPS1            = 0x0305,
        ISA_SPARC_V9UA              = 0x0306,
        ISA_SPARC_V9JPS2            = 0x0307,
 
        ISA_M68K_Family             = 0x0400,       
        ISA_M68K_68000              = 0x0401,       
        ISA_M68K_68EC000            = 0x0402,
        ISA_M68K_68HC000            = 0x0403,
        ISA_M68K_68008              = 0x0404,
        ISA_M68K_68010              = 0x0405,
        ISA_M68K_68012              = 0x0406,
        ISA_M68K_68020              = 0x0407,       
        ISA_M68K_68EC020            = 0x0408,
        ISA_M68K_68030              = 0x0409,
        ISA_M68K_68EC030            = 0x040a,
        ISA_M68K_68040              = 0x040b,       
        ISA_M68K_68EC040            = 0x040c,
        ISA_M68K_68LC040            = 0x040d,
        ISA_M68K_68060              = 0x040e,       
        ISA_M68K_ColdFire           = 0x040f,       
        ISA_M68K_DragonBall         = 0x0410,       
        ISA_M88K_Family             = 0x0500,       
        ISA_M88K_88100              = 0x0501,       
        ISA_M88K_88110              = 0x0502,       
        ISA_M88K_88110MP            = 0x0503,       
        ISA_M88K_88120              = 0x0504,       
        ISA_MIPS_Family             = 0x0600,       
        ISA_MIPS_MarkI              = 0x0601,       
        ISA_MIPS_MarkII             = 0x0602,       
        ISA_MIPS_MarkIII            = 0x0603,       
        ISA_MIPS_R2000              = 0x0604,       
        ISA_MIPS_R3000              = 0x0605,       
        ISA_MIPS_R4000              = 0x0606,       
        ISA_MIPS_R4200              = 0x0607,       
        ISA_MIPS_R4300              = 0x0608,       
        ISA_MIPS_R4600              = 0x0609,       
        ISA_MIPS_R4650              = 0x060a,       
        ISA_MIPS_R4700              = 0x060b,       
        ISA_MIPS_R5000              = 0x060c,       
        ISA_MIPS_RM7000             = 0x060d,       
        ISA_MIPS_R8000              = 0x060e,       
        ISA_MIPS_R10000             = 0x060f,       
        ISA_MIPS_R12000             = 0x0610,       
        ISA_MIPS_R14000             = 0x0611,       
        ISA_MIPS_R16000             = 0x0612,       
        ISA_MIPS_R16000A            = 0x0613,
        ISA_MIPS_16                 = 0x0614,       
        ISA_MIPS_FPU                = 0x0615,       
        ISA_MIPS_16FPU              = 0x0616,       
        ISA_I860_Family             = 0x0700,       
        ISA_I860_860XR              = 0x0701,       
        ISA_I860_860XP              = 0x0702,       
        ISA_IA64_Family             = 0x0800,       
        ISA_IA64_Itanium            = 0x0801,       
        ISA_IA64_Itanium2           = 0x0802,       
        // See http://en.wikipedia.org/wiki/ARM_architecture
        ISA_ARM_Family              = 0x0900,       
        ISA_ARM_ARM1                = 0x0901,       
        ISA_ARM_ARM2                = 0x0902,       
        ISA_ARM_ARM3                = 0x0903,       
        ISA_ARM_ARM6                = 0x0904,       
        ISA_ARM_ARM7                = 0x0905,       
        ISA_ARM_ARM7TDMI            = 0x0906,       
        ISA_ARM_StrongARM           = 0x0907,       
        ISA_ARM_ARM8                = 0x0908,       
        ISA_ARM_ARM9TDMI            = 0x0909,       
        ISA_ARM_ARM9E               = 0x090a,       
        ISA_ARM_ARM10E              = 0x090b,       
        ISA_ARM_XScale              = 0x090c,       
        ISA_ARM_ARM11               = 0x090d,       
        ISA_ARM_Cortex              = 0x090e,       
        ISA_ARM_A64                 = 0x090f,       
        ISA_JVM                     = 0x0a00,       
        // Others, not yet incorporated into this enum
        ISA_OTHER_Family            = 0xf000,
 
        ISA_ATT_WE_32100            = 0xf001,       
        ISA_IBM_System_370          = 0xf002,
        ISA_HPPA                    = 0xf003,
        ISA_Fujitsu_VPP500          = 0xf004,
        ISA_Sun_v8plus              = 0xf005,
        ISA_PowerPC                 = 0xf006,
        ISA_PowerPC_64bit           = 0xf007,
        ISA_IBM_S390                = 0xf008,
        ISA_NEC_V800_series         = 0xf009,
        ISA_Fujitsu_FR20            = 0xf00a,
        ISA_TRW_RH_32               = 0xf00b,
        ISA_Motorola_RCE            = 0xf00c,
        ISA_Digital_Alpha_fake      = 0xf00e,
        ISA_Hitachi_SH              = 0xf00f,
        ISA_Siemens_Tricore         = 0xf010,
        ISA_Argonaut_RISC_Core      = 0xf011,
        ISA_Hitachi_H8_300          = 0xf012,
        ISA_Hitachi_H8_300H         = 0xf013,
        ISA_Hitachi_H8S             = 0xf014,
        ISA_Hitachi_H8_500          = 0xf015,
        ISA_Stanford_MIPS_X         = 0xf016,
        ISA_Motorola_M68HC12        = 0xf017,
        ISA_Fujitsu_MMA_Multimedia_Accelerator=0xf018,
        ISA_Siemens_PCP             = 0xf019,
        ISA_Sony_nCPU_embeeded_RISC = 0xf01a,
        ISA_Denso_NDR1_microprocessor=0xf01b,
        ISA_Motorola_Start_Core_processor=0xf01c,
        ISA_Toyota_ME16_processor   = 0xf01d,
        ISA_STMicroelectronic_ST100_processor=0xf01e,
        ISA_Advanced_Logic_Corp_Tinyj_emb_family=0xf01f,
        ISA_AMD_x86_64_architecture = 0xf020,
        ISA_Sony_DSP_Processor      = 0xf021,
        ISA_Siemens_FX66_microcontroller=0xf022,
        ISA_STMicroelectronics_ST9_plus_8_16_microcontroller=0xf023,
        ISA_STMicroelectronics_ST7_8bit_microcontroller=0xf024,
        ISA_Motorola_MC68HC16_microcontroller=0xf025,
        ISA_Motorola_MC68HC11_microcontroller=0xf026,
        ISA_Motorola_MC68HC08_microcontroller=0xf027,
        ISA_Motorola_MC68HC05_microcontroller=0xf028,
        ISA_Silicon_Graphics_SVx    = 0xf029,
        ISA_STMicroelectronics_ST19_8bit_microcontroller=0xf02a,
        ISA_Digital_VAX             = 0xf02b,
        ISA_Axis_Communications_32bit_embedded_processor=0xf02c,
        ISA_Infineon_Technologies_32bit_embedded_processor=0xf02d,
        ISA_Element_14_64bit_DSP_Processor=0xf02e,
        ISA_LSI_Logic_16bit_DSP_Processor=0xf02f,
        ISA_Donald_Knuths_educational_64bit_processor=0xf030,
        ISA_Harvard_University_machine_independent_object_files=0xf031,
        ISA_SiTera_Prism            = 0xf032,
        ISA_Atmel_AVR_8bit_microcontroller=0xf033,
        ISA_Fujitsu_FR30            = 0xf034,
        ISA_Mitsubishi_D10V         = 0xf035,
        ISA_Mitsubishi_D30V         = 0xf036,
        ISA_NEC_v850                = 0xf037,
        ISA_Mitsubishi_M32R         = 0xf038,
        ISA_Matsushita_MN10300      = 0xf039,
        ISA_Matsushita_MN10200      = 0xf03a,
        ISA_picoJava                = 0xf03b,
        ISA_OpenRISC_32bit_embedded_processor=0xf03c,
        ISA_ARC_Cores_Tangent_A5    = 0xf03d,
        ISA_Tensilica_Xtensa_Architecture=0xf03e,
        ISA_Digital_Alpha         = 0xf03f,
        ISA_Matsushita_AM33         = 0xf040,
        ISA_EFI_ByteCode            = 0xf041
    };
    enum InsSetArchitecture {…};
 
    enum ExecPurpose {
        PURPOSE_UNSPECIFIED,                        
        PURPOSE_OTHER,                              
        PURPOSE_EXECUTABLE,                         
        PURPOSE_LIBRARY,                            
        PURPOSE_CORE_DUMP,                          
        PURPOSE_OS_SPECIFIC,                        
        PURPOSE_PROC_SPECIFIC                       
    };
    enum ExecPurpose {…};
 
    // Functions
public:
    static SgAsmGenericFile *parseBinaryFormat(const char *name);
 
    static void unparseBinaryFormat(const std::string &name, SgAsmGenericFile*);
 
    static void unparseBinaryFormat(std::ostream&, SgAsmGenericFile*);
 
    static Sawyer::Message::Facility mlog;
 
    static void initDiagnostics();
 
    // These convert enums to strings. It is better to use the automatic enum stringification instead. They have names like
    // Rose::stringifySgAsmExecutableFileFormatInsnSetArchitecture, etc. */
    static std::string isaFamilyToString(SgAsmExecutableFileFormat::InsSetArchitecture);
    static std::string isaToString(SgAsmExecutableFileFormat::InsSetArchitecture);
    static std::string toString(SgAsmExecutableFileFormat::InsSetArchitecture);
    static std::string toString(SgAsmExecutableFileFormat::ExecFamily);
    static std::string toString(SgAsmExecutableFileFormat::ExecABI);
    static std::string toString(SgAsmExecutableFileFormat::ExecPurpose);
 
    // Deprecated 2023-11
public:
    static std::string isa_family_to_string(SgAsmExecutableFileFormat::InsSetArchitecture) ROSE_DEPRECATED("use isaFamilyToString");
    static std::string isa_to_string(SgAsmExecutableFileFormat::InsSetArchitecture) ROSE_DEPRECATED("use isaToString");
    static std::string to_string(SgAsmExecutableFileFormat::InsSetArchitecture) ROSE_DEPRECATED("use toString");
    static std::string to_string(SgAsmExecutableFileFormat::ExecFamily) ROSE_DEPRECATED("use toString");
    static std::string to_string(SgAsmExecutableFileFormat::ExecABI) ROSE_DEPRECATED("use toString");
    static std::string to_string(SgAsmExecutableFileFormat::ExecPurpose) ROSE_DEPRECATED("use toString");
public:
    virtual ~SgAsmExecutableFileFormat();
 
protected:
    SgAsmExecutableFileFormat();
 
protected:
    void initializeProperties();
#endif // SgAsmExecutableFileFormat_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmExecutableFileFormat: public SgAsmNode {…};
#endif // DOCUMENTATION
 
 
// SgAsmAarch64SysMoveOperand           -- MACHINE GENERATED; DO NOT MODIFY --
 
#ifdef ROSE_ENABLE_ASM_AARCH64
DECLARE_LEAF_CLASS(AsmAarch64SysMoveOperand);
IS_SERIALIZABLE(AsmAarch64SysMoveOperand);
 
#ifndef DOCUMENTATION
AsmAarch64SysMoveOperand.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmAarch64SysMoveOperand);
#if defined(SgAsmAarch64SysMoveOperand_HEADERS) || defined(DOCUMENTATION)
#ifdef ROSE_ENABLE_ASM_AARCH64
#endif
#endif // SgAsmAarch64SysMoveOperand_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmAarch64SysMoveOperand: public SgAsmExpression {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmAarch64SysMoveOperand);
#if defined(SgAsmAarch64SysMoveOperand_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmAarch64SysMoveOperand -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmAarch64SysMoveOperand");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExpression);
        s & BOOST_SERIALIZATION_NVP(access_);
        debugSerializationEnd("SgAsmAarch64SysMoveOperand");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
private:
    unsigned access_;
 
public:
    unsigned const& access() const;
    void access(unsigned const&);
public:
    virtual ~SgAsmAarch64SysMoveOperand();
 
public:
    SgAsmAarch64SysMoveOperand();
 
public:
    explicit SgAsmAarch64SysMoveOperand(unsigned const& access);
 
protected:
    void initializeProperties();
#endif // SgAsmAarch64SysMoveOperand_OTHERS
#ifdef DOCUMENTATION
};
#endif // DOCUMENTATION
#endif
 
 
// SgAsmAarch64PState           -- MACHINE GENERATED; DO NOT MODIFY --
 
#ifdef ROSE_ENABLE_ASM_AARCH64
DECLARE_LEAF_CLASS(AsmAarch64PState);
IS_SERIALIZABLE(AsmAarch64PState);
 
#ifndef DOCUMENTATION
AsmAarch64PState.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmAarch64PState);
#if defined(SgAsmAarch64PState_HEADERS) || defined(DOCUMENTATION)
#ifdef ROSE_ENABLE_ASM_AARCH64
 
#include <Rose/BinaryAnalysis/InstructionEnumsAarch64.h>
#endif
#endif // SgAsmAarch64PState_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmAarch64PState: public SgAsmExpression {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmAarch64PState);
#if defined(SgAsmAarch64PState_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmAarch64PState -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmAarch64PState");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExpression);
        s & BOOST_SERIALIZATION_NVP(pstate_);
        debugSerializationEnd("SgAsmAarch64PState");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
private:
    Rose::BinaryAnalysis::Aarch64PState pstate_;
 
public:
    Rose::BinaryAnalysis::Aarch64PState const& pstate() const;
    void pstate(Rose::BinaryAnalysis::Aarch64PState const&);
public:
    virtual ~SgAsmAarch64PState();
 
public:
    SgAsmAarch64PState();
 
public:
    explicit SgAsmAarch64PState(Rose::BinaryAnalysis::Aarch64PState const& pstate);
 
protected:
    void initializeProperties();
#endif // SgAsmAarch64PState_OTHERS
#ifdef DOCUMENTATION
};
#endif // DOCUMENTATION
#endif
 
 
// SgAsmAarch64PrefetchOperand           -- MACHINE GENERATED; DO NOT MODIFY --
 
#ifdef ROSE_ENABLE_ASM_AARCH64
DECLARE_LEAF_CLASS(AsmAarch64PrefetchOperand);
IS_SERIALIZABLE(AsmAarch64PrefetchOperand);
 
#ifndef DOCUMENTATION
AsmAarch64PrefetchOperand.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmAarch64PrefetchOperand);
#if defined(SgAsmAarch64PrefetchOperand_HEADERS) || defined(DOCUMENTATION)
#ifdef ROSE_ENABLE_ASM_AARCH64
 
#include <Rose/BinaryAnalysis/InstructionEnumsAarch64.h>
#endif
#endif // SgAsmAarch64PrefetchOperand_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmAarch64PrefetchOperand: public SgAsmExpression {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmAarch64PrefetchOperand);
#if defined(SgAsmAarch64PrefetchOperand_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmAarch64PrefetchOperand -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmAarch64PrefetchOperand");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExpression);
        s & BOOST_SERIALIZATION_NVP(operation_);
        debugSerializationEnd("SgAsmAarch64PrefetchOperand");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
private:
    Rose::BinaryAnalysis::Aarch64PrefetchOperation operation_;
 
public:
    Rose::BinaryAnalysis::Aarch64PrefetchOperation const& operation() const;
    void operation(Rose::BinaryAnalysis::Aarch64PrefetchOperation const&);
public:
    virtual ~SgAsmAarch64PrefetchOperand();
 
public:
    SgAsmAarch64PrefetchOperand();
 
public:
    explicit SgAsmAarch64PrefetchOperand(Rose::BinaryAnalysis::Aarch64PrefetchOperation const& operation);
 
protected:
    void initializeProperties();
#endif // SgAsmAarch64PrefetchOperand_OTHERS
#ifdef DOCUMENTATION
};
#endif // DOCUMENTATION
#endif
 
 
// SgAsmAarch64Instruction           -- MACHINE GENERATED; DO NOT MODIFY --
 
#ifdef ROSE_ENABLE_ASM_AARCH64
DECLARE_LEAF_CLASS(AsmAarch64Instruction);
IS_SERIALIZABLE(AsmAarch64Instruction);
 
#ifndef DOCUMENTATION
AsmAarch64Instruction.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmAarch64Instruction);
#if defined(SgAsmAarch64Instruction_HEADERS) || defined(DOCUMENTATION)
#ifdef ROSE_ENABLE_ASM_AARCH64
#include <Rose/BinaryAnalysis/InstructionEnumsAarch64.h>
#endif
#endif // SgAsmAarch64Instruction_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmAarch64Instruction: public SgAsmInstruction {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmAarch64Instruction.setDataPrototype(
        "Rose::BinaryAnalysis::Aarch64InstructionKind", "kind", "= Rose::BinaryAnalysis::Aarch64InstructionKind::ARM64_INS_INVALID",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmAarch64Instruction.setDataPrototype(
        "Rose::BinaryAnalysis::Aarch64InstructionCondition", "condition", "= Rose::BinaryAnalysis::Aarch64InstructionCondition::ARM64_CC_INVALID",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmAarch64Instruction.setDataPrototype(
        "bool", "updatesFlags", "= false",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmAarch64Instruction);
#if defined(SgAsmAarch64Instruction_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmAarch64Instruction -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmAarch64Instruction");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmInstruction);
        s & BOOST_SERIALIZATION_NVP(p_kind);
        s & BOOST_SERIALIZATION_NVP(p_condition);
        debugSerializationEnd("SgAsmAarch64Instruction");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    Rose::BinaryAnalysis::Aarch64InstructionKind const& get_kind() const;
    void set_kind(Rose::BinaryAnalysis::Aarch64InstructionKind const&);
public:
    Rose::BinaryAnalysis::Aarch64InstructionCondition const& get_condition() const;
    void set_condition(Rose::BinaryAnalysis::Aarch64InstructionCondition const&);
    // FIXME[Robb Matzke 2023-03-18]: is the lack of serialization a bug?
public:
    bool const& get_updatesFlags() const;
    void set_updatesFlags(bool const&);
public:
    // Overrides are documented in the base class
    virtual unsigned get_anyKind() const override;
public:
    virtual ~SgAsmAarch64Instruction();
 
public:
    SgAsmAarch64Instruction();
 
public:
    SgAsmAarch64Instruction(Rose::BinaryAnalysis::Address const& address,
                            uint8_t const& architectureId,
                            Rose::BinaryAnalysis::Aarch64InstructionKind const& kind,
                            Rose::BinaryAnalysis::Aarch64InstructionCondition const& condition);
 
protected:
    void initializeProperties();
#endif // SgAsmAarch64Instruction_OTHERS
#ifdef DOCUMENTATION
};
#endif // DOCUMENTATION
#endif
 
 
// SgAsmAarch64CImmediateOperand           -- MACHINE GENERATED; DO NOT MODIFY --
 
#ifdef ROSE_ENABLE_ASM_AARCH64
DECLARE_LEAF_CLASS(AsmAarch64CImmediateOperand);
IS_SERIALIZABLE(AsmAarch64CImmediateOperand);
 
#ifndef DOCUMENTATION
AsmAarch64CImmediateOperand.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmAarch64CImmediateOperand);
#if defined(SgAsmAarch64CImmediateOperand_HEADERS) || defined(DOCUMENTATION)
#ifdef ROSE_ENABLE_ASM_AARCH64
#endif
#endif // SgAsmAarch64CImmediateOperand_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmAarch64CImmediateOperand: public SgAsmExpression {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmAarch64CImmediateOperand);
#if defined(SgAsmAarch64CImmediateOperand_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmAarch64CImmediateOperand -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmAarch64CImmediateOperand");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExpression);
        s & BOOST_SERIALIZATION_NVP(immediate_);
        debugSerializationEnd("SgAsmAarch64CImmediateOperand");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
private:
    unsigned immediate_;
 
public:
    unsigned const& immediate() const;
    void immediate(unsigned const&);
public:
    virtual ~SgAsmAarch64CImmediateOperand();
 
public:
    SgAsmAarch64CImmediateOperand();
 
public:
    explicit SgAsmAarch64CImmediateOperand(unsigned const& immediate);
 
protected:
    void initializeProperties();
#endif // SgAsmAarch64CImmediateOperand_OTHERS
#ifdef DOCUMENTATION
};
#endif // DOCUMENTATION
#endif
 
 
// SgAsmAarch64BarrierOperand           -- MACHINE GENERATED; DO NOT MODIFY --
 
#ifdef ROSE_ENABLE_ASM_AARCH64
DECLARE_LEAF_CLASS(AsmAarch64BarrierOperand);
IS_SERIALIZABLE(AsmAarch64BarrierOperand);
 
#ifndef DOCUMENTATION
AsmAarch64BarrierOperand.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmAarch64BarrierOperand);
#if defined(SgAsmAarch64BarrierOperand_HEADERS) || defined(DOCUMENTATION)
#ifdef ROSE_ENABLE_ASM_AARCH64
 
#include <Rose/BinaryAnalysis/InstructionEnumsAarch64.h>
#endif
#endif // SgAsmAarch64BarrierOperand_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmAarch64BarrierOperand: public SgAsmExpression {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmAarch64BarrierOperand);
#if defined(SgAsmAarch64BarrierOperand_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmAarch64BarrierOperand -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmAarch64BarrierOperand");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExpression);
        s & BOOST_SERIALIZATION_NVP(operation_);
        debugSerializationEnd("SgAsmAarch64BarrierOperand");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
private:
    Rose::BinaryAnalysis::Aarch64BarrierOperation operation_;
 
public:
    Rose::BinaryAnalysis::Aarch64BarrierOperation const& operation() const;
    void operation(Rose::BinaryAnalysis::Aarch64BarrierOperation const&);
public:
    virtual ~SgAsmAarch64BarrierOperand();
 
public:
    SgAsmAarch64BarrierOperand();
 
public:
    explicit SgAsmAarch64BarrierOperand(Rose::BinaryAnalysis::Aarch64BarrierOperation const& operation);
 
protected:
    void initializeProperties();
#endif // SgAsmAarch64BarrierOperand_OTHERS
#ifdef DOCUMENTATION
};
#endif // DOCUMENTATION
#endif
 
 
// SgAsmAarch64AtOperand           -- MACHINE GENERATED; DO NOT MODIFY --
 
#ifdef ROSE_ENABLE_ASM_AARCH64
DECLARE_LEAF_CLASS(AsmAarch64AtOperand);
IS_SERIALIZABLE(AsmAarch64AtOperand);
 
#ifndef DOCUMENTATION
AsmAarch64AtOperand.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmAarch64AtOperand);
#if defined(SgAsmAarch64AtOperand_HEADERS) || defined(DOCUMENTATION)
#ifdef ROSE_ENABLE_ASM_AARCH64
 
#include <Rose/BinaryAnalysis/InstructionEnumsAarch64.h>
#endif
#endif // SgAsmAarch64AtOperand_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmAarch64AtOperand: public SgAsmExpression {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmAarch64AtOperand);
#if defined(SgAsmAarch64AtOperand_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmAarch64AtOperand -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmAarch64AtOperand");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExpression);
        s & BOOST_SERIALIZATION_NVP(operation_);
        debugSerializationEnd("SgAsmAarch64AtOperand");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
private:
    Rose::BinaryAnalysis::Aarch64AtOperation operation_;
 
public:
    Rose::BinaryAnalysis::Aarch64AtOperation const& operation() const;
    void operation(Rose::BinaryAnalysis::Aarch64AtOperation const&);
public:
    virtual ~SgAsmAarch64AtOperand();
 
public:
    SgAsmAarch64AtOperand();
 
public:
    explicit SgAsmAarch64AtOperand(Rose::BinaryAnalysis::Aarch64AtOperation const& operation);
 
protected:
    void initializeProperties();
#endif // SgAsmAarch64AtOperand_OTHERS
#ifdef DOCUMENTATION
};
#endif // DOCUMENTATION
#endif
 
 
// SgAsmAarch32Instruction           -- MACHINE GENERATED; DO NOT MODIFY --
 
#ifdef ROSE_ENABLE_ASM_AARCH32
DECLARE_LEAF_CLASS(AsmAarch32Instruction);
IS_SERIALIZABLE(AsmAarch32Instruction);
 
#ifndef DOCUMENTATION
AsmAarch32Instruction.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmAarch32Instruction);
#if defined(SgAsmAarch32Instruction_HEADERS) || defined(DOCUMENTATION)
#ifdef ROSE_ENABLE_ASM_AARCH32
#include <Rose/BinaryAnalysis/InstructionEnumsAarch32.h>
#endif
#endif // SgAsmAarch32Instruction_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmAarch32Instruction: public SgAsmInstruction {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmAarch32Instruction.setDataPrototype(
        "Rose::BinaryAnalysis::Aarch32InstructionKind", "kind", "= Rose::BinaryAnalysis::Aarch32InstructionKind::ARM_INS_INVALID",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmAarch32Instruction.setDataPrototype(
        "Rose::BinaryAnalysis::Aarch32InstructionCondition", "condition", "= Rose::BinaryAnalysis::Aarch32InstructionCondition::ARM_CC_INVALID",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmAarch32Instruction.setDataPrototype(
        "bool", "updatesFlags", "= false",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmAarch32Instruction.setDataPrototype(
        "bool", "writesBack", "= false",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmAarch32Instruction.setDataPrototype(
        "bool", "writesToIp", "= false",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmAarch32Instruction);
#if defined(SgAsmAarch32Instruction_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmAarch32Instruction -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmAarch32Instruction");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmInstruction);
        s & BOOST_SERIALIZATION_NVP(p_kind);
        s & BOOST_SERIALIZATION_NVP(p_condition);
        s & BOOST_SERIALIZATION_NVP(p_updatesFlags);
        s & BOOST_SERIALIZATION_NVP(p_writesBack);
        s & BOOST_SERIALIZATION_NVP(p_writesToIp);
        debugSerializationEnd("SgAsmAarch32Instruction");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    Rose::BinaryAnalysis::Aarch32InstructionKind const& get_kind() const;
    void set_kind(Rose::BinaryAnalysis::Aarch32InstructionKind const&);
public:
    Rose::BinaryAnalysis::Aarch32InstructionCondition const& get_condition() const;
    void set_condition(Rose::BinaryAnalysis::Aarch32InstructionCondition const&);
public:
    bool const& get_updatesFlags() const;
    void set_updatesFlags(bool const&);
public:
    bool const& get_writesBack() const;
    void set_writesBack(bool const&);
public:
    bool const& get_writesToIp() const;
    void set_writesToIp(bool const&);
public:
    // Overrides are documented in the base class
    virtual unsigned get_anyKind() const override;
public:
    virtual ~SgAsmAarch32Instruction();
 
public:
    SgAsmAarch32Instruction();
 
public:
    SgAsmAarch32Instruction(Rose::BinaryAnalysis::Address const& address,
                            uint8_t const& architectureId,
                            Rose::BinaryAnalysis::Aarch32InstructionKind const& kind,
                            Rose::BinaryAnalysis::Aarch32InstructionCondition const& condition);
 
protected:
    void initializeProperties();
#endif // SgAsmAarch32Instruction_OTHERS
#ifdef DOCUMENTATION
};
#endif // DOCUMENTATION
#endif
 
 
// SgAsmInstruction           -- MACHINE GENERATED; DO NOT MODIFY --
 
#ifndef DOCUMENTATION
AstNodeClass& AsmInstruction = nonTerminalConstructor(
    "AsmInstruction",
    *this,
    "AsmInstruction",
    "AsmInstructionTag",
    SubclassListBuilder()
#ifdef ROSE_ENABLE_ASM_AARCH32
        | AsmAarch32Instruction
#endif
#ifdef ROSE_ENABLE_ASM_AARCH64
        | AsmAarch64Instruction
#endif
        | AsmCilInstruction
        | AsmJvmInstruction
        | AsmM68kInstruction
        | AsmMipsInstruction
        | AsmNullInstruction
        | AsmPowerpcInstruction
        | AsmUserInstruction
        | AsmX86Instruction
    , true);
assert(AsmInstruction.associatedGrammar != nullptr);
AsmInstruction.setCppCondition("!defined(DOCUMENTATION)");
AsmInstruction.isBoostSerializable(true);
AsmInstruction.setAutomaticGenerationOfConstructor(false);
AsmInstruction.setAutomaticGenerationOfDestructor(false);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
AsmInstruction.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmInstruction);
#if defined(SgAsmInstruction_HEADERS) || defined(DOCUMENTATION)
#include <Rose/BinaryAnalysis/Address.h>
#include <Rose/BinaryAnalysis/Architecture/BasicTypes.h>
#include <Rose/BinaryAnalysis/MemoryMap.h>
#include <sageContainer.h>
#include <Sawyer/Cached.h>
 
#ifdef ROSE_SgAsmInstruction_IMPL
#include <SgAsmExprListExp.h>
#include <SgAsmOperandList.h>
#endif
#endif // SgAsmInstruction_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmInstruction: public SgAsmStatement {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmInstruction.setDataPrototype(
        "uint8_t", "architectureId", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmInstruction.setDataPrototype(
        "SgUnsignedCharList", "rawBytes", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmInstruction.setDataPrototype(
        "SgAsmOperandList*", "operandList", "= nullptr",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmInstruction.setDataPrototype(
        "SgAsmInstruction*", "delaySlot", "= nullptr",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmInstruction.setDataPrototype(
        "SgAsmExprListExp*", "semantics", "= nullptr",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmInstruction);
#if defined(SgAsmInstruction_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmInstruction -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmInstruction");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmStatement);
        {
            auto temp = architectureIdSerialize(p_architectureId);
            s & boost::serialization::make_nvp("p_architectureId", temp);
            p_architectureId = architectureIdDeserialize(temp);
        }
        s & BOOST_SERIALIZATION_NVP(p_rawBytes);
        s & BOOST_SERIALIZATION_NVP(p_operandList);
        s & BOOST_SERIALIZATION_NVP(p_delaySlot);
        userSerializeBoost(s);
        debugSerializationEnd("SgAsmInstruction");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
    // Local types
private:
    struct SemanticFailure {
        size_t n;
        SemanticFailure(): n(0) {}
 
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
    private:
        friend class boost::serialization::access;
        template<class S>
        void serialize(S &s, const unsigned /*version*/) {
            s & BOOST_SERIALIZATION_NVP(n);
        }
#endif
    };
 
    // Properties
public:
public:
    uint8_t const& get_architectureId() const;
    // Architecture registration IDs change from run to run, so serialize the architecture name instead. The architecture names
    // will probably not change as frequently as their registration IDs.
    std::string architectureIdSerialize(uint8_t id) const;
    uint8_t architectureIdDeserialize(const std::string &name) const;
public:
    SgUnsignedCharList const& get_rawBytes() const;
    void set_rawBytes(SgUnsignedCharList const&);
public:
    SgAsmOperandList* const& get_operandList() const;
    void set_operandList(SgAsmOperandList* const&);
public:
    SgAsmInstruction* const& get_delaySlot() const;
    void set_delaySlot(SgAsmInstruction* const&);
    // FIXME[Robb Matzke 2023-03-18]: is the lack of serialization a bug?
public:
    SgAsmExprListExp* const& get_semantics() const;
    void set_semantics(SgAsmExprListExp* const&);
    // Non-property data members
private:
    SemanticFailure semanticFailure_;
 
public:
    static const int64_t INVALID_STACK_DELTA;           // [Robb Matzke 2024-10-01]: deprecated; use an optional type instead
 
    // Functions
public:
    Rose::BinaryAnalysis::Architecture::BaseConstPtr architecture() const /*final*/;
 
    std::string get_mnemonic() const;
 
    // [Robb Matzke 2023-12-04]: deprecated
    virtual std::string description() const final ROSE_DEPRECATED("use Architecture::Base::instructionDescription");
 
    size_t nOperands() const;
 
    SgAsmExpression* operand(size_t) const;
 
    // [Robb Matzke 2023-12-04]: deprecated
    virtual bool terminatesBasicBlock() final ROSE_DEPRECATED("use Architecture::Base::terminatesBasicBlock");
    virtual bool isFunctionCallFast(const std::vector<SgAsmInstruction*>&, Rose::BinaryAnalysis::Address *target,
                                    Rose::BinaryAnalysis::Address *ret) final
        ROSE_DEPRECATED("use Architecture::Base::isFunctionCallFast");
    virtual bool isFunctionCallSlow(const std::vector<SgAsmInstruction*>&, Rose::BinaryAnalysis::Address *target,
                                    Rose::BinaryAnalysis::Address *ret) final
        ROSE_DEPRECATED("use Architecture::Base::isFunctionCallSlow");
    virtual bool isFunctionReturnFast(const std::vector<SgAsmInstruction*>&) final
        ROSE_DEPRECATED("use Architecture::Base::isFunctionReturnFast");
    virtual bool isFunctionReturnSlow(const std::vector<SgAsmInstruction*>&) final
        ROSE_DEPRECATED("use Architecture::Base::isFunctionReturnSlow");
    virtual Sawyer::Optional<Rose::BinaryAnalysis::Address> branchTarget() final
        ROSE_DEPRECATED("use Architecture::Base::branchTarget");
 
    bool isFirstInBlock();
 
    bool isLastInBlock();
 
    virtual bool hasEffect();
 
    virtual bool hasEffect(const std::vector<SgAsmInstruction*>&, bool allow_branch=false,
                           bool relax_stack_semantics=false);
 
    virtual std::vector<std::pair<size_t,size_t> >
    findNoopSubsequences(const std::vector<SgAsmInstruction*>& insns, bool allow_branch=false,
                         bool relax_stack_semantics=false);
 
    // [Robb Matzke 2023-12-04]: deprecated
    virtual Rose::BinaryAnalysis::AddressSet getSuccessors(bool &complete)
        ROSE_DEPRECATED("use Architecture::Base::getSuccessors");
    virtual Rose::BinaryAnalysis::AddressSet getSuccessors(const std::vector<SgAsmInstruction*> &basicBlock,
                                                           bool &complete,
                                                           const Rose::BinaryAnalysis::MemoryMap::Ptr &initial_memory =
                                                           Rose::BinaryAnalysis::MemoryMap::Ptr())
        ROSE_DEPRECATED("use Architecture::Base::getSuccessors");
 
    virtual size_t get_size() const;
 
    // [Robb Matzke 2023-12-05]: deprecated
    virtual bool isUnknown() const final ROSE_DEPRECATED("use Architecture::Base::isUnknown");
 
    virtual unsigned get_anyKind() const;
 
    virtual std::string toString() const;
 
    virtual std::string toStringNoAddr() const;
 
    virtual std::string toStringNoColor() const;
 
    virtual std::string toStringNoAddrNoColor() const;
 
    virtual std::set<Rose::BinaryAnalysis::Address> explicitConstants() const;
 
    size_t semanticFailure() const;
    void semanticFailure(size_t);
    void incrementSemanticFailure();
    bool normalizeOperands();
 
    // Serialization
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    template<class S>
    void userSerializeBoost(S &s) {
        s & BOOST_SERIALIZATION_NVP(semanticFailure_);
    }
#endif
 
    // Deprecated
public:
    // [Robb Matzke 2023-11-07]: deprecated
    const SgUnsignedCharList& get_raw_bytes() const ROSE_DEPRECATED("use get_rawBytes");
    void set_raw_bytes(const SgUnsignedCharList&) ROSE_DEPRECATED("use set_rawBytes");
public:
    virtual ~SgAsmInstruction();
 
public:
    SgAsmInstruction();
 
public:
    SgAsmInstruction(Rose::BinaryAnalysis::Address const& address,
                     uint8_t const& architectureId);
 
protected:
    void initializeProperties();
#endif // SgAsmInstruction_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmInstruction: public SgAsmStatement {…};
#endif // DOCUMENTATION
 
 
// SgAsmStatement           -- MACHINE GENERATED; DO NOT MODIFY --
 
#ifndef DOCUMENTATION
AstNodeClass& AsmStatement = nonTerminalConstructor(
    "AsmStatement",
    *this,
    "AsmStatement",
    "AsmStatementTag",
    SubclassListBuilder()
        | AsmBlock
        | AsmInstruction
        | AsmStaticData
        | AsmSynthesizedDeclaration
    , false);
assert(AsmStatement.associatedGrammar != nullptr);
AsmStatement.setCppCondition("!defined(DOCUMENTATION)");
AsmStatement.isBoostSerializable(true);
AsmStatement.setAutomaticGenerationOfConstructor(false);
AsmStatement.setAutomaticGenerationOfDestructor(false);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
AsmStatement.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmStatement);
#if defined(SgAsmStatement_HEADERS) || defined(DOCUMENTATION)
#include <Rose/BinaryAnalysis/Address.h>
#endif // SgAsmStatement_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmStatement: public SgAsmNode {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmStatement.setDataPrototype(
        "Rose::BinaryAnalysis::Address", "address", "= 0",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmStatement.setDataPrototype(
        "std::string", "comment", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmStatement);
#if defined(SgAsmStatement_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmStatement -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmStatement");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmNode);
        s & BOOST_SERIALIZATION_NVP(p_address);
        s & BOOST_SERIALIZATION_NVP(p_comment);
        debugSerializationEnd("SgAsmStatement");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    Rose::BinaryAnalysis::Address const& get_address() const;
    void set_address(Rose::BinaryAnalysis::Address const&);
public:
    std::string const& get_comment() const;
    void set_comment(std::string const&);
public:
    virtual ~SgAsmStatement();
 
protected:
    SgAsmStatement();
 
protected:
    explicit SgAsmStatement(Rose::BinaryAnalysis::Address const& address);
 
protected:
    void initializeProperties();
#endif // SgAsmStatement_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmStatement: public SgAsmNode {…};
#endif // DOCUMENTATION
 
 
// SgAsmAarch32Coprocessor           -- MACHINE GENERATED; DO NOT MODIFY --
 
DECLARE_LEAF_CLASS(AsmAarch32Coprocessor);
IS_SERIALIZABLE(AsmAarch32Coprocessor);
 
#ifndef DOCUMENTATION
AsmAarch32Coprocessor.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmAarch32Coprocessor: public SgAsmExpression {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmAarch32Coprocessor);
#if defined(SgAsmAarch32Coprocessor_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmAarch32Coprocessor -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmAarch32Coprocessor");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExpression);
        s & BOOST_SERIALIZATION_NVP(coprocessor_);
        debugSerializationEnd("SgAsmAarch32Coprocessor");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
private:
    int coprocessor_;
 
public:
    int const& coprocessor() const;
    void coprocessor(int const&);
public:
    virtual ~SgAsmAarch32Coprocessor();
 
public:
    SgAsmAarch32Coprocessor();
 
public:
    explicit SgAsmAarch32Coprocessor(int const& coprocessor);
 
protected:
    void initializeProperties();
#endif // SgAsmAarch32Coprocessor_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmAarch32Coprocessor: public SgAsmExpression {…};
#endif // DOCUMENTATION
 
 
// SgAsmExpression           -- MACHINE GENERATED; DO NOT MODIFY --
 
#ifndef DOCUMENTATION
AstNodeClass& AsmExpression = nonTerminalConstructor(
    "AsmExpression",
    *this,
    "AsmExpression",
    "AsmExpressionTag",
    SubclassListBuilder()
        | AsmAarch32Coprocessor
#ifdef ROSE_ENABLE_ASM_AARCH64
        | AsmAarch64AtOperand
#endif
#ifdef ROSE_ENABLE_ASM_AARCH64
        | AsmAarch64BarrierOperand
#endif
#ifdef ROSE_ENABLE_ASM_AARCH64
        | AsmAarch64CImmediateOperand
#endif
#ifdef ROSE_ENABLE_ASM_AARCH64
        | AsmAarch64PrefetchOperand
#endif
#ifdef ROSE_ENABLE_ASM_AARCH64
        | AsmAarch64PState
#endif
#ifdef ROSE_ENABLE_ASM_AARCH64
        | AsmAarch64SysMoveOperand
#endif
        | AsmBinaryExpression
        | AsmByteOrder
        | AsmCommonSubExpression
        | AsmControlFlagsExpression
        | AsmExprListExp
        | AsmMemoryReferenceExpression
        | AsmRegisterNames
        | AsmRegisterReferenceExpression
        | AsmRiscOperation
        | AsmStackExpression
        | AsmUnaryExpression
        | AsmValueExpression
    , false);
assert(AsmExpression.associatedGrammar != nullptr);
AsmExpression.setCppCondition("!defined(DOCUMENTATION)");
AsmExpression.isBoostSerializable(true);
AsmExpression.setAutomaticGenerationOfConstructor(false);
AsmExpression.setAutomaticGenerationOfDestructor(false);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
AsmExpression.useSmallHeader(true);
#endif // !DOCUMENTATION
 
#ifdef DOCUMENTATION
class SgAsmExpression: public SgAsmNode {
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmExpression.setDataPrototype(
        "SgAsmType*", "type", "= nullptr",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
    AsmExpression.setDataPrototype(
        "std::string", "comment", "",
        NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
#endif // !DOCUMENTATION
 
    DECLARE_OTHERS(AsmExpression);
#if defined(SgAsmExpression_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmExpression -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmExpression");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmNode);
        s & BOOST_SERIALIZATION_NVP(p_type);
        s & BOOST_SERIALIZATION_NVP(p_comment);
        debugSerializationEnd("SgAsmExpression");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
public:
    SgAsmType* const& get_type() const;
    void set_type(SgAsmType* const&);
public:
    std::string const& get_comment() const;
    void set_comment(std::string const&);
public:
    size_t get_nBits() const;
 
    Sawyer::Optional<uint64_t> asUnsigned() const;
 
    Sawyer::Optional<int64_t> asSigned() const;
 
    virtual std::string toString() const;
public:
    virtual ~SgAsmExpression();
 
protected:
    SgAsmExpression();
 
protected:
    void initializeProperties();
#endif // SgAsmExpression_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmExpression: public SgAsmNode {…};
#endif // DOCUMENTATION
 
 
// SgAsmNode           -- MACHINE GENERATED; DO NOT MODIFY --
 
#ifndef DOCUMENTATION
AstNodeClass& AsmNode = nonTerminalConstructor(
    "AsmNode",
    *this,
    "AsmNode",
    "AsmNodeTag",
    SubclassListBuilder()
        | AsmCilNode
        | AsmExecutableFileFormat
        | AsmExpression
        | AsmGenericFileList
        | AsmInstructionList
        | AsmInterpretation
        | AsmInterpretationList
        | AsmJvmNode
        | AsmOperandList
        | AsmStatement
        | AsmType
    , false);
assert(AsmNode.associatedGrammar != nullptr);
AsmNode.setCppCondition("!defined(DOCUMENTATION)");
AsmNode.isBoostSerializable(true);
AsmNode.setAutomaticGenerationOfConstructor(false);
AsmNode.setAutomaticGenerationOfDestructor(false);
#endif // !DOCUMENTATION
 
#ifndef DOCUMENTATION
AsmNode.useSmallHeader(true);
#endif // !DOCUMENTATION
 
DECLARE_HEADERS(AsmNode);
#if defined(SgAsmNode_HEADERS) || defined(DOCUMENTATION)
#include <Sawyer/Attribute.h>
#include <boost/format.hpp>
#endif // SgAsmNode_HEADERS
 
#ifdef DOCUMENTATION
class SgAsmNode: public SgNode {
#endif // DOCUMENTATION
 
    DECLARE_OTHERS(AsmNode);
#if defined(SgAsmNode_OTHERS) || defined(DOCUMENTATION)
 
    //----------------------- Boost serialization for SgAsmNode -----------------------
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        debugSerializationBegin("SgAsmNode");
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgNode);
        debugSerializationEnd("SgAsmNode");
    }
#endif // ROSE_ENABLE_BOOST_SERIALIZATION
public:
private:
    Sawyer::Attribute::Storage<> attributes_;
 
public:
    Sawyer::Attribute::Storage<> const& attributes() const;
    Sawyer::Attribute::Storage<>& attributes();
public:
    virtual ~SgAsmNode();
 
protected:
    SgAsmNode();
 
protected:
    void initializeProperties();
#endif // SgAsmNode_OTHERS
#ifdef DOCUMENTATION
};
class SgAsmNode: public SgNode {…};
#endif // DOCUMENTATION
 
#ifndef DOCUMENTATION
} // Grammar::setUpBinaryInstructions
#endif // !DOCUMENTATION
#endif // defined(ROSE_ENABLE_BINARY_ANALYSIS)