SgAsmExecutableFileFormat.h

 
#ifndef ROSE_SgAsmExecutableFileFormat_H
#define ROSE_SgAsmExecutableFileFormat_H
#include <RoseFirst.h>
#include <Cxx_GrammarDeclarations.h>
#include <SgAsmNode.h>
 
 
 
/* #line 1 "/workspace/src/ROSETTA/Grammar/grammarClassDeclarationMacros.macro" */
 
// WARNING -- GENERATED CODE -- DO NOT MODIFY THIS CODE -- WARNING!
//      This code is automatically generated for each 
//      terminal and non-terminal within the defined 
//      grammar.  There is a simple way to change the 
//      code to fix bugs etc.  See the ROSE README file
//      for directions.
 
// tps: (02/22/2010): Adding DLL export requirements
#include "rosedll.h"
 
// predeclarations for SgAsmExecutableFileFormat
 
/* #line 25 "../../../src/frontend/SageIII//SgAsmExecutableFileFormat.h" */
/* #line 42310 "/workspace/src/ROSETTA/src/binaryInstruction.C" */
 
#include <Rose/Exception.h>
 
 
/* #line 13 "/workspace/src/ROSETTA/Grammar/grammarClassDeclarationMacros.macro after subst for $PREDECLARATIONS" */
 
/* #line 14 "/workspace/src/ROSETTA/Grammar/grammarClassDeclarationMacros.macro" */
 
#if !defined(DOCUMENTATION)
// Class Definition for SgAsmExecutableFileFormat
class ROSE_DLL_API SgAsmExecutableFileFormat  : public SgAsmNode
   {
     public:
 
 
/* #line 42 "../../../src/frontend/SageIII//SgAsmExecutableFileFormat.h" */
 
          virtual SgNode* copy ( SgCopyHelp& help) const override;
// Start of memberFunctionString
/* #line 42320 "/workspace/src/ROSETTA/src/binaryInstruction.C" */
 
 
    //----------------------- Boost serialization for SgAsmExecutableFileFormat -----------------------
#ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
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_HAVE_BOOST_SERIALIZATION_LIB
    // Local types
public:
    class ShortRead: public Rose::Exception {
    public:
        const SgAsmGenericSection *section;         
        rose_addr_t offset;                         
        rose_addr_t 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 ShortWrite: public Rose::Exception {
    public:
        const SgAsmGenericSection *section;         
        rose_addr_t          offset;                
        rose_addr_t          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 FormatError: public Rose::Exception {
    public:
        FormatError(const std::string &mesg)
            : Rose::Exception(mesg) {}
        FormatError(const char *mesg)
            : Rose::Exception(mesg) {}
        ~FormatError() throw () {}
    };
 
    typedef struct stat fileDetails;
 
    enum ExecFamily {
        FAMILY_UNSPECIFIED,                         
        FAMILY_DOS,                                 
        FAMILY_ELF,                                 
        FAMILY_JVM,                                 
        FAMILY_LE,                                  
        FAMILY_LX,                                  
        FAMILY_NE,                                  
        FAMILY_PE                                   
    };
 
    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 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 ExecPurpose {
        PURPOSE_UNSPECIFIED,                        
        PURPOSE_OTHER,                              
        PURPOSE_EXECUTABLE,                         
        PURPOSE_LIBRARY,                            
        PURPOSE_CORE_DUMP,                          
        PURPOSE_OS_SPECIFIC,                        
        PURPOSE_PROC_SPECIFIC                       
    };
 
    // 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();
 
 
// End of memberFunctionString
// Start of memberFunctionString
/* #line 1 "/workspace/src/ROSETTA/Grammar/Common.code" */
 
// *** COMMON CODE SECTION BEGINS HERE ***
 
    public:
 
       // DQ (3/25/3006): I put this back in because it had the logic for where the copy function required 
       // and not required which is required to match the other aspects of the copy mechanism code generation.
       // Specifically it is a problem to declare the copy function everywhere because it is not implemented 
       // for the SgSymbol IR nodes. I'm not clear why it is not implemented for these IR nodes.
       /* \brief Copies AST (whole subtree, depending on the SgCopyHelp class */
       // virtual SgNode* copy ( const SgCopyHelp & help) const;
 
          virtual std::string class_name() const override;
 
          virtual VariantT variantT() const override; // MS: new variant used in tree traversal
 
       // King84 (2010.08.16): Moved this to an enum to save space, since it's only used at compiler-time anyway.
       // static const VariantT static_variant = V_SgAsmExecutableFileFormat;
          enum { static_variant = V_SgAsmExecutableFileFormat };
 
       /* the generated cast function */
          ROSE_DLL_API friend       SgAsmExecutableFileFormat* isSgAsmExecutableFileFormat(       SgNode * s );
 
          ROSE_DLL_API friend const SgAsmExecutableFileFormat* isSgAsmExecutableFileFormat( const SgNode * s );
 
     // ******************************************
     // * Memory Pool / New / Delete
     // ******************************************
 
     public:
          static const unsigned pool_size; // 
          static std::vector<unsigned char *> pools; // 
          static SgAsmExecutableFileFormat * next_node; // 
 
          static unsigned long initializeStorageClassArray(SgAsmExecutableFileFormatStorageClass *); // 
 
          static void clearMemoryPool(); // 
          static void deleteMemoryPool(); // 
 
          static void extendMemoryPoolForFileIO(); // 
 
          static SgAsmExecutableFileFormat * getPointerFromGlobalIndex(unsigned long); // 
          static SgAsmExecutableFileFormat * getPointerFromGlobalIndex(AstSpecificDataManagingClass *, unsigned long); // 
 
          static unsigned long getNumberOfValidNodesAndSetGlobalIndexInFreepointer(unsigned long); // 
          static void resetValidFreepointers(); // 
          static unsigned long getNumberOfLastValidPointer(); // 
 
 
#if defined(INLINE_FUNCTIONS)
          inline void *operator new (size_t size);
#else
          void *operator new (size_t size);
#endif
          void operator delete (void* pointer, size_t size);
 
       // DQ (4/5/2007): This is not the correct operator that we want, but appears to be required to compile ROSE with ROSE.
          void operator delete (void* pointer)
             {
            // This is the generated delete operator...
               SgAsmExecutableFileFormat::operator delete (pointer,sizeof(SgAsmExecutableFileFormat));
             }
 
          static size_t numberOfNodes();
 
          static size_t memoryUsage();
 
      // End of scope which started in IR nodes specific code 
      /* */
 
      /* name Internal Functions
          \brief Internal functions ... incomplete-documentation
 
          These functions have been made public as part of the design, but they are suggested for internal use 
          or by particularly knowledgeable users for specialized tools or applications.
 
          \internal We could not make these private because they are required by user for special purposes. And 
              it would be unwieldy to have many of the internal classes in ROSE be explicitly defined as friends.
         
       */
 
       // MS: 02/12/02 container of pointers to AST successor nodes used in the traversal
       // overridden in every class by *generated* implementation
          virtual std::vector<SgNode*> get_traversalSuccessorContainer() override;
       // MS: 06/28/02 container of names of variables or container indices 
       // used used in the traversal to access AST successor nodes
       // overridden in every class by *generated* implementation
          virtual std::vector<std::string> get_traversalSuccessorNamesContainer() override;
 
       // GB (09/25/2007): Functions for index-based access to traversal successors; these are hopefully a lot faster
       // than all the vector copies. The implementation for these functions is generated for each class.
          virtual size_t get_numberOfTraversalSuccessors() override;
          virtual SgNode *get_traversalSuccessorByIndex(size_t idx) override;
          virtual size_t get_childIndex(SgNode *child) override;
 
#ifndef ROSE_USE_INTERNAL_FRONTEND_DEVELOPMENT
       // MS: 08/16/2002 method for generating RTI information
          virtual RTIReturnType roseRTI() override;
#endif
      /* */
 
 
 
      /* name Deprecated Functions
          \brief Deprecated functions ... incomplete-documentation
 
          These functions have been deprecated from use.
       */
      /* */
 
          virtual const char* sage_class_name() const  override ROSE_DEPRECATED_FUNCTION;
 
      // JJW (10/16/2008): Changed to a single function in Node.code, and put
      // getVariant() in #if 0 block to prevent confusing Doxygen
#if 0
          virtual int variant() const ROSE_DEPRECATED_FUNCTION;
       // virtual int getVariant() const ROSE_DEPRECATED_FUNCTION;
#endif
      /* */
 
 
 
 
     public:
      /* name Traversal Support Functions
          \brief Traversal support functions ... incomplete-documentation
 
          These functions have been made public as part of the design, but they are suggested for internal use 
          or by particularly knowledgable users for specialized tools or applications.
       */
      /* */
 
       // DQ (11/26/2005): Support for visitor pattern mechanims
       // (inferior to ROSE traversal mechanism, experimental).
          void executeVisitorMemberFunction (ROSE_VisitorPattern & visitor);
 
      /* DXN (08/09/2010): support for the classic visitor pattern done in GoF */
          virtual void accept (ROSE_VisitorPattern & visitor) override;
 
       // DQ (12/26/2005): Support for traversal based on the memory pool
          static void traverseMemoryPoolNodes(ROSE_VisitTraversal & visit);
 
          static void traverseMemoryPoolVisitorPattern(ROSE_VisitorPattern & visitor);
 
       // DQ (2/9/2006): Added to support traversal over single representative of each IR node
       // This traversal helps support internal tools that call static member functions.
       // note: this function operates on the memory pools.
          static void visitRepresentativeNode (ROSE_VisitTraversal & visit);
      /* */
 
     public: 
        /* NodeId support functions */
        static SgNode* getNodeByNodeId(VariantT variantT, size_t poolIdx, size_t itemIdx);
        static SgAsmExecutableFileFormat* getNodeByNodeIdInternal(size_t poolIdx, size_t itemIdx);
        static std::string getNodeIdString(SgAsmExecutableFileFormat* sgnode);
        static std::string getNodeIdStringInternal(SgAsmExecutableFileFormat* sgnode);
 
     public:
      /* name Memory Allocation Functions
          \brief Memory allocations functions ... incomplete-documentation
 
          These functions have been made public as part of the design, but they are suggested for internal use 
          or by particularly knowledgable users for specialized tools or applications.
       */
      /* */
 
          virtual bool isInMemoryPool() override;
 
          virtual void checkDataMemberPointersIfInMemoryPool() override;
 
      // DQ (4/30/2006): Modified to be a const function.
          virtual std::vector<std::pair<SgNode*,std::string> > returnDataMemberPointers() const override;
 
          virtual void processDataMemberReferenceToPointers(ReferenceToPointerHandler*) override;
 
          virtual long getChildIndex( SgNode* childNode ) const override;
 
      // DQ (9/2/2015): Since this function is generated by ROSETTA, we can't define the 
      // comment here (changed to be a C style comment and not be a doxygen comment).
      /* \brief Constructor for use by AST File I/O Mechanism
 
          This constructor permits the IR node to be rebuilt from the contiguously arranged data in memory 
          which obtained via fast binary file I/O from disk.
       */
       // SgAsmExecutableFileFormat( SgAsmExecutableFileFormatStorageClass& source );
 
 
 
 
 
 // JH (10/24/2005): methods added to support the ast file IO
    private:
 
      /* name AST Memory Allocation Support Functions
          \brief Memory allocations support....
 
          These functions handle the low leve support of the memory allocation scheme which permits IR nodes to be allocated 
          in large contiguous blocks to reduce memory fragmentation, improve performance, support specialized access (AST traversals),
          and support the AST File I/O Mechanism.
       */
      /* */
 
       /* JH (10/24/2005): Two typedefs. The TestType notes the type every pointer is cast to before
          we compare them. Since I had several problems with this, I decided to make a typdef to ensure
          that I use the same type everywhere, if any changes are made. THe second one declares the type
          (actually unsigned long) where teh pointer address gets converted to. On 64 bit platforms this
          might got changed, but unfortunatly, the return types are still unsigned longs. There exists
          a correspinding one in the AST_FILE_IO class!
       */
      // DQ (9/2/2015): This typedef is no longer used, we can't define the 
      // comment here (changed to be a C style comment and not be a doxygen comment).
      /* \brief Typedef used for low level memory access.
       */
       // typedef unsigned char* TestType;
 
      // DQ (9/2/2015): This typedef is no longer used, we can't define the 
      // comment here (changed to be a C style comment and not be a doxygen comment).
      /* \brief Typedef used to hold memory addresses as values.
       */
       // typedef unsigned long  AddressType;
 
 
 
       // necessary, to have direct access to the p_freepointer and the private methods !
          friend class AST_FILE_IO;
 
          friend class SgAsmExecutableFileFormatStorageClass;
 
          friend class AstSpecificDataManagingClass;
 
          friend class AstSpecificDataManagingClassStorageClass;
    public:
          SgAsmExecutableFileFormat( const SgAsmExecutableFileFormatStorageClass& source );
 
 // private: // JJW hack
       /*
          name AST Memory Allocation Support Variables
          Memory allocations support variables 
 
          These variables handle the low level support of the memory allocation scheme which permits IR nodes to be allocated 
          in large contiguous blocks to reduce memory fragmentation, improve performance, support specialized access (AST traversals),
          and support the AST File I/O Mechanism.
       */
      /* */
 
    public:
 
      // DQ (11/21/2009): Added function to add new Regular Expression attributes and return pointer 
      // to current node (so that it will work cleanly with build functions to specify patterns).
      // virtual SgNode* addRegExpAttribute();
          SgAsmExecutableFileFormat* addRegExpAttribute(std::string s, AstRegExAttribute* a);
 
#ifndef _MSC_VER
// Rasmussen (04/17/2019): Support for ATerms has been deprecated as it is no longer needed
// and likely never fully implemented nor tested.  Files remain in the src tree but are no
// longer built.
#define BUILD_ATERM_SUPPORT 0
   #if BUILD_ATERM_SUPPORT
   #ifdef ROSE_USE_ROSE_ATERM_SUPPORT
      // DQ (10/4/2014): Adding ATerm support to ROSE.
       // Rasmussen (1/7/2019): Added override to kill warning messages of overridden virtual function
          virtual ATerm generate_ATerm() override;
 
          virtual void generate_ATerm_Annotation(ATerm & term) override;
   #endif
   #endif // BUILD_ATERM_SUPPORT
#endif
       // These can't be virtual functions since we don't yet know what IR node to build (until we have read the aterm).
       // virtual generate_AST(ATerm & term);
       // virtual void read_ATerm_Annotation(ATerm & term);
 
// *** COMMON CODE SECTION ENDS HERE ***
 
 
// End of memberFunctionString
// Start of memberFunctionString
/* #line 706 "/workspace/src/ROSETTA/Grammar/Node.code" */
 
     // the generated cast function
     // friend ROSE_DLL_API SgAsmExecutableFileFormat* isSgAsmExecutableFileFormat ( SgNode* s );
 
          typedef SgAsmNode base_node_type;
 
 
// End of memberFunctionString
 
    protected:
 
    friend struct Rose::Traits::generated::describe_node_t<SgAsmExecutableFileFormat>;
 
/* #line 21 "/workspace/src/ROSETTA/Grammar/grammarClassDeclarationMacros.macro" */
 
 
   };
#endif
 
// postdeclarations for SgAsmExecutableFileFormat
 
/* #line 829 "../../../src/frontend/SageIII//SgAsmExecutableFileFormat.h" */
 
/* #line 27 "/workspace/src/ROSETTA/Grammar/grammarClassDeclarationMacros.macro after subst for $POSTDECLARATIONS" */
 
/* #line 28 "/workspace/src/ROSETTA/Grammar/grammarClassDeclarationMacros.macro" */
 
 
/* #line 836 "../../../src/frontend/SageIII//SgAsmExecutableFileFormat.h" */
 
#endif // ROSE_SgAsmExecutableFileFormat_H