ROSE 0.11.145.147
SgAsmCilMetadataHeap.h
1
2#ifndef ROSE_SgAsmCilMetadataHeap_H
3#define ROSE_SgAsmCilMetadataHeap_H
4#include <RoseFirst.h>
5#include <Cxx_GrammarDeclarations.h>
6#include <SgAsmCilDataStream.h>
7
8
9
10/* #line 1 "/workspace/src/ROSETTA/Grammar/grammarClassDeclarationMacros.macro" */
11
12// WARNING -- GENERATED CODE -- DO NOT MODIFY THIS CODE -- WARNING!
13// This code is automatically generated for each
14// terminal and non-terminal within the defined
15// grammar. There is a simple way to change the
16// code to fix bugs etc. See the ROSE README file
17// for directions.
18
19// tps: (02/22/2010): Adding DLL export requirements
20#include "rosedll.h"
21
22// predeclarations for SgAsmCilMetadataHeap
23
24/* #line 25 "../../../src/frontend/SageIII//SgAsmCilMetadataHeap.h" */
25/* #line 34781 "/workspace/src/ROSETTA/src/binaryInstruction.C" */
26
27#ifdef ROSE_SgAsmCilMetadataHeap_IMPL
28#include <SgAsmCilAssemblyTable.h>
29#include <SgAsmCilAssemblyOSTable.h>
30#include <SgAsmCilAssemblyProcessorTable.h>
31#include <SgAsmCilAssemblyRefTable.h>
32#include <SgAsmCilAssemblyRefOSTable.h>
33#include <SgAsmCilAssemblyRefProcessorTable.h>
34#include <SgAsmCilClassLayoutTable.h>
35#include <SgAsmCilConstantTable.h>
36#include <SgAsmCilCustomAttributeTable.h>
37#include <SgAsmCilDeclSecurityTable.h>
38#include <SgAsmCilEventTable.h>
39#include <SgAsmCilEventMapTable.h>
40#include <SgAsmCilExportedTypeTable.h>
41#include <SgAsmCilFieldTable.h>
42#include <SgAsmCilFieldLayoutTable.h>
43#include <SgAsmCilFieldMarshalTable.h>
44#include <SgAsmCilFieldRVATable.h>
45#include <SgAsmCilFileTable.h>
46#include <SgAsmCilGenericParamTable.h>
47#include <SgAsmCilGenericParamConstraintTable.h>
48#include <SgAsmCilImplMapTable.h>
49#include <SgAsmCilInterfaceImplTable.h>
50#include <SgAsmCilManifestResourceTable.h>
51#include <SgAsmCilMemberRefTable.h>
52#include <SgAsmCilMethodDefTable.h>
53#include <SgAsmCilMethodImplTable.h>
54#include <SgAsmCilMethodSemanticsTable.h>
55#include <SgAsmCilMethodSpecTable.h>
56#include <SgAsmCilModuleTable.h>
57#include <SgAsmCilModuleRefTable.h>
58#include <SgAsmCilNestedClassTable.h>
59#include <SgAsmCilParamTable.h>
60#include <SgAsmCilPropertyTable.h>
61#include <SgAsmCilPropertyMapTable.h>
62#include <SgAsmCilStandAloneSigTable.h>
63#include <SgAsmCilTypeDefTable.h>
64#include <SgAsmCilTypeRefTable.h>
65#include <SgAsmCilTypeSpecTable.h>
66#endif
67
68
69/* #line 13 "/workspace/src/ROSETTA/Grammar/grammarClassDeclarationMacros.macro after subst for $PREDECLARATIONS" */
70
71/* #line 14 "/workspace/src/ROSETTA/Grammar/grammarClassDeclarationMacros.macro" */
72
73#if !defined(DOCUMENTATION)
74// Class Definition for SgAsmCilMetadataHeap
75class ROSE_DLL_API SgAsmCilMetadataHeap : public SgAsmCilDataStream
76 {
77 public:
78
79
80/* #line 81 "../../../src/frontend/SageIII//SgAsmCilMetadataHeap.h" */
81
82 virtual SgNode* copy ( SgCopyHelp& help) const override;
83// Start of memberFunctionString
84/* #line 35112 "/workspace/src/ROSETTA/src/binaryInstruction.C" */
85
86
87 //----------------------- Boost serialization for SgAsmCilMetadataHeap -----------------------
88#ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
89private:
90 friend class boost::serialization::access;
91
92 template<class S>
93 void serialize(S &s, const unsigned /*version*/) {
94 debugSerializationBegin("SgAsmCilMetadataHeap");
95 s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilDataStream);
96 s & BOOST_SERIALIZATION_NVP(p_ReservedAlwaysZero);
97 s & BOOST_SERIALIZATION_NVP(p_MajorVersion);
98 s & BOOST_SERIALIZATION_NVP(p_MinorVersion);
99 s & BOOST_SERIALIZATION_NVP(p_HeapSizes);
100 s & BOOST_SERIALIZATION_NVP(p_ReservedAlwaysOne);
101 s & BOOST_SERIALIZATION_NVP(p_Valid);
102 s & BOOST_SERIALIZATION_NVP(p_Sorted);
103 s & BOOST_SERIALIZATION_NVP(p_NumberOfRows);
104 s & BOOST_SERIALIZATION_NVP(p_DataSizeFlags);
105 s & BOOST_SERIALIZATION_NVP(p_AssemblyTable);
106 s & BOOST_SERIALIZATION_NVP(p_AssemblyOSTable);
107 s & BOOST_SERIALIZATION_NVP(p_AssemblyProcessorTable);
108 s & BOOST_SERIALIZATION_NVP(p_AssemblyRefTable);
109 s & BOOST_SERIALIZATION_NVP(p_AssemblyRefOSTable);
110 s & BOOST_SERIALIZATION_NVP(p_AssemblyRefProcessorTable);
111 s & BOOST_SERIALIZATION_NVP(p_ClassLayoutTable);
112 s & BOOST_SERIALIZATION_NVP(p_ConstantTable);
113 s & BOOST_SERIALIZATION_NVP(p_CustomAttributeTable);
114 s & BOOST_SERIALIZATION_NVP(p_DeclSecurityTable);
115 s & BOOST_SERIALIZATION_NVP(p_EventTable);
116 s & BOOST_SERIALIZATION_NVP(p_EventMapTable);
117 s & BOOST_SERIALIZATION_NVP(p_ExportedTypeTable);
118 s & BOOST_SERIALIZATION_NVP(p_FieldTable);
119 s & BOOST_SERIALIZATION_NVP(p_FieldLayoutTable);
120 s & BOOST_SERIALIZATION_NVP(p_FieldMarshalTable);
121 s & BOOST_SERIALIZATION_NVP(p_FieldRVATable);
122 s & BOOST_SERIALIZATION_NVP(p_FileTable);
123 s & BOOST_SERIALIZATION_NVP(p_GenericParamTable);
124 s & BOOST_SERIALIZATION_NVP(p_GenericParamConstraintTable);
125 s & BOOST_SERIALIZATION_NVP(p_ImplMapTable);
126 s & BOOST_SERIALIZATION_NVP(p_InterfaceImplTable);
127 s & BOOST_SERIALIZATION_NVP(p_ManifestResourceTable);
128 s & BOOST_SERIALIZATION_NVP(p_MemberRefTable);
129 s & BOOST_SERIALIZATION_NVP(p_MethodDefTable);
130 s & BOOST_SERIALIZATION_NVP(p_MethodImplTable);
131 s & BOOST_SERIALIZATION_NVP(p_MethodSemanticsTable);
132 s & BOOST_SERIALIZATION_NVP(p_MethodSpecTable);
133 s & BOOST_SERIALIZATION_NVP(p_ModuleTable);
134 s & BOOST_SERIALIZATION_NVP(p_ModuleRefTable);
135 s & BOOST_SERIALIZATION_NVP(p_NestedClassTable);
136 s & BOOST_SERIALIZATION_NVP(p_ParamTable);
137 s & BOOST_SERIALIZATION_NVP(p_PropertyTable);
138 s & BOOST_SERIALIZATION_NVP(p_PropertyMapTable);
139 s & BOOST_SERIALIZATION_NVP(p_StandAloneSigTable);
140 s & BOOST_SERIALIZATION_NVP(p_TypeDefTable);
141 s & BOOST_SERIALIZATION_NVP(p_TypeRefTable);
142 s & BOOST_SERIALIZATION_NVP(p_TypeSpecTable);
143 debugSerializationEnd("SgAsmCilMetadataHeap");
144 }
145#endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
146
147public:
151 uint32_t const& get_ReservedAlwaysZero() const;
152 void set_ReservedAlwaysZero(uint32_t const&);
155public:
159 uint8_t const& get_MajorVersion() const;
160 void set_MajorVersion(uint8_t const&);
163public:
167 uint8_t const& get_MinorVersion() const;
168 void set_MinorVersion(uint8_t const&);
171public:
175 uint8_t const& get_HeapSizes() const;
176 void set_HeapSizes(uint8_t const&);
179public:
183 uint8_t const& get_ReservedAlwaysOne() const;
184 void set_ReservedAlwaysOne(uint8_t const&);
187public:
191 uint64_t const& get_Valid() const;
192 void set_Valid(uint64_t const&);
195public:
199 uint64_t const& get_Sorted() const;
200 void set_Sorted(uint64_t const&);
203public:
207 std::vector<uint32_t> const& get_NumberOfRows() const;
208 void set_NumberOfRows(std::vector<uint32_t> const&);
211public:
215 uint64_t const& get_DataSizeFlags() const;
216 void set_DataSizeFlags(uint64_t const&);
219public:
223 SgAsmCilAssemblyTable* const& get_AssemblyTable() const;
224 void set_AssemblyTable(SgAsmCilAssemblyTable* const&);
227public:
231 SgAsmCilAssemblyOSTable* const& get_AssemblyOSTable() const;
232 void set_AssemblyOSTable(SgAsmCilAssemblyOSTable* const&);
235public:
239 SgAsmCilAssemblyProcessorTable* const& get_AssemblyProcessorTable() const;
240 void set_AssemblyProcessorTable(SgAsmCilAssemblyProcessorTable* const&);
243public:
247 SgAsmCilAssemblyRefTable* const& get_AssemblyRefTable() const;
248 void set_AssemblyRefTable(SgAsmCilAssemblyRefTable* const&);
251public:
255 SgAsmCilAssemblyRefOSTable* const& get_AssemblyRefOSTable() const;
256 void set_AssemblyRefOSTable(SgAsmCilAssemblyRefOSTable* const&);
259public:
263 SgAsmCilAssemblyRefProcessorTable* const& get_AssemblyRefProcessorTable() const;
264 void set_AssemblyRefProcessorTable(SgAsmCilAssemblyRefProcessorTable* const&);
267public:
271 SgAsmCilClassLayoutTable* const& get_ClassLayoutTable() const;
272 void set_ClassLayoutTable(SgAsmCilClassLayoutTable* const&);
275public:
279 SgAsmCilConstantTable* const& get_ConstantTable() const;
280 void set_ConstantTable(SgAsmCilConstantTable* const&);
283public:
287 SgAsmCilCustomAttributeTable* const& get_CustomAttributeTable() const;
288 void set_CustomAttributeTable(SgAsmCilCustomAttributeTable* const&);
291public:
295 SgAsmCilDeclSecurityTable* const& get_DeclSecurityTable() const;
296 void set_DeclSecurityTable(SgAsmCilDeclSecurityTable* const&);
299public:
303 SgAsmCilEventTable* const& get_EventTable() const;
304 void set_EventTable(SgAsmCilEventTable* const&);
307public:
311 SgAsmCilEventMapTable* const& get_EventMapTable() const;
312 void set_EventMapTable(SgAsmCilEventMapTable* const&);
315public:
319 SgAsmCilExportedTypeTable* const& get_ExportedTypeTable() const;
320 void set_ExportedTypeTable(SgAsmCilExportedTypeTable* const&);
323public:
327 SgAsmCilFieldTable* const& get_FieldTable() const;
328 void set_FieldTable(SgAsmCilFieldTable* const&);
331public:
335 SgAsmCilFieldLayoutTable* const& get_FieldLayoutTable() const;
336 void set_FieldLayoutTable(SgAsmCilFieldLayoutTable* const&);
339public:
343 SgAsmCilFieldMarshalTable* const& get_FieldMarshalTable() const;
344 void set_FieldMarshalTable(SgAsmCilFieldMarshalTable* const&);
347public:
351 SgAsmCilFieldRVATable* const& get_FieldRVATable() const;
352 void set_FieldRVATable(SgAsmCilFieldRVATable* const&);
355public:
359 SgAsmCilFileTable* const& get_FileTable() const;
360 void set_FileTable(SgAsmCilFileTable* const&);
363public:
367 SgAsmCilGenericParamTable* const& get_GenericParamTable() const;
368 void set_GenericParamTable(SgAsmCilGenericParamTable* const&);
371public:
375 SgAsmCilGenericParamConstraintTable* const& get_GenericParamConstraintTable() const;
376 void set_GenericParamConstraintTable(SgAsmCilGenericParamConstraintTable* const&);
379public:
383 SgAsmCilImplMapTable* const& get_ImplMapTable() const;
384 void set_ImplMapTable(SgAsmCilImplMapTable* const&);
387public:
391 SgAsmCilInterfaceImplTable* const& get_InterfaceImplTable() const;
392 void set_InterfaceImplTable(SgAsmCilInterfaceImplTable* const&);
395public:
399 SgAsmCilManifestResourceTable* const& get_ManifestResourceTable() const;
400 void set_ManifestResourceTable(SgAsmCilManifestResourceTable* const&);
403public:
407 SgAsmCilMemberRefTable* const& get_MemberRefTable() const;
408 void set_MemberRefTable(SgAsmCilMemberRefTable* const&);
411public:
415 SgAsmCilMethodDefTable* const& get_MethodDefTable() const;
416 void set_MethodDefTable(SgAsmCilMethodDefTable* const&);
419public:
423 SgAsmCilMethodImplTable* const& get_MethodImplTable() const;
424 void set_MethodImplTable(SgAsmCilMethodImplTable* const&);
427public:
431 SgAsmCilMethodSemanticsTable* const& get_MethodSemanticsTable() const;
432 void set_MethodSemanticsTable(SgAsmCilMethodSemanticsTable* const&);
435public:
439 SgAsmCilMethodSpecTable* const& get_MethodSpecTable() const;
440 void set_MethodSpecTable(SgAsmCilMethodSpecTable* const&);
443public:
447 SgAsmCilModuleTable* const& get_ModuleTable() const;
448 void set_ModuleTable(SgAsmCilModuleTable* const&);
451public:
455 SgAsmCilModuleRefTable* const& get_ModuleRefTable() const;
456 void set_ModuleRefTable(SgAsmCilModuleRefTable* const&);
459public:
463 SgAsmCilNestedClassTable* const& get_NestedClassTable() const;
464 void set_NestedClassTable(SgAsmCilNestedClassTable* const&);
467public:
471 SgAsmCilParamTable* const& get_ParamTable() const;
472 void set_ParamTable(SgAsmCilParamTable* const&);
475public:
479 SgAsmCilPropertyTable* const& get_PropertyTable() const;
480 void set_PropertyTable(SgAsmCilPropertyTable* const&);
483public:
487 SgAsmCilPropertyMapTable* const& get_PropertyMapTable() const;
488 void set_PropertyMapTable(SgAsmCilPropertyMapTable* const&);
491public:
495 SgAsmCilStandAloneSigTable* const& get_StandAloneSigTable() const;
496 void set_StandAloneSigTable(SgAsmCilStandAloneSigTable* const&);
499public:
503 SgAsmCilTypeDefTable* const& get_TypeDefTable() const;
504 void set_TypeDefTable(SgAsmCilTypeDefTable* const&);
507public:
511 SgAsmCilTypeRefTable* const& get_TypeRefTable() const;
512 void set_TypeRefTable(SgAsmCilTypeRefTable* const&);
515public:
519 SgAsmCilTypeSpecTable* const& get_TypeSpecTable() const;
520 void set_TypeSpecTable(SgAsmCilTypeSpecTable* const&);
522public:
524 enum ReferenceKind
525 {
526 // heaps
527 e_ref_string_heap = 1 << 0,
528 e_ref_guid_heap = 1 << 1,
529 e_ref_blob_heap = 1 << 2,
530 // single-table references
531 e_ref_assembly_ref = 1 << 3,
532 e_ref_type_def = 1 << 4,
533 e_ref_event = 1 << 5,
534 e_ref_field = 1 << 6,
535 e_ref_generic_param = 1 << 7,
536 e_ref_module_ref = 1 << 8,
537 e_ref_method_def = 1 << 9,
538 e_ref_param = 1 << 10,
539 e_ref_property = 1 << 11,
540 // multi-table references
541 e_ref_has_constant = 1 << 12,
542 e_ref_has_custom_attribute = 1 << 13,
543 e_ref_has_decl_security = 1 << 14,
544 e_ref_has_field_marshall = 1 << 15,
545 e_ref_has_semantics = 1 << 16,
546 e_ref_method_def_or_ref = 1 << 17,
547 e_ref_type_def_or_ref = 1 << 18,
548 e_ref_implementation = 1 << 19,
549 e_ref_member_forwarded = 1 << 20,
550 e_ref_member_ref_parent = 1 << 21,
551 e_ref_type_or_method_def = 1 << 22,
552 e_ref_custom_attribute_type = 1 << 23,
553 e_ref_resolution_scope = 1 << 24,
554 e_ref_last = 1 << 25,
555 };
556
557 enum TableKind : std::uint8_t
558 {
559
560 e_Assembly = 0x20,
561 e_AssemblyOS = 0x22,
562 e_AssemblyProcessor = 0x21,
563 e_AssemblyRef = 0x23,
564 e_AssemblyRefOS = 0x25,
565 e_AssemblyRefProcessor = 0x24,
566 e_ClassLayout = 0x0F,
567 e_Constant = 0x0B,
568 e_CustomAttribute = 0x0C,
569 e_DeclSecurity = 0x0E,
570 e_Event = 0x14,
571 e_EventMap = 0x12,
572 e_ExportedType = 0x27,
573 e_Field = 0x04,
574 e_FieldLayout = 0x10,
575 e_FieldMarshal = 0x0D,
576 e_FieldRVA = 0x1D,
577 e_File = 0x26,
578 e_GenericParam = 0x2A,
579 e_GenericParamConstraint = 0x2C,
580 e_ImplMap = 0x1C,
581 e_InterfaceImpl = 0x09,
582 e_ManifestResource = 0x28,
583 e_MemberRef = 0x0A,
584 e_MethodDef = 0x06,
585 e_MethodImpl = 0x19,
586 e_MethodSemantics = 0x18,
587 e_MethodSpec = 0x2B,
588 e_Module = 0x00,
589 e_ModuleRef = 0x1A,
590 e_NestedClass = 0x29,
591 e_Param = 0x08,
592 e_Property = 0x17,
593 e_PropertyMap = 0x15,
594 e_StandAloneSig = 0x11,
595 e_TypeDef = 0x02,
596 e_TypeRef = 0x01,
597 e_TypeSpec = 0x1B,
598 e_Unknown_table_kind = 0xFF
599 };
600
602 void parse(const std::vector<uint8_t>& buf, size_t startOfMetaData) override;
603
605 void unparse(std::vector<uint8_t>& buf, size_t startOfMetaData) const override;
606
608 void dump(std::ostream& os) const override;
609
613 SgAsmCilMetadata* get_MetadataNode(std::uint32_t idx, TableKind tblcode) const;
614
619 SgAsmCilMetadata* get_CodedMetadataNode(std::uint32_t refcode, ReferenceKind knd) const;
620
625 SgAsmCilMetadata* get_MetadataNode(std::uint32_t refcode, ReferenceKind knd) const;
626public:
628 virtual ~SgAsmCilMetadataHeap();
629
630public:
632 SgAsmCilMetadataHeap();
633
634public:
636 SgAsmCilMetadataHeap(uint32_t const& Offset,
637 uint32_t const& Size,
638 std::string const& Name,
639 uint32_t const& NamePadding);
640
641protected:
648 void initializeProperties();
649
650
651// End of memberFunctionString
652// Start of memberFunctionString
653/* #line 1 "/workspace/src/ROSETTA/Grammar/Common.code" */
654
655// *** COMMON CODE SECTION BEGINS HERE ***
656
657 public:
658
659 // DQ (3/25/3006): I put this back in because it had the logic for where the copy function required
660 // and not required which is required to match the other aspects of the copy mechanism code generation.
661 // Specifically it is a problem to declare the copy function everywhere because it is not implemented
662 // for the SgSymbol IR nodes. I'm not clear why it is not implemented for these IR nodes.
663 /* \brief Copies AST (whole subtree, depending on the SgCopyHelp class */
664 // virtual SgNode* copy ( const SgCopyHelp & help) const;
665
667 virtual std::string class_name() const override;
668
670 virtual VariantT variantT() const override; // MS: new variant used in tree traversal
671
673 // King84 (2010.08.16): Moved this to an enum to save space, since it's only used at compiler-time anyway.
674 // static const VariantT static_variant = V_SgAsmCilMetadataHeap;
675 enum { static_variant = V_SgAsmCilMetadataHeap };
676
677 /* the generated cast function */
679 ROSE_DLL_API friend SgAsmCilMetadataHeap* isSgAsmCilMetadataHeap( SgNode * s );
680
682 ROSE_DLL_API friend const SgAsmCilMetadataHeap* isSgAsmCilMetadataHeap( const SgNode * s );
683
684 // ******************************************
685 // * Memory Pool / New / Delete
686 // ******************************************
687
688 public:
690 static const unsigned pool_size; //
692 static std::vector<unsigned char *> pools; //
694 static SgAsmCilMetadataHeap * next_node; //
695
697 static unsigned long initializeStorageClassArray(SgAsmCilMetadataHeapStorageClass *); //
698
700 static void clearMemoryPool(); //
701 static void deleteMemoryPool(); //
702
704 static void extendMemoryPoolForFileIO(); //
705
707 static SgAsmCilMetadataHeap * getPointerFromGlobalIndex(unsigned long); //
709 static SgAsmCilMetadataHeap * getPointerFromGlobalIndex(AstSpecificDataManagingClass *, unsigned long); //
710
712 static unsigned long getNumberOfValidNodesAndSetGlobalIndexInFreepointer(unsigned long); //
714 static void resetValidFreepointers(); //
716 static unsigned long getNumberOfLastValidPointer(); //
717
718
719#if defined(INLINE_FUNCTIONS)
721 inline void *operator new (size_t size);
722#else
724 void *operator new (size_t size);
725#endif
727 void operator delete (void* pointer, size_t size);
728
729 // DQ (4/5/2007): This is not the correct operator that we want, but appears to be required to compile ROSE with ROSE.
730 void operator delete (void* pointer)
731 {
732 // This is the generated delete operator...
733 SgAsmCilMetadataHeap::operator delete (pointer,sizeof(SgAsmCilMetadataHeap));
734 }
735
737 static size_t numberOfNodes();
738
740 static size_t memoryUsage();
741
742 // End of scope which started in IR nodes specific code
743 /* */
744
745 /* name Internal Functions
746 \brief Internal functions ... incomplete-documentation
747
748 These functions have been made public as part of the design, but they are suggested for internal use
749 or by particularly knowledgeable users for specialized tools or applications.
750
751 \internal We could not make these private because they are required by user for special purposes. And
752 it would be unwieldy to have many of the internal classes in ROSE be explicitly defined as friends.
753
754 */
755
756 // MS: 02/12/02 container of pointers to AST successor nodes used in the traversal
757 // overridden in every class by *generated* implementation
759 virtual std::vector<SgNode*> get_traversalSuccessorContainer() override;
760 // MS: 06/28/02 container of names of variables or container indices
761 // used used in the traversal to access AST successor nodes
762 // overridden in every class by *generated* implementation
765 virtual std::vector<std::string> get_traversalSuccessorNamesContainer() override;
766
767 // GB (09/25/2007): Functions for index-based access to traversal successors; these are hopefully a lot faster
768 // than all the vector copies. The implementation for these functions is generated for each class.
770 virtual size_t get_numberOfTraversalSuccessors() override;
772 virtual SgNode *get_traversalSuccessorByIndex(size_t idx) override;
774 virtual size_t get_childIndex(SgNode *child) override;
775
776#ifndef ROSE_USE_INTERNAL_FRONTEND_DEVELOPMENT
777 // MS: 08/16/2002 method for generating RTI information
779 virtual RTIReturnType roseRTI() override;
780#endif
781 /* */
782
783
784
785 /* name Deprecated Functions
786 \brief Deprecated functions ... incomplete-documentation
787
788 These functions have been deprecated from use.
789 */
790 /* */
791
793 virtual const char* sage_class_name() const override ROSE_DEPRECATED_FUNCTION;
794
795 // JJW (10/16/2008): Changed to a single function in Node.code, and put
796 // getVariant() in #if 0 block to prevent confusing Doxygen
797#if 0
799 virtual int variant() const ROSE_DEPRECATED_FUNCTION;
801 // virtual int getVariant() const ROSE_DEPRECATED_FUNCTION;
802#endif
803 /* */
804
805
806
807
808 public:
809 /* name Traversal Support Functions
810 \brief Traversal support functions ... incomplete-documentation
811
812 These functions have been made public as part of the design, but they are suggested for internal use
813 or by particularly knowledgable users for specialized tools or applications.
814 */
815 /* */
816
817 // DQ (11/26/2005): Support for visitor pattern mechanims
818 // (inferior to ROSE traversal mechanism, experimental).
821 void executeVisitorMemberFunction (ROSE_VisitorPattern & visitor);
822
823 /* DXN (08/09/2010): support for the classic visitor pattern done in GoF */
825 virtual void accept (ROSE_VisitorPattern & visitor) override;
826
827 // DQ (12/26/2005): Support for traversal based on the memory pool
830 static void traverseMemoryPoolNodes(ROSE_VisitTraversal & visit);
831
834 static void traverseMemoryPoolVisitorPattern(ROSE_VisitorPattern & visitor);
835
836 // DQ (2/9/2006): Added to support traversal over single representative of each IR node
837 // This traversal helps support internal tools that call static member functions.
838 // note: this function operates on the memory pools.
841 static void visitRepresentativeNode (ROSE_VisitTraversal & visit);
842 /* */
843
844 public:
845 /* NodeId support functions */
847 static SgNode* getNodeByNodeId(VariantT variantT, size_t poolIdx, size_t itemIdx);
850 static SgAsmCilMetadataHeap* getNodeByNodeIdInternal(size_t poolIdx, size_t itemIdx);
853 static std::string getNodeIdString(SgAsmCilMetadataHeap* sgnode);
854 static std::string getNodeIdStringInternal(SgAsmCilMetadataHeap* sgnode);
855
856 public:
857 /* name Memory Allocation Functions
858 \brief Memory allocations functions ... incomplete-documentation
859
860 These functions have been made public as part of the design, but they are suggested for internal use
861 or by particularly knowledgable users for specialized tools or applications.
862 */
863 /* */
864
875 virtual bool isInMemoryPool() override;
876
887 virtual void checkDataMemberPointersIfInMemoryPool() override;
888
889 // DQ (4/30/2006): Modified to be a const function.
904 virtual std::vector<std::pair<SgNode*,std::string> > returnDataMemberPointers() const override;
905
915 virtual void processDataMemberReferenceToPointers(ReferenceToPointerHandler*) override;
916
928 virtual long getChildIndex( SgNode* childNode ) const override;
929
930 // DQ (9/2/2015): Since this function is generated by ROSETTA, we can't define the
931 // comment here (changed to be a C style comment and not be a doxygen comment).
932 /* \brief Constructor for use by AST File I/O Mechanism
933
934 This constructor permits the IR node to be rebuilt from the contiguously arranged data in memory
935 which obtained via fast binary file I/O from disk.
936 */
937 // SgAsmCilMetadataHeap( SgAsmCilMetadataHeapStorageClass& source );
938
939
940
941
942
943 // JH (10/24/2005): methods added to support the ast file IO
944 private:
945
946 /* name AST Memory Allocation Support Functions
947 \brief Memory allocations support....
948
949 These functions handle the low leve support of the memory allocation scheme which permits IR nodes to be allocated
950 in large contiguous blocks to reduce memory fragmentation, improve performance, support specialized access (AST traversals),
951 and support the AST File I/O Mechanism.
952 */
953 /* */
954
955 /* JH (10/24/2005): Two typedefs. The TestType notes the type every pointer is cast to before
956 we compare them. Since I had several problems with this, I decided to make a typdef to ensure
957 that I use the same type everywhere, if any changes are made. THe second one declares the type
958 (actually unsigned long) where teh pointer address gets converted to. On 64 bit platforms this
959 might got changed, but unfortunatly, the return types are still unsigned longs. There exists
960 a correspinding one in the AST_FILE_IO class!
961 */
962 // DQ (9/2/2015): This typedef is no longer used, we can't define the
963 // comment here (changed to be a C style comment and not be a doxygen comment).
964 /* \brief Typedef used for low level memory access.
965 */
966 // typedef unsigned char* TestType;
967
968 // DQ (9/2/2015): This typedef is no longer used, we can't define the
969 // comment here (changed to be a C style comment and not be a doxygen comment).
970 /* \brief Typedef used to hold memory addresses as values.
971 */
972 // typedef unsigned long AddressType;
973
974
975
976 // necessary, to have direct access to the p_freepointer and the private methods !
978 friend class AST_FILE_IO;
979
981 friend class SgAsmCilMetadataHeapStorageClass;
982
984 friend class AstSpecificDataManagingClass;
985
987 friend class AstSpecificDataManagingClassStorageClass;
988 public:
990 SgAsmCilMetadataHeap( const SgAsmCilMetadataHeapStorageClass& source );
991
992 // private: // JJW hack
993 /*
994 name AST Memory Allocation Support Variables
995 Memory allocations support variables
996
997 These variables handle the low level support of the memory allocation scheme which permits IR nodes to be allocated
998 in large contiguous blocks to reduce memory fragmentation, improve performance, support specialized access (AST traversals),
999 and support the AST File I/O Mechanism.
1000 */
1001 /* */
1002
1003 public:
1004
1005 // DQ (11/21/2009): Added function to add new Regular Expression attributes and return pointer
1006 // to current node (so that it will work cleanly with build functions to specify patterns).
1007 // virtual SgNode* addRegExpAttribute();
1013 SgAsmCilMetadataHeap* addRegExpAttribute(std::string s, AstRegExAttribute* a);
1014
1015#ifndef _MSC_VER
1016// Rasmussen (04/17/2019): Support for ATerms has been deprecated as it is no longer needed
1017// and likely never fully implemented nor tested. Files remain in the src tree but are no
1018// longer built.
1019#define BUILD_ATERM_SUPPORT 0
1020 #if BUILD_ATERM_SUPPORT
1021 #ifdef ROSE_USE_ROSE_ATERM_SUPPORT
1022 // DQ (10/4/2014): Adding ATerm support to ROSE.
1032 // Rasmussen (1/7/2019): Added override to kill warning messages of overridden virtual function
1033 virtual ATerm generate_ATerm() override;
1034
1036 virtual void generate_ATerm_Annotation(ATerm & term) override;
1037 #endif
1038 #endif // BUILD_ATERM_SUPPORT
1039#endif
1040 // These can't be virtual functions since we don't yet know what IR node to build (until we have read the aterm).
1041 // virtual generate_AST(ATerm & term);
1042 // virtual void read_ATerm_Annotation(ATerm & term);
1043
1044// *** COMMON CODE SECTION ENDS HERE ***
1045
1046
1047// End of memberFunctionString
1048// Start of memberFunctionString
1049/* #line 706 "/workspace/src/ROSETTA/Grammar/Node.code" */
1050
1051 // the generated cast function
1052 // friend ROSE_DLL_API SgAsmCilMetadataHeap* isSgAsmCilMetadataHeap ( SgNode* s );
1053
1054 typedef SgAsmCilDataStream base_node_type;
1055
1056
1057// End of memberFunctionString
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106 protected:
1107// Start of memberFunctionString
1108uint32_t p_ReservedAlwaysZero;
1109
1110// End of memberFunctionString
1111// Start of memberFunctionString
1112uint8_t p_MajorVersion;
1113
1114// End of memberFunctionString
1115// Start of memberFunctionString
1116uint8_t p_MinorVersion;
1117
1118// End of memberFunctionString
1119// Start of memberFunctionString
1120uint8_t p_HeapSizes;
1121
1122// End of memberFunctionString
1123// Start of memberFunctionString
1124uint8_t p_ReservedAlwaysOne;
1125
1126// End of memberFunctionString
1127// Start of memberFunctionString
1128uint64_t p_Valid;
1129
1130// End of memberFunctionString
1131// Start of memberFunctionString
1132uint64_t p_Sorted;
1133
1134// End of memberFunctionString
1135// Start of memberFunctionString
1136std::vector<uint32_t> p_NumberOfRows;
1137
1138// End of memberFunctionString
1139// Start of memberFunctionString
1140uint64_t p_DataSizeFlags;
1141
1142// End of memberFunctionString
1143// Start of memberFunctionString
1144SgAsmCilAssemblyTable* p_AssemblyTable;
1145
1146// End of memberFunctionString
1147// Start of memberFunctionString
1148SgAsmCilAssemblyOSTable* p_AssemblyOSTable;
1149
1150// End of memberFunctionString
1151// Start of memberFunctionString
1152SgAsmCilAssemblyProcessorTable* p_AssemblyProcessorTable;
1153
1154// End of memberFunctionString
1155// Start of memberFunctionString
1156SgAsmCilAssemblyRefTable* p_AssemblyRefTable;
1157
1158// End of memberFunctionString
1159// Start of memberFunctionString
1160SgAsmCilAssemblyRefOSTable* p_AssemblyRefOSTable;
1161
1162// End of memberFunctionString
1163// Start of memberFunctionString
1164SgAsmCilAssemblyRefProcessorTable* p_AssemblyRefProcessorTable;
1165
1166// End of memberFunctionString
1167// Start of memberFunctionString
1168SgAsmCilClassLayoutTable* p_ClassLayoutTable;
1169
1170// End of memberFunctionString
1171// Start of memberFunctionString
1172SgAsmCilConstantTable* p_ConstantTable;
1173
1174// End of memberFunctionString
1175// Start of memberFunctionString
1176SgAsmCilCustomAttributeTable* p_CustomAttributeTable;
1177
1178// End of memberFunctionString
1179// Start of memberFunctionString
1180SgAsmCilDeclSecurityTable* p_DeclSecurityTable;
1181
1182// End of memberFunctionString
1183// Start of memberFunctionString
1184SgAsmCilEventTable* p_EventTable;
1185
1186// End of memberFunctionString
1187// Start of memberFunctionString
1188SgAsmCilEventMapTable* p_EventMapTable;
1189
1190// End of memberFunctionString
1191// Start of memberFunctionString
1192SgAsmCilExportedTypeTable* p_ExportedTypeTable;
1193
1194// End of memberFunctionString
1195// Start of memberFunctionString
1196SgAsmCilFieldTable* p_FieldTable;
1197
1198// End of memberFunctionString
1199// Start of memberFunctionString
1200SgAsmCilFieldLayoutTable* p_FieldLayoutTable;
1201
1202// End of memberFunctionString
1203// Start of memberFunctionString
1204SgAsmCilFieldMarshalTable* p_FieldMarshalTable;
1205
1206// End of memberFunctionString
1207// Start of memberFunctionString
1208SgAsmCilFieldRVATable* p_FieldRVATable;
1209
1210// End of memberFunctionString
1211// Start of memberFunctionString
1212SgAsmCilFileTable* p_FileTable;
1213
1214// End of memberFunctionString
1215// Start of memberFunctionString
1216SgAsmCilGenericParamTable* p_GenericParamTable;
1217
1218// End of memberFunctionString
1219// Start of memberFunctionString
1220SgAsmCilGenericParamConstraintTable* p_GenericParamConstraintTable;
1221
1222// End of memberFunctionString
1223// Start of memberFunctionString
1224SgAsmCilImplMapTable* p_ImplMapTable;
1225
1226// End of memberFunctionString
1227// Start of memberFunctionString
1228SgAsmCilInterfaceImplTable* p_InterfaceImplTable;
1229
1230// End of memberFunctionString
1231// Start of memberFunctionString
1232SgAsmCilManifestResourceTable* p_ManifestResourceTable;
1233
1234// End of memberFunctionString
1235// Start of memberFunctionString
1236SgAsmCilMemberRefTable* p_MemberRefTable;
1237
1238// End of memberFunctionString
1239// Start of memberFunctionString
1240SgAsmCilMethodDefTable* p_MethodDefTable;
1241
1242// End of memberFunctionString
1243// Start of memberFunctionString
1244SgAsmCilMethodImplTable* p_MethodImplTable;
1245
1246// End of memberFunctionString
1247// Start of memberFunctionString
1248SgAsmCilMethodSemanticsTable* p_MethodSemanticsTable;
1249
1250// End of memberFunctionString
1251// Start of memberFunctionString
1252SgAsmCilMethodSpecTable* p_MethodSpecTable;
1253
1254// End of memberFunctionString
1255// Start of memberFunctionString
1256SgAsmCilModuleTable* p_ModuleTable;
1257
1258// End of memberFunctionString
1259// Start of memberFunctionString
1260SgAsmCilModuleRefTable* p_ModuleRefTable;
1261
1262// End of memberFunctionString
1263// Start of memberFunctionString
1264SgAsmCilNestedClassTable* p_NestedClassTable;
1265
1266// End of memberFunctionString
1267// Start of memberFunctionString
1268SgAsmCilParamTable* p_ParamTable;
1269
1270// End of memberFunctionString
1271// Start of memberFunctionString
1272SgAsmCilPropertyTable* p_PropertyTable;
1273
1274// End of memberFunctionString
1275// Start of memberFunctionString
1276SgAsmCilPropertyMapTable* p_PropertyMapTable;
1277
1278// End of memberFunctionString
1279// Start of memberFunctionString
1280SgAsmCilStandAloneSigTable* p_StandAloneSigTable;
1281
1282// End of memberFunctionString
1283// Start of memberFunctionString
1284SgAsmCilTypeDefTable* p_TypeDefTable;
1285
1286// End of memberFunctionString
1287// Start of memberFunctionString
1288SgAsmCilTypeRefTable* p_TypeRefTable;
1289
1290// End of memberFunctionString
1291// Start of memberFunctionString
1292SgAsmCilTypeSpecTable* p_TypeSpecTable;
1293
1294// End of memberFunctionString
1295
1296 friend struct Rose::Traits::generated::describe_node_t<SgAsmCilMetadataHeap>;
1297 friend struct Rose::Traits::generated::describe_field_t<SgAsmCilMetadataHeap, uint32_t,&SgAsmCilMetadataHeap::p_ReservedAlwaysZero>;
1298 friend struct Rose::Traits::generated::describe_field_t<SgAsmCilMetadataHeap, uint8_t,&SgAsmCilMetadataHeap::p_MajorVersion>;
1299 friend struct Rose::Traits::generated::describe_field_t<SgAsmCilMetadataHeap, uint8_t,&SgAsmCilMetadataHeap::p_MinorVersion>;
1300 friend struct Rose::Traits::generated::describe_field_t<SgAsmCilMetadataHeap, uint8_t,&SgAsmCilMetadataHeap::p_HeapSizes>;
1301 friend struct Rose::Traits::generated::describe_field_t<SgAsmCilMetadataHeap, uint8_t,&SgAsmCilMetadataHeap::p_ReservedAlwaysOne>;
1302 friend struct Rose::Traits::generated::describe_field_t<SgAsmCilMetadataHeap, uint64_t,&SgAsmCilMetadataHeap::p_Valid>;
1303 friend struct Rose::Traits::generated::describe_field_t<SgAsmCilMetadataHeap, uint64_t,&SgAsmCilMetadataHeap::p_Sorted>;
1304 friend struct Rose::Traits::generated::describe_field_t<SgAsmCilMetadataHeap, std::vector<uint32_t>,&SgAsmCilMetadataHeap::p_NumberOfRows>;
1305 friend struct Rose::Traits::generated::describe_field_t<SgAsmCilMetadataHeap, uint64_t,&SgAsmCilMetadataHeap::p_DataSizeFlags>;
1306 friend struct Rose::Traits::generated::describe_field_t<SgAsmCilMetadataHeap, SgAsmCilAssemblyTable*,&SgAsmCilMetadataHeap::p_AssemblyTable>;
1307 friend struct Rose::Traits::generated::describe_field_t<SgAsmCilMetadataHeap, SgAsmCilAssemblyOSTable*,&SgAsmCilMetadataHeap::p_AssemblyOSTable>;
1308 friend struct Rose::Traits::generated::describe_field_t<SgAsmCilMetadataHeap, SgAsmCilAssemblyProcessorTable*,&SgAsmCilMetadataHeap::p_AssemblyProcessorTable>;
1309 friend struct Rose::Traits::generated::describe_field_t<SgAsmCilMetadataHeap, SgAsmCilAssemblyRefTable*,&SgAsmCilMetadataHeap::p_AssemblyRefTable>;
1310 friend struct Rose::Traits::generated::describe_field_t<SgAsmCilMetadataHeap, SgAsmCilAssemblyRefOSTable*,&SgAsmCilMetadataHeap::p_AssemblyRefOSTable>;
1311 friend struct Rose::Traits::generated::describe_field_t<SgAsmCilMetadataHeap, SgAsmCilAssemblyRefProcessorTable*,&SgAsmCilMetadataHeap::p_AssemblyRefProcessorTable>;
1312 friend struct Rose::Traits::generated::describe_field_t<SgAsmCilMetadataHeap, SgAsmCilClassLayoutTable*,&SgAsmCilMetadataHeap::p_ClassLayoutTable>;
1313 friend struct Rose::Traits::generated::describe_field_t<SgAsmCilMetadataHeap, SgAsmCilConstantTable*,&SgAsmCilMetadataHeap::p_ConstantTable>;
1314 friend struct Rose::Traits::generated::describe_field_t<SgAsmCilMetadataHeap, SgAsmCilCustomAttributeTable*,&SgAsmCilMetadataHeap::p_CustomAttributeTable>;
1315 friend struct Rose::Traits::generated::describe_field_t<SgAsmCilMetadataHeap, SgAsmCilDeclSecurityTable*,&SgAsmCilMetadataHeap::p_DeclSecurityTable>;
1316 friend struct Rose::Traits::generated::describe_field_t<SgAsmCilMetadataHeap, SgAsmCilEventTable*,&SgAsmCilMetadataHeap::p_EventTable>;
1317 friend struct Rose::Traits::generated::describe_field_t<SgAsmCilMetadataHeap, SgAsmCilEventMapTable*,&SgAsmCilMetadataHeap::p_EventMapTable>;
1318 friend struct Rose::Traits::generated::describe_field_t<SgAsmCilMetadataHeap, SgAsmCilExportedTypeTable*,&SgAsmCilMetadataHeap::p_ExportedTypeTable>;
1319 friend struct Rose::Traits::generated::describe_field_t<SgAsmCilMetadataHeap, SgAsmCilFieldTable*,&SgAsmCilMetadataHeap::p_FieldTable>;
1320 friend struct Rose::Traits::generated::describe_field_t<SgAsmCilMetadataHeap, SgAsmCilFieldLayoutTable*,&SgAsmCilMetadataHeap::p_FieldLayoutTable>;
1321 friend struct Rose::Traits::generated::describe_field_t<SgAsmCilMetadataHeap, SgAsmCilFieldMarshalTable*,&SgAsmCilMetadataHeap::p_FieldMarshalTable>;
1322 friend struct Rose::Traits::generated::describe_field_t<SgAsmCilMetadataHeap, SgAsmCilFieldRVATable*,&SgAsmCilMetadataHeap::p_FieldRVATable>;
1323 friend struct Rose::Traits::generated::describe_field_t<SgAsmCilMetadataHeap, SgAsmCilFileTable*,&SgAsmCilMetadataHeap::p_FileTable>;
1324 friend struct Rose::Traits::generated::describe_field_t<SgAsmCilMetadataHeap, SgAsmCilGenericParamTable*,&SgAsmCilMetadataHeap::p_GenericParamTable>;
1325 friend struct Rose::Traits::generated::describe_field_t<SgAsmCilMetadataHeap, SgAsmCilGenericParamConstraintTable*,&SgAsmCilMetadataHeap::p_GenericParamConstraintTable>;
1326 friend struct Rose::Traits::generated::describe_field_t<SgAsmCilMetadataHeap, SgAsmCilImplMapTable*,&SgAsmCilMetadataHeap::p_ImplMapTable>;
1327 friend struct Rose::Traits::generated::describe_field_t<SgAsmCilMetadataHeap, SgAsmCilInterfaceImplTable*,&SgAsmCilMetadataHeap::p_InterfaceImplTable>;
1328 friend struct Rose::Traits::generated::describe_field_t<SgAsmCilMetadataHeap, SgAsmCilManifestResourceTable*,&SgAsmCilMetadataHeap::p_ManifestResourceTable>;
1329 friend struct Rose::Traits::generated::describe_field_t<SgAsmCilMetadataHeap, SgAsmCilMemberRefTable*,&SgAsmCilMetadataHeap::p_MemberRefTable>;
1330 friend struct Rose::Traits::generated::describe_field_t<SgAsmCilMetadataHeap, SgAsmCilMethodDefTable*,&SgAsmCilMetadataHeap::p_MethodDefTable>;
1331 friend struct Rose::Traits::generated::describe_field_t<SgAsmCilMetadataHeap, SgAsmCilMethodImplTable*,&SgAsmCilMetadataHeap::p_MethodImplTable>;
1332 friend struct Rose::Traits::generated::describe_field_t<SgAsmCilMetadataHeap, SgAsmCilMethodSemanticsTable*,&SgAsmCilMetadataHeap::p_MethodSemanticsTable>;
1333 friend struct Rose::Traits::generated::describe_field_t<SgAsmCilMetadataHeap, SgAsmCilMethodSpecTable*,&SgAsmCilMetadataHeap::p_MethodSpecTable>;
1334 friend struct Rose::Traits::generated::describe_field_t<SgAsmCilMetadataHeap, SgAsmCilModuleTable*,&SgAsmCilMetadataHeap::p_ModuleTable>;
1335 friend struct Rose::Traits::generated::describe_field_t<SgAsmCilMetadataHeap, SgAsmCilModuleRefTable*,&SgAsmCilMetadataHeap::p_ModuleRefTable>;
1336 friend struct Rose::Traits::generated::describe_field_t<SgAsmCilMetadataHeap, SgAsmCilNestedClassTable*,&SgAsmCilMetadataHeap::p_NestedClassTable>;
1337 friend struct Rose::Traits::generated::describe_field_t<SgAsmCilMetadataHeap, SgAsmCilParamTable*,&SgAsmCilMetadataHeap::p_ParamTable>;
1338 friend struct Rose::Traits::generated::describe_field_t<SgAsmCilMetadataHeap, SgAsmCilPropertyTable*,&SgAsmCilMetadataHeap::p_PropertyTable>;
1339 friend struct Rose::Traits::generated::describe_field_t<SgAsmCilMetadataHeap, SgAsmCilPropertyMapTable*,&SgAsmCilMetadataHeap::p_PropertyMapTable>;
1340 friend struct Rose::Traits::generated::describe_field_t<SgAsmCilMetadataHeap, SgAsmCilStandAloneSigTable*,&SgAsmCilMetadataHeap::p_StandAloneSigTable>;
1341 friend struct Rose::Traits::generated::describe_field_t<SgAsmCilMetadataHeap, SgAsmCilTypeDefTable*,&SgAsmCilMetadataHeap::p_TypeDefTable>;
1342 friend struct Rose::Traits::generated::describe_field_t<SgAsmCilMetadataHeap, SgAsmCilTypeRefTable*,&SgAsmCilMetadataHeap::p_TypeRefTable>;
1343 friend struct Rose::Traits::generated::describe_field_t<SgAsmCilMetadataHeap, SgAsmCilTypeSpecTable*,&SgAsmCilMetadataHeap::p_TypeSpecTable>;
1344
1345/* #line 21 "/workspace/src/ROSETTA/Grammar/grammarClassDeclarationMacros.macro" */
1346
1347
1348 };
1349#endif
1350
1351// postdeclarations for SgAsmCilMetadataHeap
1352
1353/* #line 1354 "../../../src/frontend/SageIII//SgAsmCilMetadataHeap.h" */
1354
1355/* #line 27 "/workspace/src/ROSETTA/Grammar/grammarClassDeclarationMacros.macro after subst for $POSTDECLARATIONS" */
1356
1357/* #line 28 "/workspace/src/ROSETTA/Grammar/grammarClassDeclarationMacros.macro" */
1358
1359
1360/* #line 1361 "../../../src/frontend/SageIII//SgAsmCilMetadataHeap.h" */
1361
1362#endif // ROSE_SgAsmCilMetadataHeap_H
1363
AST_FILE_IO
Class holding static data and functions supporting File I/O.
Definition AST_FILE_IO.h:19
AstRegExAttribute
Attribute containing a regex expression as a string.
Definition AstAttributeMechanism.h:484
ROSE_VisitTraversal
Definition sageTraversal.h:22
ROSE_VisitorPattern
Definition Cxx_GrammarVisitorSupport.h:7
SgAsmCilAssemblyOSTable
CIL AssemblyOS tables.
Definition binaryInstruction.C:40113
SgAsmCilAssemblyProcessorTable
CIL AssemblyProcessor tables.
Definition binaryInstruction.C:39973
SgAsmCilAssemblyRefOSTable
CIL AssemblyRefOS tables.
Definition binaryInstruction.C:39565
SgAsmCilAssemblyRefProcessorTable
CIL AssemblyRefProcessor tables.
Definition binaryInstruction.C:39406
SgAsmCilAssemblyRefTable
CIL AssemblyRef tables.
Definition binaryInstruction.C:39340
SgAsmCilAssemblyTable
CIL Assembly tables.
Definition binaryInstruction.C:39274
SgAsmCilClassLayoutTable
CIL ClassLayout tables.
Definition binaryInstruction.C:39098
SgAsmCilConstantTable
CIL Constant tables.
Definition binaryInstruction.C:38904
SgAsmCilCustomAttributeTable
CIL CustomAttribute tables.
Definition binaryInstruction.C:38726
SgAsmCilDataStream
Base class for CIL branch of binary analysis IR nodes.
Definition binaryInstruction.C:38579
SgAsmCilDataStream::dump
virtual void dump(std::ostream &os) const
Prints the object's data in a human readable form.
SgAsmCilDataStream::unparse
virtual void unparse(std::vector< uint8_t > &buf, size_t startOfMetaData) const
Unparses the metadata objects into the buffer.
SgAsmCilDataStream::initializeProperties
void initializeProperties()
Initialize all properties that have explicit initial values.
SgAsmCilDeclSecurityTable
CIL DeclSecurity tables.
Definition binaryInstruction.C:38387
SgAsmCilEventMapTable
CIL EventMap tables.
Definition binaryInstruction.C:38116
SgAsmCilExportedTypeTable
CIL ExportedType tables.
Definition binaryInstruction.C:37692
SgAsmCilFieldLayoutTable
CIL FieldLayout tables.
Definition binaryInstruction.C:37422
SgAsmCilFieldMarshalTable
CIL FieldMarshal tables.
Definition binaryInstruction.C:37262
SgAsmCilFieldRVATable
CIL FieldRVA tables.
Definition binaryInstruction.C:37103
SgAsmCilGenericParamConstraintTable
CIL GenericParamConstraint tables.
Definition binaryInstruction.C:36700
SgAsmCilGenericParamTable
CIL GenericParam tables.
Definition binaryInstruction.C:36506
SgAsmCilImplMapTable
CIL ImplMap tables.
Definition binaryInstruction.C:36311
SgAsmCilInterfaceImplTable
CIL InterfaceImpl tables.
Definition binaryInstruction.C:36067
SgAsmCilManifestResourceTable
CIL ManifestResource tables.
Definition binaryInstruction.C:35873
SgAsmCilMemberRefTable
CIL MemberRef tables.
Definition binaryInstruction.C:35695
SgAsmCilMetadataHeap
CIL SgAsmCilMetadataHeap node.
Definition binaryInstruction.C:34826
SgAsmCilMetadata
Base class for CIL branch of binary analysis IR nodes.
Definition binaryInstruction.C:40589
SgAsmCilMethodDefTable
CIL MethodDef tables.
Definition binaryInstruction.C:34073
SgAsmCilMethodImplTable
CIL MethodImpl tables.
Definition binaryInstruction.C:33895
SgAsmCilMethodSemanticsTable
CIL MethodSemantics tables.
Definition binaryInstruction.C:33718
SgAsmCilMethodSpecTable
CIL MethodSpec tables.
Definition binaryInstruction.C:33558
SgAsmCilModuleRefTable
CIL ModuleRef tables.
Definition binaryInstruction.C:33269
SgAsmCilNestedClassTable
CIL NestedClass tables.
Definition binaryInstruction.C:33043
SgAsmCilPropertyMapTable
CIL PropertyMap tables.
Definition binaryInstruction.C:32596
SgAsmCilPropertyTable
CIL Property tables.
Definition binaryInstruction.C:32530
SgAsmCilStandAloneSigTable
CIL StandAloneSig tables.
Definition binaryInstruction.C:32388
SgAsmCilTypeDefTable
CIL TypeDef tables.
Definition binaryInstruction.C:32156
SgAsmCilTypeRefTable
CIL TypeRef tables.
Definition binaryInstruction.C:31978
SgAsmCilTypeSpecTable
CIL TypeSpec tables.
Definition binaryInstruction.C:31836
SgCopyHelp
Supporting class from copy mechanism within ROSE.
Definition sageCopy.h:26
SgNode
This class represents the base class for all IR nodes within Sage III.
Definition Cxx_Grammar.h:120
SgNode::get_numberOfTraversalSuccessors
virtual size_t get_numberOfTraversalSuccessors()
return number of children in the traversal successor list
SgNode::roseRTI
virtual RTIReturnType roseRTI()
return C++ Runtime-Time-Information
SgNode::get_traversalSuccessorNamesContainer
virtual std::vector< std::string > get_traversalSuccessorNamesContainer()
container of names of variables or container indices used used in the traversal to access AST success...
SgNode::debugSerializationEnd
virtual void debugSerializationEnd(const char *className)
Called by generated serializers.
Definition Cxx_Grammar.h:1153
SgNode::getNodeIdString
static std::string getNodeIdString(SgNode *sgnode)
compute the NodeId for a particular SgNode*.
SgNode::isInMemoryPool
virtual bool isInMemoryPool()
FOR INTERNAL USE This is used in internal tests to verify that all IR nodes are allocated from the he...
SgNode::variant
int variant() const
Older version function returns enum value "NODE".
Definition Cxx_Grammar.h:609
SgNode::processDataMemberReferenceToPointers
virtual void processDataMemberReferenceToPointers(ReferenceToPointerHandler *)
FOR INTERNAL USE Processes pairs of references to SgNode* and strings for use in AST tools
SgNode::variantT
virtual VariantT variantT() const
returns new style SageIII enum values
SgNode::getChildIndex
virtual long getChildIndex(SgNode *childNode) const
FOR INTERNAL USE Returns a unique index value for the childNode in the list of children at this IR no...
SgNode::get_childIndex
virtual size_t get_childIndex(SgNode *child)
index-based access to traversal successors by child node
SgNode::debugSerializationBegin
virtual void debugSerializationBegin(const char *className)
Called by generated serializers.
Definition Cxx_Grammar.h:1150
SgNode::get_traversalSuccessorContainer
virtual std::vector< SgNode * > get_traversalSuccessorContainer()
container of pointers to AST successor nodes used in the traversal overridden in every class by gener...
SgNode::class_name
virtual std::string class_name() const
returns a string representing the class name
SgNode::visitRepresentativeNode
static void visitRepresentativeNode(ROSE_VisitTraversal &visit)
FOR INTERNAL USE Support for type-based traversal.
SgNode::checkDataMemberPointersIfInMemoryPool
virtual void checkDataMemberPointersIfInMemoryPool()
FOR INTERNAL USE This is used in internal tests to verify that all IR nodes are allocated from the he...
SgNode::numberOfNodes
static size_t numberOfNodes()
Returns the total number of IR nodes of this type.
SgNode::accept
virtual void accept(ROSE_VisitorPattern &visitor)
support for the classic visitor pattern done in GoF
SgNode::get_traversalSuccessorByIndex
virtual SgNode * get_traversalSuccessorByIndex(size_t idx)
index-based access to traversal successors by index number
SgNode::traverseMemoryPoolVisitorPattern
static void traverseMemoryPoolVisitorPattern(ROSE_VisitorPattern &visitor)
FOR INTERNAL USE Support for visitor pattern.
SgNode::executeVisitorMemberFunction
void executeVisitorMemberFunction(ROSE_VisitorPattern &visitor)
FOR INTERNAL USE Support for visitor pattern.
SgNode::getNodeByNodeId
static SgNode * getNodeByNodeId(VariantT variantT, size_t poolIdx, size_t itemIdx)
Find a node by its variant type, pool index, and item index.
SgNode::memoryUsage
static size_t memoryUsage()
Returns the size in bytes of the total memory allocated for all IR nodes of this type.
SgNode::traverseMemoryPoolNodes
static void traverseMemoryPoolNodes(ROSE_VisitTraversal &visit)
FOR INTERNAL USE Support for visitor pattern over all IR nodes by type of IR node.
SgNode::sage_class_name
virtual const char * sage_class_name() const
generates string representing the class name: (e.g. for SgNode returns "SgNode").
SgNode::returnDataMemberPointers
virtual std::vector< std::pair< SgNode *, std::string > > returnDataMemberPointers() const
FOR INTERNAL USE Returns STL vector of pairs of SgNode* and strings for use in AST tools
SgNode::getNodeByNodeIdInternal
static SgNode * getNodeByNodeIdInternal(size_t poolIdx, size_t itemIdx)
FOR INTERNAL USE Find an SgNode from its memory pool and location therin.
SgNode::addRegExpAttribute
SgNode * addRegExpAttribute(std::string s, AstRegExAttribute *a)
Support for AST matching using regular expression.
Rose::BinaryAnalysis::Dwarf::parse
void parse(SgAsmGenericFile *)
Main function to parse DWARF information.
Rose::GraphUtility::serialize
void serialize(std::ostream &output, Graph &graph)
Serialize a graph into a stream of bytes.
Definition GraphUtility.h:17
Sawyer::Container::BitVectorSupport::copy
void copy(const Word *src, const BitRange &srcRange, Word *dst, const BitRange &dstRange)
Copy some bits.
Definition BitVectorSupport.h:448
stringify::SgAsmCilMetadataHeap::ReferenceKind
const char * ReferenceKind(int64_t)
Convert SgAsmCilMetadataHeap::ReferenceKind enum constant to a string.
Rose::Traits::generated::describe_field_t
Definition Cxx_Grammar.h:91
Rose::Traits::generated::describe_node_t
Definition Cxx_Grammar.h:90
Generated on Mon Sep 30 2024 03:24:51 for ROSE by doxygen 1.9.8