ROSE  0.11.145.0
binaryInstruction.C
1 // THIS FILE IS MACHINE GENERATED -- DO NOT MODIFY
4 //
5 // This file was generated with ROSE's "rosebud" tool by reading node definitions written in a
6 // C++-like language and emitting this ROSETTA input.
7 //
9 // DO NOT MODIFY THIS FILE MANUALLY!
11 
12 
13 #include <featureTests.h>
14 #if defined(ROSE_ENABLE_BINARY_ANALYSIS)
15 #include "ROSETTA_macros.h"
16 #include "grammar.h"
17 #include "AstNodeClass.h"
18 
19 //#undef DOCUMENTATION -- commented out so IDEs can't figure it out
20 #ifdef DOCUMENTATION
21 DOCUMENTATION_should_never_be_defined;
22 #endif
23 
24 #ifdef DOCUMENTATION
25 #define DECLARE_LEAF_CLASS(CLASS_WITHOUT_Sg) /*void*/
26 #else
27 #define DECLARE_LEAF_CLASS(CLASS_WITHOUT_Sg) \
28  NEW_TERMINAL_MACRO(CLASS_WITHOUT_Sg, #CLASS_WITHOUT_Sg, #CLASS_WITHOUT_Sg "Tag"); \
29  CLASS_WITHOUT_Sg.setCppCondition("!defined(DOCUMENTATION)");\
30  CLASS_WITHOUT_Sg.setAutomaticGenerationOfConstructor(false);\
31  CLASS_WITHOUT_Sg.setAutomaticGenerationOfDestructor(false)
32 #endif
33 
34 #ifdef DOCUMENTATION
35 #define DECLARE_HEADERS(CLASS_WITHOUT_Sg) /*void*/
36 #else
37 #define DECLARE_HEADERS(CLASS_WITHOUT_Sg) \
38  CLASS_WITHOUT_Sg.setPredeclarationString("Sg" #CLASS_WITHOUT_Sg "_HEADERS", \
39  ROSE_AUTOMAKE_ABSOLUTE_PATH_TOP_SRCDIR + "/src/ROSETTA/src/binaryInstruction.C")
40 #endif
41 
42 #ifdef DOCUMENTATION
43 #define DECLARE_OTHERS(CLASS_WITHOUT_Sg) /*void*/
44 #else
45 #define DECLARE_OTHERS(CLASS_WITHOUT_Sg) \
46  CLASS_WITHOUT_Sg.setFunctionPrototype("Sg" #CLASS_WITHOUT_Sg "_OTHERS", \
47  ROSE_AUTOMAKE_ABSOLUTE_PATH_TOP_SRCDIR + "/src/ROSETTA/src/binaryInstruction.C")
48 #endif
49 
50 #ifdef DOCUMENTATION
51 #define IS_SERIALIZABLE() /*void*/
52 #else
53 #define IS_SERIALIZABLE(CLASS_WITHOUT_Sg) \
54  CLASS_WITHOUT_Sg.isBoostSerializable(true)
55 #endif
56 
57 
58 // Since ROSETTA builds classes from the leaves up to the base, and C++ builds classes from the
59 // base down to the leaves, we need to make sure that doxygen sees the base classes before the derived classes. So
60 // just list all the non-leaf classes here.
61 #ifdef DOCUMENTATION
63 class SgAsmCilDataStream;
64 class SgAsmCilMetadata;
65 class SgAsmCilNode;
69 class SgAsmElfSection;
71 class SgAsmExpression;
72 class SgAsmGenericHeader;
74 class SgAsmGenericString;
75 class SgAsmGenericStrtab;
76 class SgAsmGenericSymbol;
77 class SgAsmInstruction;
78 class SgAsmJvmAttribute;
79 class SgAsmJvmNode;
80 class SgAsmNode;
81 class SgAsmPESection;
83 class SgAsmScalarType;
84 class SgAsmStatement;
86 class SgAsmType;
89 class SgNode;
90 #endif // DOCUMENTATION
91 
92 #ifndef DOCUMENTATION
93 void Grammar::setUpBinaryInstructions() {
94 #endif // !DOCUMENTATION
95 
96 
98 // SgAsmX86Instruction -- MACHINE GENERATED; DO NOT MODIFY --
100 
101 DECLARE_LEAF_CLASS(AsmX86Instruction);
102 IS_SERIALIZABLE(AsmX86Instruction);
103 
104 DECLARE_HEADERS(AsmX86Instruction);
105 #if defined(SgAsmX86Instruction_HEADERS) || defined(DOCUMENTATION)
106 #include <Rose/BinaryAnalysis/BasicTypes.h>
107 #include <Rose/BinaryAnalysis/InstructionEnumsX86.h>
108 #endif // SgAsmX86Instruction_HEADERS
109 
110 #ifdef DOCUMENTATION
111 
113 #endif // DOCUMENTATION
114 
115 #ifndef DOCUMENTATION
116  AsmX86Instruction.setDataPrototype(
117  "Rose::BinaryAnalysis::X86InstructionKind", "kind", "= Rose::BinaryAnalysis::x86_unknown_instruction",
118  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
119 #endif // !DOCUMENTATION
120 
121 #ifndef DOCUMENTATION
122  AsmX86Instruction.setDataPrototype(
123  "Rose::BinaryAnalysis::X86InstructionSize", "baseSize", "= Rose::BinaryAnalysis::x86_insnsize_none",
124  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
125 #endif // !DOCUMENTATION
126 
127 #ifndef DOCUMENTATION
128  AsmX86Instruction.setDataPrototype(
129  "Rose::BinaryAnalysis::X86InstructionSize", "operandSize", "= Rose::BinaryAnalysis::x86_insnsize_none",
130  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
131 #endif // !DOCUMENTATION
132 
133 #ifndef DOCUMENTATION
134  AsmX86Instruction.setDataPrototype(
135  "Rose::BinaryAnalysis::X86InstructionSize", "addressSize", "= Rose::BinaryAnalysis::x86_insnsize_none",
136  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
137 #endif // !DOCUMENTATION
138 
139 #ifndef DOCUMENTATION
140  AsmX86Instruction.setDataPrototype(
141  "bool", "lockPrefix", "= false",
142  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
143 #endif // !DOCUMENTATION
144 
145 #ifndef DOCUMENTATION
146  AsmX86Instruction.setDataPrototype(
147  "Rose::BinaryAnalysis::X86RepeatPrefix", "repeatPrefix", "= Rose::BinaryAnalysis::x86_repeat_none",
148  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
149 #endif // !DOCUMENTATION
150 
151 #ifndef DOCUMENTATION
152  AsmX86Instruction.setDataPrototype(
153  "Rose::BinaryAnalysis::X86BranchPrediction", "branchPrediction", "= Rose::BinaryAnalysis::x86_branch_prediction_none",
154  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
155 #endif // !DOCUMENTATION
156 
157 #ifndef DOCUMENTATION
158  AsmX86Instruction.setDataPrototype(
159  "Rose::BinaryAnalysis::X86SegmentRegister", "segmentOverride", "= Rose::BinaryAnalysis::x86_segreg_none",
160  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
161 #endif // !DOCUMENTATION
162 
163  DECLARE_OTHERS(AsmX86Instruction);
164 #if defined(SgAsmX86Instruction_OTHERS) || defined(DOCUMENTATION)
165 
166  //----------------------- Boost serialization for SgAsmX86Instruction -----------------------
167 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
168 private:
169  friend class boost::serialization::access;
170 
171  template<class S>
172  void serialize(S &s, const unsigned /*version*/) {
173  debugSerializationBegin("SgAsmX86Instruction");
174  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmInstruction);
175  s & BOOST_SERIALIZATION_NVP(p_kind);
176  s & BOOST_SERIALIZATION_NVP(p_baseSize);
177  s & BOOST_SERIALIZATION_NVP(p_operandSize);
178  s & BOOST_SERIALIZATION_NVP(p_addressSize);
179  s & BOOST_SERIALIZATION_NVP(p_lockPrefix);
180  s & BOOST_SERIALIZATION_NVP(p_repeatPrefix);
181  s & BOOST_SERIALIZATION_NVP(p_branchPrediction);
182  s & BOOST_SERIALIZATION_NVP(p_segmentOverride);
183  debugSerializationEnd("SgAsmX86Instruction");
184  }
185 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
186 public:
187 public:
198 public:
206 public:
214 public:
222 public:
228  bool const& get_lockPrefix() const;
229  void set_lockPrefix(bool const&);
232 public:
240 public:
248 public:
258 public:
263 
268 
274 
280 
281  // Overrides are documented in the base class
282  virtual bool terminatesBasicBlock() override;
283  virtual bool isFunctionCallFast(const std::vector<SgAsmInstruction*>&,
284  rose_addr_t *target, rose_addr_t *ret) override;
285  virtual bool isFunctionCallSlow(const std::vector<SgAsmInstruction*>&,
286  rose_addr_t *target, rose_addr_t *ret) override;
287  virtual bool isFunctionReturnFast(const std::vector<SgAsmInstruction*>&) override;
288  virtual bool isFunctionReturnSlow(const std::vector<SgAsmInstruction*>&) override;
289  virtual Sawyer::Optional<rose_addr_t> branchTarget() override;
290  virtual Rose::BinaryAnalysis::AddressSet getSuccessors(bool &complete) override;
291  virtual Rose::BinaryAnalysis::AddressSet getSuccessors(const std::vector<SgAsmInstruction*>&,
292  bool &complete,
293  const Rose::BinaryAnalysis::MemoryMap::Ptr &initial_memory =
295  virtual bool isUnknown() const override;
296  virtual unsigned get_anyKind() const override;
297 public:
299  virtual ~SgAsmX86Instruction();
300 
301 public:
304 
305 public:
307  SgAsmX86Instruction(rose_addr_t const& address,
308  std::string const& mnemonic,
311  Rose::BinaryAnalysis::X86InstructionSize const& operandSize,
312  Rose::BinaryAnalysis::X86InstructionSize const& addressSize);
313 
314 protected:
321  void initializeProperties();
322 #endif // SgAsmX86Instruction_OTHERS
323 #ifdef DOCUMENTATION
324 };
325 #endif // DOCUMENTATION
326 
327 
329 // SgAsmDwarfVolatileType -- MACHINE GENERATED; DO NOT MODIFY --
331 
332 DECLARE_LEAF_CLASS(AsmDwarfVolatileType);
333 IS_SERIALIZABLE(AsmDwarfVolatileType);
334 
335 #ifdef DOCUMENTATION
337 #endif // DOCUMENTATION
338 
339  DECLARE_OTHERS(AsmDwarfVolatileType);
340 #if defined(SgAsmDwarfVolatileType_OTHERS) || defined(DOCUMENTATION)
341 
342  //----------------------- Boost serialization for SgAsmDwarfVolatileType -----------------------
343 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
344 private:
345  friend class boost::serialization::access;
346 
347  template<class S>
348  void serialize(S &s, const unsigned /*version*/) {
349  debugSerializationBegin("SgAsmDwarfVolatileType");
350  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
351  debugSerializationEnd("SgAsmDwarfVolatileType");
352  }
353 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
354 
355 public:
357  virtual ~SgAsmDwarfVolatileType();
358 
359 public:
362 
363 public:
365  SgAsmDwarfVolatileType(int const& nesting_level,
366  uint64_t const& offset,
367  uint64_t const& overall_offset);
368 
369 protected:
376  void initializeProperties();
377 #endif // SgAsmDwarfVolatileType_OTHERS
378 #ifdef DOCUMENTATION
379 };
380 #endif // DOCUMENTATION
381 
382 
384 // SgAsmVectorType -- MACHINE GENERATED; DO NOT MODIFY --
386 
387 DECLARE_LEAF_CLASS(AsmVectorType);
388 IS_SERIALIZABLE(AsmVectorType);
389 
390 #ifdef DOCUMENTATION
391 
392 class SgAsmVectorType: public SgAsmType {
393 #endif // DOCUMENTATION
394 
395 #ifndef DOCUMENTATION
396  AsmVectorType.setDataPrototype(
397  "size_t", "nElmts", "= 0",
398  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
399 #endif // !DOCUMENTATION
400 
401 #ifndef DOCUMENTATION
402  AsmVectorType.setDataPrototype(
403  "SgAsmType*", "elmtType", "= nullptr",
404  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
405 #endif // !DOCUMENTATION
406 
407  DECLARE_OTHERS(AsmVectorType);
408 #if defined(SgAsmVectorType_OTHERS) || defined(DOCUMENTATION)
409 
410  //----------------------- Boost serialization for SgAsmVectorType -----------------------
411 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
412 private:
413  friend class boost::serialization::access;
414 
415  template<class S>
416  void serialize(S &s, const unsigned /*version*/) {
417  debugSerializationBegin("SgAsmVectorType");
418  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmType);
419  s & BOOST_SERIALIZATION_NVP(p_nElmts);
420  s & BOOST_SERIALIZATION_NVP(p_elmtType);
421  debugSerializationEnd("SgAsmVectorType");
422  }
423 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
424 
425 public:
431 public:
436 public:
438  SgAsmVectorType(size_t nElmts, SgAsmType *elmtType);
439 
441  size_t get_nElmts() const;
442 
444  SgAsmType* get_elmtType() const;
445 
446  // Overrides documented in base class
447  virtual void check() const override;
448  virtual std::string toString() const override;
449  virtual size_t get_nBits() const override;
450 public:
452  virtual ~SgAsmVectorType();
453 
454 public:
456  SgAsmVectorType();
457 
458 protected:
465  void initializeProperties();
466 #endif // SgAsmVectorType_OTHERS
467 #ifdef DOCUMENTATION
468 };
469 #endif // DOCUMENTATION
470 
471 
473 // SgAsmUnaryUnsignedExtend -- MACHINE GENERATED; DO NOT MODIFY --
475 
476 DECLARE_LEAF_CLASS(AsmUnaryUnsignedExtend);
477 IS_SERIALIZABLE(AsmUnaryUnsignedExtend);
478 
479 #ifdef DOCUMENTATION
480 
486 #endif // DOCUMENTATION
487 
488  DECLARE_OTHERS(AsmUnaryUnsignedExtend);
489 #if defined(SgAsmUnaryUnsignedExtend_OTHERS) || defined(DOCUMENTATION)
490 
491  //----------------------- Boost serialization for SgAsmUnaryUnsignedExtend -----------------------
492 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
493 private:
494  friend class boost::serialization::access;
495 
496  template<class S>
497  void serialize(S &s, const unsigned /*version*/) {
498  debugSerializationBegin("SgAsmUnaryUnsignedExtend");
499  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmUnaryExpression);
500  debugSerializationEnd("SgAsmUnaryUnsignedExtend");
501  }
502 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
503 
504 public:
506  virtual ~SgAsmUnaryUnsignedExtend();
507 
508 public:
511 
512 public:
514  explicit SgAsmUnaryUnsignedExtend(SgAsmExpression* const& operand);
515 
516 protected:
523  void initializeProperties();
524 #endif // SgAsmUnaryUnsignedExtend_OTHERS
525 #ifdef DOCUMENTATION
526 };
527 #endif // DOCUMENTATION
528 
529 
531 // SgAsmUnaryTruncate -- MACHINE GENERATED; DO NOT MODIFY --
533 
534 DECLARE_LEAF_CLASS(AsmUnaryTruncate);
535 IS_SERIALIZABLE(AsmUnaryTruncate);
536 
537 #ifdef DOCUMENTATION
538 
544 #endif // DOCUMENTATION
545 
546  DECLARE_OTHERS(AsmUnaryTruncate);
547 #if defined(SgAsmUnaryTruncate_OTHERS) || defined(DOCUMENTATION)
548 
549  //----------------------- Boost serialization for SgAsmUnaryTruncate -----------------------
550 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
551 private:
552  friend class boost::serialization::access;
553 
554  template<class S>
555  void serialize(S &s, const unsigned /*version*/) {
556  debugSerializationBegin("SgAsmUnaryTruncate");
557  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmUnaryExpression);
558  debugSerializationEnd("SgAsmUnaryTruncate");
559  }
560 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
561 
562 public:
564  virtual ~SgAsmUnaryTruncate();
565 
566 public:
569 
570 public:
572  explicit SgAsmUnaryTruncate(SgAsmExpression* const& operand);
573 
574 protected:
581  void initializeProperties();
582 #endif // SgAsmUnaryTruncate_OTHERS
583 #ifdef DOCUMENTATION
584 };
585 #endif // DOCUMENTATION
586 
587 
589 // SgAsmUnarySignedExtend -- MACHINE GENERATED; DO NOT MODIFY --
591 
592 DECLARE_LEAF_CLASS(AsmUnarySignedExtend);
593 IS_SERIALIZABLE(AsmUnarySignedExtend);
594 
595 #ifdef DOCUMENTATION
596 
602 #endif // DOCUMENTATION
603 
604  DECLARE_OTHERS(AsmUnarySignedExtend);
605 #if defined(SgAsmUnarySignedExtend_OTHERS) || defined(DOCUMENTATION)
606 
607  //----------------------- Boost serialization for SgAsmUnarySignedExtend -----------------------
608 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
609 private:
610  friend class boost::serialization::access;
611 
612  template<class S>
613  void serialize(S &s, const unsigned /*version*/) {
614  debugSerializationBegin("SgAsmUnarySignedExtend");
615  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmUnaryExpression);
616  debugSerializationEnd("SgAsmUnarySignedExtend");
617  }
618 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
619 
620 public:
622  virtual ~SgAsmUnarySignedExtend();
623 
624 public:
627 
628 public:
630  explicit SgAsmUnarySignedExtend(SgAsmExpression* const& operand);
631 
632 protected:
639  void initializeProperties();
640 #endif // SgAsmUnarySignedExtend_OTHERS
641 #ifdef DOCUMENTATION
642 };
643 #endif // DOCUMENTATION
644 
645 
647 // SgAsmUnaryRrx -- MACHINE GENERATED; DO NOT MODIFY --
649 
650 DECLARE_LEAF_CLASS(AsmUnaryRrx);
651 IS_SERIALIZABLE(AsmUnaryRrx);
652 
653 DECLARE_HEADERS(AsmUnaryRrx);
654 #if defined(SgAsmUnaryRrx_HEADERS) || defined(DOCUMENTATION)
655 // FIXME[Robb P Matzke 2016-10-31]: no idea what this is
656 #endif // SgAsmUnaryRrx_HEADERS
657 
658 #ifdef DOCUMENTATION
660 #endif // DOCUMENTATION
661 
662  DECLARE_OTHERS(AsmUnaryRrx);
663 #if defined(SgAsmUnaryRrx_OTHERS) || defined(DOCUMENTATION)
664 
665  //----------------------- Boost serialization for SgAsmUnaryRrx -----------------------
666 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
667 private:
668  friend class boost::serialization::access;
669 
670  template<class S>
671  void serialize(S &s, const unsigned /*version*/) {
672  debugSerializationBegin("SgAsmUnaryRrx");
673  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmUnaryExpression);
674  debugSerializationEnd("SgAsmUnaryRrx");
675  }
676 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
677 
678 public:
680  virtual ~SgAsmUnaryRrx();
681 
682 public:
684  SgAsmUnaryRrx();
685 
686 public:
688  explicit SgAsmUnaryRrx(SgAsmExpression* const& operand);
689 
690 protected:
697  void initializeProperties();
698 #endif // SgAsmUnaryRrx_OTHERS
699 #ifdef DOCUMENTATION
700 };
701 #endif // DOCUMENTATION
702 
703 
705 // SgAsmUnaryPlus -- MACHINE GENERATED; DO NOT MODIFY --
707 
708 DECLARE_LEAF_CLASS(AsmUnaryPlus);
709 IS_SERIALIZABLE(AsmUnaryPlus);
710 
711 #ifdef DOCUMENTATION
712 
714 #endif // DOCUMENTATION
715 
716  DECLARE_OTHERS(AsmUnaryPlus);
717 #if defined(SgAsmUnaryPlus_OTHERS) || defined(DOCUMENTATION)
718 
719  //----------------------- Boost serialization for SgAsmUnaryPlus -----------------------
720 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
721 private:
722  friend class boost::serialization::access;
723 
724  template<class S>
725  void serialize(S &s, const unsigned /*version*/) {
726  debugSerializationBegin("SgAsmUnaryPlus");
727  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmUnaryExpression);
728  debugSerializationEnd("SgAsmUnaryPlus");
729  }
730 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
731 
732 public:
734  virtual ~SgAsmUnaryPlus();
735 
736 public:
738  SgAsmUnaryPlus();
739 
740 public:
742  explicit SgAsmUnaryPlus(SgAsmExpression* const& operand);
743 
744 protected:
751  void initializeProperties();
752 #endif // SgAsmUnaryPlus_OTHERS
753 #ifdef DOCUMENTATION
754 };
755 #endif // DOCUMENTATION
756 
757 
759 // SgAsmUnaryMinus -- MACHINE GENERATED; DO NOT MODIFY --
761 
762 DECLARE_LEAF_CLASS(AsmUnaryMinus);
763 IS_SERIALIZABLE(AsmUnaryMinus);
764 
765 #ifdef DOCUMENTATION
766 
768 #endif // DOCUMENTATION
769 
770  DECLARE_OTHERS(AsmUnaryMinus);
771 #if defined(SgAsmUnaryMinus_OTHERS) || defined(DOCUMENTATION)
772 
773  //----------------------- Boost serialization for SgAsmUnaryMinus -----------------------
774 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
775 private:
776  friend class boost::serialization::access;
777 
778  template<class S>
779  void serialize(S &s, const unsigned /*version*/) {
780  debugSerializationBegin("SgAsmUnaryMinus");
781  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmUnaryExpression);
782  debugSerializationEnd("SgAsmUnaryMinus");
783  }
784 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
785 
786 public:
788  virtual ~SgAsmUnaryMinus();
789 
790 public:
792  SgAsmUnaryMinus();
793 
794 public:
796  explicit SgAsmUnaryMinus(SgAsmExpression* const& operand);
797 
798 protected:
805  void initializeProperties();
806 #endif // SgAsmUnaryMinus_OTHERS
807 #ifdef DOCUMENTATION
808 };
809 #endif // DOCUMENTATION
810 
811 
813 // SgAsmUnaryExpression -- MACHINE GENERATED; DO NOT MODIFY --
815 
816 #ifndef DOCUMENTATION
817 AstNodeClass& AsmUnaryExpression = nonTerminalConstructor(
818  "AsmUnaryExpression",
819  *this,
820  "AsmUnaryExpression",
821  "AsmUnaryExpressionTag",
822  SubclassListBuilder()
823  | AsmUnaryMinus
824  | AsmUnaryPlus
825  | AsmUnaryRrx
826  | AsmUnarySignedExtend
827  | AsmUnaryTruncate
828  | AsmUnaryUnsignedExtend
829  , false);
830 assert(AsmUnaryExpression.associatedGrammar != nullptr);
831 AsmUnaryExpression.setCppCondition("!defined(DOCUMENTATION)");
832 AsmUnaryExpression.isBoostSerializable(true);
833 AsmUnaryExpression.setAutomaticGenerationOfConstructor(false);
834 AsmUnaryExpression.setAutomaticGenerationOfDestructor(false);
835 #endif // !DOCUMENTATION
836 
837 #ifdef DOCUMENTATION
838 
840 #endif // DOCUMENTATION
841 
842 #ifndef DOCUMENTATION
843  AsmUnaryExpression.setDataPrototype(
844  "SgAsmExpression*", "operand", "= nullptr",
845  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
846 #endif // !DOCUMENTATION
847 
848  DECLARE_OTHERS(AsmUnaryExpression);
849 #if defined(SgAsmUnaryExpression_OTHERS) || defined(DOCUMENTATION)
850 
851  //----------------------- Boost serialization for SgAsmUnaryExpression -----------------------
852 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
853 private:
854  friend class boost::serialization::access;
855 
856  template<class S>
857  void serialize(S &s, const unsigned /*version*/) {
858  debugSerializationBegin("SgAsmUnaryExpression");
859  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExpression);
860  s & BOOST_SERIALIZATION_NVP(p_operand);
861  debugSerializationEnd("SgAsmUnaryExpression");
862  }
863 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
864 
865 public:
869  SgAsmExpression* const& get_operand() const;
870  void set_operand(SgAsmExpression* const&);
873 public:
875  virtual ~SgAsmUnaryExpression();
876 
877 protected:
880 
881 protected:
883  explicit SgAsmUnaryExpression(SgAsmExpression* const& operand);
884 
885 protected:
892  void initializeProperties();
893 #endif // SgAsmUnaryExpression_OTHERS
894 #ifdef DOCUMENTATION
895 };
896 #endif // DOCUMENTATION
897 
898 
900 // SgAsmSynthesizedFieldDeclaration -- MACHINE GENERATED; DO NOT MODIFY --
902 
903 DECLARE_LEAF_CLASS(AsmSynthesizedFieldDeclaration);
904 IS_SERIALIZABLE(AsmSynthesizedFieldDeclaration);
905 
906 DECLARE_HEADERS(AsmSynthesizedFieldDeclaration);
907 #if defined(SgAsmSynthesizedFieldDeclaration_HEADERS) || defined(DOCUMENTATION)
908 // FIXME[Robb P Matzke 2017-02-13]: what is this?
909 #endif // SgAsmSynthesizedFieldDeclaration_HEADERS
910 
911 #ifdef DOCUMENTATION
913 #endif // DOCUMENTATION
914 
915 #ifndef DOCUMENTATION
916  AsmSynthesizedFieldDeclaration.setDataPrototype(
917  "std::string", "name", "",
918  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
919 #endif // !DOCUMENTATION
920 
921 #ifndef DOCUMENTATION
922  AsmSynthesizedFieldDeclaration.setDataPrototype(
923  "uint64_t", "offset", "= 0",
924  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
925 #endif // !DOCUMENTATION
926 
927  DECLARE_OTHERS(AsmSynthesizedFieldDeclaration);
928 #if defined(SgAsmSynthesizedFieldDeclaration_OTHERS) || defined(DOCUMENTATION)
929 
930  //----------------------- Boost serialization for SgAsmSynthesizedFieldDeclaration -----------------------
931 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
932 private:
933  friend class boost::serialization::access;
934 
935  template<class S>
936  void serialize(S &s, const unsigned /*version*/) {
937  debugSerializationBegin("SgAsmSynthesizedFieldDeclaration");
938  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmSynthesizedDeclaration);
939  s & BOOST_SERIALIZATION_NVP(p_name);
940  s & BOOST_SERIALIZATION_NVP(p_offset);
941  debugSerializationEnd("SgAsmSynthesizedFieldDeclaration");
942  }
943 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
944 
945 public:
949  std::string const& get_name() const;
950  void set_name(std::string const&);
952  // FIXME[Robb P Matzke 2017-02-13]: Is this bytes, bits, or what?
953  // Not clear if we want to store the offset explicitly
954 public:
958  uint64_t const& get_offset() const;
959  void set_offset(uint64_t const&);
962 public:
965 
966 public:
969 
970 public:
972  explicit SgAsmSynthesizedFieldDeclaration(rose_addr_t const& address);
973 
974 protected:
981  void initializeProperties();
982 #endif // SgAsmSynthesizedFieldDeclaration_OTHERS
983 #ifdef DOCUMENTATION
984 };
985 #endif // DOCUMENTATION
986 
987 
989 // SgAsmSynthesizedDataStructureDeclaration -- MACHINE GENERATED; DO NOT MODIFY --
991 
992 DECLARE_LEAF_CLASS(AsmSynthesizedDataStructureDeclaration);
993 IS_SERIALIZABLE(AsmSynthesizedDataStructureDeclaration);
994 
995 #ifdef DOCUMENTATION
996 
1007 #endif // DOCUMENTATION
1008 
1009  DECLARE_OTHERS(AsmSynthesizedDataStructureDeclaration);
1010 #if defined(SgAsmSynthesizedDataStructureDeclaration_OTHERS) || defined(DOCUMENTATION)
1011 
1012  //----------------------- Boost serialization for SgAsmSynthesizedDataStructureDeclaration -----------------------
1013 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
1014 private:
1015  friend class boost::serialization::access;
1016 
1017  template<class S>
1018  void serialize(S &s, const unsigned /*version*/) {
1019  debugSerializationBegin("SgAsmSynthesizedDataStructureDeclaration");
1020  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmSynthesizedDeclaration);
1021  debugSerializationEnd("SgAsmSynthesizedDataStructureDeclaration");
1022  }
1023 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
1024 protected:
1025  SgAsmSynthesizedDeclarationPtrList p_declarationList;
1026 
1027 public:
1030  p_declarationList.push_back(declaration);
1031  }
1032 public:
1035 
1036 public:
1039 
1040 public:
1042  explicit SgAsmSynthesizedDataStructureDeclaration(rose_addr_t const& address);
1043 
1044 protected:
1051  void initializeProperties();
1052 #endif // SgAsmSynthesizedDataStructureDeclaration_OTHERS
1053 #ifdef DOCUMENTATION
1054 };
1055 #endif // DOCUMENTATION
1056 
1057 
1059 // SgAsmStringStorage -- MACHINE GENERATED; DO NOT MODIFY --
1061 
1062 DECLARE_LEAF_CLASS(AsmStringStorage);
1063 IS_SERIALIZABLE(AsmStringStorage);
1064 
1065 #ifdef DOCUMENTATION
1066 
1068 #endif // DOCUMENTATION
1069 
1070 #ifndef DOCUMENTATION
1071  AsmStringStorage.setDataPrototype(
1072  "SgAsmGenericStrtab*", "strtab", "= nullptr",
1073  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
1074 #endif // !DOCUMENTATION
1075 
1076 #ifndef DOCUMENTATION
1077  AsmStringStorage.setDataPrototype(
1078  "std::string", "string", "",
1079  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
1080 #endif // !DOCUMENTATION
1081 
1082 #ifndef DOCUMENTATION
1083  AsmStringStorage.setDataPrototype(
1084  "rose_addr_t", "offset", "= 0",
1085  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
1086 #endif // !DOCUMENTATION
1087 
1088  DECLARE_OTHERS(AsmStringStorage);
1089 #if defined(SgAsmStringStorage_OTHERS) || defined(DOCUMENTATION)
1090 
1091  //----------------------- Boost serialization for SgAsmStringStorage -----------------------
1092 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
1093 private:
1094  friend class boost::serialization::access;
1095 
1096  template<class S>
1097  void serialize(S &s, const unsigned /*version*/) {
1098  debugSerializationBegin("SgAsmStringStorage");
1099  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
1100  s & BOOST_SERIALIZATION_NVP(p_strtab);
1101  s & BOOST_SERIALIZATION_NVP(p_string);
1102  s & BOOST_SERIALIZATION_NVP(p_offset);
1103  debugSerializationEnd("SgAsmStringStorage");
1104  }
1105 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
1106 
1107 public:
1111  SgAsmGenericStrtab* const& get_strtab() const;
1112  void set_strtab(SgAsmGenericStrtab* const&);
1115 public:
1119  std::string const& get_string() const;
1120  void set_string(std::string const&);
1123 public:
1127  rose_addr_t const& get_offset() const;
1128  void set_offset(rose_addr_t const&);
1130 public:
1131  SgAsmStringStorage(SgAsmGenericStrtab *strtab, const std::string &string, rose_addr_t offset);
1132 
1133  void dump(FILE *s, const char *prefix, ssize_t idx) const;
1134 
1135  /* Accessors. The set_* accessors are private because we don't want anyone messing with them. These data members are
1136  * used to control string allocation in ELF string tables and must only be modified by allocators in closely related
1137  * classes. For instance, to change the value of the string one should call SgAsmGenericString::set_string()
1138  * instead. */
1139 
1140  private:
1141  friend class SgAsmStoredString; /*allowed to set private data members*/
1142  friend class SgAsmStoredStrtab; /*allowed to set private data members*/
1143 public:
1145  virtual ~SgAsmStringStorage();
1146 
1147 public:
1150 
1151 protected:
1158  void initializeProperties();
1159 #endif // SgAsmStringStorage_OTHERS
1160 #ifdef DOCUMENTATION
1161 };
1162 #endif // DOCUMENTATION
1163 
1164 
1166 // SgAsmStoredString -- MACHINE GENERATED; DO NOT MODIFY --
1168 
1169 DECLARE_LEAF_CLASS(AsmStoredString);
1170 IS_SERIALIZABLE(AsmStoredString);
1171 
1172 #ifdef DOCUMENTATION
1173 
1175 #endif // DOCUMENTATION
1176 
1177 #ifndef DOCUMENTATION
1178  AsmStoredString.setDataPrototype(
1179  "SgAsmStringStorage*", "storage", "= nullptr",
1180  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
1181 #endif // !DOCUMENTATION
1182 
1183  DECLARE_OTHERS(AsmStoredString);
1184 #if defined(SgAsmStoredString_OTHERS) || defined(DOCUMENTATION)
1185 
1186  //----------------------- Boost serialization for SgAsmStoredString -----------------------
1187 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
1188 private:
1189  friend class boost::serialization::access;
1190 
1191  template<class S>
1192  void serialize(S &s, const unsigned /*version*/) {
1193  debugSerializationBegin("SgAsmStoredString");
1194  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmGenericString);
1195  s & BOOST_SERIALIZATION_NVP(p_storage);
1196  debugSerializationEnd("SgAsmStoredString");
1197  }
1198 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
1199 
1200 public:
1204  SgAsmStringStorage* const& get_storage() const;
1205  void set_storage(SgAsmStringStorage* const&);
1207 public:
1209  SgAsmStoredString(SgAsmGenericStrtab*, rose_addr_t offset);
1210 
1212  SgAsmStoredString(SgAsmGenericStrtab*, const std::string&);
1213 
1215  explicit SgAsmStoredString(class SgAsmStringStorage*);
1216 
1218  virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
1219 
1224 
1226  virtual std::string get_string(bool escape=false) const override;
1227 
1231  virtual void set_string(const std::string&) override;
1232 
1236  virtual void set_string(rose_addr_t) override;
1237 
1241  virtual rose_addr_t get_offset() const override;
1242 public:
1244  virtual ~SgAsmStoredString();
1245 
1246 public:
1249 
1250 protected:
1257  void initializeProperties();
1258 #endif // SgAsmStoredString_OTHERS
1259 #ifdef DOCUMENTATION
1260 };
1261 #endif // DOCUMENTATION
1262 
1263 
1265 // SgAsmStaticData -- MACHINE GENERATED; DO NOT MODIFY --
1267 
1268 DECLARE_LEAF_CLASS(AsmStaticData);
1269 IS_SERIALIZABLE(AsmStaticData);
1270 
1271 #ifdef DOCUMENTATION
1272 
1280 #endif // DOCUMENTATION
1281 
1282 #ifndef DOCUMENTATION
1283  AsmStaticData.setDataPrototype(
1284  "SgUnsignedCharList", "raw_bytes", "",
1285  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
1286 #endif // !DOCUMENTATION
1287 
1288  DECLARE_OTHERS(AsmStaticData);
1289 #if defined(SgAsmStaticData_OTHERS) || defined(DOCUMENTATION)
1290 
1291  //----------------------- Boost serialization for SgAsmStaticData -----------------------
1292 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
1293 private:
1294  friend class boost::serialization::access;
1295 
1296  template<class S>
1297  void serialize(S &s, const unsigned /*version*/) {
1298  debugSerializationBegin("SgAsmStaticData");
1299  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmStatement);
1300  s & BOOST_SERIALIZATION_NVP(p_raw_bytes);
1301  debugSerializationEnd("SgAsmStaticData");
1302  }
1303 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
1304 
1305 public:
1312  SgUnsignedCharList const& get_raw_bytes() const;
1313  void set_raw_bytes(SgUnsignedCharList const&);
1315 public:
1319  size_t get_size() const { return p_raw_bytes.size(); }
1320 public:
1322  virtual ~SgAsmStaticData();
1323 
1324 public:
1326  SgAsmStaticData();
1327 
1328 public:
1330  explicit SgAsmStaticData(rose_addr_t const& address);
1331 
1332 protected:
1339  void initializeProperties();
1340 #endif // SgAsmStaticData_OTHERS
1341 #ifdef DOCUMENTATION
1342 };
1343 #endif // DOCUMENTATION
1344 
1345 
1347 // SgAsmStackExpression -- MACHINE GENERATED; DO NOT MODIFY --
1349 
1350 DECLARE_LEAF_CLASS(AsmStackExpression);
1351 IS_SERIALIZABLE(AsmStackExpression);
1352 
1353 #ifdef DOCUMENTATION
1354 
1356 #endif // DOCUMENTATION
1357 
1358 #ifndef DOCUMENTATION
1359  AsmStackExpression.setDataPrototype(
1360  "int", "stack_position", "= 0",
1361  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
1362 #endif // !DOCUMENTATION
1363 
1364  DECLARE_OTHERS(AsmStackExpression);
1365 #if defined(SgAsmStackExpression_OTHERS) || defined(DOCUMENTATION)
1366 
1367  //----------------------- Boost serialization for SgAsmStackExpression -----------------------
1368 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
1369 private:
1370  friend class boost::serialization::access;
1371 
1372  template<class S>
1373  void serialize(S &s, const unsigned /*version*/) {
1374  debugSerializationBegin("SgAsmStackExpression");
1375  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExpression);
1376  s & BOOST_SERIALIZATION_NVP(p_stack_position);
1377  debugSerializationEnd("SgAsmStackExpression");
1378  }
1379 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
1380 
1381 public:
1388  int const& get_stack_position() const;
1389  void set_stack_position(int const&);
1392 public:
1394  virtual ~SgAsmStackExpression();
1395 
1396 public:
1399 
1400 public:
1402  explicit SgAsmStackExpression(int const& stack_position);
1403 
1404 protected:
1411  void initializeProperties();
1412 #endif // SgAsmStackExpression_OTHERS
1413 #ifdef DOCUMENTATION
1414 };
1415 #endif // DOCUMENTATION
1416 
1417 
1419 // SgAsmRiscOperation -- MACHINE GENERATED; DO NOT MODIFY --
1421 
1422 DECLARE_LEAF_CLASS(AsmRiscOperation);
1423 IS_SERIALIZABLE(AsmRiscOperation);
1424 
1425 #ifdef DOCUMENTATION
1426 
1435 #endif // DOCUMENTATION
1436 
1437 #ifndef DOCUMENTATION
1438  AsmRiscOperation.setDataPrototype(
1439  "SgAsmRiscOperation::RiscOperator", "riscOperator", "= OP_NONE",
1440  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
1441 #endif // !DOCUMENTATION
1442 
1443 #ifndef DOCUMENTATION
1444  AsmRiscOperation.setDataPrototype(
1445  "SgAsmExprListExp*", "operands", "= nullptr",
1446  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
1447 #endif // !DOCUMENTATION
1448 
1449  DECLARE_OTHERS(AsmRiscOperation);
1450 #if defined(SgAsmRiscOperation_OTHERS) || defined(DOCUMENTATION)
1451 
1452  //----------------------- Boost serialization for SgAsmRiscOperation -----------------------
1453 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
1454 private:
1455  friend class boost::serialization::access;
1456 
1457  template<class S>
1458  void serialize(S &s, const unsigned /*version*/) {
1459  debugSerializationBegin("SgAsmRiscOperation");
1460  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExpression);
1461  s & BOOST_SERIALIZATION_NVP(p_riscOperator);
1462  s & BOOST_SERIALIZATION_NVP(p_operands);
1463  debugSerializationEnd("SgAsmRiscOperation");
1464  }
1465 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
1466  // Local types
1469 public:
1476  OP_NONE,
1477  OP_bottom,
1478  OP_undefined,
1479  OP_unspecified,
1480  OP_filterCallTarget,
1481  OP_filterReturnTarget,
1482  OP_filterIndirectJumpTarget,
1483  OP_hlt,
1484  OP_cpuid,
1485  OP_rdtsc,
1486  OP_and_,
1487  OP_or_,
1488  OP_xor_,
1489  OP_invert,
1490  OP_extract,
1491  OP_concat,
1492  OP_leastSignificantSetBit,
1493  OP_mostSignificantSetBit,
1494  OP_rotateLeft,
1495  OP_rotateRight,
1496  OP_shiftLeft,
1497  OP_shiftRight,
1498  OP_shiftRightArithmetic,
1499  OP_equalToZero,
1500  OP_ite,
1501  OP_isEqual,
1502  OP_isNotEqual,
1503  OP_isUnsignedLessThan,
1504  OP_isUnsignedLessThanOrEqual,
1505  OP_isUnsignedGreaterThan,
1506  OP_isUnsignedGreaterThanOrEqual,
1507  OP_isSignedLessThan,
1508  OP_isSignedLessThanOrEqual,
1509  OP_isSignedGreaterThan,
1510  OP_isSignedGreaterThanOrEqual,
1511  OP_unsignedExtend,
1512  OP_signExtend,
1515  OP_subtract,
1516  OP_negate,
1517  OP_signedDivide,
1518  OP_signedModulo,
1519  OP_signedMultiply,
1520  OP_unsignedDivide,
1521  OP_unsignedModulo,
1522  OP_unsignedMultiply,
1523  OP_interrupt,
1524  OP_readRegister,
1525  OP_peekRegister,
1526  OP_writeRegister,
1528  OP_peekMemory,
1530  OP_N_OPERATORS // MUST BE LAST!
1531  };
1532 
1534  // Properties
1536 
1537  // Note that the qualification for the type is necessary only for ROSETTA. Remove it when ROSETTA finally goes away.
1538 public:
1549 public:
1556  SgAsmExprListExp* const& get_operands() const;
1557  void set_operands(SgAsmExprListExp* const&);
1560 public:
1562  virtual ~SgAsmRiscOperation();
1563 
1564 public:
1567 
1568 public:
1570  explicit SgAsmRiscOperation(SgAsmRiscOperation::RiscOperator const& riscOperator);
1571 
1572 protected:
1579  void initializeProperties();
1580 #endif // SgAsmRiscOperation_OTHERS
1581 #ifdef DOCUMENTATION
1582 };
1583 #endif // DOCUMENTATION
1584 
1585 
1587 // SgAsmRegisterNames -- MACHINE GENERATED; DO NOT MODIFY --
1589 
1590 DECLARE_LEAF_CLASS(AsmRegisterNames);
1591 IS_SERIALIZABLE(AsmRegisterNames);
1592 
1593 #ifdef DOCUMENTATION
1594 
1596 #endif // DOCUMENTATION
1597 
1598 #ifndef DOCUMENTATION
1599  AsmRegisterNames.setDataPrototype(
1600  "SgAsmRegisterReferenceExpressionPtrList", "registers", "",
1601  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
1602 #endif // !DOCUMENTATION
1603 
1604 #ifndef DOCUMENTATION
1605  AsmRegisterNames.setDataPrototype(
1606  "unsigned", "mask", "= 0",
1607  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
1608 #endif // !DOCUMENTATION
1609 
1610  DECLARE_OTHERS(AsmRegisterNames);
1611 #if defined(SgAsmRegisterNames_OTHERS) || defined(DOCUMENTATION)
1612 
1613  //----------------------- Boost serialization for SgAsmRegisterNames -----------------------
1614 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
1615 private:
1616  friend class boost::serialization::access;
1617 
1618  template<class S>
1619  void serialize(S &s, const unsigned /*version*/) {
1620  debugSerializationBegin("SgAsmRegisterNames");
1621  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExpression);
1622  s & BOOST_SERIALIZATION_NVP(p_registers);
1623  s & BOOST_SERIALIZATION_NVP(p_mask);
1624  debugSerializationEnd("SgAsmRegisterNames");
1625  }
1626 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
1627 
1628 public:
1635  SgAsmRegisterReferenceExpressionPtrList const& get_registers() const;
1636  SgAsmRegisterReferenceExpressionPtrList& get_registers();
1637  void set_registers(SgAsmRegisterReferenceExpressionPtrList const&);
1640 public:
1647  unsigned const& get_mask() const;
1648  void set_mask(unsigned const&);
1651 public:
1653  virtual ~SgAsmRegisterNames();
1654 
1655 public:
1658 
1659 protected:
1666  void initializeProperties();
1667 #endif // SgAsmRegisterNames_OTHERS
1668 #ifdef DOCUMENTATION
1669 };
1670 #endif // DOCUMENTATION
1671 
1672 
1674 // SgAsmPowerpcInstruction -- MACHINE GENERATED; DO NOT MODIFY --
1676 
1677 DECLARE_LEAF_CLASS(AsmPowerpcInstruction);
1678 IS_SERIALIZABLE(AsmPowerpcInstruction);
1679 
1680 DECLARE_HEADERS(AsmPowerpcInstruction);
1681 #if defined(SgAsmPowerpcInstruction_HEADERS) || defined(DOCUMENTATION)
1682 #include <Rose/BinaryAnalysis/InstructionEnumsPowerpc.h>
1683 #endif // SgAsmPowerpcInstruction_HEADERS
1684 
1685 #ifdef DOCUMENTATION
1686 
1688 #endif // DOCUMENTATION
1689 
1690 #ifndef DOCUMENTATION
1691  AsmPowerpcInstruction.setDataPrototype(
1692  "Rose::BinaryAnalysis::PowerpcInstructionKind", "kind", "= Rose::BinaryAnalysis::powerpc_unknown_instruction",
1693  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
1694 #endif // !DOCUMENTATION
1695 
1696  DECLARE_OTHERS(AsmPowerpcInstruction);
1697 #if defined(SgAsmPowerpcInstruction_OTHERS) || defined(DOCUMENTATION)
1698 
1699  //----------------------- Boost serialization for SgAsmPowerpcInstruction -----------------------
1700 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
1701 private:
1702  friend class boost::serialization::access;
1703 
1704  template<class S>
1705  void serialize(S &s, const unsigned /*version*/) {
1706  debugSerializationBegin("SgAsmPowerpcInstruction");
1707  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmInstruction);
1708  s & BOOST_SERIALIZATION_NVP(p_kind);
1709  debugSerializationEnd("SgAsmPowerpcInstruction");
1710  }
1711 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
1712 public:
1713 public:
1723 public:
1729  std::string conditionalBranchDescription() const;
1730 
1736 
1737  // Overrides are documented in the base class
1738  virtual std::string description() const override;
1739  virtual bool terminatesBasicBlock() override;
1740  virtual Rose::BinaryAnalysis::AddressSet getSuccessors(bool &complete) override;
1741  virtual bool isUnknown() const override;
1742  virtual unsigned get_anyKind() const override;
1743  virtual bool isFunctionCallFast(const std::vector<SgAsmInstruction*>&,
1744  rose_addr_t *target, rose_addr_t *retva) override;
1745  virtual bool isFunctionCallSlow(const std::vector<SgAsmInstruction*>&,
1746  rose_addr_t *target, rose_addr_t *retva) override;
1747  virtual bool isFunctionReturnFast(const std::vector<SgAsmInstruction*>&) override;
1748  virtual bool isFunctionReturnSlow(const std::vector<SgAsmInstruction*>&) override;
1749 public:
1751  virtual ~SgAsmPowerpcInstruction();
1752 
1753 public:
1756 
1757 public:
1759  SgAsmPowerpcInstruction(rose_addr_t const& address,
1760  std::string const& mnemonic,
1762 
1763 protected:
1770  void initializeProperties();
1771 #endif // SgAsmPowerpcInstruction_OTHERS
1772 #ifdef DOCUMENTATION
1773 };
1774 #endif // DOCUMENTATION
1775 
1776 
1778 // SgAsmPEStringSection -- MACHINE GENERATED; DO NOT MODIFY --
1780 
1781 DECLARE_LEAF_CLASS(AsmPEStringSection);
1782 IS_SERIALIZABLE(AsmPEStringSection);
1783 
1784 #ifdef DOCUMENTATION
1785 
1787 #endif // DOCUMENTATION
1788 
1789 #ifndef DOCUMENTATION
1790  AsmPEStringSection.setDataPrototype(
1791  "SgAsmCoffStrtab*", "strtab", "= nullptr",
1792  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
1793 #endif // !DOCUMENTATION
1794 
1795  DECLARE_OTHERS(AsmPEStringSection);
1796 #if defined(SgAsmPEStringSection_OTHERS) || defined(DOCUMENTATION)
1797 
1798  //----------------------- Boost serialization for SgAsmPEStringSection -----------------------
1799 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
1800 private:
1801  friend class boost::serialization::access;
1802 
1803  template<class S>
1804  void serialize(S &s, const unsigned /*version*/) {
1805  debugSerializationBegin("SgAsmPEStringSection");
1806  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmPESection);
1807  s & BOOST_SERIALIZATION_NVP(p_strtab);
1808  debugSerializationEnd("SgAsmPEStringSection");
1809  }
1810 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
1811 
1812 public:
1818  SgAsmCoffStrtab* const& get_strtab() const;
1819  void set_strtab(SgAsmCoffStrtab* const&);
1821 public:
1823  virtual SgAsmPEStringSection* parse() override;
1824  virtual bool reallocate() override;
1825  virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
1826  virtual void set_size(rose_addr_t newsize) override;
1827  virtual void unparse(std::ostream&) const override;
1828 public:
1830  virtual ~SgAsmPEStringSection();
1831 
1832 public:
1835 
1836 protected:
1843  void initializeProperties();
1844 #endif // SgAsmPEStringSection_OTHERS
1845 #ifdef DOCUMENTATION
1846 };
1847 #endif // DOCUMENTATION
1848 
1849 
1851 // SgAsmPESectionTable -- MACHINE GENERATED; DO NOT MODIFY --
1853 
1854 DECLARE_LEAF_CLASS(AsmPESectionTable);
1855 IS_SERIALIZABLE(AsmPESectionTable);
1856 
1857 #ifdef DOCUMENTATION
1858 
1860 #endif // DOCUMENTATION
1861 
1862  DECLARE_OTHERS(AsmPESectionTable);
1863 #if defined(SgAsmPESectionTable_OTHERS) || defined(DOCUMENTATION)
1864 
1865  //----------------------- Boost serialization for SgAsmPESectionTable -----------------------
1866 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
1867 private:
1868  friend class boost::serialization::access;
1869 
1870  template<class S>
1871  void serialize(S &s, const unsigned /*version*/) {
1872  debugSerializationBegin("SgAsmPESectionTable");
1873  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmGenericSection);
1874  debugSerializationEnd("SgAsmPESectionTable");
1875  }
1876 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
1877 public:
1879  virtual SgAsmPESectionTable* parse() override;
1880 
1885  void add_section(SgAsmPESection *section);
1886  virtual bool reallocate() override;
1887  virtual void unparse(std::ostream&) const override;
1888  virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
1889 public:
1891  virtual ~SgAsmPESectionTable();
1892 
1893 public:
1896 
1897 protected:
1904  void initializeProperties();
1905 #endif // SgAsmPESectionTable_OTHERS
1906 #ifdef DOCUMENTATION
1907 };
1908 #endif // DOCUMENTATION
1909 
1910 
1912 // SgAsmPESectionTableEntry -- MACHINE GENERATED; DO NOT MODIFY --
1914 
1915 DECLARE_LEAF_CLASS(AsmPESectionTableEntry);
1916 IS_SERIALIZABLE(AsmPESectionTableEntry);
1917 
1918 #ifdef DOCUMENTATION
1919 
1921 #endif // DOCUMENTATION
1922 
1923 #ifndef DOCUMENTATION
1924  AsmPESectionTableEntry.setDataPrototype(
1925  "std::string", "name", "",
1926  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
1927 #endif // !DOCUMENTATION
1928 
1929 #ifndef DOCUMENTATION
1930  AsmPESectionTableEntry.setDataPrototype(
1931  "rose_addr_t", "virtual_size", "= 0",
1932  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
1933 #endif // !DOCUMENTATION
1934 
1935 #ifndef DOCUMENTATION
1936  AsmPESectionTableEntry.setDataPrototype(
1937  "rose_addr_t", "rva", "= 0",
1938  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
1939 #endif // !DOCUMENTATION
1940 
1941 #ifndef DOCUMENTATION
1942  AsmPESectionTableEntry.setDataPrototype(
1943  "rose_addr_t", "physical_size", "= 0",
1944  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
1945 #endif // !DOCUMENTATION
1946 
1947 #ifndef DOCUMENTATION
1948  AsmPESectionTableEntry.setDataPrototype(
1949  "rose_addr_t", "physical_offset", "= 0",
1950  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
1951 #endif // !DOCUMENTATION
1952 
1953 #ifndef DOCUMENTATION
1954  AsmPESectionTableEntry.setDataPrototype(
1955  "unsigned", "coff_line_nums", "= 0",
1956  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
1957 #endif // !DOCUMENTATION
1958 
1959 #ifndef DOCUMENTATION
1960  AsmPESectionTableEntry.setDataPrototype(
1961  "unsigned", "n_relocs", "= 0",
1962  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
1963 #endif // !DOCUMENTATION
1964 
1965 #ifndef DOCUMENTATION
1966  AsmPESectionTableEntry.setDataPrototype(
1967  "unsigned", "n_coff_line_nums", "= 0",
1968  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
1969 #endif // !DOCUMENTATION
1970 
1971 #ifndef DOCUMENTATION
1972  AsmPESectionTableEntry.setDataPrototype(
1973  "unsigned", "flags", "= 0",
1974  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
1975 #endif // !DOCUMENTATION
1976 
1977  DECLARE_OTHERS(AsmPESectionTableEntry);
1978 #if defined(SgAsmPESectionTableEntry_OTHERS) || defined(DOCUMENTATION)
1979 
1980  //----------------------- Boost serialization for SgAsmPESectionTableEntry -----------------------
1981 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
1982 private:
1983  friend class boost::serialization::access;
1984 
1985  template<class S>
1986  void serialize(S &s, const unsigned /*version*/) {
1987  debugSerializationBegin("SgAsmPESectionTableEntry");
1988  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
1989  s & BOOST_SERIALIZATION_NVP(p_name);
1990  s & BOOST_SERIALIZATION_NVP(p_virtual_size);
1991  s & BOOST_SERIALIZATION_NVP(p_rva);
1992  s & BOOST_SERIALIZATION_NVP(p_physical_size);
1993  s & BOOST_SERIALIZATION_NVP(p_physical_offset);
1994  s & BOOST_SERIALIZATION_NVP(p_coff_line_nums);
1995  s & BOOST_SERIALIZATION_NVP(p_n_relocs);
1996  s & BOOST_SERIALIZATION_NVP(p_n_coff_line_nums);
1997  s & BOOST_SERIALIZATION_NVP(p_flags);
1998  debugSerializationEnd("SgAsmPESectionTableEntry");
1999  }
2000 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
2001  // Local types
2004 public:
2005 #ifdef _MSC_VER
2006 # pragma pack (1)
2007 #endif
2008  /* File format of a section table entry. All fields are little endian. Sections are ordered by RVA. */
2010  char name[8]; /* NUL-padded */
2011  uint32_t virtual_size; /* virtual memory size, >= physical_size and difference is zero filled */
2012  uint32_t rva; /* relative virt addr wrt Image Base; multiple of section_align; dense space */
2013  uint32_t physical_size; /* bytes of initialized data on disk; multiple of file_align & <= virtual_size*/
2014  uint32_t physical_offset; /* location of initialized data on disk; multiple of file_align */
2015  uint32_t coff_line_nums; /* file offset of COFF line number info or zero */
2016  uint32_t n_relocs; /* number of relocation entries; should be zero for executables */
2017  uint32_t n_coff_line_nums; /* number of COFF line number entries */
2018  uint32_t flags; /* PESectionFlags bits: code, data, caching, paging, shared, permissions, etc.*/
2019  }
2020 #if !defined(SWIG) && !defined(_MSC_VER)
2021  __attribute__((packed))
2022 #endif
2023  ;
2024 #ifdef _MSC_VER
2025 # pragma pack ()
2026 #endif
2027 
2028  /* These come from the windows PE documentation and
2029  * http://en.wikibooks.org/wiki/X86_Disassembly/Windows_Executable_Files */
2030  enum PESectionFlags {
2031  OF_CODE = 0x00000020, /* section contains code */
2032  OF_IDATA = 0x00000040, /* initialized data */
2033  OF_UDATA = 0x00000080, /* uninitialized data */
2034  OF_INFO = 0x00000200, /* comments or some other type of info */
2035  OF_REMOVE = 0x00000800, /* section will not become part of image */
2036  OF_COMDAT = 0x00001000, /* section contains comdat */
2037  OF_NO_DEFER_SPEC_EXC= 0x00004000, /* reset speculative exception handling bits in the TLB entires for
2038  * this section */
2039  OF_GPREL = 0x00008000, /* section content can be access relative to GP */
2040  OF_ALIGN_1 = 0x00100000, /* no alignment */
2041  OF_ALIGN_2 = 0x00200000, /* 2-byte alignment */
2042  OF_ALIGN_4 = 0x00300000, /* 4-byte alignment */
2043  OF_ALIGN_8 = 0x00400000, /* 8-byte alignment */
2044  OF_ALIGN_16 = 0x00500000, /* 16-byte alignment (default if not other alignment specified) */
2045  OF_ALIGN_32 = 0x00600000, /* 32-byte alignment */
2046  OF_ALIGN_64 = 0x00700000, /* 64-byte alignment */
2047  OF_ALIGN_128 = 0x00800000, /* 128-byte alignment */
2048  OF_ALIGN_256 = 0x00900000, /* 256-byte alignment */
2049  OF_ALIGN_512 = 0x00a00000, /* 512-byte alignment */
2050  OF_ALIGN_1k = 0x00b00000, /* 1024-byte alignment */
2051  OF_ALIGN_2k = 0x00c00000, /* 2048-byte alignment */
2052  OF_ALIGN_4k = 0x00d00000, /* 4096-byte alignment */
2053  OF_ALIGN_8k = 0x00e00000, /* 8192-byte alignment */
2054  OF_ALIGN_MASK = 0x00f00000, /* mask for alignment value */
2055  OF_NRELOC_OVFL = 0x01000000, /* section contains extended relocations */
2056  OF_DISCARDABLE = 0x02000000, /* can be discarded */
2057  OF_NO_CACHE = 0x04000000, /* section must not be cached */
2058  OF_NO_PAGING = 0x08000000, /* section is not pageable */
2059  OF_SHARED = 0x10000000, /* section is shared */
2060  OF_EXECUTABLE = 0x20000000, /* execute permission */
2061  OF_READABLE = 0x40000000, /* read permission */
2062  OF_WRITABLE = 0x80000000 /* write permission */
2063  };
2064 
2066  // Properties
2068 public:
2074  std::string const& get_name() const;
2075  void set_name(std::string const&);
2078 public:
2084  rose_addr_t const& get_virtual_size() const;
2085  void set_virtual_size(rose_addr_t const&);
2088 public:
2094  rose_addr_t const& get_rva() const;
2095  void set_rva(rose_addr_t const&);
2098 public:
2104  rose_addr_t const& get_physical_size() const;
2105  void set_physical_size(rose_addr_t const&);
2108 public:
2114  rose_addr_t const& get_physical_offset() const;
2115  void set_physical_offset(rose_addr_t const&);
2118 public:
2124  unsigned const& get_coff_line_nums() const;
2125  void set_coff_line_nums(unsigned const&);
2128 public:
2134  unsigned const& get_n_relocs() const;
2135  void set_n_relocs(unsigned const&);
2138 public:
2144  unsigned const& get_n_coff_line_nums() const;
2145  void set_n_coff_line_nums(unsigned const&);
2148 public:
2154  unsigned const& get_flags() const;
2155  void set_flags(unsigned const&);
2157  // Functions
2160 public:
2162 
2164  void update_from_section(SgAsmPESection *section);
2166  virtual void dump(FILE*, const char *prefix, ssize_t idx) const;
2167 public:
2169  virtual ~SgAsmPESectionTableEntry();
2170 
2171 public:
2174 
2175 protected:
2182  void initializeProperties();
2183 #endif // SgAsmPESectionTableEntry_OTHERS
2184 #ifdef DOCUMENTATION
2185 };
2186 #endif // DOCUMENTATION
2187 
2188 
2190 // SgAsmPERVASizePairList -- MACHINE GENERATED; DO NOT MODIFY --
2192 
2193 DECLARE_LEAF_CLASS(AsmPERVASizePairList);
2194 IS_SERIALIZABLE(AsmPERVASizePairList);
2195 
2196 #ifdef DOCUMENTATION
2197 
2202 #endif // DOCUMENTATION
2203 
2204 #ifndef DOCUMENTATION
2205  AsmPERVASizePairList.setDataPrototype(
2206  "SgAsmPERVASizePairPtrList", "pairs", "",
2207  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
2208 #endif // !DOCUMENTATION
2209 
2210  DECLARE_OTHERS(AsmPERVASizePairList);
2211 #if defined(SgAsmPERVASizePairList_OTHERS) || defined(DOCUMENTATION)
2212 
2213  //----------------------- Boost serialization for SgAsmPERVASizePairList -----------------------
2214 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
2215 private:
2216  friend class boost::serialization::access;
2217 
2218  template<class S>
2219  void serialize(S &s, const unsigned /*version*/) {
2220  debugSerializationBegin("SgAsmPERVASizePairList");
2221  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
2222  s & BOOST_SERIALIZATION_NVP(p_pairs);
2223  debugSerializationEnd("SgAsmPERVASizePairList");
2224  }
2225 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
2226 
2227 public:
2231  SgAsmPERVASizePairPtrList const& get_pairs() const;
2232  SgAsmPERVASizePairPtrList& get_pairs();
2233  void set_pairs(SgAsmPERVASizePairPtrList const&);
2235 public:
2236  explicit SgAsmPERVASizePairList(SgAsmPEFileHeader *parent);
2237 public:
2239  virtual ~SgAsmPERVASizePairList();
2240 
2241 public:
2244 
2245 protected:
2252  void initializeProperties();
2253 #endif // SgAsmPERVASizePairList_OTHERS
2254 #ifdef DOCUMENTATION
2255 };
2256 #endif // DOCUMENTATION
2257 
2258 
2260 // SgAsmPERVASizePair -- MACHINE GENERATED; DO NOT MODIFY --
2262 
2263 DECLARE_LEAF_CLASS(AsmPERVASizePair);
2264 IS_SERIALIZABLE(AsmPERVASizePair);
2265 
2266 #ifdef DOCUMENTATION
2267 
2269 #endif // DOCUMENTATION
2270 
2271 #ifndef DOCUMENTATION
2272  AsmPERVASizePair.setDataPrototype(
2273  "rose_rva_t", "e_rva", "= 0",
2274  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
2275 #endif // !DOCUMENTATION
2276 
2277 #ifndef DOCUMENTATION
2278  AsmPERVASizePair.setDataPrototype(
2279  "rose_addr_t", "e_size", "= 0",
2280  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
2281 #endif // !DOCUMENTATION
2282 
2283 #ifndef DOCUMENTATION
2284  AsmPERVASizePair.setDataPrototype(
2285  "SgAsmGenericSection*", "section", "= nullptr",
2286  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
2287 #endif // !DOCUMENTATION
2288 
2289  DECLARE_OTHERS(AsmPERVASizePair);
2290 #if defined(SgAsmPERVASizePair_OTHERS) || defined(DOCUMENTATION)
2291 
2292  //----------------------- Boost serialization for SgAsmPERVASizePair -----------------------
2293 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
2294 private:
2295  friend class boost::serialization::access;
2296 
2297  template<class S>
2298  void serialize(S &s, const unsigned /*version*/) {
2299  debugSerializationBegin("SgAsmPERVASizePair");
2300  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
2301  s & BOOST_SERIALIZATION_NVP(p_e_rva);
2302  s & BOOST_SERIALIZATION_NVP(p_e_size);
2303  s & BOOST_SERIALIZATION_NVP(p_section);
2304  debugSerializationEnd("SgAsmPERVASizePair");
2305  }
2306 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
2307  // Local types
2310 public:
2311 #ifdef _MSC_VER
2312 # pragma pack (1)
2313 #endif
2314 
2318  uint32_t e_rva;
2319  uint32_t e_size;
2320  }
2321 #if !defined(SWIG) && !defined(_MSC_VER)
2322  __attribute__((packed))
2323 #endif
2324  ;
2325 #ifdef _MSC_VER
2326 # pragma pack ()
2327 #endif
2328 
2330  // Properties
2332 public:
2338  rose_rva_t const& get_e_rva() const;
2339  rose_rva_t& get_e_rva();
2340  void set_e_rva(rose_rva_t const&);
2343 public:
2349  rose_addr_t const& get_e_size() const;
2350  void set_e_size(rose_addr_t const&);
2353 public:
2360  // Functions
2363 public:
2365  SgAsmPERVASizePair(SgAsmPERVASizePairList *parent, rose_addr_t rva, rose_addr_t size);
2366 
2371  void set_section(SgAsmGenericSection *section);
2372 
2377 
2378  void *encode(SgAsmPERVASizePair::RVASizePair_disk *disk) const;
2379 public:
2381  virtual ~SgAsmPERVASizePair();
2382 
2383 public:
2386 
2387 protected:
2394  void initializeProperties();
2395 #endif // SgAsmPERVASizePair_OTHERS
2396 #ifdef DOCUMENTATION
2397 };
2398 #endif // DOCUMENTATION
2399 
2400 
2402 // SgAsmPEImportSection -- MACHINE GENERATED; DO NOT MODIFY --
2404 
2405 DECLARE_LEAF_CLASS(AsmPEImportSection);
2406 IS_SERIALIZABLE(AsmPEImportSection);
2407 
2408 #ifdef DOCUMENTATION
2409 
2552 #endif // DOCUMENTATION
2553 
2554 #ifndef DOCUMENTATION
2555  AsmPEImportSection.setDataPrototype(
2556  "SgAsmPEImportDirectoryList*", "import_directories", "= createAndParent<SgAsmPEImportDirectoryList>(this)",
2557  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
2558 #endif // !DOCUMENTATION
2559 
2560  DECLARE_OTHERS(AsmPEImportSection);
2561 #if defined(SgAsmPEImportSection_OTHERS) || defined(DOCUMENTATION)
2562 
2563  //----------------------- Boost serialization for SgAsmPEImportSection -----------------------
2564 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
2565 private:
2566  friend class boost::serialization::access;
2567 
2568  template<class S>
2569  void serialize(S &s, const unsigned /*version*/) {
2570  debugSerializationBegin("SgAsmPEImportSection");
2571  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmPESection);
2572  s & BOOST_SERIALIZATION_NVP(p_import_directories);
2573  debugSerializationEnd("SgAsmPEImportSection");
2574  }
2575 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
2576 
2577 public:
2586 public:
2588  virtual SgAsmPEImportSection *parse() override;
2589  virtual bool reallocate() override;
2590  virtual void unparse(std::ostream&) const override;
2591  virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
2592 
2595 
2598  static bool show_import_mesg();
2599  static void import_mesg_reset() { mesg_nprinted=0; }
2600 
2608  size_t reallocate_iats(rose_rva_t start_at);
2609 
2610 private:
2611  static size_t mesg_nprinted; //counter for import_mesg()
2612 public:
2614  virtual ~SgAsmPEImportSection();
2615 
2616 public:
2619 
2620 protected:
2627  void initializeProperties();
2628 #endif // SgAsmPEImportSection_OTHERS
2629 #ifdef DOCUMENTATION
2630 };
2631 #endif // DOCUMENTATION
2632 
2633 
2635 // SgAsmPEImportItemList -- MACHINE GENERATED; DO NOT MODIFY --
2637 
2638 DECLARE_LEAF_CLASS(AsmPEImportItemList);
2639 IS_SERIALIZABLE(AsmPEImportItemList);
2640 
2641 #ifdef DOCUMENTATION
2642 
2647 #endif // DOCUMENTATION
2648 
2649 #ifndef DOCUMENTATION
2650  AsmPEImportItemList.setDataPrototype(
2651  "SgAsmPEImportItemPtrList", "vector", "",
2652  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
2653 #endif // !DOCUMENTATION
2654 
2655  DECLARE_OTHERS(AsmPEImportItemList);
2656 #if defined(SgAsmPEImportItemList_OTHERS) || defined(DOCUMENTATION)
2657 
2658  //----------------------- Boost serialization for SgAsmPEImportItemList -----------------------
2659 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
2660 private:
2661  friend class boost::serialization::access;
2662 
2663  template<class S>
2664  void serialize(S &s, const unsigned /*version*/) {
2665  debugSerializationBegin("SgAsmPEImportItemList");
2666  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
2667  s & BOOST_SERIALIZATION_NVP(p_vector);
2668  debugSerializationEnd("SgAsmPEImportItemList");
2669  }
2670 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
2671 
2672 public:
2676  SgAsmPEImportItemPtrList const& get_vector() const;
2677  SgAsmPEImportItemPtrList& get_vector();
2678  void set_vector(SgAsmPEImportItemPtrList const&);
2681 public:
2683  virtual ~SgAsmPEImportItemList();
2684 
2685 public:
2688 
2689 protected:
2696  void initializeProperties();
2697 #endif // SgAsmPEImportItemList_OTHERS
2698 #ifdef DOCUMENTATION
2699 };
2700 #endif // DOCUMENTATION
2701 
2702 
2704 // SgAsmPEImportItem -- MACHINE GENERATED; DO NOT MODIFY --
2706 
2707 DECLARE_LEAF_CLASS(AsmPEImportItem);
2708 IS_SERIALIZABLE(AsmPEImportItem);
2709 
2710 #ifdef DOCUMENTATION
2711 
2719 #endif // DOCUMENTATION
2720 
2721 #ifndef DOCUMENTATION
2722  AsmPEImportItem.setDataPrototype(
2723  "bool", "by_ordinal", "= true",
2724  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
2725 #endif // !DOCUMENTATION
2726 
2727 #ifndef DOCUMENTATION
2728  AsmPEImportItem.setDataPrototype(
2729  "unsigned", "ordinal", "= 0",
2730  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
2731 #endif // !DOCUMENTATION
2732 
2733 #ifndef DOCUMENTATION
2734  AsmPEImportItem.setDataPrototype(
2735  "unsigned", "hint", "= 0",
2736  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
2737 #endif // !DOCUMENTATION
2738 
2739 #ifndef DOCUMENTATION
2740  AsmPEImportItem.setDataPrototype(
2741  "SgAsmGenericString*", "name", "= createAndParent<SgAsmBasicString>(this)",
2742  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
2743 #endif // !DOCUMENTATION
2744 
2745 #ifndef DOCUMENTATION
2746  AsmPEImportItem.setDataPrototype(
2747  "rose_rva_t", "hintname_rva", "= 0",
2748  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
2749 #endif // !DOCUMENTATION
2750 
2751 #ifndef DOCUMENTATION
2752  AsmPEImportItem.setDataPrototype(
2753  "size_t", "hintname_nalloc", "= 0",
2754  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
2755 #endif // !DOCUMENTATION
2756 
2757 #ifndef DOCUMENTATION
2758  AsmPEImportItem.setDataPrototype(
2759  "rose_rva_t", "bound_rva", "= 0",
2760  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
2761 #endif // !DOCUMENTATION
2762 
2763 #ifndef DOCUMENTATION
2764  AsmPEImportItem.setDataPrototype(
2765  "bool", "iat_written", "= false",
2766  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
2767 #endif // !DOCUMENTATION
2768 
2769  DECLARE_OTHERS(AsmPEImportItem);
2770 #if defined(SgAsmPEImportItem_OTHERS) || defined(DOCUMENTATION)
2771 
2772  //----------------------- Boost serialization for SgAsmPEImportItem -----------------------
2773 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
2774 private:
2775  friend class boost::serialization::access;
2776 
2777  template<class S>
2778  void serialize(S &s, const unsigned /*version*/) {
2779  debugSerializationBegin("SgAsmPEImportItem");
2780  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
2781  s & BOOST_SERIALIZATION_NVP(p_by_ordinal);
2782  s & BOOST_SERIALIZATION_NVP(p_ordinal);
2783  s & BOOST_SERIALIZATION_NVP(p_hint);
2784  s & BOOST_SERIALIZATION_NVP(p_name);
2785  s & BOOST_SERIALIZATION_NVP(p_hintname_rva);
2786  s & BOOST_SERIALIZATION_NVP(p_hintname_nalloc);
2787  s & BOOST_SERIALIZATION_NVP(p_bound_rva);
2788  s & BOOST_SERIALIZATION_NVP(p_iat_written);
2789  debugSerializationEnd("SgAsmPEImportItem");
2790  }
2791 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
2792 
2793 public:
2799  bool const& get_by_ordinal() const;
2800  void set_by_ordinal(bool const&);
2803 public:
2809  unsigned const& get_ordinal() const;
2810  void set_ordinal(unsigned const&);
2813 public:
2819  unsigned const& get_hint() const;
2820  void set_hint(unsigned const&);
2823 public:
2829  SgAsmGenericString* const& get_name() const;
2830  void set_name(SgAsmGenericString* const&);
2833 public:
2839  rose_rva_t const& get_hintname_rva() const;
2841  void set_hintname_rva(rose_rva_t const&);
2844 public:
2850  size_t const& get_hintname_nalloc() const;
2851  void set_hintname_nalloc(size_t const&);
2854 public:
2860  rose_rva_t const& get_bound_rva() const;
2862  void set_bound_rva(rose_rva_t const&);
2865 public:
2871  bool const& get_iat_written() const;
2872  void set_iat_written(bool const&);
2874 public:
2875  explicit SgAsmPEImportItem(SgAsmPEImportItemList *parent);
2877  SgAsmPEImportItem(SgAsmPEImportDirectory*, const std::string &name, unsigned hint=0);
2878  SgAsmPEImportItem(SgAsmPEImportDirectory*, const unsigned ordinal);
2879 
2880  virtual void dump(FILE*, const char *prefix, ssize_t idx) const;
2881 
2887  size_t hintname_required_size() const;
2888 
2893  rose_addr_t get_iat_entry_va() const;
2894 
2895 private:
2896  void initFromParent(SgAsmPEImportItemList *parent);
2897 public:
2899  virtual ~SgAsmPEImportItem();
2900 
2901 public:
2904 
2905 protected:
2912  void initializeProperties();
2913 #endif // SgAsmPEImportItem_OTHERS
2914 #ifdef DOCUMENTATION
2915 };
2916 #endif // DOCUMENTATION
2917 
2918 
2920 // SgAsmPEImportDirectoryList -- MACHINE GENERATED; DO NOT MODIFY --
2922 
2923 DECLARE_LEAF_CLASS(AsmPEImportDirectoryList);
2924 IS_SERIALIZABLE(AsmPEImportDirectoryList);
2925 
2926 #ifdef DOCUMENTATION
2927 
2932 #endif // DOCUMENTATION
2933 
2934 #ifndef DOCUMENTATION
2935  AsmPEImportDirectoryList.setDataPrototype(
2936  "SgAsmPEImportDirectoryPtrList", "vector", "",
2937  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
2938 #endif // !DOCUMENTATION
2939 
2940  DECLARE_OTHERS(AsmPEImportDirectoryList);
2941 #if defined(SgAsmPEImportDirectoryList_OTHERS) || defined(DOCUMENTATION)
2942 
2943  //----------------------- Boost serialization for SgAsmPEImportDirectoryList -----------------------
2944 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
2945 private:
2946  friend class boost::serialization::access;
2947 
2948  template<class S>
2949  void serialize(S &s, const unsigned /*version*/) {
2950  debugSerializationBegin("SgAsmPEImportDirectoryList");
2951  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
2952  s & BOOST_SERIALIZATION_NVP(p_vector);
2953  debugSerializationEnd("SgAsmPEImportDirectoryList");
2954  }
2955 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
2956 
2957 public:
2963  SgAsmPEImportDirectoryPtrList const& get_vector() const;
2964  SgAsmPEImportDirectoryPtrList& get_vector();
2965  void set_vector(SgAsmPEImportDirectoryPtrList const&);
2968 public:
2970  virtual ~SgAsmPEImportDirectoryList();
2971 
2972 public:
2975 
2976 protected:
2983  void initializeProperties();
2984 #endif // SgAsmPEImportDirectoryList_OTHERS
2985 #ifdef DOCUMENTATION
2986 };
2987 #endif // DOCUMENTATION
2988 
2989 
2991 // SgAsmPEImportDirectory -- MACHINE GENERATED; DO NOT MODIFY --
2993 
2994 DECLARE_LEAF_CLASS(AsmPEImportDirectory);
2995 IS_SERIALIZABLE(AsmPEImportDirectory);
2996 
2997 #ifdef DOCUMENTATION
2998 
3003 #endif // DOCUMENTATION
3004 
3005 #ifndef DOCUMENTATION
3006  AsmPEImportDirectory.setDataPrototype(
3007  "SgAsmGenericString*", "dll_name", "= 0",
3008  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
3009 #endif // !DOCUMENTATION
3010 
3011 #ifndef DOCUMENTATION
3012  AsmPEImportDirectory.setDataPrototype(
3013  "rose_rva_t", "dll_name_rva", "= 0",
3014  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
3015 #endif // !DOCUMENTATION
3016 
3017 #ifndef DOCUMENTATION
3018  AsmPEImportDirectory.setDataPrototype(
3019  "size_t", "dll_name_nalloc", "= 0",
3020  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
3021 #endif // !DOCUMENTATION
3022 
3023 #ifndef DOCUMENTATION
3024  AsmPEImportDirectory.setDataPrototype(
3025  "time_t", "time", "= 0",
3026  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
3027 #endif // !DOCUMENTATION
3028 
3029 #ifndef DOCUMENTATION
3030  AsmPEImportDirectory.setDataPrototype(
3031  "unsigned", "forwarder_chain", "= 0",
3032  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
3033 #endif // !DOCUMENTATION
3034 
3035 #ifndef DOCUMENTATION
3036  AsmPEImportDirectory.setDataPrototype(
3037  "rose_rva_t", "ilt_rva", "= 0",
3038  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
3039 #endif // !DOCUMENTATION
3040 
3041 #ifndef DOCUMENTATION
3042  AsmPEImportDirectory.setDataPrototype(
3043  "size_t", "ilt_nalloc", "= 0",
3044  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
3045 #endif // !DOCUMENTATION
3046 
3047 #ifndef DOCUMENTATION
3048  AsmPEImportDirectory.setDataPrototype(
3049  "rose_rva_t", "iat_rva", "= 0",
3050  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
3051 #endif // !DOCUMENTATION
3052 
3053 #ifndef DOCUMENTATION
3054  AsmPEImportDirectory.setDataPrototype(
3055  "size_t", "iat_nalloc", "= 0",
3056  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
3057 #endif // !DOCUMENTATION
3058 
3059 #ifndef DOCUMENTATION
3060  AsmPEImportDirectory.setDataPrototype(
3061  "SgAsmPEImportItemList*", "imports", "= createAndParent<SgAsmPEImportItemList>(this)",
3062  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
3063 #endif // !DOCUMENTATION
3064 
3065  DECLARE_OTHERS(AsmPEImportDirectory);
3066 #if defined(SgAsmPEImportDirectory_OTHERS) || defined(DOCUMENTATION)
3067 
3068  //----------------------- Boost serialization for SgAsmPEImportDirectory -----------------------
3069 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
3070 private:
3071  friend class boost::serialization::access;
3072 
3073  template<class S>
3074  void serialize(S &s, const unsigned /*version*/) {
3075  debugSerializationBegin("SgAsmPEImportDirectory");
3076  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
3077  s & BOOST_SERIALIZATION_NVP(p_dll_name);
3078  s & BOOST_SERIALIZATION_NVP(p_dll_name_rva);
3079  s & BOOST_SERIALIZATION_NVP(p_dll_name_nalloc);
3080  s & BOOST_SERIALIZATION_NVP(p_time);
3081  s & BOOST_SERIALIZATION_NVP(p_forwarder_chain);
3082  s & BOOST_SERIALIZATION_NVP(p_ilt_rva);
3083  s & BOOST_SERIALIZATION_NVP(p_ilt_nalloc);
3084  s & BOOST_SERIALIZATION_NVP(p_iat_rva);
3085  s & BOOST_SERIALIZATION_NVP(p_iat_nalloc);
3086  s & BOOST_SERIALIZATION_NVP(p_imports);
3087  debugSerializationEnd("SgAsmPEImportDirectory");
3088  }
3089 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
3090  // Local types
3093 public:
3094 #ifdef _MSC_VER
3095 # pragma pack (1)
3096 #endif
3098  uint32_t ilt_rva; /* 0x00 Import Lookup Table RVA */
3099  uint32_t time; /* 0x04 Zero until the image is bound, then time stamp of the DLL */
3100  uint32_t forwarder_chain; /* 0x08 Index of the first forwarder chain */
3101  uint32_t dll_name_rva; /* 0x0c address of NUL-terminated DLL name */
3102  uint32_t iat_rva; /* 0x10 Import Address Table (Thunk Table) RVA */
3103  } /* 0x14 */
3104 #if !defined(SWIG) && !defined(_MSC_VER)
3105  __attribute__((packed))
3106 #endif
3107  ;
3108 #ifdef _MSC_VER
3109 # pragma pack ()
3110 #endif
3111 
3113  // Properties
3115 public:
3121  SgAsmGenericString* const& get_dll_name() const;
3122  void set_dll_name(SgAsmGenericString* const&);
3125 public:
3131  rose_rva_t const& get_dll_name_rva() const;
3133  void set_dll_name_rva(rose_rva_t const&);
3136 public:
3142  size_t const& get_dll_name_nalloc() const;
3143  void set_dll_name_nalloc(size_t const&);
3146 public:
3152  time_t const& get_time() const;
3153  void set_time(time_t const&);
3156 public:
3162  unsigned const& get_forwarder_chain() const;
3163  void set_forwarder_chain(unsigned const&);
3166 public:
3172  rose_rva_t const& get_ilt_rva() const;
3174  void set_ilt_rva(rose_rva_t const&);
3177 public:
3183  size_t const& get_ilt_nalloc() const;
3184  void set_ilt_nalloc(size_t const&);
3187 public:
3193  rose_rva_t const& get_iat_rva() const;
3195  void set_iat_rva(rose_rva_t const&);
3198 public:
3204  size_t const& get_iat_nalloc() const;
3205  void set_iat_nalloc(size_t const&);
3208 public:
3214  SgAsmPEImportItemList* const& get_imports() const;
3215  void set_imports(SgAsmPEImportItemList* const&);
3217  // Functions
3220 public:
3221  explicit SgAsmPEImportDirectory(SgAsmPEImportSection *isec, const std::string &dll_name="");
3222 
3228  SgAsmPEImportDirectory *parse(rose_addr_t va, bool isLastEntry);
3229 
3237  size_t reallocate(rose_rva_t starting_rva);
3238 
3241  virtual void unparse(std::ostream&, const SgAsmPEImportSection*, size_t idx) const;
3242  virtual void dump(FILE*, const char *prefix, ssize_t idx) const;
3243 
3249  size_t iat_required_size() const;
3250 
3255  int find_import_item(const SgAsmPEImportItem *item, int hint=0) const;
3256 
3268  size_t hintname_table_extent(AddressIntervalSet &extent/*in,out*/) const;
3269 
3270 private:
3271  void parse_ilt_iat(const rose_rva_t &table_start, bool assume_bound);
3272  void unparse_ilt_iat(std::ostream&,const rose_rva_t &table_start, bool assume_bound, size_t nalloc) const;
3273 public:
3275  virtual ~SgAsmPEImportDirectory();
3276 
3277 public:
3280 
3281 protected:
3288  void initializeProperties();
3289 #endif // SgAsmPEImportDirectory_OTHERS
3290 #ifdef DOCUMENTATION
3291 };
3292 #endif // DOCUMENTATION
3293 
3294 
3296 // SgAsmPEFileHeader -- MACHINE GENERATED; DO NOT MODIFY --
3298 
3299 DECLARE_LEAF_CLASS(AsmPEFileHeader);
3300 IS_SERIALIZABLE(AsmPEFileHeader);
3301 
3302 #ifdef DOCUMENTATION
3303 
3307 #endif // DOCUMENTATION
3308 
3309 #ifndef DOCUMENTATION
3310  AsmPEFileHeader.setDataPrototype(
3311  "unsigned", "e_cpu_type", "= 0",
3312  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
3313 #endif // !DOCUMENTATION
3314 
3315 #ifndef DOCUMENTATION
3316  AsmPEFileHeader.setDataPrototype(
3317  "unsigned", "e_nsections", "= 0",
3318  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
3319 #endif // !DOCUMENTATION
3320 
3321 #ifndef DOCUMENTATION
3322  AsmPEFileHeader.setDataPrototype(
3323  "unsigned", "e_time", "= 0",
3324  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
3325 #endif // !DOCUMENTATION
3326 
3327 #ifndef DOCUMENTATION
3328  AsmPEFileHeader.setDataPrototype(
3329  "rose_addr_t", "e_coff_symtab", "= 0",
3330  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
3331 #endif // !DOCUMENTATION
3332 
3333 #ifndef DOCUMENTATION
3334  AsmPEFileHeader.setDataPrototype(
3335  "rose_addr_t", "e_nt_hdr_size", "= 0",
3336  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
3337 #endif // !DOCUMENTATION
3338 
3339 #ifndef DOCUMENTATION
3340  AsmPEFileHeader.setDataPrototype(
3341  "unsigned", "e_coff_nsyms", "= 0",
3342  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
3343 #endif // !DOCUMENTATION
3344 
3345 #ifndef DOCUMENTATION
3346  AsmPEFileHeader.setDataPrototype(
3347  "unsigned", "e_flags", "= 0",
3348  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
3349 #endif // !DOCUMENTATION
3350 
3351 #ifndef DOCUMENTATION
3352  AsmPEFileHeader.setDataPrototype(
3353  "unsigned", "e_opt_magic", "= 0",
3354  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
3355 #endif // !DOCUMENTATION
3356 
3357 #ifndef DOCUMENTATION
3358  AsmPEFileHeader.setDataPrototype(
3359  "unsigned", "e_lmajor", "= 0",
3360  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
3361 #endif // !DOCUMENTATION
3362 
3363 #ifndef DOCUMENTATION
3364  AsmPEFileHeader.setDataPrototype(
3365  "unsigned", "e_lminor", "= 0",
3366  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
3367 #endif // !DOCUMENTATION
3368 
3369 #ifndef DOCUMENTATION
3370  AsmPEFileHeader.setDataPrototype(
3371  "unsigned", "e_code_size", "= 0",
3372  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
3373 #endif // !DOCUMENTATION
3374 
3375 #ifndef DOCUMENTATION
3376  AsmPEFileHeader.setDataPrototype(
3377  "unsigned", "e_data_size", "= 0",
3378  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
3379 #endif // !DOCUMENTATION
3380 
3381 #ifndef DOCUMENTATION
3382  AsmPEFileHeader.setDataPrototype(
3383  "unsigned", "e_bss_size", "= 0",
3384  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
3385 #endif // !DOCUMENTATION
3386 
3387 #ifndef DOCUMENTATION
3388  AsmPEFileHeader.setDataPrototype(
3389  "rose_rva_t", "e_code_rva", "= 0",
3390  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
3391 #endif // !DOCUMENTATION
3392 
3393 #ifndef DOCUMENTATION
3394  AsmPEFileHeader.setDataPrototype(
3395  "rose_rva_t", "e_data_rva", "= 0",
3396  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
3397 #endif // !DOCUMENTATION
3398 
3399 #ifndef DOCUMENTATION
3400  AsmPEFileHeader.setDataPrototype(
3401  "unsigned", "e_section_align", "= 0",
3402  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
3403 #endif // !DOCUMENTATION
3404 
3405 #ifndef DOCUMENTATION
3406  AsmPEFileHeader.setDataPrototype(
3407  "unsigned", "e_file_align", "= 0",
3408  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
3409 #endif // !DOCUMENTATION
3410 
3411 #ifndef DOCUMENTATION
3412  AsmPEFileHeader.setDataPrototype(
3413  "unsigned", "e_os_major", "= 0",
3414  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
3415 #endif // !DOCUMENTATION
3416 
3417 #ifndef DOCUMENTATION
3418  AsmPEFileHeader.setDataPrototype(
3419  "unsigned", "e_os_minor", "= 0",
3420  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
3421 #endif // !DOCUMENTATION
3422 
3423 #ifndef DOCUMENTATION
3424  AsmPEFileHeader.setDataPrototype(
3425  "unsigned", "e_user_major", "= 0",
3426  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
3427 #endif // !DOCUMENTATION
3428 
3429 #ifndef DOCUMENTATION
3430  AsmPEFileHeader.setDataPrototype(
3431  "unsigned", "e_user_minor", "= 0",
3432  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
3433 #endif // !DOCUMENTATION
3434 
3435 #ifndef DOCUMENTATION
3436  AsmPEFileHeader.setDataPrototype(
3437  "unsigned", "e_subsys_major", "= 0",
3438  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
3439 #endif // !DOCUMENTATION
3440 
3441 #ifndef DOCUMENTATION
3442  AsmPEFileHeader.setDataPrototype(
3443  "unsigned", "e_subsys_minor", "= 0",
3444  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
3445 #endif // !DOCUMENTATION
3446 
3447 #ifndef DOCUMENTATION
3448  AsmPEFileHeader.setDataPrototype(
3449  "unsigned", "e_reserved9", "= 0",
3450  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
3451 #endif // !DOCUMENTATION
3452 
3453 #ifndef DOCUMENTATION
3454  AsmPEFileHeader.setDataPrototype(
3455  "unsigned", "e_image_size", "= 0",
3456  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
3457 #endif // !DOCUMENTATION
3458 
3459 #ifndef DOCUMENTATION
3460  AsmPEFileHeader.setDataPrototype(
3461  "unsigned", "e_header_size", "= 0",
3462  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
3463 #endif // !DOCUMENTATION
3464 
3465 #ifndef DOCUMENTATION
3466  AsmPEFileHeader.setDataPrototype(
3467  "unsigned", "e_file_checksum", "= 0",
3468  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
3469 #endif // !DOCUMENTATION
3470 
3471 #ifndef DOCUMENTATION
3472  AsmPEFileHeader.setDataPrototype(
3473  "unsigned", "e_subsystem", "= 0",
3474  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
3475 #endif // !DOCUMENTATION
3476 
3477 #ifndef DOCUMENTATION
3478  AsmPEFileHeader.setDataPrototype(
3479  "unsigned", "e_dll_flags", "= 0",
3480  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
3481 #endif // !DOCUMENTATION
3482 
3483 #ifndef DOCUMENTATION
3484  AsmPEFileHeader.setDataPrototype(
3485  "unsigned", "e_stack_reserve_size", "= 0",
3486  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
3487 #endif // !DOCUMENTATION
3488 
3489 #ifndef DOCUMENTATION
3490  AsmPEFileHeader.setDataPrototype(
3491  "unsigned", "e_stack_commit_size", "= 0",
3492  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
3493 #endif // !DOCUMENTATION
3494 
3495 #ifndef DOCUMENTATION
3496  AsmPEFileHeader.setDataPrototype(
3497  "unsigned", "e_heap_reserve_size", "= 0",
3498  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
3499 #endif // !DOCUMENTATION
3500 
3501 #ifndef DOCUMENTATION
3502  AsmPEFileHeader.setDataPrototype(
3503  "unsigned", "e_heap_commit_size", "= 0",
3504  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
3505 #endif // !DOCUMENTATION
3506 
3507 #ifndef DOCUMENTATION
3508  AsmPEFileHeader.setDataPrototype(
3509  "unsigned", "e_loader_flags", "= 0",
3510  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
3511 #endif // !DOCUMENTATION
3512 
3513 #ifndef DOCUMENTATION
3514  AsmPEFileHeader.setDataPrototype(
3515  "unsigned", "e_num_rvasize_pairs", "= 0",
3516  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
3517 #endif // !DOCUMENTATION
3518 
3519 #ifndef DOCUMENTATION
3520  AsmPEFileHeader.setDataPrototype(
3521  "SgAsmPERVASizePairList*", "rvasize_pairs", "= nullptr",
3522  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
3523 #endif // !DOCUMENTATION
3524 
3525 #ifndef DOCUMENTATION
3526  AsmPEFileHeader.setDataPrototype(
3527  "SgAsmPESectionTable*", "section_table", "= NULL",
3528  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
3529 #endif // !DOCUMENTATION
3530 
3531 #ifndef DOCUMENTATION
3532  AsmPEFileHeader.setDataPrototype(
3533  "SgAsmCoffSymbolTable*", "coff_symtab", "= NULL",
3534  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
3535 #endif // !DOCUMENTATION
3536 
3537  DECLARE_OTHERS(AsmPEFileHeader);
3538 #if defined(SgAsmPEFileHeader_OTHERS) || defined(DOCUMENTATION)
3539 
3540  //----------------------- Boost serialization for SgAsmPEFileHeader -----------------------
3541 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
3542 private:
3543  friend class boost::serialization::access;
3544 
3545  template<class S>
3546  void serialize(S &s, const unsigned /*version*/) {
3547  debugSerializationBegin("SgAsmPEFileHeader");
3548  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmGenericHeader);
3549  s & BOOST_SERIALIZATION_NVP(p_e_cpu_type);
3550  s & BOOST_SERIALIZATION_NVP(p_e_nsections);
3551  s & BOOST_SERIALIZATION_NVP(p_e_time);
3552  s & BOOST_SERIALIZATION_NVP(p_e_coff_symtab);
3553  s & BOOST_SERIALIZATION_NVP(p_e_nt_hdr_size);
3554  s & BOOST_SERIALIZATION_NVP(p_e_coff_nsyms);
3555  s & BOOST_SERIALIZATION_NVP(p_e_flags);
3556  s & BOOST_SERIALIZATION_NVP(p_e_opt_magic);
3557  s & BOOST_SERIALIZATION_NVP(p_e_lmajor);
3558  s & BOOST_SERIALIZATION_NVP(p_e_lminor);
3559  s & BOOST_SERIALIZATION_NVP(p_e_code_size);
3560  s & BOOST_SERIALIZATION_NVP(p_e_data_size);
3561  s & BOOST_SERIALIZATION_NVP(p_e_bss_size);
3562  s & BOOST_SERIALIZATION_NVP(p_e_code_rva);
3563  s & BOOST_SERIALIZATION_NVP(p_e_data_rva);
3564  s & BOOST_SERIALIZATION_NVP(p_e_section_align);
3565  s & BOOST_SERIALIZATION_NVP(p_e_file_align);
3566  s & BOOST_SERIALIZATION_NVP(p_e_os_major);
3567  s & BOOST_SERIALIZATION_NVP(p_e_os_minor);
3568  s & BOOST_SERIALIZATION_NVP(p_e_user_major);
3569  s & BOOST_SERIALIZATION_NVP(p_e_user_minor);
3570  s & BOOST_SERIALIZATION_NVP(p_e_subsys_major);
3571  s & BOOST_SERIALIZATION_NVP(p_e_subsys_minor);
3572  s & BOOST_SERIALIZATION_NVP(p_e_reserved9);
3573  s & BOOST_SERIALIZATION_NVP(p_e_image_size);
3574  s & BOOST_SERIALIZATION_NVP(p_e_header_size);
3575  s & BOOST_SERIALIZATION_NVP(p_e_file_checksum);
3576  s & BOOST_SERIALIZATION_NVP(p_e_subsystem);
3577  s & BOOST_SERIALIZATION_NVP(p_e_dll_flags);
3578  s & BOOST_SERIALIZATION_NVP(p_e_stack_reserve_size);
3579  s & BOOST_SERIALIZATION_NVP(p_e_stack_commit_size);
3580  s & BOOST_SERIALIZATION_NVP(p_e_heap_reserve_size);
3581  s & BOOST_SERIALIZATION_NVP(p_e_heap_commit_size);
3582  s & BOOST_SERIALIZATION_NVP(p_e_loader_flags);
3583  s & BOOST_SERIALIZATION_NVP(p_e_num_rvasize_pairs);
3584  s & BOOST_SERIALIZATION_NVP(p_rvasize_pairs);
3585  s & BOOST_SERIALIZATION_NVP(p_section_table);
3586  s & BOOST_SERIALIZATION_NVP(p_coff_symtab);
3587  debugSerializationEnd("SgAsmPEFileHeader");
3588  }
3589 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
3590  // Local types
3593 public:
3594 #ifdef _MSC_VER
3595 # pragma pack (1)
3596 #endif
3597  /* File format of a PE File Header. All fields are little endian. */
3599  unsigned char e_magic[4]; /* 0x00 magic number "PE\0\0" */
3600  uint16_t e_cpu_type; /* 0x04 e.g., 0x014c = Intel 386 */
3601  uint16_t e_nsections; /* 0x06 number of sections defined in the Section Table */
3602  uint32_t e_time; /* 0x08 time and date file was created or modified by the linker */
3603  uint32_t e_coff_symtab; /* 0x0c offset to COFF symbol table */
3604  uint32_t e_coff_nsyms; /* 0x10 number of symbols in COFF symbol table */
3605  uint16_t e_nt_hdr_size; /* 0x14 num remaining bytes in the header following the 'flags' field */
3606  uint16_t e_flags; /* 0x16 Bit flags: exe file, program/library image, fixed address, etc. */
3607  } /* 0x18 */
3608 #if !defined(SWIG) && !defined(_MSC_VER)
3609  __attribute__((packed))
3610 #endif
3611  ;
3612 
3614  uint16_t e_opt_magic; /* 0x18 magic number */
3615  uint16_t e_lmajor; /* 0x1a linker version */
3616  uint16_t e_lminor; /* 0x1c */
3617  uint16_t e_code_size; /* 0x1e Size of .text or sum of all code sections */
3618  uint32_t e_data_size; /* 0x20 Sum size of initialized data */
3619  uint32_t e_bss_size; /* 0x24 Sum size of uninitialized data */
3620  uint32_t e_entrypoint_rva; /* 0x28 RVA="relative virtual address"; relative to 'image_base', below */
3621  uint32_t e_code_rva; /* 0x2c Addr relative to image base for code section when memory mapped */
3622  uint32_t e_data_rva; /* 0x30 Address relative to image base for data section */
3623  uint32_t e_image_base; /* 0x34 Virt base of image (first byte of file, DOS header). 64k aligned */
3624  uint32_t e_section_align; /* 0x38 Alignment of sections in memory. Power of two 512<=x<=256M */
3625  uint32_t e_file_align; /* 0x3c Alignment factor (in bytes) for image pages */
3626  uint16_t e_os_major; /* 0x40 OS version number required to run this image */
3627  uint16_t e_os_minor; /* 0x42 */
3628  uint16_t e_user_major; /* 0x44 User-specified for differentiating between image revs */
3629  uint16_t e_user_minor; /* 0x46 */
3630  uint16_t e_subsys_major; /* 0x48 Subsystem version number */
3631  uint16_t e_subsys_minor; /* 0x4a */
3632  uint32_t e_reserved9; /* 0x4c */
3633  uint32_t e_image_size; /* 0x50 Virtual size of the image inc. all headers; section_align */
3634  uint32_t e_header_size; /* 0x54 Total header size (DOS Header + PE Header + Section table */
3635  uint32_t e_file_checksum; /* 0x58 Checksum for entire file; Set to zero by the linker */
3636  uint16_t e_subsystem; /* 0x5c Native, WindowsGUI, WindowsCharacter, OS/2 Character, etc. */
3637  uint16_t e_dll_flags; /* 0x5e Bit flags for library init/terminate per process or thread */
3638  uint32_t e_stack_reserve_size;/*0x60 Virtual mem reserved for stack; non-committed pages are guards */
3639  uint32_t e_stack_commit_size;/* 0x64 Size of valid stack; other pages are guards; <=stack_reserve_size*/
3640  uint32_t e_heap_reserve_size;/* 0x68 Size (bytes) of local heap to reserve */
3641  uint32_t e_heap_commit_size; /* 0x6c Size (bytes) of valid local heap */
3642  uint32_t e_loader_flags; /* 0x70 Reserved, must be zero */
3643  uint32_t e_num_rvasize_pairs;/* 0x74 Num RVASizePair entries that follow this member; part of header */
3644  } /* 0x78 */
3645 #if !defined(SWIG) && !defined(_MSC_VER)
3646  __attribute__((packed))
3647 #endif
3648  ;
3649 
3651  uint16_t e_opt_magic; /* 0x18 */
3652  uint16_t e_lmajor; /* 0x1a */
3653  uint16_t e_lminor; /* 0x1c */
3654  uint16_t e_code_size; /* 0x1e */
3655  uint32_t e_data_size; /* 0x20 */
3656  uint32_t e_bss_size; /* 0x24 */
3657  uint32_t e_entrypoint_rva; /* 0x28 */
3658  uint32_t e_code_rva; /* 0x2c */
3659  // uint32_t e_data_rva; /* Not present in PE32+ */
3660  uint64_t e_image_base; /* 0x30 */
3661  uint32_t e_section_align; /* 0x38 */
3662  uint32_t e_file_align; /* 0x3c */
3663  uint16_t e_os_major; /* 0x40 */
3664  uint16_t e_os_minor; /* 0x42 */
3665  uint16_t e_user_major; /* 0x44 */
3666  uint16_t e_user_minor; /* 0x46 */
3667  uint16_t e_subsys_major; /* 0x48 */
3668  uint16_t e_subsys_minor; /* 0x4a */
3669  uint32_t e_reserved9; /* 0x4c */
3670  uint32_t e_image_size; /* 0x50 */
3671  uint32_t e_header_size; /* 0x54 */
3672  uint32_t e_file_checksum; /* 0x58 */
3673  uint16_t e_subsystem; /* 0x5c */
3674  uint16_t e_dll_flags; /* 0x5e */
3675  uint64_t e_stack_reserve_size;/*0x60 */
3676  uint64_t e_stack_commit_size;/* 0x68 */
3677  uint64_t e_heap_reserve_size;/* 0x70 */
3678  uint64_t e_heap_commit_size; /* 0x78 */
3679  uint32_t e_loader_flags; /* 0x80 */
3680  uint32_t e_num_rvasize_pairs;/* 0x84 */
3681  } /* 0x88 */
3682 #if !defined(SWIG) && !defined(_MSC_VER)
3683  __attribute__((packed))
3684 #endif
3685  ;
3686 #ifdef _MSC_VER
3687 # pragma pack ()
3688 #endif
3689 
3690  /* Bit flags for the PE header 'flags' member */
3691  enum HeaderFlags {
3692  HF_PROGRAM = 0x0000, /* Program image (no non-reserved bits set) */
3693  HF_EXECUTABLE = 0x0002, /* Clear indicates can't load: link errors or incrementally linked */
3694  HF_FIXED = 0x0200, /* Image *must* be loaded at image_base address or error */
3695  HF_LIBRARY = 0x2000, /* Library image */
3696  HF_RESERVED_MASK = 0xddfd /* Reserved bits */
3697  };
3698 
3699  /* Values for the PE header 'subsystem' member */
3700  enum Subsystem {
3701  HF_SPEC_UNKNOWN = 0x0000, /* Specified as 'unknown' in the file */
3702  HF_NATIVE = 0x0001, /* Native */
3703  HF_WINGUI = 0x0002, /* Windows GUI */
3704  HF_WINCHAR = 0x0003, /* Windows character */
3705  HF_OS2CHAR = 0x0005, /* OS/2 character */
3706  HF_POSIX = 0x0007 /* POSIX character */
3707  };
3708 
3709  /* Bit flags for the PE header 'dll_flags' member */
3710  enum DLLFlags {
3711  DLL_PROC_INIT = 0x0001, /* Per-process library initialization */
3712  DLL_PROC_TERM = 0x0002, /* Per-process library termination */
3713  DLL_THRD_INIT = 0x0004, /* Per-thread library initialization */
3714  DLL_THRD_TERM = 0x0008, /* Per-thread library termination */
3715  DLL_RESERVED_MASK = 0xfff0 /* Reserved bits */
3716  };
3717 
3719  enum PairPurpose { // Values are important
3720  PAIR_EXPORTS = 0,
3721  PAIR_IMPORTS = 1,
3722  PAIR_RESOURCES = 2,
3723  PAIR_EXCEPTIONS = 3,
3724  PAIR_CERTIFICATES = 4,
3725  PAIR_BASERELOCS = 5,
3726  PAIR_DEBUG = 6,
3727  PAIR_ARCHITECTURE = 7,
3728  PAIR_GLOBALPTR = 8,
3729  PAIR_TLS = 9, // Thread local storage
3730  PAIR_LOADCONFIG = 10,
3731  PAIR_BOUNDIMPORT = 11,
3732  PAIR_IAT = 12, // Import address table
3733  PAIR_DELAYIMPORT = 13, // Delay import descriptor
3734  PAIR_CLRRUNTIME = 14, // CLR(?) runtime header
3735  PAIR_RESERVED15 = 15 // Reserved (always zero according to specification)
3736  };
3737 
3739  // Properties
3741 public:
3747  unsigned const& get_e_cpu_type() const;
3748  void set_e_cpu_type(unsigned const&);
3751 public:
3757  unsigned const& get_e_nsections() const;
3758  void set_e_nsections(unsigned const&);
3761 public:
3767  unsigned const& get_e_time() const;
3768  void set_e_time(unsigned const&);
3771 public:
3777  rose_addr_t const& get_e_coff_symtab() const;
3778  void set_e_coff_symtab(rose_addr_t const&);
3781 public:
3787  rose_addr_t const& get_e_nt_hdr_size() const;
3788  void set_e_nt_hdr_size(rose_addr_t const&);
3791 public:
3797  unsigned const& get_e_coff_nsyms() const;
3798  void set_e_coff_nsyms(unsigned const&);
3801 public:
3807  unsigned const& get_e_flags() const;
3808  void set_e_flags(unsigned const&);
3811 public:
3817  unsigned const& get_e_opt_magic() const;
3818  void set_e_opt_magic(unsigned const&);
3821 public:
3827  unsigned const& get_e_lmajor() const;
3828  void set_e_lmajor(unsigned const&);
3831 public:
3837  unsigned const& get_e_lminor() const;
3838  void set_e_lminor(unsigned const&);
3841 public:
3847  unsigned const& get_e_code_size() const;
3848  void set_e_code_size(unsigned const&);
3851 public:
3857  unsigned const& get_e_data_size() const;
3858  void set_e_data_size(unsigned const&);
3861 public:
3867  unsigned const& get_e_bss_size() const;
3868  void set_e_bss_size(unsigned const&);
3871 public:
3877  rose_rva_t const& get_e_code_rva() const;
3879  void set_e_code_rva(rose_rva_t const&);
3882 public:
3888  rose_rva_t const& get_e_data_rva() const;
3890  void set_e_data_rva(rose_rva_t const&);
3893 public:
3899  unsigned const& get_e_section_align() const;
3900  void set_e_section_align(unsigned const&);
3903 public:
3909  unsigned const& get_e_file_align() const;
3910  void set_e_file_align(unsigned const&);
3913 public:
3919  unsigned const& get_e_os_major() const;
3920  void set_e_os_major(unsigned const&);
3923 public:
3929  unsigned const& get_e_os_minor() const;
3930  void set_e_os_minor(unsigned const&);
3933 public:
3939  unsigned const& get_e_user_major() const;
3940  void set_e_user_major(unsigned const&);
3943 public:
3949  unsigned const& get_e_user_minor() const;
3950  void set_e_user_minor(unsigned const&);
3953 public:
3959  unsigned const& get_e_subsys_major() const;
3960  void set_e_subsys_major(unsigned const&);
3963 public:
3969  unsigned const& get_e_subsys_minor() const;
3970  void set_e_subsys_minor(unsigned const&);
3973 public:
3979  unsigned const& get_e_reserved9() const;
3980  void set_e_reserved9(unsigned const&);
3983 public:
3989  unsigned const& get_e_image_size() const;
3990  void set_e_image_size(unsigned const&);
3993 public:
3999  unsigned const& get_e_header_size() const;
4000  void set_e_header_size(unsigned const&);
4003 public:
4009  unsigned const& get_e_file_checksum() const;
4010  void set_e_file_checksum(unsigned const&);
4013 public:
4019  unsigned const& get_e_subsystem() const;
4020  void set_e_subsystem(unsigned const&);
4023 public:
4029  unsigned const& get_e_dll_flags() const;
4030  void set_e_dll_flags(unsigned const&);
4033 public:
4039  unsigned const& get_e_stack_reserve_size() const;
4040  void set_e_stack_reserve_size(unsigned const&);
4043 public:
4049  unsigned const& get_e_stack_commit_size() const;
4050  void set_e_stack_commit_size(unsigned const&);
4053 public:
4059  unsigned const& get_e_heap_reserve_size() const;
4060  void set_e_heap_reserve_size(unsigned const&);
4063 public:
4069  unsigned const& get_e_heap_commit_size() const;
4070  void set_e_heap_commit_size(unsigned const&);
4073 public:
4079  unsigned const& get_e_loader_flags() const;
4080  void set_e_loader_flags(unsigned const&);
4083 public:
4089  unsigned const& get_e_num_rvasize_pairs() const;
4090  void set_e_num_rvasize_pairs(unsigned const&);
4093 public:
4099  SgAsmPERVASizePairList* const& get_rvasize_pairs() const;
4103 public:
4109  SgAsmPESectionTable* const& get_section_table() const;
4110  void set_section_table(SgAsmPESectionTable* const&);
4113 public:
4119  SgAsmCoffSymbolTable* const& get_coff_symtab() const;
4120  void set_coff_symtab(SgAsmCoffSymbolTable* const&);
4122  // Functions
4125 public:
4127 
4128  virtual const char *format_name() const override {return "PE";}
4129 
4135  static bool is_PE (SgAsmGenericFile*);
4136 
4141  std::string rvasize_pair_name(PairPurpose, const char **short_name);
4142 
4145 
4147  void update_rvasize_pairs();
4148 
4149  void add_rvasize_pairs();
4150 
4151  virtual SgAsmPEFileHeader *parse() override;
4152  virtual bool reallocate() override;
4153  virtual void unparse(std::ostream&) const override;
4154  virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
4155  void create_table_sections();
4156 
4157  /* Loader memory maps */
4158  Rose::BinaryAnalysis::MemoryMap::Ptr get_loader_map() const {return p_loader_map;}
4159  void set_loader_map(const Rose::BinaryAnalysis::MemoryMap::Ptr &map) {p_loader_map=map;}
4160 
4161 private:
4162  void *encode(SgAsmPEFileHeader::PEFileHeader_disk*) const;
4163  void *encode(SgAsmPEFileHeader::PE32OptHeader_disk*) const;
4164  void *encode(SgAsmPEFileHeader::PE64OptHeader_disk*) const;
4166 public:
4168  virtual ~SgAsmPEFileHeader();
4169 
4170 public:
4173 
4174 protected:
4181  void initializeProperties();
4182 #endif // SgAsmPEFileHeader_OTHERS
4183 #ifdef DOCUMENTATION
4184 };
4185 #endif // DOCUMENTATION
4186 
4187 
4189 // SgAsmPEExportSection -- MACHINE GENERATED; DO NOT MODIFY --
4191 
4192 DECLARE_LEAF_CLASS(AsmPEExportSection);
4193 IS_SERIALIZABLE(AsmPEExportSection);
4194 
4195 #ifdef DOCUMENTATION
4196 
4198 #endif // DOCUMENTATION
4199 
4200 #ifndef DOCUMENTATION
4201  AsmPEExportSection.setDataPrototype(
4202  "SgAsmPEExportDirectory*", "export_dir", "= nullptr",
4203  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
4204 #endif // !DOCUMENTATION
4205 
4206 #ifndef DOCUMENTATION
4207  AsmPEExportSection.setDataPrototype(
4208  "SgAsmPEExportEntryList*", "exports", "= createAndParent<SgAsmPEExportEntryList>(this)",
4209  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
4210 #endif // !DOCUMENTATION
4211 
4212  DECLARE_OTHERS(AsmPEExportSection);
4213 #if defined(SgAsmPEExportSection_OTHERS) || defined(DOCUMENTATION)
4214 
4215  //----------------------- Boost serialization for SgAsmPEExportSection -----------------------
4216 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
4217 private:
4218  friend class boost::serialization::access;
4219 
4220  template<class S>
4221  void serialize(S &s, const unsigned /*version*/) {
4222  debugSerializationBegin("SgAsmPEExportSection");
4223  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmPESection);
4224  s & BOOST_SERIALIZATION_NVP(p_export_dir);
4225  s & BOOST_SERIALIZATION_NVP(p_exports);
4226  debugSerializationEnd("SgAsmPEExportSection");
4227  }
4228 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
4229 
4230 public:
4236  SgAsmPEExportDirectory* const& get_export_dir() const;
4237  void set_export_dir(SgAsmPEExportDirectory* const&);
4240 public:
4246  SgAsmPEExportEntryList* const& get_exports() const;
4247  void set_exports(SgAsmPEExportEntryList* const&);
4249 public:
4255  typedef uint32_t ExportAddress_disk;
4256 
4260  typedef uint32_t ExportNamePtr_disk;
4261 
4265  typedef uint16_t ExportOrdinal_disk;
4266 
4268  virtual SgAsmPEExportSection *parse() override;
4269  virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
4270  void add_entry(SgAsmPEExportEntry*);
4271 public:
4273  virtual ~SgAsmPEExportSection();
4274 
4275 public:
4278 
4279 protected:
4286  void initializeProperties();
4287 #endif // SgAsmPEExportSection_OTHERS
4288 #ifdef DOCUMENTATION
4289 };
4290 #endif // DOCUMENTATION
4291 
4292 
4294 // SgAsmPESection -- MACHINE GENERATED; DO NOT MODIFY --
4296 
4297 #ifndef DOCUMENTATION
4298 AstNodeClass& AsmPESection = nonTerminalConstructor(
4299  "AsmPESection",
4300  *this,
4301  "AsmPESection",
4302  "AsmPESectionTag",
4303  SubclassListBuilder()
4304  | AsmPEExportSection
4305  | AsmPEImportSection
4306  | AsmPEStringSection
4307  , true);
4308 assert(AsmPESection.associatedGrammar != nullptr);
4309 AsmPESection.setCppCondition("!defined(DOCUMENTATION)");
4310 AsmPESection.isBoostSerializable(true);
4311 AsmPESection.setAutomaticGenerationOfConstructor(false);
4312 AsmPESection.setAutomaticGenerationOfDestructor(false);
4313 #endif // !DOCUMENTATION
4314 
4315 #ifdef DOCUMENTATION
4316 
4318 #endif // DOCUMENTATION
4319 
4320 #ifndef DOCUMENTATION
4321  AsmPESection.setDataPrototype(
4322  "SgAsmPESectionTableEntry*", "section_entry", "= nullptr",
4323  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
4324 #endif // !DOCUMENTATION
4325 
4326  DECLARE_OTHERS(AsmPESection);
4327 #if defined(SgAsmPESection_OTHERS) || defined(DOCUMENTATION)
4328 
4329  //----------------------- Boost serialization for SgAsmPESection -----------------------
4330 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
4331 private:
4332  friend class boost::serialization::access;
4333 
4334  template<class S>
4335  void serialize(S &s, const unsigned /*version*/) {
4336  debugSerializationBegin("SgAsmPESection");
4337  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmGenericSection);
4338  s & BOOST_SERIALIZATION_NVP(p_section_entry);
4339  debugSerializationEnd("SgAsmPESection");
4340  }
4341 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
4342 
4343 public:
4352 public:
4353  explicit SgAsmPESection(SgAsmPEFileHeader*);
4354 
4361  virtual bool reallocate() override;
4362  virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
4363 public:
4365  virtual ~SgAsmPESection();
4366 
4367 public:
4369  SgAsmPESection();
4370 
4371 protected:
4378  void initializeProperties();
4379 #endif // SgAsmPESection_OTHERS
4380 #ifdef DOCUMENTATION
4381 };
4382 #endif // DOCUMENTATION
4383 
4384 
4386 // SgAsmPEExportEntryList -- MACHINE GENERATED; DO NOT MODIFY --
4388 
4389 DECLARE_LEAF_CLASS(AsmPEExportEntryList);
4390 IS_SERIALIZABLE(AsmPEExportEntryList);
4391 
4392 #ifdef DOCUMENTATION
4393 
4398 #endif // DOCUMENTATION
4399 
4400 #ifndef DOCUMENTATION
4401  AsmPEExportEntryList.setDataPrototype(
4402  "SgAsmPEExportEntryPtrList", "exports", "",
4403  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
4404 #endif // !DOCUMENTATION
4405 
4406  DECLARE_OTHERS(AsmPEExportEntryList);
4407 #if defined(SgAsmPEExportEntryList_OTHERS) || defined(DOCUMENTATION)
4408 
4409  //----------------------- Boost serialization for SgAsmPEExportEntryList -----------------------
4410 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
4411 private:
4412  friend class boost::serialization::access;
4413 
4414  template<class S>
4415  void serialize(S &s, const unsigned /*version*/) {
4416  debugSerializationBegin("SgAsmPEExportEntryList");
4417  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
4418  s & BOOST_SERIALIZATION_NVP(p_exports);
4419  debugSerializationEnd("SgAsmPEExportEntryList");
4420  }
4421 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
4422 
4423 public:
4427  SgAsmPEExportEntryPtrList const& get_exports() const;
4428  SgAsmPEExportEntryPtrList& get_exports();
4429  void set_exports(SgAsmPEExportEntryPtrList const&);
4432 public:
4434  virtual ~SgAsmPEExportEntryList();
4435 
4436 public:
4439 
4440 protected:
4447  void initializeProperties();
4448 #endif // SgAsmPEExportEntryList_OTHERS
4449 #ifdef DOCUMENTATION
4450 };
4451 #endif // DOCUMENTATION
4452 
4453 
4455 // SgAsmPEExportEntry -- MACHINE GENERATED; DO NOT MODIFY --
4457 
4458 DECLARE_LEAF_CLASS(AsmPEExportEntry);
4459 IS_SERIALIZABLE(AsmPEExportEntry);
4460 
4461 #ifdef DOCUMENTATION
4462 
4464 #endif // DOCUMENTATION
4465 
4466 #ifndef DOCUMENTATION
4467  AsmPEExportEntry.setDataPrototype(
4468  "SgAsmGenericString*", "name", "= nullptr",
4469  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
4470 #endif // !DOCUMENTATION
4471 
4472 #ifndef DOCUMENTATION
4473  AsmPEExportEntry.setDataPrototype(
4474  "unsigned", "ordinal", "= 0",
4475  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
4476 #endif // !DOCUMENTATION
4477 
4478 #ifndef DOCUMENTATION
4479  AsmPEExportEntry.setDataPrototype(
4480  "rose_rva_t", "export_rva", "= 0",
4481  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
4482 #endif // !DOCUMENTATION
4483 
4484 #ifndef DOCUMENTATION
4485  AsmPEExportEntry.setDataPrototype(
4486  "SgAsmGenericString*", "forwarder", "= nullptr",
4487  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
4488 #endif // !DOCUMENTATION
4489 
4490  DECLARE_OTHERS(AsmPEExportEntry);
4491 #if defined(SgAsmPEExportEntry_OTHERS) || defined(DOCUMENTATION)
4492 
4493  //----------------------- Boost serialization for SgAsmPEExportEntry -----------------------
4494 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
4495 private:
4496  friend class boost::serialization::access;
4497 
4498  template<class S>
4499  void serialize(S &s, const unsigned /*version*/) {
4500  debugSerializationBegin("SgAsmPEExportEntry");
4501  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
4502  s & BOOST_SERIALIZATION_NVP(p_name);
4503  s & BOOST_SERIALIZATION_NVP(p_ordinal);
4504  s & BOOST_SERIALIZATION_NVP(p_export_rva);
4505  s & BOOST_SERIALIZATION_NVP(p_forwarder);
4506  debugSerializationEnd("SgAsmPEExportEntry");
4507  }
4508 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
4509 
4510 public:
4516  SgAsmGenericString* const& get_name() const;
4519 public:
4525  unsigned const& get_ordinal() const;
4526  void set_ordinal(unsigned const&);
4529 public:
4535  rose_rva_t const& get_export_rva() const;
4537  void set_export_rva(rose_rva_t const&);
4540 public:
4546  SgAsmGenericString* const& get_forwarder() const;
4550 public:
4551  SgAsmPEExportEntry(SgAsmGenericString *name, unsigned ordinal, rose_rva_t export_rva, SgAsmGenericString *forwarder);
4552  void dump(FILE *f,const char *prefix,ssize_t idx) const;
4553  /* Accessors. Override ROSETTA because we adjust parents. */
4554 
4560  Sawyer::Result<unsigned /*ordinal*/, std::string /*reason*/> biasedOrdinal() const;
4561 public:
4563  virtual ~SgAsmPEExportEntry();
4564 
4565 public:
4568 
4569 protected:
4576  void initializeProperties();
4577 #endif // SgAsmPEExportEntry_OTHERS
4578 #ifdef DOCUMENTATION
4579 };
4580 #endif // DOCUMENTATION
4581 
4582 
4584 // SgAsmPEExportDirectory -- MACHINE GENERATED; DO NOT MODIFY --
4586 
4587 DECLARE_LEAF_CLASS(AsmPEExportDirectory);
4588 IS_SERIALIZABLE(AsmPEExportDirectory);
4589 
4590 #ifdef DOCUMENTATION
4591 
4593 #endif // DOCUMENTATION
4594 
4595 #ifndef DOCUMENTATION
4596  AsmPEExportDirectory.setDataPrototype(
4597  "unsigned", "res1", "= 0",
4598  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
4599 #endif // !DOCUMENTATION
4600 
4601 #ifndef DOCUMENTATION
4602  AsmPEExportDirectory.setDataPrototype(
4603  "time_t", "timestamp", "= 0",
4604  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
4605 #endif // !DOCUMENTATION
4606 
4607 #ifndef DOCUMENTATION
4608  AsmPEExportDirectory.setDataPrototype(
4609  "unsigned", "vmajor", "= 0",
4610  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
4611 #endif // !DOCUMENTATION
4612 
4613 #ifndef DOCUMENTATION
4614  AsmPEExportDirectory.setDataPrototype(
4615  "unsigned", "vminor", "= 0",
4616  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
4617 #endif // !DOCUMENTATION
4618 
4619 #ifndef DOCUMENTATION
4620  AsmPEExportDirectory.setDataPrototype(
4621  "rose_rva_t", "name_rva", "= 0",
4622  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
4623 #endif // !DOCUMENTATION
4624 
4625 #ifndef DOCUMENTATION
4626  AsmPEExportDirectory.setDataPrototype(
4627  "unsigned", "ord_base", "= 0",
4628  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
4629 #endif // !DOCUMENTATION
4630 
4631 #ifndef DOCUMENTATION
4632  AsmPEExportDirectory.setDataPrototype(
4633  "size_t", "expaddr_n", "= 0",
4634  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
4635 #endif // !DOCUMENTATION
4636 
4637 #ifndef DOCUMENTATION
4638  AsmPEExportDirectory.setDataPrototype(
4639  "size_t", "nameptr_n", "= 0",
4640  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
4641 #endif // !DOCUMENTATION
4642 
4643 #ifndef DOCUMENTATION
4644  AsmPEExportDirectory.setDataPrototype(
4645  "rose_rva_t", "expaddr_rva", "= 0",
4646  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
4647 #endif // !DOCUMENTATION
4648 
4649 #ifndef DOCUMENTATION
4650  AsmPEExportDirectory.setDataPrototype(
4651  "rose_rva_t", "nameptr_rva", "= 0",
4652  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
4653 #endif // !DOCUMENTATION
4654 
4655 #ifndef DOCUMENTATION
4656  AsmPEExportDirectory.setDataPrototype(
4657  "rose_rva_t", "ordinals_rva", "= 0",
4658  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
4659 #endif // !DOCUMENTATION
4660 
4661 #ifndef DOCUMENTATION
4662  AsmPEExportDirectory.setDataPrototype(
4663  "SgAsmGenericString*", "name", "= NULL",
4664  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
4665 #endif // !DOCUMENTATION
4666 
4667  DECLARE_OTHERS(AsmPEExportDirectory);
4668 #if defined(SgAsmPEExportDirectory_OTHERS) || defined(DOCUMENTATION)
4669 
4670  //----------------------- Boost serialization for SgAsmPEExportDirectory -----------------------
4671 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
4672 private:
4673  friend class boost::serialization::access;
4674 
4675  template<class S>
4676  void serialize(S &s, const unsigned /*version*/) {
4677  debugSerializationBegin("SgAsmPEExportDirectory");
4678  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
4679  s & BOOST_SERIALIZATION_NVP(p_res1);
4680  s & BOOST_SERIALIZATION_NVP(p_timestamp);
4681  s & BOOST_SERIALIZATION_NVP(p_vmajor);
4682  s & BOOST_SERIALIZATION_NVP(p_vminor);
4683  s & BOOST_SERIALIZATION_NVP(p_name_rva);
4684  s & BOOST_SERIALIZATION_NVP(p_ord_base);
4685  s & BOOST_SERIALIZATION_NVP(p_expaddr_n);
4686  s & BOOST_SERIALIZATION_NVP(p_nameptr_n);
4687  s & BOOST_SERIALIZATION_NVP(p_expaddr_rva);
4688  s & BOOST_SERIALIZATION_NVP(p_nameptr_rva);
4689  s & BOOST_SERIALIZATION_NVP(p_ordinals_rva);
4690  s & BOOST_SERIALIZATION_NVP(p_name);
4691  debugSerializationEnd("SgAsmPEExportDirectory");
4692  }
4693 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
4694  // Local types
4697 public:
4698 #ifdef _MSC_VER
4699 # pragma pack (1)
4700 #endif
4701  /* An Export Section begins with the Export Directory */
4703  uint32_t res1; /* 0x00 Reserved, must be zero */
4704  uint32_t timestamp; /* 0x04 Time that export data was created */
4705  uint16_t vmajor; /* 0x08 Major version number (user defined) */
4706  uint16_t vminor; /* 0x0a Minor version number (user defined) */
4707  uint32_t name_rva; /* 0x0c Location of name of DLL */
4708  uint32_t ord_base; /* 0x10 Starting ordinal for exports in this image (usually 1) */
4709  uint32_t expaddr_n; /* 0x14 Number of entries in the export address table */
4710  uint32_t nameptr_n; /* 0x18 Number of entries in the name pointer table and ordinal table */
4711  uint32_t expaddr_rva; /* 0x1c Location of Export Address Table */
4712  uint32_t nameptr_rva; /* 0x20 Location of Export Name Pointer Table */
4713  uint32_t ordinals_rva; /* 0x24 Location of Ordinal Table */
4714  } /* 0x28 */
4715 #if !defined(SWIG) && !defined(_MSC_VER)
4716  __attribute__((packed))
4717 #endif
4718  ;
4719 #ifdef _MSC_VER
4720 # pragma pack ()
4721 #endif
4722 
4724  // Properties
4726 public:
4732  unsigned const& get_res1() const;
4733  void set_res1(unsigned const&);
4736 public:
4742  time_t const& get_timestamp() const;
4743  void set_timestamp(time_t const&);
4746 public:
4752  unsigned const& get_vmajor() const;
4753  void set_vmajor(unsigned const&);
4756 public:
4762  unsigned const& get_vminor() const;
4763  void set_vminor(unsigned const&);
4766 public:
4772  rose_rva_t const& get_name_rva() const;
4774  void set_name_rva(rose_rva_t const&);
4777 public:
4783  unsigned const& get_ord_base() const;
4784  void set_ord_base(unsigned const&);
4787 public:
4793  size_t const& get_expaddr_n() const;
4794  void set_expaddr_n(size_t const&);
4797 public:
4803  size_t const& get_nameptr_n() const;
4804  void set_nameptr_n(size_t const&);
4807 public:
4813  rose_rva_t const& get_expaddr_rva() const;
4815  void set_expaddr_rva(rose_rva_t const&);
4818 public:
4824  rose_rva_t const& get_nameptr_rva() const;
4826  void set_nameptr_rva(rose_rva_t const&);
4829 public:
4835  rose_rva_t const& get_ordinals_rva() const;
4837  void set_ordinals_rva(rose_rva_t const&);
4840 public:
4846  SgAsmGenericString* const& get_name() const;
4847  void set_name(SgAsmGenericString* const&);
4849  // Functions
4852 public:
4854  void dump(FILE *f, const char *prefix, ssize_t idx) const;
4855 public:
4857  virtual ~SgAsmPEExportDirectory();
4858 
4859 public:
4862 
4863 protected:
4870  void initializeProperties();
4871 #endif // SgAsmPEExportDirectory_OTHERS
4872 #ifdef DOCUMENTATION
4873 };
4874 #endif // DOCUMENTATION
4875 
4876 
4878 // SgAsmOperandList -- MACHINE GENERATED; DO NOT MODIFY --
4880 
4881 DECLARE_LEAF_CLASS(AsmOperandList);
4882 IS_SERIALIZABLE(AsmOperandList);
4883 
4884 #ifdef DOCUMENTATION
4885 
4887 #endif // DOCUMENTATION
4888 
4889 #ifndef DOCUMENTATION
4890  AsmOperandList.setDataPrototype(
4891  "SgAsmExpressionPtrList", "operands", "",
4892  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
4893 #endif // !DOCUMENTATION
4894 
4895  DECLARE_OTHERS(AsmOperandList);
4896 #if defined(SgAsmOperandList_OTHERS) || defined(DOCUMENTATION)
4897 
4898  //----------------------- Boost serialization for SgAsmOperandList -----------------------
4899 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
4900 private:
4901  friend class boost::serialization::access;
4902 
4903  template<class S>
4904  void serialize(S &s, const unsigned /*version*/) {
4905  debugSerializationBegin("SgAsmOperandList");
4906  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmNode);
4907  s & BOOST_SERIALIZATION_NVP(p_operands);
4908  debugSerializationEnd("SgAsmOperandList");
4909  }
4910 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
4911 
4912 public:
4919  SgAsmExpressionPtrList const& get_operands() const;
4920  SgAsmExpressionPtrList& get_operands();
4921  void set_operands(SgAsmExpressionPtrList const&);
4923 public:
4925  void append_operand(SgAsmExpression* operand);
4926 public:
4928  virtual ~SgAsmOperandList();
4929 
4930 public:
4932  SgAsmOperandList();
4933 
4934 protected:
4941  void initializeProperties();
4942 #endif // SgAsmOperandList_OTHERS
4943 #ifdef DOCUMENTATION
4944 };
4945 #endif // DOCUMENTATION
4946 
4947 
4949 // SgAsmNullInstruction -- MACHINE GENERATED; DO NOT MODIFY --
4951 
4952 DECLARE_LEAF_CLASS(AsmNullInstruction);
4953 IS_SERIALIZABLE(AsmNullInstruction);
4954 
4955 #ifdef DOCUMENTATION
4957 #endif // DOCUMENTATION
4958 
4959  DECLARE_OTHERS(AsmNullInstruction);
4960 #if defined(SgAsmNullInstruction_OTHERS) || defined(DOCUMENTATION)
4961 
4962  //----------------------- Boost serialization for SgAsmNullInstruction -----------------------
4963 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
4964 private:
4965  friend class boost::serialization::access;
4966 
4967  template<class S>
4968  void serialize(S &s, const unsigned /*version*/) {
4969  debugSerializationBegin("SgAsmNullInstruction");
4970  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmInstruction);
4971  debugSerializationEnd("SgAsmNullInstruction");
4972  }
4973 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
4974 public:
4975  // there's only one kind of null instruction
4976  enum Kind { null_unknown };
4977 
4978 public: // overrides
4979  virtual bool terminatesBasicBlock() override;
4980  virtual bool isFunctionCallFast(const std::vector<SgAsmInstruction*> &insns,
4981  rose_addr_t *target/*out*/, rose_addr_t *ret/*out*/) override;
4982  virtual bool isFunctionCallSlow(const std::vector<SgAsmInstruction*>&,
4983  rose_addr_t *target, rose_addr_t *ret) override;
4984  virtual bool isFunctionReturnFast(const std::vector<SgAsmInstruction*> &insns) override;
4985  virtual bool isFunctionReturnSlow(const std::vector<SgAsmInstruction*> &insns) override;
4986  virtual Sawyer::Optional<rose_addr_t> branchTarget() override;
4987  virtual Rose::BinaryAnalysis::AddressSet getSuccessors(bool &complete) override;
4988  virtual Rose::BinaryAnalysis::AddressSet getSuccessors(const std::vector<SgAsmInstruction*>&,
4989  bool &complete,
4990  const Rose::BinaryAnalysis::MemoryMap::Ptr &initial_memory =
4992  virtual bool isUnknown() const override;
4993  virtual unsigned get_anyKind() const override;
4994 public:
4996  virtual ~SgAsmNullInstruction();
4997 
4998 public:
5001 
5002 public:
5004  SgAsmNullInstruction(rose_addr_t const& address,
5005  std::string const& mnemonic);
5006 
5007 protected:
5014  void initializeProperties();
5015 #endif // SgAsmNullInstruction_OTHERS
5016 #ifdef DOCUMENTATION
5017 };
5018 #endif // DOCUMENTATION
5019 
5020 
5022 // SgAsmNEStringTable -- MACHINE GENERATED; DO NOT MODIFY --
5024 
5025 DECLARE_LEAF_CLASS(AsmNEStringTable);
5026 IS_SERIALIZABLE(AsmNEStringTable);
5027 
5028 #ifdef DOCUMENTATION
5030 #endif // DOCUMENTATION
5031 
5032  DECLARE_OTHERS(AsmNEStringTable);
5033 #if defined(SgAsmNEStringTable_OTHERS) || defined(DOCUMENTATION)
5034 
5035  //----------------------- Boost serialization for SgAsmNEStringTable -----------------------
5036 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
5037 private:
5038  friend class boost::serialization::access;
5039 
5040  template<class S>
5041  void serialize(S &s, const unsigned /*version*/) {
5042  debugSerializationBegin("SgAsmNEStringTable");
5043  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmGenericSection);
5044  debugSerializationEnd("SgAsmNEStringTable");
5045  }
5046 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
5047 public:
5048  SgAsmNEStringTable(SgAsmNEFileHeader *fhdr, rose_addr_t offset, rose_addr_t size);
5049  virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
5050  std::string get_string(rose_addr_t offset);
5051 public:
5053  virtual ~SgAsmNEStringTable();
5054 
5055 public:
5058 
5059 protected:
5066  void initializeProperties();
5067 #endif // SgAsmNEStringTable_OTHERS
5068 #ifdef DOCUMENTATION
5069 };
5070 #endif // DOCUMENTATION
5071 
5072 
5074 // SgAsmNESectionTable -- MACHINE GENERATED; DO NOT MODIFY --
5076 
5077 DECLARE_LEAF_CLASS(AsmNESectionTable);
5078 IS_SERIALIZABLE(AsmNESectionTable);
5079 
5080 #ifdef DOCUMENTATION
5082 #endif // DOCUMENTATION
5083 
5084 #ifndef DOCUMENTATION
5085  AsmNESectionTable.setDataPrototype(
5086  "unsigned", "flags", "= 0",
5087  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
5088 #endif // !DOCUMENTATION
5089 
5090 #ifndef DOCUMENTATION
5091  AsmNESectionTable.setDataPrototype(
5092  "unsigned", "sector", "= 0",
5093  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
5094 #endif // !DOCUMENTATION
5095 
5096 #ifndef DOCUMENTATION
5097  AsmNESectionTable.setDataPrototype(
5098  "rose_addr_t", "physical_size", "= 0",
5099  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
5100 #endif // !DOCUMENTATION
5101 
5102 #ifndef DOCUMENTATION
5103  AsmNESectionTable.setDataPrototype(
5104  "rose_addr_t", "virtual_size", "= 0",
5105  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
5106 #endif // !DOCUMENTATION
5107 
5108  DECLARE_OTHERS(AsmNESectionTable);
5109 #if defined(SgAsmNESectionTable_OTHERS) || defined(DOCUMENTATION)
5110 
5111  //----------------------- Boost serialization for SgAsmNESectionTable -----------------------
5112 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
5113 private:
5114  friend class boost::serialization::access;
5115 
5116  template<class S>
5117  void serialize(S &s, const unsigned /*version*/) {
5118  debugSerializationBegin("SgAsmNESectionTable");
5119  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmGenericSection);
5120  s & BOOST_SERIALIZATION_NVP(p_flags);
5121  s & BOOST_SERIALIZATION_NVP(p_sector);
5122  s & BOOST_SERIALIZATION_NVP(p_physical_size);
5123  s & BOOST_SERIALIZATION_NVP(p_virtual_size);
5124  debugSerializationEnd("SgAsmNESectionTable");
5125  }
5126 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
5127 
5128 public:
5129  unsigned const& get_flags() const;
5130  void set_flags(unsigned const&);
5131 
5132 public:
5133  unsigned const& get_sector() const;
5134  void set_sector(unsigned const&);
5135 
5136 public:
5137  rose_addr_t const& get_physical_size() const;
5138  void set_physical_size(rose_addr_t const&);
5139 
5140 public:
5141  rose_addr_t const& get_virtual_size() const;
5142  void set_virtual_size(rose_addr_t const&);
5143 public:
5145  virtual void unparse(std::ostream&) const override;
5146  virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
5147 public:
5149  virtual ~SgAsmNESectionTable();
5150 
5151 public:
5154 
5155 protected:
5162  void initializeProperties();
5163 #endif // SgAsmNESectionTable_OTHERS
5164 #ifdef DOCUMENTATION
5165 };
5166 #endif // DOCUMENTATION
5167 
5168 
5170 // SgAsmNESectionTableEntry -- MACHINE GENERATED; DO NOT MODIFY --
5172 
5173 DECLARE_LEAF_CLASS(AsmNESectionTableEntry);
5174 IS_SERIALIZABLE(AsmNESectionTableEntry);
5175 
5176 #ifdef DOCUMENTATION
5178 #endif // DOCUMENTATION
5179 
5180 #ifndef DOCUMENTATION
5181  AsmNESectionTableEntry.setDataPrototype(
5182  "unsigned", "flags", "= 0",
5183  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
5184 #endif // !DOCUMENTATION
5185 
5186 #ifndef DOCUMENTATION
5187  AsmNESectionTableEntry.setDataPrototype(
5188  "unsigned", "sector", "= 0",
5189  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
5190 #endif // !DOCUMENTATION
5191 
5192 #ifndef DOCUMENTATION
5193  AsmNESectionTableEntry.setDataPrototype(
5194  "rose_addr_t", "physical_size", "= 0",
5195  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
5196 #endif // !DOCUMENTATION
5197 
5198 #ifndef DOCUMENTATION
5199  AsmNESectionTableEntry.setDataPrototype(
5200  "rose_addr_t", "virtual_size", "= 0",
5201  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
5202 #endif // !DOCUMENTATION
5203 
5204  DECLARE_OTHERS(AsmNESectionTableEntry);
5205 #if defined(SgAsmNESectionTableEntry_OTHERS) || defined(DOCUMENTATION)
5206 
5207  //----------------------- Boost serialization for SgAsmNESectionTableEntry -----------------------
5208 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
5209 private:
5210  friend class boost::serialization::access;
5211 
5212  template<class S>
5213  void serialize(S &s, const unsigned /*version*/) {
5214  debugSerializationBegin("SgAsmNESectionTableEntry");
5215  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
5216  s & BOOST_SERIALIZATION_NVP(p_flags);
5217  s & BOOST_SERIALIZATION_NVP(p_sector);
5218  s & BOOST_SERIALIZATION_NVP(p_physical_size);
5219  s & BOOST_SERIALIZATION_NVP(p_virtual_size);
5220  debugSerializationEnd("SgAsmNESectionTableEntry");
5221  }
5222 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
5223  // Local types
5226 public:
5227 #ifdef _MSC_VER
5228 # pragma pack (1)
5229 #endif
5230  /* File format of a section table entry. All fields are little endian. */
5232  uint16_t sector; /* 0x00 File offset (sector size defined in hdr); zero means no file data */
5233  uint16_t physical_size; /* 0x02 Length of segment in file; zero means 64k if sector is non-zero */
5234  uint16_t flags; /* 0x04 Segment bit flags */
5235  uint16_t virtual_size; /* 0x06 Total size of segment when mapped to memory; zero means 64k */
5236  } /* 0x08 */
5237 // DQ (3/7/2013): Adding support to restrict visability to SWIG.
5238 #ifndef SWIG
5239 #ifndef _MSC_VER
5240  __attribute__((packed))
5241 #endif
5242 #endif
5243  ;
5244 #ifdef _MSC_VER
5245 # pragma pack ()
5246 #endif
5247 
5248  enum NESectionFlags {
5249  SF_RESERVED = 0x0e08, /* these bits are reserved */
5250 
5251  SF_TYPE_MASK = 0x0007, /* segment-type field */
5252  SF_CODE = 0x0000, /* code-segment type */
5253  SF_DATA = 0x0001, /* data-segment (otherwise segment is code) */
5254  SF_ALLOC = 0x0002, /* loader allocates memory */
5255  SF_LOAD = 0x0004, /* load the segment */
5256 
5257  SF_MOVABLE = 0x0010, /* segment is not fixed */
5258  SF_PURE = 0x0020, /* segment is pure, or sharable; otherwise impure or non-sharable */
5259  SF_PRELOAD = 0x0040, /* segment will be preloaded; read-only if this is a data segment */
5260  SF_NOT_WRITABLE = 0x0080, /* code segment is execute only; data segment is read-only */
5261  SF_RELOCINFO = 0x0100, /* segment has relocation records */
5262  SF_DISCARDABLE = 0x1000, /* discardable */
5263  SF_DISCARD = 0xf000 /* discard priority */
5264  };
5265 
5267  // Properties
5269 public:
5270  unsigned const& get_flags() const;
5271  void set_flags(unsigned const&);
5272 
5273 public:
5274  unsigned const& get_sector() const;
5275  void set_sector(unsigned const&);
5276 
5277 public:
5278  rose_addr_t const& get_physical_size() const;
5279  void set_physical_size(rose_addr_t const&);
5280 
5281 public:
5282  rose_addr_t const& get_virtual_size() const;
5283  void set_virtual_size(rose_addr_t const&);
5285  // Functions
5287 public:
5290  virtual void dump(FILE *f, const char *prefix, ssize_t idx) const {dump(f, prefix, idx, NULL);}
5291  void dump(FILE*, const char *prefix, ssize_t idx, SgAsmNEFileHeader *fhdr) const;
5292 public:
5294  virtual ~SgAsmNESectionTableEntry();
5295 
5296 public:
5299 
5300 protected:
5307  void initializeProperties();
5308 #endif // SgAsmNESectionTableEntry_OTHERS
5309 #ifdef DOCUMENTATION
5310 };
5311 #endif // DOCUMENTATION
5312 
5313 
5315 // SgAsmNESection -- MACHINE GENERATED; DO NOT MODIFY --
5317 
5318 DECLARE_LEAF_CLASS(AsmNESection);
5319 IS_SERIALIZABLE(AsmNESection);
5320 
5321 #ifdef DOCUMENTATION
5323 #endif // DOCUMENTATION
5324 
5325 #ifndef DOCUMENTATION
5326  AsmNESection.setDataPrototype(
5327  "SgAsmNESectionTableEntry*", "st_entry", "= nullptr",
5328  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
5329 #endif // !DOCUMENTATION
5330 
5331 #ifndef DOCUMENTATION
5332  AsmNESection.setDataPrototype(
5333  "SgAsmNERelocTable*", "reloc_table", "= nullptr",
5334  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
5335 #endif // !DOCUMENTATION
5336 
5337  DECLARE_OTHERS(AsmNESection);
5338 #if defined(SgAsmNESection_OTHERS) || defined(DOCUMENTATION)
5339 
5340  //----------------------- Boost serialization for SgAsmNESection -----------------------
5341 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
5342 private:
5343  friend class boost::serialization::access;
5344 
5345  template<class S>
5346  void serialize(S &s, const unsigned /*version*/) {
5347  debugSerializationBegin("SgAsmNESection");
5348  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmGenericSection);
5349  s & BOOST_SERIALIZATION_NVP(p_st_entry);
5350  s & BOOST_SERIALIZATION_NVP(p_reloc_table);
5351  debugSerializationEnd("SgAsmNESection");
5352  }
5353 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
5354 
5355 public:
5356  SgAsmNESectionTableEntry* const& get_st_entry() const;
5357  void set_st_entry(SgAsmNESectionTableEntry* const&);
5358 
5359 public:
5360  SgAsmNERelocTable* const& get_reloc_table() const;
5361  void set_reloc_table(SgAsmNERelocTable* const&);
5362 public:
5363  explicit SgAsmNESection(SgAsmNEFileHeader *fhdr);
5364  virtual void unparse(std::ostream&) const override;
5365  virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
5366 public:
5368  virtual ~SgAsmNESection();
5369 
5370 public:
5372  SgAsmNESection();
5373 
5374 protected:
5381  void initializeProperties();
5382 #endif // SgAsmNESection_OTHERS
5383 #ifdef DOCUMENTATION
5384 };
5385 #endif // DOCUMENTATION
5386 
5387 
5389 // SgAsmNERelocTable -- MACHINE GENERATED; DO NOT MODIFY --
5391 
5392 DECLARE_LEAF_CLASS(AsmNERelocTable);
5393 IS_SERIALIZABLE(AsmNERelocTable);
5394 
5395 #ifdef DOCUMENTATION
5397 #endif // DOCUMENTATION
5398 
5399 #ifndef DOCUMENTATION
5400  AsmNERelocTable.setDataPrototype(
5401  "SgAsmNERelocEntryPtrList", "entries", "",
5402  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
5403 #endif // !DOCUMENTATION
5404 
5405  DECLARE_OTHERS(AsmNERelocTable);
5406 #if defined(SgAsmNERelocTable_OTHERS) || defined(DOCUMENTATION)
5407 
5408  //----------------------- Boost serialization for SgAsmNERelocTable -----------------------
5409 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
5410 private:
5411  friend class boost::serialization::access;
5412 
5413  template<class S>
5414  void serialize(S &s, const unsigned /*version*/) {
5415  debugSerializationBegin("SgAsmNERelocTable");
5416  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmGenericSection);
5417  s & BOOST_SERIALIZATION_NVP(p_entries);
5418  debugSerializationEnd("SgAsmNERelocTable");
5419  }
5420 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
5421 
5422 public:
5423  SgAsmNERelocEntryPtrList const& get_entries() const;
5424  SgAsmNERelocEntryPtrList& get_entries();
5425  void set_entries(SgAsmNERelocEntryPtrList const&);
5426 public:
5427  explicit SgAsmNERelocTable(SgAsmNEFileHeader *fhdr, SgAsmNESection *section);
5428  virtual void unparse(std::ostream&) const override;
5429  virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
5430 public:
5432  virtual ~SgAsmNERelocTable();
5433 
5434 public:
5437 
5438 protected:
5445  void initializeProperties();
5446 #endif // SgAsmNERelocTable_OTHERS
5447 #ifdef DOCUMENTATION
5448 };
5449 #endif // DOCUMENTATION
5450 
5451 
5453 // SgAsmNERelocEntry -- MACHINE GENERATED; DO NOT MODIFY --
5455 
5456 DECLARE_LEAF_CLASS(AsmNERelocEntry);
5457 IS_SERIALIZABLE(AsmNERelocEntry);
5458 
5459 #ifdef DOCUMENTATION
5461 #endif // DOCUMENTATION
5462 
5463 #ifndef DOCUMENTATION
5464  AsmNERelocEntry.setDataPrototype(
5465  "SgAsmNERelocEntry::NERelocSrcType", "src_type", "= SgAsmNERelocEntry::RF_SRCTYPE_8OFF",
5466  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
5467 #endif // !DOCUMENTATION
5468 
5469 #ifndef DOCUMENTATION
5470  AsmNERelocEntry.setDataPrototype(
5471  "SgAsmNERelocEntry::NERelocModifiers", "modifier", "= SgAsmNERelocEntry::RF_MODIFIER_SINGLE",
5472  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
5473 #endif // !DOCUMENTATION
5474 
5475 #ifndef DOCUMENTATION
5476  AsmNERelocEntry.setDataPrototype(
5477  "SgAsmNERelocEntry::NERelocTgtType", "tgt_type", "= SgAsmNERelocEntry::RF_TGTTYPE_IREF",
5478  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
5479 #endif // !DOCUMENTATION
5480 
5481 #ifndef DOCUMENTATION
5482  AsmNERelocEntry.setDataPrototype(
5483  "SgAsmNERelocEntry::NERelocFlags", "flags", "= SgAsmNERelocEntry::RF_ADDITIVE",
5484  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
5485 #endif // !DOCUMENTATION
5486 
5487 #ifndef DOCUMENTATION
5488  AsmNERelocEntry.setDataPrototype(
5489  "rose_addr_t", "src_offset", "= 0",
5490  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
5491 #endif // !DOCUMENTATION
5492 
5493 #ifndef DOCUMENTATION
5494  AsmNERelocEntry.setDataPrototype(
5495  "SgAsmNERelocEntry::iref_type", "iref", "",
5496  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
5497 #endif // !DOCUMENTATION
5498 
5499 #ifndef DOCUMENTATION
5500  AsmNERelocEntry.setDataPrototype(
5501  "SgAsmNERelocEntry::iord_type", "iord", "",
5502  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
5503 #endif // !DOCUMENTATION
5504 
5505 #ifndef DOCUMENTATION
5506  AsmNERelocEntry.setDataPrototype(
5507  "SgAsmNERelocEntry::iname_type", "iname", "",
5508  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
5509 #endif // !DOCUMENTATION
5510 
5511 #ifndef DOCUMENTATION
5512  AsmNERelocEntry.setDataPrototype(
5513  "SgAsmNERelocEntry::osfixup_type", "osfixup", "",
5514  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
5515 #endif // !DOCUMENTATION
5516 
5517  DECLARE_OTHERS(AsmNERelocEntry);
5518 #if defined(SgAsmNERelocEntry_OTHERS) || defined(DOCUMENTATION)
5519 
5520  //----------------------- Boost serialization for SgAsmNERelocEntry -----------------------
5521 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
5522 private:
5523  friend class boost::serialization::access;
5524 
5525  template<class S>
5526  void serialize(S &s, const unsigned /*version*/) {
5527  debugSerializationBegin("SgAsmNERelocEntry");
5528  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
5529  s & BOOST_SERIALIZATION_NVP(p_src_type);
5530  s & BOOST_SERIALIZATION_NVP(p_modifier);
5531  s & BOOST_SERIALIZATION_NVP(p_tgt_type);
5532  s & BOOST_SERIALIZATION_NVP(p_flags);
5533  s & BOOST_SERIALIZATION_NVP(p_src_offset);
5534  s & BOOST_SERIALIZATION_NVP(p_iref);
5535  s & BOOST_SERIALIZATION_NVP(p_iord);
5536  s & BOOST_SERIALIZATION_NVP(p_iname);
5537  s & BOOST_SERIALIZATION_NVP(p_osfixup);
5538  debugSerializationEnd("SgAsmNERelocEntry");
5539  }
5540 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
5541  // Local types
5544 public:
5545  /* NERelocEntry_disk -- variable size with multiple levels of 'union'. It's easier to just parse it in NERelocEntry::ctor()
5546  * than defining it here as a struct. */
5547  enum NERelocSrcType {
5548  RF_SRCTYPE_8OFF = 0, /* Byte offset */
5549  RF_SRCTYPE_WORDSEG = 2, /* Word segment, 16-bit selector */
5550  RF_SRCTYPE_16PTR = 3, /* 16-bit far pointer */
5551  RF_SRCTYPE_16OFF = 5, /* 16-bit offset */
5552  RF_SRCTYPE_32PTR = 6, /* 32-bit far pointer */
5553  RF_SRCTYPE_32OFF = 7, /* 32-bit offset */
5554  RF_SRCTYPE_NEARCALL = 8, /* near call or jump, WORD/DWROD based on section attribute */
5555  RF_SRCTYPE_48PTR = 11, /* 48-bit pointer */
5556  RF_SRCTYPE_32OFF_b = 13 /* 32-bit offset (not sure how this differs from case 7) */
5557  };
5558 
5559  enum NERelocTgtType {
5560  RF_TGTTYPE_IREF = 0, /* Internal reference */
5561  RF_TGTTYPE_IORD = 1, /* Imported (extern) ordinal */
5562  RF_TGTTYPE_INAME = 2, /* Imported (extern) name */
5563  RF_TGTTYPE_OSFIXUP = 3 /* Operating system fixup */
5564  };
5565 
5566  enum NERelocModifiers {
5567  RF_MODIFIER_SINGLE = 1,
5568  RF_MODIFIER_MULTI = 3
5569  };
5570 
5571  enum NERelocFlags {
5572  RF_ADDITIVE = 0x01, /* add target to source rather than replace source with target */
5573  RF_RESERVED = 0x02, /* reserved bits */
5574  RF_2EXTRA = 0x04, /* relocation info has size with new two bytes at end */
5575  RF_32ADD = 0x08, /* addition with 32-bits rather than 16 */
5576  RF_16SECTION = 0x10, /* 16-bit object number & module name rather than 8-bit */
5577  RF_8ORDINAL = 0x20 /* Ordinal is 8-bits rather than 16 */
5578  };
5579 
5580  // 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
5581  // this in ROSETTA. One solution might be to implement a common base class of unsigned, unsigned, rose_addr_t; and then use
5582  // member functions to access the data in the base class.
5583  struct iref_type { /*tgt_type==0x00: internal reference*/
5584  unsigned sect_idx; /* section index (1-origin) */
5585  unsigned res1; /* reserved */
5586  rose_addr_t tgt_offset;
5587 
5588 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
5589  template<class S>
5590  void serialize(S &s, const unsigned /*version*/) {
5591  s & BOOST_SERIALIZATION_NVP(sect_idx);
5592  s & BOOST_SERIALIZATION_NVP(res1);
5593  s & BOOST_SERIALIZATION_NVP(tgt_offset);
5594  }
5595 #endif
5596 
5597  // Added to support RTI support in ROSE
5598  friend std::ostream & operator<< ( std::ostream & os, const iref_type & x );
5599 
5600  iref_type();
5601  };
5602 
5603  struct iord_type { /*tgt_type==0x01: imported ordinal*/
5604  unsigned modref; /* 1-based index into import module table */
5605  unsigned ordinal;
5606  rose_addr_t addend; /* value to add (only present for flags & RF_2EXTRA) */
5607 
5608 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
5609  template<class S>
5610  void serialize(S &s, const unsigned /*version*/) {
5611  s & BOOST_SERIALIZATION_NVP(modref);
5612  s & BOOST_SERIALIZATION_NVP(ordinal);
5613  s & BOOST_SERIALIZATION_NVP(addend);
5614  }
5615 #endif
5616 
5617  // Added to support RTI support in ROSE
5618  friend std::ostream & operator<< ( std::ostream & os, const iord_type & x );
5619 
5620  iord_type();
5621  };
5622 
5623  struct iname_type { /*tgt_type==0x02: imported name*/
5624  unsigned modref; /* 1-based index into import module table */
5625  unsigned nm_off; /* offset into import procedure names */
5626  rose_addr_t addend; /* value to add (only present for flags & RF_2EXTRA) */
5627 
5628 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
5629  template<class S>
5630  void serialize(S &s, const unsigned /*version*/) {
5631  s & BOOST_SERIALIZATION_NVP(modref);
5632  s & BOOST_SERIALIZATION_NVP(nm_off);
5633  s & BOOST_SERIALIZATION_NVP(addend);
5634  }
5635 #endif
5636 
5637  // Added to support RTI support in ROSE
5638  friend std::ostream & operator<< ( std::ostream & os, const iname_type & x );
5639 
5640  iname_type();
5641  };
5642 
5643  struct osfixup_type { /*tgt_type==0x03: operating system fixup*/
5644  unsigned type;
5645  unsigned res3;
5646 
5647 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
5648  template<class S>
5649  void serialize(S &s, const unsigned /*version*/) {
5650  s & BOOST_SERIALIZATION_NVP(type);
5651  s & BOOST_SERIALIZATION_NVP(res3);
5652  }
5653 #endif
5654 
5655  // Added to support RTI support in ROSE
5656  friend std::ostream & operator<< ( std::ostream & os, const osfixup_type & x );
5657 
5658  osfixup_type();
5659  };
5660 
5662  // Properties
5664 public:
5665  SgAsmNERelocEntry::NERelocSrcType const& get_src_type() const;
5666  void set_src_type(SgAsmNERelocEntry::NERelocSrcType const&);
5667 
5668 public:
5669  SgAsmNERelocEntry::NERelocModifiers const& get_modifier() const;
5670  void set_modifier(SgAsmNERelocEntry::NERelocModifiers const&);
5671 
5672 public:
5673  SgAsmNERelocEntry::NERelocTgtType const& get_tgt_type() const;
5674  void set_tgt_type(SgAsmNERelocEntry::NERelocTgtType const&);
5675 
5676 public:
5677  SgAsmNERelocEntry::NERelocFlags const& get_flags() const;
5678  void set_flags(SgAsmNERelocEntry::NERelocFlags const&);
5679 
5680 public:
5681  rose_addr_t const& get_src_offset() const;
5682  void set_src_offset(rose_addr_t const&);
5683 
5684 public:
5685  SgAsmNERelocEntry::iref_type const& get_iref() const;
5686  void set_iref(SgAsmNERelocEntry::iref_type const&);
5687 
5688 public:
5689  SgAsmNERelocEntry::iord_type const& get_iord() const;
5690  void set_iord(SgAsmNERelocEntry::iord_type const&);
5691 
5692 public:
5693  SgAsmNERelocEntry::iname_type const& get_iname() const;
5694  void set_iname(SgAsmNERelocEntry::iname_type const&);
5695 
5696 public:
5697  SgAsmNERelocEntry::osfixup_type const& get_osfixup() const;
5698  void set_osfixup(SgAsmNERelocEntry::osfixup_type const&);
5700  // Functions
5702 public:
5703  SgAsmNERelocEntry(SgAsmGenericSection *relocs, rose_addr_t at, rose_addr_t *rec_size);
5704  rose_addr_t unparse(std::ostream&, const SgAsmGenericSection*, rose_addr_t spos) const;
5705  void dump(FILE*, const char *prefix, ssize_t idx) const;
5706 public:
5708  virtual ~SgAsmNERelocEntry();
5709 
5710 public:
5713 
5714 protected:
5721  void initializeProperties();
5722 #endif // SgAsmNERelocEntry_OTHERS
5723 #ifdef DOCUMENTATION
5724 };
5725 #endif // DOCUMENTATION
5726 
5727 
5729 // SgAsmNENameTable -- MACHINE GENERATED; DO NOT MODIFY --
5731 
5732 DECLARE_LEAF_CLASS(AsmNENameTable);
5733 IS_SERIALIZABLE(AsmNENameTable);
5734 
5735 #ifdef DOCUMENTATION
5737 #endif // DOCUMENTATION
5738 
5739 #ifndef DOCUMENTATION
5740  AsmNENameTable.setDataPrototype(
5741  "SgStringList", "names", "",
5742  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
5743 #endif // !DOCUMENTATION
5744 
5745 #ifndef DOCUMENTATION
5746  AsmNENameTable.setDataPrototype(
5747  "SgUnsignedList", "ordinals", "",
5748  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
5749 #endif // !DOCUMENTATION
5750 
5751  DECLARE_OTHERS(AsmNENameTable);
5752 #if defined(SgAsmNENameTable_OTHERS) || defined(DOCUMENTATION)
5753 
5754  //----------------------- Boost serialization for SgAsmNENameTable -----------------------
5755 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
5756 private:
5757  friend class boost::serialization::access;
5758 
5759  template<class S>
5760  void serialize(S &s, const unsigned /*version*/) {
5761  debugSerializationBegin("SgAsmNENameTable");
5762  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmGenericSection);
5763  s & BOOST_SERIALIZATION_NVP(p_names);
5764  s & BOOST_SERIALIZATION_NVP(p_ordinals);
5765  debugSerializationEnd("SgAsmNENameTable");
5766  }
5767 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
5768 
5769 public:
5770  SgStringList const& get_names() const;
5771  void set_names(SgStringList const&);
5772 
5773 public:
5774  SgUnsignedList const& get_ordinals() const;
5775  void set_ordinals(SgUnsignedList const&);
5776 public:
5777  SgAsmNENameTable(SgAsmNEFileHeader *fhdr, rose_addr_t offset);
5778  virtual void unparse(std::ostream&) const override;
5779  virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
5780  std::vector<std::string> get_names_by_ordinal(unsigned ordinal);
5781 public:
5783  virtual ~SgAsmNENameTable();
5784 
5785 public:
5787  SgAsmNENameTable();
5788 
5789 protected:
5796  void initializeProperties();
5797 #endif // SgAsmNENameTable_OTHERS
5798 #ifdef DOCUMENTATION
5799 };
5800 #endif // DOCUMENTATION
5801 
5802 
5804 // SgAsmNEModuleTable -- MACHINE GENERATED; DO NOT MODIFY --
5806 
5807 DECLARE_LEAF_CLASS(AsmNEModuleTable);
5808 IS_SERIALIZABLE(AsmNEModuleTable);
5809 
5810 #ifdef DOCUMENTATION
5812 #endif // DOCUMENTATION
5813 
5814 #ifndef DOCUMENTATION
5815  AsmNEModuleTable.setDataPrototype(
5816  "SgAsmNEStringTable*", "strtab", "= nullptr",
5817  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
5818 #endif // !DOCUMENTATION
5819 
5820 #ifndef DOCUMENTATION
5821  AsmNEModuleTable.setDataPrototype(
5822  "SgAddressList", "name_offsets", "",
5823  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
5824 #endif // !DOCUMENTATION
5825 
5826 #ifndef DOCUMENTATION
5827  AsmNEModuleTable.setDataPrototype(
5828  "SgStringList", "names", "",
5829  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
5830 #endif // !DOCUMENTATION
5831 
5832  DECLARE_OTHERS(AsmNEModuleTable);
5833 #if defined(SgAsmNEModuleTable_OTHERS) || defined(DOCUMENTATION)
5834 
5835  //----------------------- Boost serialization for SgAsmNEModuleTable -----------------------
5836 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
5837 private:
5838  friend class boost::serialization::access;
5839 
5840  template<class S>
5841  void serialize(S &s, const unsigned /*version*/) {
5842  debugSerializationBegin("SgAsmNEModuleTable");
5843  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmGenericSection);
5844  s & BOOST_SERIALIZATION_NVP(p_strtab);
5845  s & BOOST_SERIALIZATION_NVP(p_name_offsets);
5846  s & BOOST_SERIALIZATION_NVP(p_names);
5847  debugSerializationEnd("SgAsmNEModuleTable");
5848  }
5849 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
5850 
5851 public:
5852  SgAsmNEStringTable* const& get_strtab() const;
5853  void set_strtab(SgAsmNEStringTable* const&);
5854 
5855 public:
5856  SgAddressList const& get_name_offsets() const;
5857  void set_name_offsets(SgAddressList const&);
5858 
5859 public:
5860  SgStringList const& get_names() const;
5861  void set_names(SgStringList const&);
5862 public:
5863  SgAsmNEModuleTable(SgAsmNEFileHeader *fhdr, SgAsmNEStringTable *strtab, rose_addr_t offset, rose_addr_t size);
5864  virtual void unparse(std::ostream&) const override;
5865  virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
5866 public:
5868  virtual ~SgAsmNEModuleTable();
5869 
5870 public:
5873 
5874 protected:
5881  void initializeProperties();
5882 #endif // SgAsmNEModuleTable_OTHERS
5883 #ifdef DOCUMENTATION
5884 };
5885 #endif // DOCUMENTATION
5886 
5887 
5889 // SgAsmNEFileHeader -- MACHINE GENERATED; DO NOT MODIFY --
5891 
5892 DECLARE_LEAF_CLASS(AsmNEFileHeader);
5893 IS_SERIALIZABLE(AsmNEFileHeader);
5894 
5895 #ifdef DOCUMENTATION
5897 #endif // DOCUMENTATION
5898 
5899 #ifndef DOCUMENTATION
5900  AsmNEFileHeader.setDataPrototype(
5901  "unsigned", "e_linker_major", "= 0",
5902  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
5903 #endif // !DOCUMENTATION
5904 
5905 #ifndef DOCUMENTATION
5906  AsmNEFileHeader.setDataPrototype(
5907  "unsigned", "e_linker_minor", "= 0",
5908  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
5909 #endif // !DOCUMENTATION
5910 
5911 #ifndef DOCUMENTATION
5912  AsmNEFileHeader.setDataPrototype(
5913  "unsigned", "e_checksum", "= 0",
5914  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
5915 #endif // !DOCUMENTATION
5916 
5917 #ifndef DOCUMENTATION
5918  AsmNEFileHeader.setDataPrototype(
5919  "unsigned", "e_flags1", "= 0",
5920  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
5921 #endif // !DOCUMENTATION
5922 
5923 #ifndef DOCUMENTATION
5924  AsmNEFileHeader.setDataPrototype(
5925  "unsigned", "e_autodata_sn", "= 0",
5926  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
5927 #endif // !DOCUMENTATION
5928 
5929 #ifndef DOCUMENTATION
5930  AsmNEFileHeader.setDataPrototype(
5931  "unsigned", "e_bss_size", "= 0",
5932  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
5933 #endif // !DOCUMENTATION
5934 
5935 #ifndef DOCUMENTATION
5936  AsmNEFileHeader.setDataPrototype(
5937  "unsigned", "e_stack_size", "= 0",
5938  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
5939 #endif // !DOCUMENTATION
5940 
5941 #ifndef DOCUMENTATION
5942  AsmNEFileHeader.setDataPrototype(
5943  "unsigned", "e_csip", "= 0",
5944  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
5945 #endif // !DOCUMENTATION
5946 
5947 #ifndef DOCUMENTATION
5948  AsmNEFileHeader.setDataPrototype(
5949  "unsigned", "e_sssp", "= 0",
5950  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
5951 #endif // !DOCUMENTATION
5952 
5953 #ifndef DOCUMENTATION
5954  AsmNEFileHeader.setDataPrototype(
5955  "unsigned", "e_nsections", "= 0",
5956  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
5957 #endif // !DOCUMENTATION
5958 
5959 #ifndef DOCUMENTATION
5960  AsmNEFileHeader.setDataPrototype(
5961  "unsigned", "e_nmodrefs", "= 0",
5962  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
5963 #endif // !DOCUMENTATION
5964 
5965 #ifndef DOCUMENTATION
5966  AsmNEFileHeader.setDataPrototype(
5967  "unsigned", "e_nnonresnames", "= 0",
5968  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
5969 #endif // !DOCUMENTATION
5970 
5971 #ifndef DOCUMENTATION
5972  AsmNEFileHeader.setDataPrototype(
5973  "unsigned", "e_nmovable_entries", "= 0",
5974  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
5975 #endif // !DOCUMENTATION
5976 
5977 #ifndef DOCUMENTATION
5978  AsmNEFileHeader.setDataPrototype(
5979  "unsigned", "e_sector_align", "= 0",
5980  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
5981 #endif // !DOCUMENTATION
5982 
5983 #ifndef DOCUMENTATION
5984  AsmNEFileHeader.setDataPrototype(
5985  "unsigned", "e_nresources", "= 0",
5986  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
5987 #endif // !DOCUMENTATION
5988 
5989 #ifndef DOCUMENTATION
5990  AsmNEFileHeader.setDataPrototype(
5991  "unsigned", "e_exetype", "= 0",
5992  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
5993 #endif // !DOCUMENTATION
5994 
5995 #ifndef DOCUMENTATION
5996  AsmNEFileHeader.setDataPrototype(
5997  "unsigned", "e_flags2", "= 0",
5998  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
5999 #endif // !DOCUMENTATION
6000 
6001 #ifndef DOCUMENTATION
6002  AsmNEFileHeader.setDataPrototype(
6003  "unsigned", "e_res1", "= 0",
6004  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
6005 #endif // !DOCUMENTATION
6006 
6007 #ifndef DOCUMENTATION
6008  AsmNEFileHeader.setDataPrototype(
6009  "unsigned", "e_winvers", "= 0",
6010  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
6011 #endif // !DOCUMENTATION
6012 
6013 #ifndef DOCUMENTATION
6014  AsmNEFileHeader.setDataPrototype(
6015  "rose_addr_t", "e_entrytab_rfo", "= 0",
6016  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
6017 #endif // !DOCUMENTATION
6018 
6019 #ifndef DOCUMENTATION
6020  AsmNEFileHeader.setDataPrototype(
6021  "rose_addr_t", "e_entrytab_size", "= 0",
6022  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
6023 #endif // !DOCUMENTATION
6024 
6025 #ifndef DOCUMENTATION
6026  AsmNEFileHeader.setDataPrototype(
6027  "rose_addr_t", "e_sectab_rfo", "= 0",
6028  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
6029 #endif // !DOCUMENTATION
6030 
6031 #ifndef DOCUMENTATION
6032  AsmNEFileHeader.setDataPrototype(
6033  "rose_addr_t", "e_rsrctab_rfo", "= 0",
6034  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
6035 #endif // !DOCUMENTATION
6036 
6037 #ifndef DOCUMENTATION
6038  AsmNEFileHeader.setDataPrototype(
6039  "rose_addr_t", "e_resnametab_rfo", "= 0",
6040  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
6041 #endif // !DOCUMENTATION
6042 
6043 #ifndef DOCUMENTATION
6044  AsmNEFileHeader.setDataPrototype(
6045  "rose_addr_t", "e_modreftab_rfo", "= 0",
6046  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
6047 #endif // !DOCUMENTATION
6048 
6049 #ifndef DOCUMENTATION
6050  AsmNEFileHeader.setDataPrototype(
6051  "rose_addr_t", "e_importnametab_rfo", "= 0",
6052  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
6053 #endif // !DOCUMENTATION
6054 
6055 #ifndef DOCUMENTATION
6056  AsmNEFileHeader.setDataPrototype(
6057  "rose_addr_t", "e_nonresnametab_offset", "= 0",
6058  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
6059 #endif // !DOCUMENTATION
6060 
6061 #ifndef DOCUMENTATION
6062  AsmNEFileHeader.setDataPrototype(
6063  "rose_addr_t", "e_fastload_sector", "= 0",
6064  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
6065 #endif // !DOCUMENTATION
6066 
6067 #ifndef DOCUMENTATION
6068  AsmNEFileHeader.setDataPrototype(
6069  "rose_addr_t", "e_fastload_nsectors", "= 0",
6070  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
6071 #endif // !DOCUMENTATION
6072 
6073 #ifndef DOCUMENTATION
6074  AsmNEFileHeader.setDataPrototype(
6075  "SgAsmDOSExtendedHeader*", "dos2_header", "= nullptr",
6076  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
6077 #endif // !DOCUMENTATION
6078 
6079 #ifndef DOCUMENTATION
6080  AsmNEFileHeader.setDataPrototype(
6081  "SgAsmNESectionTable*", "section_table", "= nullptr",
6082  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
6083 #endif // !DOCUMENTATION
6084 
6085 #ifndef DOCUMENTATION
6086  AsmNEFileHeader.setDataPrototype(
6087  "SgAsmNENameTable*", "resname_table", "= nullptr",
6088  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
6089 #endif // !DOCUMENTATION
6090 
6091 #ifndef DOCUMENTATION
6092  AsmNEFileHeader.setDataPrototype(
6093  "SgAsmNENameTable*", "nonresname_table", "= nullptr",
6094  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
6095 #endif // !DOCUMENTATION
6096 
6097 #ifndef DOCUMENTATION
6098  AsmNEFileHeader.setDataPrototype(
6099  "SgAsmNEModuleTable*", "module_table", "= nullptr",
6100  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
6101 #endif // !DOCUMENTATION
6102 
6103 #ifndef DOCUMENTATION
6104  AsmNEFileHeader.setDataPrototype(
6105  "SgAsmNEEntryTable*", "entry_table", "= nullptr",
6106  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
6107 #endif // !DOCUMENTATION
6108 
6109  DECLARE_OTHERS(AsmNEFileHeader);
6110 #if defined(SgAsmNEFileHeader_OTHERS) || defined(DOCUMENTATION)
6111 
6112  //----------------------- Boost serialization for SgAsmNEFileHeader -----------------------
6113 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
6114 private:
6115  friend class boost::serialization::access;
6116 
6117  template<class S>
6118  void serialize(S &s, const unsigned /*version*/) {
6119  debugSerializationBegin("SgAsmNEFileHeader");
6120  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmGenericHeader);
6121  s & BOOST_SERIALIZATION_NVP(p_e_linker_major);
6122  s & BOOST_SERIALIZATION_NVP(p_e_linker_minor);
6123  s & BOOST_SERIALIZATION_NVP(p_e_checksum);
6124  s & BOOST_SERIALIZATION_NVP(p_e_flags1);
6125  s & BOOST_SERIALIZATION_NVP(p_e_autodata_sn);
6126  s & BOOST_SERIALIZATION_NVP(p_e_bss_size);
6127  s & BOOST_SERIALIZATION_NVP(p_e_stack_size);
6128  s & BOOST_SERIALIZATION_NVP(p_e_csip);
6129  s & BOOST_SERIALIZATION_NVP(p_e_sssp);
6130  s & BOOST_SERIALIZATION_NVP(p_e_nsections);
6131  s & BOOST_SERIALIZATION_NVP(p_e_nmodrefs);
6132  s & BOOST_SERIALIZATION_NVP(p_e_nnonresnames);
6133  s & BOOST_SERIALIZATION_NVP(p_e_nmovable_entries);
6134  s & BOOST_SERIALIZATION_NVP(p_e_sector_align);
6135  s & BOOST_SERIALIZATION_NVP(p_e_nresources);
6136  s & BOOST_SERIALIZATION_NVP(p_e_exetype);
6137  s & BOOST_SERIALIZATION_NVP(p_e_flags2);
6138  s & BOOST_SERIALIZATION_NVP(p_e_res1);
6139  s & BOOST_SERIALIZATION_NVP(p_e_winvers);
6140  s & BOOST_SERIALIZATION_NVP(p_e_entrytab_rfo);
6141  s & BOOST_SERIALIZATION_NVP(p_e_entrytab_size);
6142  s & BOOST_SERIALIZATION_NVP(p_e_sectab_rfo);
6143  s & BOOST_SERIALIZATION_NVP(p_e_rsrctab_rfo);
6144  s & BOOST_SERIALIZATION_NVP(p_e_resnametab_rfo);
6145  s & BOOST_SERIALIZATION_NVP(p_e_modreftab_rfo);
6146  s & BOOST_SERIALIZATION_NVP(p_e_importnametab_rfo);
6147  s & BOOST_SERIALIZATION_NVP(p_e_nonresnametab_offset);
6148  s & BOOST_SERIALIZATION_NVP(p_e_fastload_sector);
6149  s & BOOST_SERIALIZATION_NVP(p_e_fastload_nsectors);
6150  s & BOOST_SERIALIZATION_NVP(p_dos2_header);
6151  s & BOOST_SERIALIZATION_NVP(p_section_table);
6152  s & BOOST_SERIALIZATION_NVP(p_resname_table);
6153  s & BOOST_SERIALIZATION_NVP(p_nonresname_table);
6154  s & BOOST_SERIALIZATION_NVP(p_module_table);
6155  s & BOOST_SERIALIZATION_NVP(p_entry_table);
6156  debugSerializationEnd("SgAsmNEFileHeader");
6157  }
6158 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
6159  // Local types
6162 public:
6163 #ifdef _MSC_VER
6164 # pragma pack (1)
6165 #endif
6166  /* File format of an NE File Header. All fields are little endian.
6167  *
6168  * NOTES
6169  *
6170  * e_sssp: The value specified in SS is an index (1-origin) into the segment table. If SS addresses the automatic data segment
6171  * and SP is zero then SP is set to the address obtained by adding the size of the automatic data segment to the size
6172  * of the stack. */
6174  unsigned char e_magic[2]; /* 0x00 magic number "NE" */
6175  unsigned char e_linker_major; /* 0x02 linker major version number */
6176  unsigned char e_linker_minor; /* 0x03 linker minor version number */
6177  uint16_t e_entrytab_rfo; /* 0x04 entry table offset relative to start of header */
6178  uint16_t e_entrytab_size; /* 0x06 size of entry table in bytes */
6179  uint32_t e_checksum; /* 0x08 32-bit CRC of entire file (this word is taken a zero during the calculation) */
6180  uint16_t e_flags1; /* 0x0c file-level bit flags (see HeaderFlags1) */
6181  uint16_t e_autodata_sn; /* 0x0e auto data section number if (flags & 0x3)==0; else zero */
6182  uint16_t e_bss_size; /* 0x10 num bytes added to data segment for BSS */
6183  uint16_t e_stack_size; /* 0x12 num bytes added to data segment for stack (zero of SS!=DS registers) */
6184  uint32_t e_csip; /* 0x14 section number:offset of CS:IP */
6185  uint32_t e_sssp; /* 0x18 section number:offset of SS:SP (see note 1 above) */
6186  uint16_t e_nsections; /* 0x1c number of entries in the section table */
6187  uint16_t e_nmodrefs; /* 0x1e number of entries in the module reference table */
6188  uint16_t e_nnonresnames; /* 0x20 number of entries in the non-resident name table */
6189  uint16_t e_sectab_rfo; /* 0x22 offset of section table relative to start of header */
6190  uint16_t e_rsrctab_rfo; /* 0x24 offset of resource table relative to start of header */
6191  uint16_t e_resnametab_rfo; /* 0x26 offset of resident name table relative to start of header */
6192  uint16_t e_modreftab_rfo; /* 0x28 offset of module reference table relative to start of header */
6193  uint16_t e_importnametab_rfo; /* 0x2a offset of imported names table relative to start of header */
6194  uint32_t e_nonresnametab_offset; /* 0x2c file offset of non-resident name table */
6195  uint16_t e_nmovable_entries; /* 0x30 number of movable entries in Entry Table */
6196  uint16_t e_sector_align; /* 0x32 sector alignment shift count (log2 of segment sector size) */
6197  uint16_t e_nresources; /* 0x34 number of resource entries */
6198  unsigned char e_exetype; /* 0x36 executable type (2==windows) */
6199  unsigned char e_flags2; /* 0x37 additional flags (see HeaderFlags2) */
6200  uint16_t e_fastload_sector; /* 0x38 sector offset to fast-load area (only for Windows) */
6201  uint16_t e_fastload_nsectors; /* 0x3a size of fast-load area in sectors (only for Windows) */
6202  uint16_t e_res1; /* 0x3c reserved */
6203  uint16_t e_winvers; /* 0x3e expected version number for Windows (only for Windows) */
6204  } /* 0x40 */
6205 // DQ (3/7/2013): Adding support to restrict visability to SWIG.
6206 #ifndef SWIG
6207 #ifndef _MSC_VER
6208  __attribute__((packed))
6209 #endif
6210 #endif
6211  ;
6212 #ifdef _MSC_VER
6213 # pragma pack ()
6214 #endif
6215 
6216  /* Bit flags for the NE header 'e_flags' member.
6217  *
6218  * If HF_LIBRARY (bit 15) is set then the CS:IP registers point to an initialization procedure called with the value in the AX
6219  * register equal to the module handle. The initialization procedure must execute a far return to the caller. The resulting
6220  * value in AX is a status indicator (non-zero for success, zero for failure). */
6221  enum HeaderFlags1 {
6222  HF1_RESERVED = 0x57f4, /* Reserved bits */
6223  HF1_NO_DATA = 0x0000, /* (flags&0x03==0) => an exe not containing a data segment */
6224  HF1_SINGLE_DATA = 0x0001, /* Executable contains one data segment; set if file is a DLL */
6225  HF1_MULTIPLE_DATA = 0x0002, /* Exe with multiple data segments; set if a windows application */
6226  HF1_LOADER_SEGMENT = 0x0800, /* First segment contains code that loads the application */
6227  HF1_FATAL_ERRORS = 0x2000, /* Errors detected at link time; module will not load */
6228  HF1_LIBRARY = 0x8000 /* Module is a library */
6229  };
6230 
6231  /* Bit flags for the NE header 'e_flags2' member. */
6232  enum HeaderFlags2 {
6233  HF2_RESERVED = 0xf1, /* Reserved bits */
6234  HF2_PROTECTED_MODE = 0x02, /* Windows 2.x application that runs in 3.x protected mode */
6235  HF2_PFONTS = 0x04, /* Windows 2.x application that supports proportional fonts */
6236  HF2_FASTLOAD = 0x08 /* Executable contains a fast-load area */
6237  };
6238 
6240  // Properties
6242 public:
6243  unsigned const& get_e_linker_major() const;
6244  void set_e_linker_major(unsigned const&);
6245 
6246 public:
6247  unsigned const& get_e_linker_minor() const;
6248  void set_e_linker_minor(unsigned const&);
6249 
6250 public:
6251  unsigned const& get_e_checksum() const;
6252  void set_e_checksum(unsigned const&);
6253 
6254 public:
6255  unsigned const& get_e_flags1() const;
6256  void set_e_flags1(unsigned const&);
6257 
6258 public:
6259  unsigned const& get_e_autodata_sn() const;
6260  void set_e_autodata_sn(unsigned const&);
6261 
6262 public:
6263  unsigned const& get_e_bss_size() const;
6264  void set_e_bss_size(unsigned const&);
6265 
6266 public:
6267  unsigned const& get_e_stack_size() const;
6268  void set_e_stack_size(unsigned const&);
6269 
6270 public:
6271  unsigned const& get_e_csip() const;
6272  void set_e_csip(unsigned const&);
6273 
6274 public:
6275  unsigned const& get_e_sssp() const;
6276  void set_e_sssp(unsigned const&);
6277 
6278 public:
6279  unsigned const& get_e_nsections() const;
6280  void set_e_nsections(unsigned const&);
6281 
6282 public:
6283  unsigned const& get_e_nmodrefs() const;
6284  void set_e_nmodrefs(unsigned const&);
6285 
6286 public:
6287  unsigned const& get_e_nnonresnames() const;
6288  void set_e_nnonresnames(unsigned const&);
6289 
6290 public:
6291  unsigned const& get_e_nmovable_entries() const;
6292  void set_e_nmovable_entries(unsigned const&);
6293 
6294 public:
6295  unsigned const& get_e_sector_align() const;
6296  void set_e_sector_align(unsigned const&);
6297 
6298 public:
6299  unsigned const& get_e_nresources() const;
6300  void set_e_nresources(unsigned const&);
6301 
6302 public:
6303  unsigned const& get_e_exetype() const;
6304  void set_e_exetype(unsigned const&);
6305 
6306 public:
6307  unsigned const& get_e_flags2() const;
6308  void set_e_flags2(unsigned const&);
6309 
6310 public:
6311  unsigned const& get_e_res1() const;
6312  void set_e_res1(unsigned const&);
6313 
6314 public:
6315  unsigned const& get_e_winvers() const;
6316  void set_e_winvers(unsigned const&);
6317 
6318 public:
6319  rose_addr_t const& get_e_entrytab_rfo() const;
6320  void set_e_entrytab_rfo(rose_addr_t const&);
6321 
6322 public:
6323  rose_addr_t const& get_e_entrytab_size() const;
6324  void set_e_entrytab_size(rose_addr_t const&);
6325 
6326 public:
6327  rose_addr_t const& get_e_sectab_rfo() const;
6328  void set_e_sectab_rfo(rose_addr_t const&);
6329 
6330 public:
6331  rose_addr_t const& get_e_rsrctab_rfo() const;
6332  void set_e_rsrctab_rfo(rose_addr_t const&);
6333 
6334 public:
6335  rose_addr_t const& get_e_resnametab_rfo() const;
6336  void set_e_resnametab_rfo(rose_addr_t const&);
6337 
6338 public:
6339  rose_addr_t const& get_e_modreftab_rfo() const;
6340  void set_e_modreftab_rfo(rose_addr_t const&);
6341 
6342 public:
6343  rose_addr_t const& get_e_importnametab_rfo() const;
6344  void set_e_importnametab_rfo(rose_addr_t const&);
6345 
6346 public:
6347  rose_addr_t const& get_e_nonresnametab_offset() const;
6348  void set_e_nonresnametab_offset(rose_addr_t const&);
6349 
6350 public:
6351  rose_addr_t const& get_e_fastload_sector() const;
6352  void set_e_fastload_sector(rose_addr_t const&);
6353 
6354 public:
6355  rose_addr_t const& get_e_fastload_nsectors() const;
6356  void set_e_fastload_nsectors(rose_addr_t const&);
6357 
6358 public:
6359  SgAsmDOSExtendedHeader* const& get_dos2_header() const;
6360  void set_dos2_header(SgAsmDOSExtendedHeader* const&);
6361 
6362 public:
6363  SgAsmNESectionTable* const& get_section_table() const;
6364  void set_section_table(SgAsmNESectionTable* const&);
6365 
6366 public:
6367  SgAsmNENameTable* const& get_resname_table() const;
6368  void set_resname_table(SgAsmNENameTable* const&);
6369 
6370 public:
6371  SgAsmNENameTable* const& get_nonresname_table() const;
6372  void set_nonresname_table(SgAsmNENameTable* const&);
6373 
6374 public:
6375  SgAsmNEModuleTable* const& get_module_table() const;
6376  void set_module_table(SgAsmNEModuleTable* const&);
6377 
6378 public:
6379  SgAsmNEEntryTable* const& get_entry_table() const;
6380  void set_entry_table(SgAsmNEEntryTable* const&);
6382  // Functions
6384 public:
6385  SgAsmNEFileHeader(SgAsmGenericFile *f, rose_addr_t offset);
6386 
6387  static bool is_NE (SgAsmGenericFile*);
6388  static SgAsmNEFileHeader *parse(SgAsmDOSFileHeader*);
6389  virtual void unparse(std::ostream&) const override;
6390  virtual const char *format_name() const override {return "NE";}
6391  virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
6392 
6393 private:
6394  void *encode(SgAsmNEFileHeader::NEFileHeader_disk*) const;
6395 public:
6397  virtual ~SgAsmNEFileHeader();
6398 
6399 public:
6402 
6403 protected:
6410  void initializeProperties();
6411 #endif // SgAsmNEFileHeader_OTHERS
6412 #ifdef DOCUMENTATION
6413 };
6414 #endif // DOCUMENTATION
6415 
6416 
6418 // SgAsmNEEntryTable -- MACHINE GENERATED; DO NOT MODIFY --
6420 
6421 DECLARE_LEAF_CLASS(AsmNEEntryTable);
6422 IS_SERIALIZABLE(AsmNEEntryTable);
6423 
6424 #ifdef DOCUMENTATION
6426 #endif // DOCUMENTATION
6427 
6428 #ifndef DOCUMENTATION
6429  AsmNEEntryTable.setDataPrototype(
6430  "SgSizeTList", "bundle_sizes", "",
6431  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
6432 #endif // !DOCUMENTATION
6433 
6434 #ifndef DOCUMENTATION
6435  AsmNEEntryTable.setDataPrototype(
6436  "SgAsmNEEntryPointPtrList", "entries", "",
6437  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
6438 #endif // !DOCUMENTATION
6439 
6440  DECLARE_OTHERS(AsmNEEntryTable);
6441 #if defined(SgAsmNEEntryTable_OTHERS) || defined(DOCUMENTATION)
6442 
6443  //----------------------- Boost serialization for SgAsmNEEntryTable -----------------------
6444 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
6445 private:
6446  friend class boost::serialization::access;
6447 
6448  template<class S>
6449  void serialize(S &s, const unsigned /*version*/) {
6450  debugSerializationBegin("SgAsmNEEntryTable");
6451  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmGenericSection);
6452  s & BOOST_SERIALIZATION_NVP(p_bundle_sizes);
6453  s & BOOST_SERIALIZATION_NVP(p_entries);
6454  debugSerializationEnd("SgAsmNEEntryTable");
6455  }
6456 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
6457 
6458 public:
6459  SgSizeTList const& get_bundle_sizes() const;
6460  void set_bundle_sizes(SgSizeTList const&);
6461 
6462 public:
6463  SgAsmNEEntryPointPtrList const& get_entries() const;
6464  SgAsmNEEntryPointPtrList& get_entries();
6465  void set_entries(SgAsmNEEntryPointPtrList const&);
6466 public:
6467  SgAsmNEEntryTable(SgAsmNEFileHeader *fhdr, rose_addr_t offset, rose_addr_t size);
6468  void populate_entries();
6469  virtual void unparse(std::ostream&) const override;
6470  virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
6471 public:
6473  virtual ~SgAsmNEEntryTable();
6474 
6475 public:
6478 
6479 protected:
6486  void initializeProperties();
6487 #endif // SgAsmNEEntryTable_OTHERS
6488 #ifdef DOCUMENTATION
6489 };
6490 #endif // DOCUMENTATION
6491 
6492 
6494 // SgAsmNEEntryPoint -- MACHINE GENERATED; DO NOT MODIFY --
6496 
6497 DECLARE_LEAF_CLASS(AsmNEEntryPoint);
6498 IS_SERIALIZABLE(AsmNEEntryPoint);
6499 
6500 #ifdef DOCUMENTATION
6502 #endif // DOCUMENTATION
6503 
6504 #ifndef DOCUMENTATION
6505  AsmNEEntryPoint.setDataPrototype(
6506  "SgAsmNEEntryPoint::NEEntryFlags", "flags", "= SgAsmNEEntryPoint::EF_ZERO",
6507  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
6508 #endif // !DOCUMENTATION
6509 
6510 #ifndef DOCUMENTATION
6511  AsmNEEntryPoint.setDataPrototype(
6512  "unsigned", "int3f", "= 0",
6513  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
6514 #endif // !DOCUMENTATION
6515 
6516 #ifndef DOCUMENTATION
6517  AsmNEEntryPoint.setDataPrototype(
6518  "unsigned", "section_idx", "= 0",
6519  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
6520 #endif // !DOCUMENTATION
6521 
6522 #ifndef DOCUMENTATION
6523  AsmNEEntryPoint.setDataPrototype(
6524  "unsigned", "section_offset", "= 0",
6525  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
6526 #endif // !DOCUMENTATION
6527 
6528  DECLARE_OTHERS(AsmNEEntryPoint);
6529 #if defined(SgAsmNEEntryPoint_OTHERS) || defined(DOCUMENTATION)
6530 
6531  //----------------------- Boost serialization for SgAsmNEEntryPoint -----------------------
6532 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
6533 private:
6534  friend class boost::serialization::access;
6535 
6536  template<class S>
6537  void serialize(S &s, const unsigned /*version*/) {
6538  debugSerializationBegin("SgAsmNEEntryPoint");
6539  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
6540  s & BOOST_SERIALIZATION_NVP(p_flags);
6541  s & BOOST_SERIALIZATION_NVP(p_int3f);
6542  s & BOOST_SERIALIZATION_NVP(p_section_idx);
6543  s & BOOST_SERIALIZATION_NVP(p_section_offset);
6544  debugSerializationEnd("SgAsmNEEntryPoint");
6545  }
6546 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
6547  // Local types
6550 public:
6551  enum NEEntryFlags {
6552  EF_ZERO = 0x00, /* No flags set */
6553  EF_RESERVED = 0xfc, /* Reserved bits */
6554  EF_EXPORTED = 0x01, /* Exported */
6555  EF_GLOBAL = 0x02 /* Uses a global (shared) data section */
6556  };
6557 
6559  // Properties
6561 public:
6562  SgAsmNEEntryPoint::NEEntryFlags const& get_flags() const;
6563  void set_flags(SgAsmNEEntryPoint::NEEntryFlags const&);
6564 
6565 public:
6566  unsigned const& get_int3f() const;
6567  void set_int3f(unsigned const&);
6568 
6569 public:
6570  unsigned const& get_section_idx() const;
6571  void set_section_idx(unsigned const&);
6572 
6573 public:
6574  unsigned const& get_section_offset() const;
6575  void set_section_offset(unsigned const&);
6577  // Functions
6579 public:
6580  SgAsmNEEntryPoint(SgAsmNEEntryPoint::NEEntryFlags flags, unsigned int3f, unsigned s_idx, unsigned s_off);
6581  void dump(FILE*, const char *prefix, ssize_t idx) const;
6582 public:
6584  virtual ~SgAsmNEEntryPoint();
6585 
6586 public:
6589 
6590 protected:
6597  void initializeProperties();
6598 #endif // SgAsmNEEntryPoint_OTHERS
6599 #ifdef DOCUMENTATION
6600 };
6601 #endif // DOCUMENTATION
6602 
6603 
6605 // SgAsmMipsInstruction -- MACHINE GENERATED; DO NOT MODIFY --
6607 
6608 DECLARE_LEAF_CLASS(AsmMipsInstruction);
6609 IS_SERIALIZABLE(AsmMipsInstruction);
6610 
6611 DECLARE_HEADERS(AsmMipsInstruction);
6612 #if defined(SgAsmMipsInstruction_HEADERS) || defined(DOCUMENTATION)
6613 #include <Rose/BinaryAnalysis/InstructionEnumsMips.h>
6614 #endif // SgAsmMipsInstruction_HEADERS
6615 
6616 #ifdef DOCUMENTATION
6617 
6619 #endif // DOCUMENTATION
6620 
6621 #ifndef DOCUMENTATION
6622  AsmMipsInstruction.setDataPrototype(
6623  "Rose::BinaryAnalysis::MipsInstructionKind", "kind", "= Rose::BinaryAnalysis::mips_unknown_instruction",
6624  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
6625 #endif // !DOCUMENTATION
6626 
6627  DECLARE_OTHERS(AsmMipsInstruction);
6628 #if defined(SgAsmMipsInstruction_OTHERS) || defined(DOCUMENTATION)
6629 
6630  //----------------------- Boost serialization for SgAsmMipsInstruction -----------------------
6631 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
6632 private:
6633  friend class boost::serialization::access;
6634 
6635  template<class S>
6636  void serialize(S &s, const unsigned /*version*/) {
6637  debugSerializationBegin("SgAsmMipsInstruction");
6638  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmInstruction);
6639  s & BOOST_SERIALIZATION_NVP(p_kind);
6640  debugSerializationEnd("SgAsmMipsInstruction");
6641  }
6642 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
6643 
6644 public:
6654 public:
6655  // Overrides are documented in the base class
6656  virtual std::string description() const override;
6657  virtual bool terminatesBasicBlock() override;
6658  virtual bool isFunctionCallFast(const std::vector<SgAsmInstruction*> &insns,
6659  rose_addr_t *target/*out*/, rose_addr_t *ret/*out*/) override;
6660  virtual bool isFunctionCallSlow(const std::vector<SgAsmInstruction*>&,
6661  rose_addr_t *target, rose_addr_t *ret) override;
6662  virtual bool isFunctionReturnFast(const std::vector<SgAsmInstruction*> &insns) override;
6663  virtual bool isFunctionReturnSlow(const std::vector<SgAsmInstruction*> &insns) override;
6664  virtual Rose::BinaryAnalysis::AddressSet getSuccessors(bool &complete) override;
6665  virtual bool isUnknown() const override;
6666  virtual Sawyer::Optional<rose_addr_t> branchTarget() override;
6667  virtual unsigned get_anyKind() const override;
6668 public:
6670  virtual ~SgAsmMipsInstruction();
6671 
6672 public:
6675 
6676 public:
6678  SgAsmMipsInstruction(rose_addr_t const& address,
6679  std::string const& mnemonic,
6681 
6682 protected:
6689  void initializeProperties();
6690 #endif // SgAsmMipsInstruction_OTHERS
6691 #ifdef DOCUMENTATION
6692 };
6693 #endif // DOCUMENTATION
6694 
6695 
6697 // SgAsmMemoryReferenceExpression -- MACHINE GENERATED; DO NOT MODIFY --
6699 
6700 DECLARE_LEAF_CLASS(AsmMemoryReferenceExpression);
6701 IS_SERIALIZABLE(AsmMemoryReferenceExpression);
6702 
6703 #ifdef DOCUMENTATION
6704 
6706 #endif // DOCUMENTATION
6707 
6708 #ifndef DOCUMENTATION
6709  AsmMemoryReferenceExpression.setDataPrototype(
6710  "SgAsmExpression*", "address", "= nullptr",
6711  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
6712 #endif // !DOCUMENTATION
6713 
6714 #ifndef DOCUMENTATION
6715  AsmMemoryReferenceExpression.setDataPrototype(
6716  "SgAsmExpression*", "segment", "= nullptr",
6717  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
6718 #endif // !DOCUMENTATION
6719 
6720  DECLARE_OTHERS(AsmMemoryReferenceExpression);
6721 #if defined(SgAsmMemoryReferenceExpression_OTHERS) || defined(DOCUMENTATION)
6722 
6723  //----------------------- Boost serialization for SgAsmMemoryReferenceExpression -----------------------
6724 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
6725 private:
6726  friend class boost::serialization::access;
6727 
6728  template<class S>
6729  void serialize(S &s, const unsigned /*version*/) {
6730  debugSerializationBegin("SgAsmMemoryReferenceExpression");
6731  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExpression);
6732  s & BOOST_SERIALIZATION_NVP(p_address);
6733  s & BOOST_SERIALIZATION_NVP(p_segment);
6734  debugSerializationEnd("SgAsmMemoryReferenceExpression");
6735  }
6736 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
6737 
6738 public:
6746  SgAsmExpression* const& get_address() const;
6747  void set_address(SgAsmExpression* const&);
6750 public:
6758  SgAsmExpression* const& get_segment() const;
6759  void set_segment(SgAsmExpression* const&);
6762 public:
6765 
6766 public:
6769 
6770 public:
6773  SgAsmExpression* const& segment);
6774 
6775 protected:
6782  void initializeProperties();
6783 #endif // SgAsmMemoryReferenceExpression_OTHERS
6784 #ifdef DOCUMENTATION
6785 };
6786 #endif // DOCUMENTATION
6787 
6788 
6790 // SgAsmM68kInstruction -- MACHINE GENERATED; DO NOT MODIFY --
6792 
6793 DECLARE_LEAF_CLASS(AsmM68kInstruction);
6794 IS_SERIALIZABLE(AsmM68kInstruction);
6795 
6796 DECLARE_HEADERS(AsmM68kInstruction);
6797 #if defined(SgAsmM68kInstruction_HEADERS) || defined(DOCUMENTATION)
6798 #include <Rose/BinaryAnalysis/InstructionEnumsM68k.h>
6799 #endif // SgAsmM68kInstruction_HEADERS
6800 
6801 #ifdef DOCUMENTATION
6803 #endif // DOCUMENTATION
6804 
6805 #ifndef DOCUMENTATION
6806  AsmM68kInstruction.setDataPrototype(
6807  "Rose::BinaryAnalysis::M68kInstructionKind", "kind", "= Rose::BinaryAnalysis::m68k_unknown_instruction",
6808  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
6809 #endif // !DOCUMENTATION
6810 
6811  DECLARE_OTHERS(AsmM68kInstruction);
6812 #if defined(SgAsmM68kInstruction_OTHERS) || defined(DOCUMENTATION)
6813 
6814  //----------------------- Boost serialization for SgAsmM68kInstruction -----------------------
6815 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
6816 private:
6817  friend class boost::serialization::access;
6818 
6819  template<class S>
6820  void serialize(S &s, const unsigned /*version*/) {
6821  debugSerializationBegin("SgAsmM68kInstruction");
6822  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmInstruction);
6823  s & BOOST_SERIALIZATION_NVP(p_kind);
6824  debugSerializationEnd("SgAsmM68kInstruction");
6825  }
6826 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
6827 public:
6828 public:
6838 public:
6839  // Overrides are documented in the base class
6840  virtual std::string description() const override;
6841  virtual bool terminatesBasicBlock() override;
6842  virtual bool isFunctionCallFast(const std::vector<SgAsmInstruction*> &insns,
6843  rose_addr_t *target/*out*/, rose_addr_t *ret/*out*/) override;
6844  virtual bool isFunctionCallSlow(const std::vector<SgAsmInstruction*>&,
6845  rose_addr_t *target, rose_addr_t *ret) override;
6846  virtual bool isFunctionReturnFast(const std::vector<SgAsmInstruction*> &insns) override;
6847  virtual bool isFunctionReturnSlow(const std::vector<SgAsmInstruction*> &insns) override;
6848  virtual Sawyer::Optional<rose_addr_t> branchTarget() override;
6849  virtual Rose::BinaryAnalysis::AddressSet getSuccessors(bool &complete) override;
6850  virtual Rose::BinaryAnalysis::AddressSet getSuccessors(const std::vector<SgAsmInstruction*>&,
6851  bool &complete,
6852  const Rose::BinaryAnalysis::MemoryMap::Ptr &initial_memory =
6854  virtual bool isUnknown() const override;
6855  virtual unsigned get_anyKind() const override;
6856 public:
6858  virtual ~SgAsmM68kInstruction();
6859 
6860 public:
6863 
6864 public:
6866  SgAsmM68kInstruction(rose_addr_t const& address,
6867  std::string const& mnemonic,
6869 
6870 protected:
6877  void initializeProperties();
6878 #endif // SgAsmM68kInstruction_OTHERS
6879 #ifdef DOCUMENTATION
6880 };
6881 #endif // DOCUMENTATION
6882 
6883 
6885 // SgAsmLESectionTable -- MACHINE GENERATED; DO NOT MODIFY --
6887 
6888 DECLARE_LEAF_CLASS(AsmLESectionTable);
6889 IS_SERIALIZABLE(AsmLESectionTable);
6890 
6891 #ifdef DOCUMENTATION
6893 #endif // DOCUMENTATION
6894 
6895  DECLARE_OTHERS(AsmLESectionTable);
6896 #if defined(SgAsmLESectionTable_OTHERS) || defined(DOCUMENTATION)
6897 
6898  //----------------------- Boost serialization for SgAsmLESectionTable -----------------------
6899 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
6900 private:
6901  friend class boost::serialization::access;
6902 
6903  template<class S>
6904  void serialize(S &s, const unsigned /*version*/) {
6905  debugSerializationBegin("SgAsmLESectionTable");
6906  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmGenericSection);
6907  debugSerializationEnd("SgAsmLESectionTable");
6908  }
6909 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
6910 public:
6911  SgAsmLESectionTable(SgAsmLEFileHeader *fhdr, rose_addr_t offset, rose_addr_t size);
6912  virtual void unparse(std::ostream&) const override;
6913  virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
6914 public:
6916  virtual ~SgAsmLESectionTable();
6917 
6918 public:
6921 
6922 protected:
6929  void initializeProperties();
6930 #endif // SgAsmLESectionTable_OTHERS
6931 #ifdef DOCUMENTATION
6932 };
6933 #endif // DOCUMENTATION
6934 
6935 
6937 // SgAsmLESectionTableEntry -- MACHINE GENERATED; DO NOT MODIFY --
6939 
6940 DECLARE_LEAF_CLASS(AsmLESectionTableEntry);
6941 IS_SERIALIZABLE(AsmLESectionTableEntry);
6942 
6943 DECLARE_HEADERS(AsmLESectionTableEntry);
6944 #if defined(SgAsmLESectionTableEntry_HEADERS) || defined(DOCUMENTATION)
6945 #include <Rose/BinaryAnalysis/ByteOrder.h>
6946 #endif // SgAsmLESectionTableEntry_HEADERS
6947 
6948 #ifdef DOCUMENTATION
6950 #endif // DOCUMENTATION
6951 
6952 #ifndef DOCUMENTATION
6953  AsmLESectionTableEntry.setDataPrototype(
6954  "unsigned", "flags", "= 0",
6955  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
6956 #endif // !DOCUMENTATION
6957 
6958 #ifndef DOCUMENTATION
6959  AsmLESectionTableEntry.setDataPrototype(
6960  "unsigned", "pagemap_index", "= 0",
6961  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
6962 #endif // !DOCUMENTATION
6963 
6964 #ifndef DOCUMENTATION
6965  AsmLESectionTableEntry.setDataPrototype(
6966  "unsigned", "pagemap_nentries", "= 0",
6967  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
6968 #endif // !DOCUMENTATION
6969 
6970 #ifndef DOCUMENTATION
6971  AsmLESectionTableEntry.setDataPrototype(
6972  "unsigned", "res1", "= 0",
6973  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
6974 #endif // !DOCUMENTATION
6975 
6976 #ifndef DOCUMENTATION
6977  AsmLESectionTableEntry.setDataPrototype(
6978  "rose_addr_t", "mapped_size", "= 0",
6979  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
6980 #endif // !DOCUMENTATION
6981 
6982 #ifndef DOCUMENTATION
6983  AsmLESectionTableEntry.setDataPrototype(
6984  "rose_addr_t", "base_addr", "= 0",
6985  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
6986 #endif // !DOCUMENTATION
6987 
6988  DECLARE_OTHERS(AsmLESectionTableEntry);
6989 #if defined(SgAsmLESectionTableEntry_OTHERS) || defined(DOCUMENTATION)
6990 
6991  //----------------------- Boost serialization for SgAsmLESectionTableEntry -----------------------
6992 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
6993 private:
6994  friend class boost::serialization::access;
6995 
6996  template<class S>
6997  void serialize(S &s, const unsigned /*version*/) {
6998  debugSerializationBegin("SgAsmLESectionTableEntry");
6999  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
7000  s & BOOST_SERIALIZATION_NVP(p_flags);
7001  s & BOOST_SERIALIZATION_NVP(p_pagemap_index);
7002  s & BOOST_SERIALIZATION_NVP(p_pagemap_nentries);
7003  s & BOOST_SERIALIZATION_NVP(p_res1);
7004  s & BOOST_SERIALIZATION_NVP(p_mapped_size);
7005  s & BOOST_SERIALIZATION_NVP(p_base_addr);
7006  debugSerializationEnd("SgAsmLESectionTableEntry");
7007  }
7008 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
7009  // Local types
7012 public:
7013 #ifdef _MSC_VER
7014 # pragma pack (1)
7015 #endif
7016  /* File format of a section table entry. Fields are big- or little-endian depending on file header. */
7018  uint32_t mapped_size; /* 0x00 virtual segment size in bytes */
7019  uint32_t base_addr; /* 0x04 relocation base address */
7020  uint32_t flags; /* 0x08 bit flags, see LESectionFlags */
7021  uint32_t pagemap_index; /* 0x0c */
7022  uint32_t pagemap_nentries; /* 0x10 number of entries in the page map */
7023  uint32_t res1; /* 0x14 reserved */
7024  } /* 0x18 */
7025 // DQ (3/7/2013): Adding support to restrict visability to SWIG.
7026 #ifndef SWIG
7027 #ifndef _MSC_VER
7028  __attribute__((packed))
7029 #endif
7030 #endif
7031  ;
7032 #ifdef _MSC_VER
7033 # pragma pack ()
7034 #endif
7035 
7036  /* SF_BIG_BIT: The "big/default" bit, for data segments, controls the setting of the Big bit in the segment descriptor. (The
7037  * Big bit, or B-bit, determines whether ESP or SP is used as the stack pointer.) For code segments, this bit
7038  * controls the setting of the Default bit in the segment descriptor. (The Default bit, or D-bit, determines
7039  * whether the default word size is 32-bits or 16-bits. It also affects the interpretation of the instruction
7040  * stream.) */
7042  SF_RESERVED = 0xffff0800, /* Reserved bits (FIXME) */
7043 
7044  SF_READABLE = 0x00000001,
7045  SF_WRITABLE = 0x00000002,
7046  SF_EXECUTABLE = 0x00000004,
7048  SF_RESOURCE = 0x00000008,
7049  SF_DISCARDABLE = 0x00000010,
7050  SF_SHARED = 0x00000020,
7051  SF_PRELOAD_PAGES = 0x00000040,
7052  SF_INVALID_PAGES = 0x00000080,
7054  SF_TYPE_MASK = 0x00000300, /*NO_STRINGIFY*/
7055  SF_TYPE_NORMAL = 0x00000000,
7056  SF_TYPE_ZERO = 0x00000100,
7057  SF_TYPE_RESIDENT = 0x00000200,
7058  SF_TYPE_RESCONT = 0x00000300,
7060  SF_RES_LONG_LOCK = 0x00000400,
7061  SF_1616_ALIAS = 0x00001000,
7062  SF_BIG_BIT = 0x00002000,
7063  SF_CODE_CONFORM = 0x00004000,
7064  SF_IO_PRIV = 0x00008000
7065  };
7066 
7068  // Properties
7070 public:
7071  unsigned const& get_flags() const;
7072  void set_flags(unsigned const&);
7073 
7074 public:
7075  unsigned const& get_pagemap_index() const;
7076  void set_pagemap_index(unsigned const&);
7077 
7078 public:
7079  unsigned const& get_pagemap_nentries() const;
7080  void set_pagemap_nentries(unsigned const&);
7081 
7082 public:
7083  unsigned const& get_res1() const;
7084  void set_res1(unsigned const&);
7085 
7086 public:
7087  rose_addr_t const& get_mapped_size() const;
7088  void set_mapped_size(rose_addr_t const&);
7089 
7090 public:
7091  rose_addr_t const& get_base_addr() const;
7092  void set_base_addr(rose_addr_t const&);
7094  // Functions
7096 public:
7097  SgAsmLESectionTableEntry(Rose::BinaryAnalysis::ByteOrder::Endianness sex,
7099  void *encode(Rose::BinaryAnalysis::ByteOrder::Endianness, SgAsmLESectionTableEntry::LESectionTableEntry_disk*) const;
7100  virtual void dump(FILE *f, const char *prefix, ssize_t idx) const;
7101 public:
7103  virtual ~SgAsmLESectionTableEntry();
7104 
7105 public:
7108 
7109 protected:
7116  void initializeProperties();
7117 #endif // SgAsmLESectionTableEntry_OTHERS
7118 #ifdef DOCUMENTATION
7119 };
7120 #endif // DOCUMENTATION
7121 
7122 
7124 // SgAsmLESection -- MACHINE GENERATED; DO NOT MODIFY --
7126 
7127 DECLARE_LEAF_CLASS(AsmLESection);
7128 IS_SERIALIZABLE(AsmLESection);
7129 
7130 #ifdef DOCUMENTATION
7132 #endif // DOCUMENTATION
7133 
7134 #ifndef DOCUMENTATION
7135  AsmLESection.setDataPrototype(
7136  "SgAsmLESectionTableEntry*", "st_entry", "= NULL",
7137  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
7138 #endif // !DOCUMENTATION
7139 
7140  DECLARE_OTHERS(AsmLESection);
7141 #if defined(SgAsmLESection_OTHERS) || defined(DOCUMENTATION)
7142 
7143  //----------------------- Boost serialization for SgAsmLESection -----------------------
7144 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
7145 private:
7146  friend class boost::serialization::access;
7147 
7148  template<class S>
7149  void serialize(S &s, const unsigned /*version*/) {
7150  debugSerializationBegin("SgAsmLESection");
7151  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmGenericSection);
7152  s & BOOST_SERIALIZATION_NVP(p_st_entry);
7153  debugSerializationEnd("SgAsmLESection");
7154  }
7155 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
7156 
7157 public:
7158  SgAsmLESectionTableEntry* const& get_st_entry() const;
7159  void set_st_entry(SgAsmLESectionTableEntry* const&);
7160 public:
7161  explicit SgAsmLESection(SgAsmLEFileHeader*);
7162  virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
7163 public:
7165  virtual ~SgAsmLESection();
7166 
7167 public:
7169  SgAsmLESection();
7170 
7171 protected:
7178  void initializeProperties();
7179 #endif // SgAsmLESection_OTHERS
7180 #ifdef DOCUMENTATION
7181 };
7182 #endif // DOCUMENTATION
7183 
7184 
7186 // SgAsmLERelocTable -- MACHINE GENERATED; DO NOT MODIFY --
7188 
7189 DECLARE_LEAF_CLASS(AsmLERelocTable);
7190 IS_SERIALIZABLE(AsmLERelocTable);
7191 
7192 #ifdef DOCUMENTATION
7194 #endif // DOCUMENTATION
7195 
7196 #ifndef DOCUMENTATION
7197  AsmLERelocTable.setDataPrototype(
7198  "SgAsmLERelocEntryPtrList", "entries", "",
7199  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
7200 #endif // !DOCUMENTATION
7201 
7202  DECLARE_OTHERS(AsmLERelocTable);
7203 #if defined(SgAsmLERelocTable_OTHERS) || defined(DOCUMENTATION)
7204 
7205  //----------------------- Boost serialization for SgAsmLERelocTable -----------------------
7206 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
7207 private:
7208  friend class boost::serialization::access;
7209 
7210  template<class S>
7211  void serialize(S &s, const unsigned /*version*/) {
7212  debugSerializationBegin("SgAsmLERelocTable");
7213  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmGenericSection);
7214  s & BOOST_SERIALIZATION_NVP(p_entries);
7215  debugSerializationEnd("SgAsmLERelocTable");
7216  }
7217 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
7218 
7219 public:
7220  SgAsmLERelocEntryPtrList const& get_entries() const;
7221  SgAsmLERelocEntryPtrList& get_entries();
7222  void set_entries(SgAsmLERelocEntryPtrList const&);
7223 public:
7224  SgAsmLERelocTable(SgAsmLEFileHeader *fhdr, rose_addr_t offset);
7225  virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
7226 public:
7228  virtual ~SgAsmLERelocTable();
7229 
7230 public:
7233 
7234 protected:
7241  void initializeProperties();
7242 #endif // SgAsmLERelocTable_OTHERS
7243 #ifdef DOCUMENTATION
7244 };
7245 #endif // DOCUMENTATION
7246 
7247 
7249 // SgAsmLEPageTable -- MACHINE GENERATED; DO NOT MODIFY --
7251 
7252 DECLARE_LEAF_CLASS(AsmLEPageTable);
7253 IS_SERIALIZABLE(AsmLEPageTable);
7254 
7255 #ifdef DOCUMENTATION
7257 #endif // DOCUMENTATION
7258 
7259 #ifndef DOCUMENTATION
7260  AsmLEPageTable.setDataPrototype(
7261  "SgAsmLEPageTableEntryPtrList", "entries", "",
7262  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
7263 #endif // !DOCUMENTATION
7264 
7265  DECLARE_OTHERS(AsmLEPageTable);
7266 #if defined(SgAsmLEPageTable_OTHERS) || defined(DOCUMENTATION)
7267 
7268  //----------------------- Boost serialization for SgAsmLEPageTable -----------------------
7269 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
7270 private:
7271  friend class boost::serialization::access;
7272 
7273  template<class S>
7274  void serialize(S &s, const unsigned /*version*/) {
7275  debugSerializationBegin("SgAsmLEPageTable");
7276  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmGenericSection);
7277  s & BOOST_SERIALIZATION_NVP(p_entries);
7278  debugSerializationEnd("SgAsmLEPageTable");
7279  }
7280 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
7281 
7282 public:
7283  SgAsmLEPageTableEntryPtrList const& get_entries() const;
7284  SgAsmLEPageTableEntryPtrList& get_entries();
7285  void set_entries(SgAsmLEPageTableEntryPtrList const&);
7286 public:
7287  SgAsmLEPageTable(SgAsmLEFileHeader *fhdr, rose_addr_t offset, rose_addr_t size);
7288  virtual void unparse(std::ostream&) const override;
7289  virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
7290  SgAsmLEPageTableEntry *get_page(size_t idx);
7291 public:
7293  virtual ~SgAsmLEPageTable();
7294 
7295 public:
7297  SgAsmLEPageTable();
7298 
7299 protected:
7306  void initializeProperties();
7307 #endif // SgAsmLEPageTable_OTHERS
7308 #ifdef DOCUMENTATION
7309 };
7310 #endif // DOCUMENTATION
7311 
7312 
7314 // SgAsmLEPageTableEntry -- MACHINE GENERATED; DO NOT MODIFY --
7316 
7317 DECLARE_LEAF_CLASS(AsmLEPageTableEntry);
7318 IS_SERIALIZABLE(AsmLEPageTableEntry);
7319 
7320 DECLARE_HEADERS(AsmLEPageTableEntry);
7321 #if defined(SgAsmLEPageTableEntry_HEADERS) || defined(DOCUMENTATION)
7322 #include <Rose/BinaryAnalysis/ByteOrder.h>
7323 #endif // SgAsmLEPageTableEntry_HEADERS
7324 
7325 #ifdef DOCUMENTATION
7327 #endif // DOCUMENTATION
7328 
7329 #ifndef DOCUMENTATION
7330  AsmLEPageTableEntry.setDataPrototype(
7331  "unsigned", "pageno", "= 0",
7332  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
7333 #endif // !DOCUMENTATION
7334 
7335 #ifndef DOCUMENTATION
7336  AsmLEPageTableEntry.setDataPrototype(
7337  "unsigned", "flags", "= 0",
7338  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
7339 #endif // !DOCUMENTATION
7340 
7341  DECLARE_OTHERS(AsmLEPageTableEntry);
7342 #if defined(SgAsmLEPageTableEntry_OTHERS) || defined(DOCUMENTATION)
7343 
7344  //----------------------- Boost serialization for SgAsmLEPageTableEntry -----------------------
7345 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
7346 private:
7347  friend class boost::serialization::access;
7348 
7349  template<class S>
7350  void serialize(S &s, const unsigned /*version*/) {
7351  debugSerializationBegin("SgAsmLEPageTableEntry");
7352  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
7353  s & BOOST_SERIALIZATION_NVP(p_pageno);
7354  s & BOOST_SERIALIZATION_NVP(p_flags);
7355  debugSerializationEnd("SgAsmLEPageTableEntry");
7356  }
7357 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
7358  // Local types
7361 public:
7362  /* The object page table provides information about a logical page in a section. A logical page may be an enumerated page, a
7363  * pseudo page, or an iterated page. The page table allows for efficient access to a page when a page fault occurs, while still
7364  * allowing the physical page to be located in the preload page, demand load page, or iterated data page sections of the
7365  * executable file. Entries in the page table use 1-origin indices. This table is parallel with the Fixup Page Table (they are
7366  * both indexed by the logical page number). */
7367 
7368 #ifdef _MSC_VER
7369 # pragma pack (1)
7370 #endif
7371  /* File format for a page table entry */
7373  uint16_t pageno_hi;
7374  unsigned char pageno_lo;
7375  unsigned char flags;
7376  }
7377 // DQ (3/7/2013): Adding support to restrict visability to SWIG.
7378 #ifndef SWIG
7379 #ifndef _MSC_VER
7380  __attribute__((packed))
7381 #endif
7382 #endif
7383  ;
7384 #ifdef _MSC_VER
7385 # pragma pack ()
7386 #endif
7387 
7389  // Properties
7391 public:
7392  unsigned const& get_pageno() const;
7393  void set_pageno(unsigned const&);
7394 
7395 public:
7396  unsigned const& get_flags() const;
7397  void set_flags(unsigned const&);
7399  // Functions
7401 public:
7402  SgAsmLEPageTableEntry(Rose::BinaryAnalysis::ByteOrder::Endianness sex,
7404  void dump(FILE*, const char *prefix, ssize_t idx) const;
7405  void *encode(Rose::BinaryAnalysis::ByteOrder::Endianness, SgAsmLEPageTableEntry::LEPageTableEntry_disk*) const;
7406 public:
7408  virtual ~SgAsmLEPageTableEntry();
7409 
7410 public:
7413 
7414 protected:
7421  void initializeProperties();
7422 #endif // SgAsmLEPageTableEntry_OTHERS
7423 #ifdef DOCUMENTATION
7424 };
7425 #endif // DOCUMENTATION
7426 
7427 
7429 // SgAsmLENameTable -- MACHINE GENERATED; DO NOT MODIFY --
7431 
7432 DECLARE_LEAF_CLASS(AsmLENameTable);
7433 IS_SERIALIZABLE(AsmLENameTable);
7434 
7435 #ifdef DOCUMENTATION
7437 #endif // DOCUMENTATION
7438 
7439 #ifndef DOCUMENTATION
7440  AsmLENameTable.setDataPrototype(
7441  "SgStringList", "names", "",
7442  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
7443 #endif // !DOCUMENTATION
7444 
7445 #ifndef DOCUMENTATION
7446  AsmLENameTable.setDataPrototype(
7447  "SgUnsignedList", "ordinals", "",
7448  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
7449 #endif // !DOCUMENTATION
7450 
7451  DECLARE_OTHERS(AsmLENameTable);
7452 #if defined(SgAsmLENameTable_OTHERS) || defined(DOCUMENTATION)
7453 
7454  //----------------------- Boost serialization for SgAsmLENameTable -----------------------
7455 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
7456 private:
7457  friend class boost::serialization::access;
7458 
7459  template<class S>
7460  void serialize(S &s, const unsigned /*version*/) {
7461  debugSerializationBegin("SgAsmLENameTable");
7462  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmGenericSection);
7463  s & BOOST_SERIALIZATION_NVP(p_names);
7464  s & BOOST_SERIALIZATION_NVP(p_ordinals);
7465  debugSerializationEnd("SgAsmLENameTable");
7466  }
7467 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
7468 
7469 public:
7470  SgStringList const& get_names() const;
7471  void set_names(SgStringList const&);
7472 
7473 public:
7474  SgUnsignedList const& get_ordinals() const;
7475  void set_ordinals(SgUnsignedList const&);
7476 public:
7477  /* This table contains a module name followed by the list of exported function names. Each name is associated with an "ordinal"
7478  * which serves as an index into the Entry Table. The ordinal for the first string (module name) is meaningless and should be
7479  * zero. In the non-resident name table the first entry is a module description and the functions are not always resident in
7480  * system memory (they are discardable). */
7481  SgAsmLENameTable(SgAsmLEFileHeader *fhdr, rose_addr_t offset);
7482  virtual void unparse(std::ostream&) const override;
7483  virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
7484 public:
7486  virtual ~SgAsmLENameTable();
7487 
7488 public:
7490  SgAsmLENameTable();
7491 
7492 protected:
7499  void initializeProperties();
7500 #endif // SgAsmLENameTable_OTHERS
7501 #ifdef DOCUMENTATION
7502 };
7503 #endif // DOCUMENTATION
7504 
7505 
7507 // SgAsmLEFileHeader -- MACHINE GENERATED; DO NOT MODIFY --
7509 
7510 DECLARE_LEAF_CLASS(AsmLEFileHeader);
7511 IS_SERIALIZABLE(AsmLEFileHeader);
7512 
7513 DECLARE_HEADERS(AsmLEFileHeader);
7514 #if defined(SgAsmLEFileHeader_HEADERS) || defined(DOCUMENTATION)
7515 #include <Rose/BinaryAnalysis/ByteOrder.h>
7516 #endif // SgAsmLEFileHeader_HEADERS
7517 
7518 #ifdef DOCUMENTATION
7520 #endif // DOCUMENTATION
7521 
7522 #ifndef DOCUMENTATION
7523  AsmLEFileHeader.setDataPrototype(
7524  "unsigned", "e_byte_order", "= 0",
7525  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
7526 #endif // !DOCUMENTATION
7527 
7528 #ifndef DOCUMENTATION
7529  AsmLEFileHeader.setDataPrototype(
7530  "unsigned", "e_word_order", "= 0",
7531  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
7532 #endif // !DOCUMENTATION
7533 
7534 #ifndef DOCUMENTATION
7535  AsmLEFileHeader.setDataPrototype(
7536  "unsigned", "e_format_level", "= 0",
7537  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
7538 #endif // !DOCUMENTATION
7539 
7540 #ifndef DOCUMENTATION
7541  AsmLEFileHeader.setDataPrototype(
7542  "unsigned", "e_cpu_type", "= 0",
7543  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
7544 #endif // !DOCUMENTATION
7545 
7546 #ifndef DOCUMENTATION
7547  AsmLEFileHeader.setDataPrototype(
7548  "unsigned", "e_os_type", "= 0",
7549  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
7550 #endif // !DOCUMENTATION
7551 
7552 #ifndef DOCUMENTATION
7553  AsmLEFileHeader.setDataPrototype(
7554  "unsigned", "e_module_version", "= 0",
7555  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
7556 #endif // !DOCUMENTATION
7557 
7558 #ifndef DOCUMENTATION
7559  AsmLEFileHeader.setDataPrototype(
7560  "unsigned", "e_flags", "= 0",
7561  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
7562 #endif // !DOCUMENTATION
7563 
7564 #ifndef DOCUMENTATION
7565  AsmLEFileHeader.setDataPrototype(
7566  "unsigned", "e_eip_section", "= 0",
7567  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
7568 #endif // !DOCUMENTATION
7569 
7570 #ifndef DOCUMENTATION
7571  AsmLEFileHeader.setDataPrototype(
7572  "unsigned", "e_esp_section", "= 0",
7573  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
7574 #endif // !DOCUMENTATION
7575 
7576 #ifndef DOCUMENTATION
7577  AsmLEFileHeader.setDataPrototype(
7578  "unsigned", "e_last_page_size", "= 0",
7579  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
7580 #endif // !DOCUMENTATION
7581 
7582 #ifndef DOCUMENTATION
7583  AsmLEFileHeader.setDataPrototype(
7584  "unsigned", "e_page_offset_shift", "= 0",
7585  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
7586 #endif // !DOCUMENTATION
7587 
7588 #ifndef DOCUMENTATION
7589  AsmLEFileHeader.setDataPrototype(
7590  "unsigned", "e_fixup_sect_cksum", "= 0",
7591  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
7592 #endif // !DOCUMENTATION
7593 
7594 #ifndef DOCUMENTATION
7595  AsmLEFileHeader.setDataPrototype(
7596  "unsigned", "e_loader_sect_cksum", "= 0",
7597  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
7598 #endif // !DOCUMENTATION
7599 
7600 #ifndef DOCUMENTATION
7601  AsmLEFileHeader.setDataPrototype(
7602  "unsigned", "e_secttab_nentries", "= 0",
7603  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
7604 #endif // !DOCUMENTATION
7605 
7606 #ifndef DOCUMENTATION
7607  AsmLEFileHeader.setDataPrototype(
7608  "unsigned", "e_rsrctab_nentries", "= 0",
7609  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
7610 #endif // !DOCUMENTATION
7611 
7612 #ifndef DOCUMENTATION
7613  AsmLEFileHeader.setDataPrototype(
7614  "unsigned", "e_fmtdirtab_nentries", "= 0",
7615  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
7616 #endif // !DOCUMENTATION
7617 
7618 #ifndef DOCUMENTATION
7619  AsmLEFileHeader.setDataPrototype(
7620  "unsigned", "e_import_modtab_nentries", "= 0",
7621  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
7622 #endif // !DOCUMENTATION
7623 
7624 #ifndef DOCUMENTATION
7625  AsmLEFileHeader.setDataPrototype(
7626  "unsigned", "e_preload_npages", "= 0",
7627  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
7628 #endif // !DOCUMENTATION
7629 
7630 #ifndef DOCUMENTATION
7631  AsmLEFileHeader.setDataPrototype(
7632  "unsigned", "e_nonresnametab_size", "= 0",
7633  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
7634 #endif // !DOCUMENTATION
7635 
7636 #ifndef DOCUMENTATION
7637  AsmLEFileHeader.setDataPrototype(
7638  "unsigned", "e_nonresnametab_cksum", "= 0",
7639  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
7640 #endif // !DOCUMENTATION
7641 
7642 #ifndef DOCUMENTATION
7643  AsmLEFileHeader.setDataPrototype(
7644  "unsigned", "e_auto_ds_section", "= 0",
7645  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
7646 #endif // !DOCUMENTATION
7647 
7648 #ifndef DOCUMENTATION
7649  AsmLEFileHeader.setDataPrototype(
7650  "unsigned", "e_debug_info_size", "= 0",
7651  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
7652 #endif // !DOCUMENTATION
7653 
7654 #ifndef DOCUMENTATION
7655  AsmLEFileHeader.setDataPrototype(
7656  "unsigned", "e_num_instance_preload", "= 0",
7657  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
7658 #endif // !DOCUMENTATION
7659 
7660 #ifndef DOCUMENTATION
7661  AsmLEFileHeader.setDataPrototype(
7662  "unsigned", "e_num_instance_demand", "= 0",
7663  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
7664 #endif // !DOCUMENTATION
7665 
7666 #ifndef DOCUMENTATION
7667  AsmLEFileHeader.setDataPrototype(
7668  "unsigned", "e_heap_size", "= 0",
7669  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
7670 #endif // !DOCUMENTATION
7671 
7672 #ifndef DOCUMENTATION
7673  AsmLEFileHeader.setDataPrototype(
7674  "rose_addr_t", "e_npages", "= 0",
7675  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
7676 #endif // !DOCUMENTATION
7677 
7678 #ifndef DOCUMENTATION
7679  AsmLEFileHeader.setDataPrototype(
7680  "rose_addr_t", "e_eip", "= 0",
7681  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
7682 #endif // !DOCUMENTATION
7683 
7684 #ifndef DOCUMENTATION
7685  AsmLEFileHeader.setDataPrototype(
7686  "rose_addr_t", "e_esp", "= 0",
7687  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
7688 #endif // !DOCUMENTATION
7689 
7690 #ifndef DOCUMENTATION
7691  AsmLEFileHeader.setDataPrototype(
7692  "rose_addr_t", "e_page_size", "= 0",
7693  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
7694 #endif // !DOCUMENTATION
7695 
7696 #ifndef DOCUMENTATION
7697  AsmLEFileHeader.setDataPrototype(
7698  "rose_addr_t", "e_fixup_sect_size", "= 0",
7699  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
7700 #endif // !DOCUMENTATION
7701 
7702 #ifndef DOCUMENTATION
7703  AsmLEFileHeader.setDataPrototype(
7704  "rose_addr_t", "e_loader_sect_size", "= 0",
7705  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
7706 #endif // !DOCUMENTATION
7707 
7708 #ifndef DOCUMENTATION
7709  AsmLEFileHeader.setDataPrototype(
7710  "rose_addr_t", "e_secttab_rfo", "= 0",
7711  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
7712 #endif // !DOCUMENTATION
7713 
7714 #ifndef DOCUMENTATION
7715  AsmLEFileHeader.setDataPrototype(
7716  "rose_addr_t", "e_pagetab_rfo", "= 0",
7717  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
7718 #endif // !DOCUMENTATION
7719 
7720 #ifndef DOCUMENTATION
7721  AsmLEFileHeader.setDataPrototype(
7722  "rose_addr_t", "e_iterpages_offset", "= 0",
7723  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
7724 #endif // !DOCUMENTATION
7725 
7726 #ifndef DOCUMENTATION
7727  AsmLEFileHeader.setDataPrototype(
7728  "rose_addr_t", "e_rsrctab_rfo", "= 0",
7729  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
7730 #endif // !DOCUMENTATION
7731 
7732 #ifndef DOCUMENTATION
7733  AsmLEFileHeader.setDataPrototype(
7734  "rose_addr_t", "e_resnametab_rfo", "= 0",
7735  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
7736 #endif // !DOCUMENTATION
7737 
7738 #ifndef DOCUMENTATION
7739  AsmLEFileHeader.setDataPrototype(
7740  "rose_addr_t", "e_entrytab_rfo", "= 0",
7741  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
7742 #endif // !DOCUMENTATION
7743 
7744 #ifndef DOCUMENTATION
7745  AsmLEFileHeader.setDataPrototype(
7746  "rose_addr_t", "e_fmtdirtab_rfo", "= 0",
7747  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
7748 #endif // !DOCUMENTATION
7749 
7750 #ifndef DOCUMENTATION
7751  AsmLEFileHeader.setDataPrototype(
7752  "rose_addr_t", "e_fixup_pagetab_rfo", "= 0",
7753  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
7754 #endif // !DOCUMENTATION
7755 
7756 #ifndef DOCUMENTATION
7757  AsmLEFileHeader.setDataPrototype(
7758  "rose_addr_t", "e_fixup_rectab_rfo", "= 0",
7759  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
7760 #endif // !DOCUMENTATION
7761 
7762 #ifndef DOCUMENTATION
7763  AsmLEFileHeader.setDataPrototype(
7764  "rose_addr_t", "e_import_modtab_rfo", "= 0",
7765  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
7766 #endif // !DOCUMENTATION
7767 
7768 #ifndef DOCUMENTATION
7769  AsmLEFileHeader.setDataPrototype(
7770  "rose_addr_t", "e_import_proctab_rfo", "= 0",
7771  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
7772 #endif // !DOCUMENTATION
7773 
7774 #ifndef DOCUMENTATION
7775  AsmLEFileHeader.setDataPrototype(
7776  "rose_addr_t", "e_ppcksumtab_rfo", "= 0",
7777  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
7778 #endif // !DOCUMENTATION
7779 
7780 #ifndef DOCUMENTATION
7781  AsmLEFileHeader.setDataPrototype(
7782  "rose_addr_t", "e_data_pages_offset", "= 0",
7783  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
7784 #endif // !DOCUMENTATION
7785 
7786 #ifndef DOCUMENTATION
7787  AsmLEFileHeader.setDataPrototype(
7788  "rose_addr_t", "e_nonresnametab_offset", "= 0",
7789  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
7790 #endif // !DOCUMENTATION
7791 
7792 #ifndef DOCUMENTATION
7793  AsmLEFileHeader.setDataPrototype(
7794  "rose_addr_t", "e_debug_info_rfo", "= 0",
7795  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
7796 #endif // !DOCUMENTATION
7797 
7798 #ifndef DOCUMENTATION
7799  AsmLEFileHeader.setDataPrototype(
7800  "SgAsmDOSExtendedHeader*", "dos2_header", "= nullptr",
7801  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
7802 #endif // !DOCUMENTATION
7803 
7804 #ifndef DOCUMENTATION
7805  AsmLEFileHeader.setDataPrototype(
7806  "SgAsmLESectionTable*", "section_table", "= nullptr",
7807  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
7808 #endif // !DOCUMENTATION
7809 
7810 #ifndef DOCUMENTATION
7811  AsmLEFileHeader.setDataPrototype(
7812  "SgAsmLEPageTable*", "page_table", "= nullptr",
7813  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
7814 #endif // !DOCUMENTATION
7815 
7816 #ifndef DOCUMENTATION
7817  AsmLEFileHeader.setDataPrototype(
7818  "SgAsmLENameTable*", "resname_table", "= nullptr",
7819  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
7820 #endif // !DOCUMENTATION
7821 
7822 #ifndef DOCUMENTATION
7823  AsmLEFileHeader.setDataPrototype(
7824  "SgAsmLENameTable*", "nonresname_table", "= nullptr",
7825  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
7826 #endif // !DOCUMENTATION
7827 
7828 #ifndef DOCUMENTATION
7829  AsmLEFileHeader.setDataPrototype(
7830  "SgAsmLEEntryTable*", "entry_table", "= nullptr",
7831  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
7832 #endif // !DOCUMENTATION
7833 
7834 #ifndef DOCUMENTATION
7835  AsmLEFileHeader.setDataPrototype(
7836  "SgAsmLERelocTable*", "reloc_table", "= nullptr",
7837  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
7838 #endif // !DOCUMENTATION
7839 
7840  DECLARE_OTHERS(AsmLEFileHeader);
7841 #if defined(SgAsmLEFileHeader_OTHERS) || defined(DOCUMENTATION)
7842 
7843  //----------------------- Boost serialization for SgAsmLEFileHeader -----------------------
7844 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
7845 private:
7846  friend class boost::serialization::access;
7847 
7848  template<class S>
7849  void serialize(S &s, const unsigned /*version*/) {
7850  debugSerializationBegin("SgAsmLEFileHeader");
7851  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmGenericHeader);
7852  s & BOOST_SERIALIZATION_NVP(p_e_byte_order);
7853  s & BOOST_SERIALIZATION_NVP(p_e_word_order);
7854  s & BOOST_SERIALIZATION_NVP(p_e_format_level);
7855  s & BOOST_SERIALIZATION_NVP(p_e_cpu_type);
7856  s & BOOST_SERIALIZATION_NVP(p_e_os_type);
7857  s & BOOST_SERIALIZATION_NVP(p_e_module_version);
7858  s & BOOST_SERIALIZATION_NVP(p_e_flags);
7859  s & BOOST_SERIALIZATION_NVP(p_e_eip_section);
7860  s & BOOST_SERIALIZATION_NVP(p_e_esp_section);
7861  s & BOOST_SERIALIZATION_NVP(p_e_last_page_size);
7862  s & BOOST_SERIALIZATION_NVP(p_e_page_offset_shift);
7863  s & BOOST_SERIALIZATION_NVP(p_e_fixup_sect_cksum);
7864  s & BOOST_SERIALIZATION_NVP(p_e_loader_sect_cksum);
7865  s & BOOST_SERIALIZATION_NVP(p_e_secttab_nentries);
7866  s & BOOST_SERIALIZATION_NVP(p_e_rsrctab_nentries);
7867  s & BOOST_SERIALIZATION_NVP(p_e_fmtdirtab_nentries);
7868  s & BOOST_SERIALIZATION_NVP(p_e_import_modtab_nentries);
7869  s & BOOST_SERIALIZATION_NVP(p_e_preload_npages);
7870  s & BOOST_SERIALIZATION_NVP(p_e_nonresnametab_size);
7871  s & BOOST_SERIALIZATION_NVP(p_e_nonresnametab_cksum);
7872  s & BOOST_SERIALIZATION_NVP(p_e_auto_ds_section);
7873  s & BOOST_SERIALIZATION_NVP(p_e_debug_info_size);
7874  s & BOOST_SERIALIZATION_NVP(p_e_num_instance_preload);
7875  s & BOOST_SERIALIZATION_NVP(p_e_num_instance_demand);
7876  s & BOOST_SERIALIZATION_NVP(p_e_heap_size);
7877  s & BOOST_SERIALIZATION_NVP(p_e_npages);
7878  s & BOOST_SERIALIZATION_NVP(p_e_eip);
7879  s & BOOST_SERIALIZATION_NVP(p_e_esp);
7880  s & BOOST_SERIALIZATION_NVP(p_e_page_size);
7881  s & BOOST_SERIALIZATION_NVP(p_e_fixup_sect_size);
7882  s & BOOST_SERIALIZATION_NVP(p_e_loader_sect_size);
7883  s & BOOST_SERIALIZATION_NVP(p_e_secttab_rfo);
7884  s & BOOST_SERIALIZATION_NVP(p_e_pagetab_rfo);
7885  s & BOOST_SERIALIZATION_NVP(p_e_iterpages_offset);
7886  s & BOOST_SERIALIZATION_NVP(p_e_rsrctab_rfo);
7887  s & BOOST_SERIALIZATION_NVP(p_e_resnametab_rfo);
7888  s & BOOST_SERIALIZATION_NVP(p_e_entrytab_rfo);
7889  s & BOOST_SERIALIZATION_NVP(p_e_fmtdirtab_rfo);
7890  s & BOOST_SERIALIZATION_NVP(p_e_fixup_pagetab_rfo);
7891  s & BOOST_SERIALIZATION_NVP(p_e_fixup_rectab_rfo);
7892  s & BOOST_SERIALIZATION_NVP(p_e_import_modtab_rfo);
7893  s & BOOST_SERIALIZATION_NVP(p_e_import_proctab_rfo);
7894  s & BOOST_SERIALIZATION_NVP(p_e_ppcksumtab_rfo);
7895  s & BOOST_SERIALIZATION_NVP(p_e_data_pages_offset);
7896  s & BOOST_SERIALIZATION_NVP(p_e_nonresnametab_offset);
7897  s & BOOST_SERIALIZATION_NVP(p_e_debug_info_rfo);
7898  s & BOOST_SERIALIZATION_NVP(p_dos2_header);
7899  s & BOOST_SERIALIZATION_NVP(p_section_table);
7900  s & BOOST_SERIALIZATION_NVP(p_page_table);
7901  s & BOOST_SERIALIZATION_NVP(p_resname_table);
7902  s & BOOST_SERIALIZATION_NVP(p_nonresname_table);
7903  s & BOOST_SERIALIZATION_NVP(p_entry_table);
7904  s & BOOST_SERIALIZATION_NVP(p_reloc_table);
7905  debugSerializationEnd("SgAsmLEFileHeader");
7906  }
7907 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
7908  // Local types
7911 public:
7912 #ifdef _MSC_VER
7913 # pragma pack (1)
7914 #endif
7915  /* File format of an LE/LX File Header (they are identical except bytes 0x2c-0x2f) */
7917  unsigned char e_magic[2]; /* 0x00 magic number "LX" */
7918  unsigned char e_byte_order; /* 0x02 byte order (0=>little endian; otherwise big endian) */
7919  unsigned char e_word_order; /* 0x03 word order (0=>little endian; otherwise big endian) */
7920  uint32_t e_format_level; /* 0x04 LX file format version number */
7921  uint16_t e_cpu_type; /* 0x08 1=>80286, 2=>80386, 3=>80486,4=80586, etc. (see ctor) */
7922  uint16_t e_os_type; /* 0x0a 0=>unknown, 1=>0S/2, 2=>Windows, 3=>DOS 4.x, 4=>Windows 386 */
7923  uint32_t e_module_version; /* 0x0c user-specified module version number */
7924  uint32_t e_flags; /* 0x10 bit flags (see LXFileHeaderFlags) */
7925  uint32_t e_npages; /* 0x14 number of physically contained pages (see e_page_size) */
7926  uint32_t e_eip_section; /* 0x18 the section number to which e_eip is relative */
7927  uint32_t e_eip; /* 0x1c entry address relative to e_eip_section */
7928  uint32_t e_esp_section; /* 0x20 the section number to which e_esp is relative */
7929  uint32_t e_esp; /* 0x24 starting stack address relative to e_esp_section */
7930  uint32_t e_page_size; /* 0x28 page size in bytes */
7931  uint32_t e_lps_or_shift; /* 0x2c size of last page (LE) or shift for page table's page offset field (LX) */
7932  uint32_t e_fixup_sect_size; /* 0x30 total size of fixup info in bytes (fixup page/record tables + import names) */
7933  uint32_t e_fixup_sect_cksum; /* 0x34 cryptographic checksum of all fixup info, or zero */
7934  uint32_t e_loader_sect_size; /* 0x38 size of memory resident tables (section table through per-page checksum table) */
7935  uint32_t e_loader_sect_cksum; /* 0x3c cryptographic checksum for all loader info, or zero */
7936  uint32_t e_secttab_rfo; /* 0x40 offset of section table relative to this header */
7937  uint32_t e_secttab_nentries; /* 0x44 number of entries in section table */
7938  uint32_t e_pagetab_rfo; /* 0x48 section page table offset relative to this header */
7939  uint32_t e_iterpages_offset; /* 0x4c section iterated pages offset (absolute file offset) */
7940  uint32_t e_rsrctab_rfo; /* 0x50 offset of resource table relative to this header */
7941  uint32_t e_rsrctab_nentries; /* 0x54 number of entries in the resource table */
7942  uint32_t e_resnametab_rfo; /* 0x58 offset of resident name table relative to this header */
7943  uint32_t e_entrytab_rfo; /* 0x5c offset of entry table relative to this header */
7944  uint32_t e_fmtdirtab_rfo; /* 0x60 offset of module format directives relative to this header */
7945  uint32_t e_fmtdirtab_nentries; /* 0x64 number of entries in module format directives table */
7946  uint32_t e_fixup_pagetab_rfo; /* 0x68 offset of fixup page table relative to this header */
7947  uint32_t e_fixup_rectab_rfo; /* 0x6c offset of fixup record table relative to this header */
7948  uint32_t e_import_modtab_rfo; /* 0x70 offset of import module name table relative to this header */
7949  uint32_t e_import_modtab_nentries;/*0x74 number of entries in import module name table */
7950  uint32_t e_import_proctab_rfo; /* 0x78 offset of import procedure name table relative to this header */
7951  uint32_t e_ppcksumtab_rfo; /* 0x7c offset of per-page checksum table relative to this header */
7952  uint32_t e_data_pages_offset; /* 0x80 offset of data pages (absolute file offset) */
7953  uint32_t e_preload_npages; /* 0x84 number of preload pages (not respected by OS/2) */
7954  uint32_t e_nonresnametab_offset; /* 0x88 offset of non-resident name table (absolute file offset) */
7955  uint32_t e_nonresnametab_size; /* 0x8c size of non-resident name table in bytes */
7956  uint32_t e_nonresnametab_cksum; /* 0x90 cryptographic checksum of the non-resident name table */
7957  uint32_t e_auto_ds_section; /* 0x94 auto data segment section number (not used by 32-bit modules) */
7958  uint32_t e_debug_info_rfo; /* 0x98 offset of debug information relative to this header */
7959  uint32_t e_debug_info_size; /* 0x9c size of debug information in bytes */
7960  uint32_t e_num_instance_preload; /* 0xa0 number of instance data pages found in the preload section */
7961  uint32_t e_num_instance_demand; /* 0xa4 number of instance data pages found in the demand section */
7962  uint32_t e_heap_size; /* 0xa8 number of bytes added to auto data segment by loader (not used by 32-bit) */
7963  } /* 0xac */
7964 // DQ (3/7/2013): Adding support to restrict visability to SWIG.
7965 #ifndef SWIG
7966 #ifndef _MSC_VER
7967  __attribute__((packed))
7968 #endif
7969 #endif
7970  ;
7971 #ifdef _MSC_VER
7972 # pragma pack ()
7973 #endif
7974 
7975  enum LEFileHeaderFlags {
7976  HF_RESERVED = 0xbffc5ccb, /* Reserved bits */
7977  HF_PROC_LIB_INIT = 0x00000004, /* Per-process library initialization; not used for executables */
7978  HF_IFIXUPS_APPLIED = 0x00000010, /* Sections have preferred load addresses and internal relocs have been applied */
7979  HF_EFIXUPS_APPLIED = 0x00000020, /* External fixups for the module have been applied */
7980  HF_PM_WINDOW_NO = 0x00000100, /* Incompatible with PM windowing */
7981  HF_PM_WINDOW_OK = 0x00000200, /* Compatible with PM windowing */
7982  HF_PM_WINDOW_USE = 0x00000300, /* Uses PM windowing API */
7983  HF_NOT_LOADABLE = 0x00002000, /* Module is not loadable (has errors or incrementally linked) */
7984  HF_PROC_LIB_TERM = 0x40000000, /* Per-process library termination; not used for executables */
7985 
7986  HF_MODTYPE_MASK = 0x00038000, /* Module type mask */
7987  HF_MODTYPE_PROG = 0x00000000, /* Program module (other modules cannot link to this one) */
7988  HF_MODTYPE_LIB = 0x00008000, /* Library module */
7989  HF_MODTYPE_PLIB = 0x00018000, /* Protected memory library module */
7990  HF_MODTYPE_PDEV = 0x00020000, /* Physical device driver module */
7991  HF_MODTYPE_VDEV = 0x00028000 /* Virtual device driver module */
7992  };
7993 
7995  // Properties
7997 public:
7998  unsigned const& get_e_byte_order() const;
7999  void set_e_byte_order(unsigned const&);
8000 
8001 public:
8002  unsigned const& get_e_word_order() const;
8003  void set_e_word_order(unsigned const&);
8004 
8005 public:
8006  unsigned const& get_e_format_level() const;
8007  void set_e_format_level(unsigned const&);
8008 
8009 public:
8010  unsigned const& get_e_cpu_type() const;
8011  void set_e_cpu_type(unsigned const&);
8012 
8013 public:
8014  unsigned const& get_e_os_type() const;
8015  void set_e_os_type(unsigned const&);
8016 
8017 public:
8018  unsigned const& get_e_module_version() const;
8019  void set_e_module_version(unsigned const&);
8020 
8021 public:
8022  unsigned const& get_e_flags() const;
8023  void set_e_flags(unsigned const&);
8024 
8025 public:
8026  unsigned const& get_e_eip_section() const;
8027  void set_e_eip_section(unsigned const&);
8028 
8029 public:
8030  unsigned const& get_e_esp_section() const;
8031  void set_e_esp_section(unsigned const&);
8032 
8033 public:
8034  unsigned const& get_e_last_page_size() const;
8035  void set_e_last_page_size(unsigned const&);
8036 
8037 public:
8038  unsigned const& get_e_page_offset_shift() const;
8039  void set_e_page_offset_shift(unsigned const&);
8040 
8041 public:
8042  unsigned const& get_e_fixup_sect_cksum() const;
8043  void set_e_fixup_sect_cksum(unsigned const&);
8044 
8045 public:
8046  unsigned const& get_e_loader_sect_cksum() const;
8047  void set_e_loader_sect_cksum(unsigned const&);
8048 
8049 public:
8050  unsigned const& get_e_secttab_nentries() const;
8051  void set_e_secttab_nentries(unsigned const&);
8052 
8053 public:
8054  unsigned const& get_e_rsrctab_nentries() const;
8055  void set_e_rsrctab_nentries(unsigned const&);
8056 
8057 public:
8058  unsigned const& get_e_fmtdirtab_nentries() const;
8059  void set_e_fmtdirtab_nentries(unsigned const&);
8060 
8061 public:
8062  unsigned const& get_e_import_modtab_nentries() const;
8063  void set_e_import_modtab_nentries(unsigned const&);
8064 
8065 public:
8066  unsigned const& get_e_preload_npages() const;
8067  void set_e_preload_npages(unsigned const&);
8068 
8069 public:
8070  unsigned const& get_e_nonresnametab_size() const;
8071  void set_e_nonresnametab_size(unsigned const&);
8072 
8073 public:
8074  unsigned const& get_e_nonresnametab_cksum() const;
8075  void set_e_nonresnametab_cksum(unsigned const&);
8076 
8077 public:
8078  unsigned const& get_e_auto_ds_section() const;
8079  void set_e_auto_ds_section(unsigned const&);
8080 
8081 public:
8082  unsigned const& get_e_debug_info_size() const;
8083  void set_e_debug_info_size(unsigned const&);
8084 
8085 public:
8086  unsigned const& get_e_num_instance_preload() const;
8087  void set_e_num_instance_preload(unsigned const&);
8088 
8089 public:
8090  unsigned const& get_e_num_instance_demand() const;
8091  void set_e_num_instance_demand(unsigned const&);
8092 
8093 public:
8094  unsigned const& get_e_heap_size() const;
8095  void set_e_heap_size(unsigned const&);
8096 
8097 public:
8098  rose_addr_t const& get_e_npages() const;
8099  void set_e_npages(rose_addr_t const&);
8100 
8101 public:
8102  rose_addr_t const& get_e_eip() const;
8103  void set_e_eip(rose_addr_t const&);
8104 
8105 public:
8106  rose_addr_t const& get_e_esp() const;
8107  void set_e_esp(rose_addr_t const&);
8108 
8109 public:
8110  rose_addr_t const& get_e_page_size() const;
8111  void set_e_page_size(rose_addr_t const&);
8112 
8113 public:
8114  rose_addr_t const& get_e_fixup_sect_size() const;
8115  void set_e_fixup_sect_size(rose_addr_t const&);
8116 
8117 public:
8118  rose_addr_t const& get_e_loader_sect_size() const;
8119  void set_e_loader_sect_size(rose_addr_t const&);
8120 
8121 public:
8122  rose_addr_t const& get_e_secttab_rfo() const;
8123  void set_e_secttab_rfo(rose_addr_t const&);
8124 
8125 public:
8126  rose_addr_t const& get_e_pagetab_rfo() const;
8127  void set_e_pagetab_rfo(rose_addr_t const&);
8128 
8129 public:
8130  rose_addr_t const& get_e_iterpages_offset() const;
8131  void set_e_iterpages_offset(rose_addr_t const&);
8132 
8133 public:
8134  rose_addr_t const& get_e_rsrctab_rfo() const;
8135  void set_e_rsrctab_rfo(rose_addr_t const&);
8136 
8137 public:
8138  rose_addr_t const& get_e_resnametab_rfo() const;
8139  void set_e_resnametab_rfo(rose_addr_t const&);
8140 
8141 public:
8142  rose_addr_t const& get_e_entrytab_rfo() const;
8143  void set_e_entrytab_rfo(rose_addr_t const&);
8144 
8145 public:
8146  rose_addr_t const& get_e_fmtdirtab_rfo() const;
8147  void set_e_fmtdirtab_rfo(rose_addr_t const&);
8148 
8149 public:
8150  rose_addr_t const& get_e_fixup_pagetab_rfo() const;
8151  void set_e_fixup_pagetab_rfo(rose_addr_t const&);
8152 
8153 public:
8154  rose_addr_t const& get_e_fixup_rectab_rfo() const;
8155  void set_e_fixup_rectab_rfo(rose_addr_t const&);
8156 
8157 public:
8158  rose_addr_t const& get_e_import_modtab_rfo() const;
8159  void set_e_import_modtab_rfo(rose_addr_t const&);
8160 
8161 public:
8162  rose_addr_t const& get_e_import_proctab_rfo() const;
8163  void set_e_import_proctab_rfo(rose_addr_t const&);
8164 
8165 public:
8166  rose_addr_t const& get_e_ppcksumtab_rfo() const;
8167  void set_e_ppcksumtab_rfo(rose_addr_t const&);
8168 
8169 public:
8170  rose_addr_t const& get_e_data_pages_offset() const;
8171  void set_e_data_pages_offset(rose_addr_t const&);
8172 
8173 public:
8174  rose_addr_t const& get_e_nonresnametab_offset() const;
8175  void set_e_nonresnametab_offset(rose_addr_t const&);
8176 
8177 public:
8178  rose_addr_t const& get_e_debug_info_rfo() const;
8179  void set_e_debug_info_rfo(rose_addr_t const&);
8180 
8181 public:
8182  SgAsmDOSExtendedHeader* const& get_dos2_header() const;
8183  void set_dos2_header(SgAsmDOSExtendedHeader* const&);
8184 
8185 public:
8186  SgAsmLESectionTable* const& get_section_table() const;
8187  void set_section_table(SgAsmLESectionTable* const&);
8188 
8189 public:
8190  SgAsmLEPageTable* const& get_page_table() const;
8191  void set_page_table(SgAsmLEPageTable* const&);
8192 
8193 public:
8194  SgAsmLENameTable* const& get_resname_table() const;
8195  void set_resname_table(SgAsmLENameTable* const&);
8196 
8197 public:
8198  SgAsmLENameTable* const& get_nonresname_table() const;
8199  void set_nonresname_table(SgAsmLENameTable* const&);
8200 
8201 public:
8202  SgAsmLEEntryTable* const& get_entry_table() const;
8203  void set_entry_table(SgAsmLEEntryTable* const&);
8204 
8205 public:
8206  SgAsmLERelocTable* const& get_reloc_table() const;
8207  void set_reloc_table(SgAsmLERelocTable* const&);
8209  // Functions
8211 public:
8212  SgAsmLEFileHeader(SgAsmGenericFile *f, rose_addr_t offset);
8213  virtual void unparse(std::ostream&) const override;
8214  virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
8215 
8216  // Overloaded base class virtual function
8217  const char *format_name() const override;
8218 
8219  static bool is_LE (SgAsmGenericFile*);
8220  static SgAsmLEFileHeader *parse(SgAsmDOSFileHeader*);
8221 
8222 private:
8223  void *encode(Rose::BinaryAnalysis::ByteOrder::Endianness sex, SgAsmLEFileHeader::LEFileHeader_disk*) const;
8224 public:
8226  virtual ~SgAsmLEFileHeader();
8227 
8228 public:
8231 
8232 protected:
8239  void initializeProperties();
8240 #endif // SgAsmLEFileHeader_OTHERS
8241 #ifdef DOCUMENTATION
8242 };
8243 #endif // DOCUMENTATION
8244 
8245 
8247 // SgAsmLEEntryTable -- MACHINE GENERATED; DO NOT MODIFY --
8249 
8250 DECLARE_LEAF_CLASS(AsmLEEntryTable);
8251 IS_SERIALIZABLE(AsmLEEntryTable);
8252 
8253 #ifdef DOCUMENTATION
8255 #endif // DOCUMENTATION
8256 
8257 #ifndef DOCUMENTATION
8258  AsmLEEntryTable.setDataPrototype(
8259  "SgSizeTList", "bundle_sizes", "",
8260  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
8261 #endif // !DOCUMENTATION
8262 
8263 #ifndef DOCUMENTATION
8264  AsmLEEntryTable.setDataPrototype(
8265  "SgAsmLEEntryPointPtrList", "entries", "",
8266  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
8267 #endif // !DOCUMENTATION
8268 
8269  DECLARE_OTHERS(AsmLEEntryTable);
8270 #if defined(SgAsmLEEntryTable_OTHERS) || defined(DOCUMENTATION)
8271 
8272  //----------------------- Boost serialization for SgAsmLEEntryTable -----------------------
8273 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
8274 private:
8275  friend class boost::serialization::access;
8276 
8277  template<class S>
8278  void serialize(S &s, const unsigned /*version*/) {
8279  debugSerializationBegin("SgAsmLEEntryTable");
8280  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmGenericSection);
8281  s & BOOST_SERIALIZATION_NVP(p_bundle_sizes);
8282  s & BOOST_SERIALIZATION_NVP(p_entries);
8283  debugSerializationEnd("SgAsmLEEntryTable");
8284  }
8285 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
8286 
8287 public:
8288  SgSizeTList const& get_bundle_sizes() const;
8289  void set_bundle_sizes(SgSizeTList const&);
8290 
8291 public:
8292  SgAsmLEEntryPointPtrList const& get_entries() const;
8293  SgAsmLEEntryPointPtrList& get_entries();
8294  void set_entries(SgAsmLEEntryPointPtrList const&);
8295 public:
8296  SgAsmLEEntryTable(SgAsmLEFileHeader *fhdr, rose_addr_t offset);
8297  virtual void unparse(std::ostream&) const override;
8298  virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
8299 public:
8301  virtual ~SgAsmLEEntryTable();
8302 
8303 public:
8306 
8307 protected:
8314  void initializeProperties();
8315 #endif // SgAsmLEEntryTable_OTHERS
8316 #ifdef DOCUMENTATION
8317 };
8318 #endif // DOCUMENTATION
8319 
8320 
8322 // SgAsmLEEntryPoint -- MACHINE GENERATED; DO NOT MODIFY --
8324 
8325 DECLARE_LEAF_CLASS(AsmLEEntryPoint);
8326 IS_SERIALIZABLE(AsmLEEntryPoint);
8327 
8328 DECLARE_HEADERS(AsmLEEntryPoint);
8329 #if defined(SgAsmLEEntryPoint_HEADERS) || defined(DOCUMENTATION)
8330 #include <Rose/BinaryAnalysis/ByteOrder.h>
8331 #endif // SgAsmLEEntryPoint_HEADERS
8332 
8333 #ifdef DOCUMENTATION
8335 #endif // DOCUMENTATION
8336 
8337 #ifndef DOCUMENTATION
8338  AsmLEEntryPoint.setDataPrototype(
8339  "SgAsmLEEntryPointPtrList", "entries", "",
8340  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
8341 #endif // !DOCUMENTATION
8342 
8343 #ifndef DOCUMENTATION
8344  AsmLEEntryPoint.setDataPrototype(
8345  "unsigned", "flags", "= 0",
8346  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
8347 #endif // !DOCUMENTATION
8348 
8349 #ifndef DOCUMENTATION
8350  AsmLEEntryPoint.setDataPrototype(
8351  "unsigned", "objnum", "= 0",
8352  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
8353 #endif // !DOCUMENTATION
8354 
8355 #ifndef DOCUMENTATION
8356  AsmLEEntryPoint.setDataPrototype(
8357  "unsigned", "entry_type", "= 0",
8358  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
8359 #endif // !DOCUMENTATION
8360 
8361 #ifndef DOCUMENTATION
8362  AsmLEEntryPoint.setDataPrototype(
8363  "unsigned", "res1", "= 0",
8364  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
8365 #endif // !DOCUMENTATION
8366 
8367 #ifndef DOCUMENTATION
8368  AsmLEEntryPoint.setDataPrototype(
8369  "rose_addr_t", "entry_offset", "= 0",
8370  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
8371 #endif // !DOCUMENTATION
8372 
8373  DECLARE_OTHERS(AsmLEEntryPoint);
8374 #if defined(SgAsmLEEntryPoint_OTHERS) || defined(DOCUMENTATION)
8375 
8376  //----------------------- Boost serialization for SgAsmLEEntryPoint -----------------------
8377 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
8378 private:
8379  friend class boost::serialization::access;
8380 
8381  template<class S>
8382  void serialize(S &s, const unsigned /*version*/) {
8383  debugSerializationBegin("SgAsmLEEntryPoint");
8384  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
8385  s & BOOST_SERIALIZATION_NVP(p_entries);
8386  s & BOOST_SERIALIZATION_NVP(p_flags);
8387  s & BOOST_SERIALIZATION_NVP(p_objnum);
8388  s & BOOST_SERIALIZATION_NVP(p_entry_type);
8389  s & BOOST_SERIALIZATION_NVP(p_res1);
8390  s & BOOST_SERIALIZATION_NVP(p_entry_offset);
8391  debugSerializationEnd("SgAsmLEEntryPoint");
8392  }
8393 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
8394  // Local types
8397 public:
8398 #ifdef _MSC_VER
8399 # pragma pack (1)
8400 #endif
8401  /* 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
8402  * next entry point description follows immediately after the flag. */
8404  uint8_t flags; /* 0x00 Bit flags (0x01=>non-empty bundle; 0x02=>32-bit entry*/
8405  uint16_t objnum; /* 0x01 Object number */
8406  uint8_t entry_type; /* 0x03 Flags for entry type */
8407  uint32_t entry_offset; /* 0x04 Offset of entry point */
8408  uint16_t res1; /* 0x08 Reserved */
8409  } /* 0x0a */
8410 // DQ (3/7/2013): Adding support to restrict visability to SWIG.
8411 #ifndef SWIG
8412 #ifndef _MSC_VER
8413  __attribute__((packed))
8414 #endif
8415 #endif
8416  ;
8417 #ifdef _MSC_VER
8418 # pragma pack ()
8419 #endif
8420 
8422  // Properties
8424 public:
8425  SgAsmLEEntryPointPtrList const& get_entries() const;
8426  SgAsmLEEntryPointPtrList& get_entries();
8427  void set_entries(SgAsmLEEntryPointPtrList const&);
8428 
8429 public:
8430  unsigned const& get_flags() const;
8431  void set_flags(unsigned const&);
8432 
8433 public:
8434  unsigned const& get_objnum() const;
8435  void set_objnum(unsigned const&);
8436 
8437 public:
8438  unsigned const& get_entry_type() const;
8439  void set_entry_type(unsigned const&);
8440 
8441 public:
8442  unsigned const& get_res1() const;
8443  void set_res1(unsigned const&);
8444 
8445 public:
8446  rose_addr_t const& get_entry_offset() const;
8447  void set_entry_offset(rose_addr_t const&);
8449  // Functions
8451 public:
8452  SgAsmLEEntryPoint(Rose::BinaryAnalysis::ByteOrder::Endianness sex, const SgAsmLEEntryPoint::LEEntryPoint_disk *disk);
8453  SgAsmLEEntryPoint(Rose::BinaryAnalysis::ByteOrder::Endianness sex, unsigned flags);
8454  rose_addr_t unparse(std::ostream&, Rose::BinaryAnalysis::ByteOrder::Endianness, const SgAsmGenericSection*,
8455  rose_addr_t spos) const;
8456  void dump(FILE*, const char *prefix, ssize_t idx) const;
8457 public:
8459  virtual ~SgAsmLEEntryPoint();
8460 
8461 public:
8464 
8465 protected:
8472  void initializeProperties();
8473 #endif // SgAsmLEEntryPoint_OTHERS
8474 #ifdef DOCUMENTATION
8475 };
8476 #endif // DOCUMENTATION
8477 
8478 
8480 // SgAsmJvmStackMapVerificationType -- MACHINE GENERATED; DO NOT MODIFY --
8482 
8483 DECLARE_LEAF_CLASS(AsmJvmStackMapVerificationType);
8484 IS_SERIALIZABLE(AsmJvmStackMapVerificationType);
8485 
8486 #ifdef DOCUMENTATION
8487 
8491 #endif // DOCUMENTATION
8492 
8493 #ifndef DOCUMENTATION
8494  AsmJvmStackMapVerificationType.setDataPrototype(
8495  "uint8_t", "tag", "= 9",
8496  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
8497 #endif // !DOCUMENTATION
8498 
8499 #ifndef DOCUMENTATION
8500  AsmJvmStackMapVerificationType.setDataPrototype(
8501  "uint16_t", "cpool_index", "= 0",
8502  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
8503 #endif // !DOCUMENTATION
8504 
8505 #ifndef DOCUMENTATION
8506  AsmJvmStackMapVerificationType.setDataPrototype(
8507  "uint16_t", "offset", "= 0",
8508  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
8509 #endif // !DOCUMENTATION
8510 
8511  DECLARE_OTHERS(AsmJvmStackMapVerificationType);
8512 #if defined(SgAsmJvmStackMapVerificationType_OTHERS) || defined(DOCUMENTATION)
8513 
8514  //----------------------- Boost serialization for SgAsmJvmStackMapVerificationType -----------------------
8515 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
8516 private:
8517  friend class boost::serialization::access;
8518 
8519  template<class S>
8520  void serialize(S &s, const unsigned /*version*/) {
8521  debugSerializationBegin("SgAsmJvmStackMapVerificationType");
8522  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmJvmNode);
8523  s & BOOST_SERIALIZATION_NVP(p_tag);
8524  s & BOOST_SERIALIZATION_NVP(p_cpool_index);
8525  s & BOOST_SERIALIZATION_NVP(p_offset);
8526  debugSerializationEnd("SgAsmJvmStackMapVerificationType");
8527  }
8528 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
8529 private:
8534  enum verification_type_tag {
8535  ITEM_Top = 0,
8536  ITEM_Integer = 1,
8537  ITEM_Float = 2,
8538  ITEM_Double = 3,
8539  ITEM_Long = 4,
8540  ITEM_Null = 5,
8541  ITEM_UninitializedThis = 6,
8542  ITEM_Object = 7,
8543  ITEM_Uninitialized = 8
8544  };
8545 
8547  // Local types (for documentation purposes only)
8549 #ifdef DOCUMENTATION
8550 
8553  union verification_type_info {
8554  Top_variable_info;
8555  Integer_variable_info;
8556  Float_variable_info;
8557  Long_variable_info;
8558  Double_variable_info;
8559  Null_variable_info;
8560  UninitializedThis_variable_info;
8561  Object_variable_info;
8562  Uninitialized_variable_info;
8563  };
8564 
8566  struct Top_variable_info {
8567  uint8_t tag;
8568  };
8569  struct Integer_variable_info {
8570  uint8_t tag;
8571  };
8572  struct Float_variable_info {
8573  uint8_t tag;
8574  };
8575  struct Long_variable_info {
8576  uint8_t tag;
8577  };
8578  struct Double_variable_info {
8579  uint8_t tag;
8580  };
8581  struct Null_variable_info {
8582  uint8_t tag;
8583  };
8584  struct UnitializedThis_variable_info {
8585  uint8_t tag;
8586  };
8587  struct Object_variable_info {
8588  uint8_t tag;
8589  uint16_t cpool_index;
8590  };
8591  struct Unitialized_variable_info {
8592  uint8_t tag;
8593  uint16_t offset;
8594  };
8595 #endif
8596 
8598  // Properties
8600 private:
8601 public:
8607  uint8_t const& get_tag() const;
8608  void set_tag(uint8_t const&);
8610  /* Not a legal entry */
8611 public:
8617  uint16_t const& get_cpool_index() const;
8618  void set_cpool_index(uint16_t const&);
8621 public:
8627  uint16_t const& get_offset() const;
8628  void set_offset(uint16_t const&);
8630  // Functions
8633 public:
8638 
8641 
8643  virtual void unparse(std::ostream&) const override;
8644 
8646  void dump(FILE*, const char *prefix, ssize_t idx) const override;
8647 public:
8650 
8651 public:
8654 
8655 protected:
8662  void initializeProperties();
8663 #endif // SgAsmJvmStackMapVerificationType_OTHERS
8664 #ifdef DOCUMENTATION
8665 };
8666 #endif // DOCUMENTATION
8667 
8668 
8670 // SgAsmJvmStackMapTable -- MACHINE GENERATED; DO NOT MODIFY --
8672 
8673 DECLARE_LEAF_CLASS(AsmJvmStackMapTable);
8674 IS_SERIALIZABLE(AsmJvmStackMapTable);
8675 
8676 #ifdef DOCUMENTATION
8677 
8682 #endif // DOCUMENTATION
8683 
8684 #ifndef DOCUMENTATION
8685  AsmJvmStackMapTable.setDataPrototype(
8686  "SgAsmJvmStackMapFramePtrList", "entries", "",
8687  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
8688 #endif // !DOCUMENTATION
8689 
8690  DECLARE_OTHERS(AsmJvmStackMapTable);
8691 #if defined(SgAsmJvmStackMapTable_OTHERS) || defined(DOCUMENTATION)
8692 
8693  //----------------------- Boost serialization for SgAsmJvmStackMapTable -----------------------
8694 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
8695 private:
8696  friend class boost::serialization::access;
8697 
8698  template<class S>
8699  void serialize(S &s, const unsigned /*version*/) {
8700  debugSerializationBegin("SgAsmJvmStackMapTable");
8701  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmJvmAttribute);
8702  s & BOOST_SERIALIZATION_NVP(p_entries);
8703  debugSerializationEnd("SgAsmJvmStackMapTable");
8704  }
8705 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
8706 private:
8708  // Properties
8710 public:
8714  SgAsmJvmStackMapFramePtrList const& get_entries() const;
8715  SgAsmJvmStackMapFramePtrList& get_entries();
8716  void set_entries(SgAsmJvmStackMapFramePtrList const&);
8718  // Functions
8721 public:
8726 
8728  virtual SgAsmJvmStackMapTable* parse(SgAsmJvmConstantPool* pool) override;
8729 
8731  virtual void unparse(std::ostream&) const override;
8732 
8734  void dump(FILE*, const char *prefix, ssize_t idx) const override;
8735 public:
8737  virtual ~SgAsmJvmStackMapTable();
8738 
8739 public:
8742 
8743 protected:
8750  void initializeProperties();
8751 #endif // SgAsmJvmStackMapTable_OTHERS
8752 #ifdef DOCUMENTATION
8753 };
8754 #endif // DOCUMENTATION
8755 
8756 
8758 // SgAsmJvmStackMapFrame -- MACHINE GENERATED; DO NOT MODIFY --
8760 
8761 DECLARE_LEAF_CLASS(AsmJvmStackMapFrame);
8762 IS_SERIALIZABLE(AsmJvmStackMapFrame);
8763 
8764 #ifdef DOCUMENTATION
8765 
8769 #endif // DOCUMENTATION
8770 
8771 #ifndef DOCUMENTATION
8772  AsmJvmStackMapFrame.setDataPrototype(
8773  "SgAsmJvmStackMapVerificationTypePtrList", "stack", "",
8774  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
8775 #endif // !DOCUMENTATION
8776 
8777 #ifndef DOCUMENTATION
8778  AsmJvmStackMapFrame.setDataPrototype(
8779  "SgAsmJvmStackMapVerificationTypePtrList", "locals", "",
8780  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
8781 #endif // !DOCUMENTATION
8782 
8783 #ifndef DOCUMENTATION
8784  AsmJvmStackMapFrame.setDataPrototype(
8785  "uint8_t", "frame_type", "= 0",
8786  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
8787 #endif // !DOCUMENTATION
8788 
8789 #ifndef DOCUMENTATION
8790  AsmJvmStackMapFrame.setDataPrototype(
8791  "uint16_t", "offset_delta", "= 0",
8792  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
8793 #endif // !DOCUMENTATION
8794 
8795  DECLARE_OTHERS(AsmJvmStackMapFrame);
8796 #if defined(SgAsmJvmStackMapFrame_OTHERS) || defined(DOCUMENTATION)
8797 
8798  //----------------------- Boost serialization for SgAsmJvmStackMapFrame -----------------------
8799 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
8800 private:
8801  friend class boost::serialization::access;
8802 
8803  template<class S>
8804  void serialize(S &s, const unsigned /*version*/) {
8805  debugSerializationBegin("SgAsmJvmStackMapFrame");
8806  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmJvmNode);
8807  s & BOOST_SERIALIZATION_NVP(p_stack);
8808  s & BOOST_SERIALIZATION_NVP(p_locals);
8809  s & BOOST_SERIALIZATION_NVP(p_frame_type);
8810  s & BOOST_SERIALIZATION_NVP(p_offset_delta);
8811  debugSerializationEnd("SgAsmJvmStackMapFrame");
8812  }
8813 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
8814 private:
8815 public:
8819  SgAsmJvmStackMapVerificationTypePtrList const& get_stack() const;
8820  SgAsmJvmStackMapVerificationTypePtrList& get_stack();
8821  void set_stack(SgAsmJvmStackMapVerificationTypePtrList const&);
8824 public:
8828  SgAsmJvmStackMapVerificationTypePtrList const& get_locals() const;
8829  SgAsmJvmStackMapVerificationTypePtrList& get_locals();
8830  void set_locals(SgAsmJvmStackMapVerificationTypePtrList const&);
8832  // Local types (for documentation purposes only)
8835 #ifdef DOCUMENTATION
8836 
8840  same_frame;
8842  same_locals_1_stack_item_frame_extended;
8843  chop_frame;
8845  append_frame;
8846  full_frame;
8847  };
8848 
8849  struct same_frame {
8850  uint8_t frame_type; /* 0-63 */
8851  };
8853  uint8_t frame_type; /* 64-127 */
8854  verification_type_info stack;
8855  };
8857  uint8_t frame_type; /* 247 */
8858  uint16_t offset_delta;
8859  verification_type_info stack;
8860  };
8861  struct chop_frame {
8862  uint8_t frame_type; /* 248-250 */
8863  uint16_t offset_delta;
8864  };
8866  uint8_t frame_type; /* 251 */
8867  uint16_t offset_delta;
8868  };
8869  struct append_frame {
8870  uint8_t frame_type; /* 252-254 */
8871  uint16_t offset_delta;
8872  verification_type_info stack;
8873  };
8874  struct full_frame {
8875  uint8_t frame_type; /* 252-254 */
8876  uint16_t offset_delta;
8877  uint16_t number_of_locals;
8878  verification_type_info stack[number_of_locals];
8879  uint16_t number_of_stack_items;
8880  verification_type_info stack[number_of_stack_items];
8881  };
8882 #endif
8883 
8885  // Properties
8887 private:
8888 public:
8894  uint8_t const& get_frame_type() const;
8895  void set_frame_type(uint8_t const&);
8898 public:
8904  uint16_t const& get_offset_delta() const;
8905  void set_offset_delta(uint16_t const&);
8907  // Functions
8910 public:
8915 
8918 
8920  virtual void unparse(std::ostream&) const override;
8921 
8923  void dump(FILE*, const char *prefix, ssize_t idx) const override;
8924 public:
8926  virtual ~SgAsmJvmStackMapFrame();
8927 
8928 public:
8931 
8932 protected:
8939  void initializeProperties();
8940 #endif // SgAsmJvmStackMapFrame_OTHERS
8941 #ifdef DOCUMENTATION
8942 };
8943 #endif // DOCUMENTATION
8944 
8945 
8947 // SgAsmJvmSourceFile -- MACHINE GENERATED; DO NOT MODIFY --
8949 
8950 DECLARE_LEAF_CLASS(AsmJvmSourceFile);
8951 IS_SERIALIZABLE(AsmJvmSourceFile);
8952 
8953 #ifdef DOCUMENTATION
8954 
8958 #endif // DOCUMENTATION
8959 
8960 #ifndef DOCUMENTATION
8961  AsmJvmSourceFile.setDataPrototype(
8962  "uint16_t", "sourcefile_index", "= 0",
8963  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
8964 #endif // !DOCUMENTATION
8965 
8966  DECLARE_OTHERS(AsmJvmSourceFile);
8967 #if defined(SgAsmJvmSourceFile_OTHERS) || defined(DOCUMENTATION)
8968 
8969  //----------------------- Boost serialization for SgAsmJvmSourceFile -----------------------
8970 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
8971 private:
8972  friend class boost::serialization::access;
8973 
8974  template<class S>
8975  void serialize(S &s, const unsigned /*version*/) {
8976  debugSerializationBegin("SgAsmJvmSourceFile");
8977  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmJvmAttribute);
8978  s & BOOST_SERIALIZATION_NVP(p_sourcefile_index);
8979  debugSerializationEnd("SgAsmJvmSourceFile");
8980  }
8981 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
8982 
8983 public:
8989  uint16_t const& get_sourcefile_index() const;
8990  void set_sourcefile_index(uint16_t const&);
8992 public:
8996  explicit SgAsmJvmSourceFile(SgAsmJvmAttributeTable* table);
8997 
8999  virtual SgAsmJvmAttribute* parse(SgAsmJvmConstantPool* pool) override;
9000 
9002  virtual void unparse(std::ostream&) const override;
9003 
9005  virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
9006 public:
9008  virtual ~SgAsmJvmSourceFile();
9009 
9010 public:
9013 
9014 protected:
9021  void initializeProperties();
9022 #endif // SgAsmJvmSourceFile_OTHERS
9023 #ifdef DOCUMENTATION
9024 };
9025 #endif // DOCUMENTATION
9026 
9027 
9029 // SgAsmJvmSignature -- MACHINE GENERATED; DO NOT MODIFY --
9031 
9032 DECLARE_LEAF_CLASS(AsmJvmSignature);
9033 IS_SERIALIZABLE(AsmJvmSignature);
9034 
9035 #ifdef DOCUMENTATION
9036 
9041 #endif // DOCUMENTATION
9042 
9043 #ifndef DOCUMENTATION
9044  AsmJvmSignature.setDataPrototype(
9045  "uint16_t", "signature_index", "= 0",
9046  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
9047 #endif // !DOCUMENTATION
9048 
9049  DECLARE_OTHERS(AsmJvmSignature);
9050 #if defined(SgAsmJvmSignature_OTHERS) || defined(DOCUMENTATION)
9051 
9052  //----------------------- Boost serialization for SgAsmJvmSignature -----------------------
9053 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
9054 private:
9055  friend class boost::serialization::access;
9056 
9057  template<class S>
9058  void serialize(S &s, const unsigned /*version*/) {
9059  debugSerializationBegin("SgAsmJvmSignature");
9060  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmJvmAttribute);
9061  s & BOOST_SERIALIZATION_NVP(p_signature_index);
9062  debugSerializationEnd("SgAsmJvmSignature");
9063  }
9064 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
9065 
9066 public:
9072  uint16_t const& get_signature_index() const;
9073  void set_signature_index(uint16_t const&);
9075 public:
9079  explicit SgAsmJvmSignature(SgAsmJvmAttributeTable* table);
9080 
9082  virtual SgAsmJvmAttribute* parse(SgAsmJvmConstantPool* pool) override;
9083 
9085  virtual void unparse(std::ostream&) const override;
9086 
9088  virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
9089 public:
9091  virtual ~SgAsmJvmSignature();
9092 
9093 public:
9096 
9097 protected:
9104  void initializeProperties();
9105 #endif // SgAsmJvmSignature_OTHERS
9106 #ifdef DOCUMENTATION
9107 };
9108 #endif // DOCUMENTATION
9109 
9110 
9112 // SgAsmJvmNestMembers -- MACHINE GENERATED; DO NOT MODIFY --
9114 
9115 DECLARE_LEAF_CLASS(AsmJvmNestMembers);
9116 IS_SERIALIZABLE(AsmJvmNestMembers);
9117 
9118 #ifdef DOCUMENTATION
9119 
9125 #endif // DOCUMENTATION
9126 
9127 #ifndef DOCUMENTATION
9128  AsmJvmNestMembers.setDataPrototype(
9129  "SgUnsigned16List", "classes", "",
9130  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
9131 #endif // !DOCUMENTATION
9132 
9133  DECLARE_OTHERS(AsmJvmNestMembers);
9134 #if defined(SgAsmJvmNestMembers_OTHERS) || defined(DOCUMENTATION)
9135 
9136  //----------------------- Boost serialization for SgAsmJvmNestMembers -----------------------
9137 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
9138 private:
9139  friend class boost::serialization::access;
9140 
9141  template<class S>
9142  void serialize(S &s, const unsigned /*version*/) {
9143  debugSerializationBegin("SgAsmJvmNestMembers");
9144  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmJvmAttribute);
9145  s & BOOST_SERIALIZATION_NVP(p_classes);
9146  debugSerializationEnd("SgAsmJvmNestMembers");
9147  }
9148 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
9149 
9150 public:
9159  SgUnsigned16List const& get_classes() const;
9160  void set_classes(SgUnsigned16List const&);
9162 public:
9167 
9169  virtual SgAsmJvmNestMembers* parse(SgAsmJvmConstantPool* pool) override;
9170 
9172  virtual void unparse(std::ostream&) const override;
9173 
9175  virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
9176 public:
9178  virtual ~SgAsmJvmNestMembers();
9179 
9180 public:
9183 
9184 protected:
9191  void initializeProperties();
9192 #endif // SgAsmJvmNestMembers_OTHERS
9193 #ifdef DOCUMENTATION
9194 };
9195 #endif // DOCUMENTATION
9196 
9197 
9199 // SgAsmJvmNestHost -- MACHINE GENERATED; DO NOT MODIFY --
9201 
9202 DECLARE_LEAF_CLASS(AsmJvmNestHost);
9203 IS_SERIALIZABLE(AsmJvmNestHost);
9204 
9205 #ifdef DOCUMENTATION
9206 
9211 #endif // DOCUMENTATION
9212 
9213 #ifndef DOCUMENTATION
9214  AsmJvmNestHost.setDataPrototype(
9215  "uint16_t", "host_class_index", "= 0",
9216  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
9217 #endif // !DOCUMENTATION
9218 
9219  DECLARE_OTHERS(AsmJvmNestHost);
9220 #if defined(SgAsmJvmNestHost_OTHERS) || defined(DOCUMENTATION)
9221 
9222  //----------------------- Boost serialization for SgAsmJvmNestHost -----------------------
9223 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
9224 private:
9225  friend class boost::serialization::access;
9226 
9227  template<class S>
9228  void serialize(S &s, const unsigned /*version*/) {
9229  debugSerializationBegin("SgAsmJvmNestHost");
9230  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmJvmAttribute);
9231  s & BOOST_SERIALIZATION_NVP(p_host_class_index);
9232  debugSerializationEnd("SgAsmJvmNestHost");
9233  }
9234 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
9235 
9236 public:
9245  uint16_t const& get_host_class_index() const;
9246  void set_host_class_index(uint16_t const&);
9248 public:
9252  explicit SgAsmJvmNestHost(SgAsmJvmAttributeTable* table);
9253 
9255  virtual SgAsmJvmNestHost* parse(SgAsmJvmConstantPool* pool) override;
9256 
9258  virtual void unparse(std::ostream&) const override;
9259 
9261  virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
9262 public:
9264  virtual ~SgAsmJvmNestHost();
9265 
9266 public:
9268  SgAsmJvmNestHost();
9269 
9270 protected:
9277  void initializeProperties();
9278 #endif // SgAsmJvmNestHost_OTHERS
9279 #ifdef DOCUMENTATION
9280 };
9281 #endif // DOCUMENTATION
9282 
9283 
9285 // SgAsmJvmModuleMainClass -- MACHINE GENERATED; DO NOT MODIFY --
9287 
9288 DECLARE_LEAF_CLASS(AsmJvmModuleMainClass);
9289 IS_SERIALIZABLE(AsmJvmModuleMainClass);
9290 
9291 #ifdef DOCUMENTATION
9292 
9297 #endif // DOCUMENTATION
9298 
9299 #ifndef DOCUMENTATION
9300  AsmJvmModuleMainClass.setDataPrototype(
9301  "uint16_t", "main_class_index", "= 0",
9302  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
9303 #endif // !DOCUMENTATION
9304 
9305  DECLARE_OTHERS(AsmJvmModuleMainClass);
9306 #if defined(SgAsmJvmModuleMainClass_OTHERS) || defined(DOCUMENTATION)
9307 
9308  //----------------------- Boost serialization for SgAsmJvmModuleMainClass -----------------------
9309 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
9310 private:
9311  friend class boost::serialization::access;
9312 
9313  template<class S>
9314  void serialize(S &s, const unsigned /*version*/) {
9315  debugSerializationBegin("SgAsmJvmModuleMainClass");
9316  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmJvmAttribute);
9317  s & BOOST_SERIALIZATION_NVP(p_main_class_index);
9318  debugSerializationEnd("SgAsmJvmModuleMainClass");
9319  }
9320 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
9321 
9322 public:
9328  uint16_t const& get_main_class_index() const;
9329  void set_main_class_index(uint16_t const&);
9331 public:
9336 
9338  virtual SgAsmJvmAttribute* parse(SgAsmJvmConstantPool* pool) override;
9339 
9341  virtual void unparse(std::ostream&) const override;
9342 
9344  virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
9345 public:
9347  virtual ~SgAsmJvmModuleMainClass();
9348 
9349 public:
9352 
9353 protected:
9360  void initializeProperties();
9361 #endif // SgAsmJvmModuleMainClass_OTHERS
9362 #ifdef DOCUMENTATION
9363 };
9364 #endif // DOCUMENTATION
9365 
9366 
9368 // SgAsmJvmMethodTable -- MACHINE GENERATED; DO NOT MODIFY --
9370 
9371 DECLARE_LEAF_CLASS(AsmJvmMethodTable);
9372 IS_SERIALIZABLE(AsmJvmMethodTable);
9373 
9374 #ifdef DOCUMENTATION
9375 
9381 #endif // DOCUMENTATION
9382 
9383 #ifndef DOCUMENTATION
9384  AsmJvmMethodTable.setDataPrototype(
9385  "SgAsmJvmMethodPtrList", "methods", "",
9386  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
9387 #endif // !DOCUMENTATION
9388 
9389  DECLARE_OTHERS(AsmJvmMethodTable);
9390 #if defined(SgAsmJvmMethodTable_OTHERS) || defined(DOCUMENTATION)
9391 
9392  //----------------------- Boost serialization for SgAsmJvmMethodTable -----------------------
9393 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
9394 private:
9395  friend class boost::serialization::access;
9396 
9397  template<class S>
9398  void serialize(S &s, const unsigned /*version*/) {
9399  debugSerializationBegin("SgAsmJvmMethodTable");
9400  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmGenericSection);
9401  s & BOOST_SERIALIZATION_NVP(p_methods);
9402  debugSerializationEnd("SgAsmJvmMethodTable");
9403  }
9404 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
9405 
9406 public:
9410  SgAsmJvmMethodPtrList const& get_methods() const;
9411  SgAsmJvmMethodPtrList& get_methods();
9412  void set_methods(SgAsmJvmMethodPtrList const&);
9414 public:
9419 
9424  virtual SgAsmJvmMethodTable* parse() override;
9425 
9427  virtual void unparse(std::ostream&) const override;
9428 
9430  virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
9431 public:
9433  virtual ~SgAsmJvmMethodTable();
9434 
9435 public:
9438 
9439 protected:
9446  void initializeProperties();
9447 #endif // SgAsmJvmMethodTable_OTHERS
9448 #ifdef DOCUMENTATION
9449 };
9450 #endif // DOCUMENTATION
9451 
9452 
9454 // SgAsmJvmMethod -- MACHINE GENERATED; DO NOT MODIFY --
9456 
9457 DECLARE_LEAF_CLASS(AsmJvmMethod);
9458 IS_SERIALIZABLE(AsmJvmMethod);
9459 
9460 #ifdef DOCUMENTATION
9461 
9466 #endif // DOCUMENTATION
9467 
9468 #ifndef DOCUMENTATION
9469  AsmJvmMethod.setDataPrototype(
9470  "uint16_t", "access_flags", "= 0",
9471  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
9472 #endif // !DOCUMENTATION
9473 
9474 #ifndef DOCUMENTATION
9475  AsmJvmMethod.setDataPrototype(
9476  "uint16_t", "name_index", "= 0",
9477  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
9478 #endif // !DOCUMENTATION
9479 
9480 #ifndef DOCUMENTATION
9481  AsmJvmMethod.setDataPrototype(
9482  "uint16_t", "descriptor_index", "= 0",
9483  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
9484 #endif // !DOCUMENTATION
9485 
9486 #ifndef DOCUMENTATION
9487  AsmJvmMethod.setDataPrototype(
9488  "SgAsmJvmAttributeTable*", "attribute_table", "= nullptr",
9489  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
9490 #endif // !DOCUMENTATION
9491 
9492 #ifndef DOCUMENTATION
9493  AsmJvmMethod.setDataPrototype(
9494  "SgAsmInstructionList*", "instruction_list", "= createAndParent<SgAsmInstructionList>(this)",
9495  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
9496 #endif // !DOCUMENTATION
9497 
9498  DECLARE_OTHERS(AsmJvmMethod);
9499 #if defined(SgAsmJvmMethod_OTHERS) || defined(DOCUMENTATION)
9500 
9501  //----------------------- Boost serialization for SgAsmJvmMethod -----------------------
9502 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
9503 private:
9504  friend class boost::serialization::access;
9505 
9506  template<class S>
9507  void serialize(S &s, const unsigned /*version*/) {
9508  debugSerializationBegin("SgAsmJvmMethod");
9509  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmJvmNode);
9510  s & BOOST_SERIALIZATION_NVP(p_access_flags);
9511  s & BOOST_SERIALIZATION_NVP(p_name_index);
9512  s & BOOST_SERIALIZATION_NVP(p_descriptor_index);
9513  s & BOOST_SERIALIZATION_NVP(p_attribute_table);
9514  s & BOOST_SERIALIZATION_NVP(p_instruction_list);
9515  debugSerializationEnd("SgAsmJvmMethod");
9516  }
9517 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
9518 
9519 public:
9526  uint16_t const& get_access_flags() const;
9527  void set_access_flags(uint16_t const&);
9530 public:
9536  uint16_t const& get_name_index() const;
9537  void set_name_index(uint16_t const&);
9540 public:
9546  uint16_t const& get_descriptor_index() const;
9547  void set_descriptor_index(uint16_t const&);
9550 public:
9558 public:
9567 public:
9572 
9575 
9577  virtual void unparse(std::ostream&) const override;
9578 
9580  void dump(FILE*, const char *prefix, ssize_t idx) const override;
9581 public:
9583  virtual ~SgAsmJvmMethod();
9584 
9585 public:
9587  SgAsmJvmMethod();
9588 
9589 protected:
9596  void initializeProperties();
9597 #endif // SgAsmJvmMethod_OTHERS
9598 #ifdef DOCUMENTATION
9599 };
9600 #endif // DOCUMENTATION
9601 
9602 
9604 // SgAsmJvmLineNumberTable -- MACHINE GENERATED; DO NOT MODIFY --
9606 
9607 DECLARE_LEAF_CLASS(AsmJvmLineNumberTable);
9608 IS_SERIALIZABLE(AsmJvmLineNumberTable);
9609 
9610 #ifdef DOCUMENTATION
9611 
9617 #endif // DOCUMENTATION
9618 
9619 #ifndef DOCUMENTATION
9620  AsmJvmLineNumberTable.setDataPrototype(
9621  "SgAsmJvmLineNumberEntryPtrList", "line_number_table", "",
9622  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
9623 #endif // !DOCUMENTATION
9624 
9625  DECLARE_OTHERS(AsmJvmLineNumberTable);
9626 #if defined(SgAsmJvmLineNumberTable_OTHERS) || defined(DOCUMENTATION)
9627 
9628  //----------------------- Boost serialization for SgAsmJvmLineNumberTable -----------------------
9629 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
9630 private:
9631  friend class boost::serialization::access;
9632 
9633  template<class S>
9634  void serialize(S &s, const unsigned /*version*/) {
9635  debugSerializationBegin("SgAsmJvmLineNumberTable");
9636  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmJvmAttribute);
9637  s & BOOST_SERIALIZATION_NVP(p_line_number_table);
9638  debugSerializationEnd("SgAsmJvmLineNumberTable");
9639  }
9640 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
9641 
9642 public:
9648  SgAsmJvmLineNumberEntryPtrList const& get_line_number_table() const;
9649  SgAsmJvmLineNumberEntryPtrList& get_line_number_table();
9650  void set_line_number_table(SgAsmJvmLineNumberEntryPtrList const&);
9652 public:
9657 
9659  virtual SgAsmJvmLineNumberTable* parse(SgAsmJvmConstantPool* pool) override;
9660 
9662  virtual void unparse(std::ostream&) const override;
9663 
9665  virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
9666 public:
9668  virtual ~SgAsmJvmLineNumberTable();
9669 
9670 public:
9673 
9674 protected:
9681  void initializeProperties();
9682 #endif // SgAsmJvmLineNumberTable_OTHERS
9683 #ifdef DOCUMENTATION
9684 };
9685 #endif // DOCUMENTATION
9686 
9687 
9689 // SgAsmJvmLineNumberEntry -- MACHINE GENERATED; DO NOT MODIFY --
9691 
9692 DECLARE_LEAF_CLASS(AsmJvmLineNumberEntry);
9693 IS_SERIALIZABLE(AsmJvmLineNumberEntry);
9694 
9695 #ifdef DOCUMENTATION
9696 
9700 #endif // DOCUMENTATION
9701 
9702 #ifndef DOCUMENTATION
9703  AsmJvmLineNumberEntry.setDataPrototype(
9704  "uint16_t", "start_pc", "= 0",
9705  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
9706 #endif // !DOCUMENTATION
9707 
9708 #ifndef DOCUMENTATION
9709  AsmJvmLineNumberEntry.setDataPrototype(
9710  "uint16_t", "line_number", "= 0",
9711  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
9712 #endif // !DOCUMENTATION
9713 
9714  DECLARE_OTHERS(AsmJvmLineNumberEntry);
9715 #if defined(SgAsmJvmLineNumberEntry_OTHERS) || defined(DOCUMENTATION)
9716 
9717  //----------------------- Boost serialization for SgAsmJvmLineNumberEntry -----------------------
9718 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
9719 private:
9720  friend class boost::serialization::access;
9721 
9722  template<class S>
9723  void serialize(S &s, const unsigned /*version*/) {
9724  debugSerializationBegin("SgAsmJvmLineNumberEntry");
9725  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmJvmNode);
9726  s & BOOST_SERIALIZATION_NVP(p_start_pc);
9727  s & BOOST_SERIALIZATION_NVP(p_line_number);
9728  debugSerializationEnd("SgAsmJvmLineNumberEntry");
9729  }
9730 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
9731 
9732 public:
9738  uint16_t const& get_start_pc() const;
9739  void set_start_pc(uint16_t const&);
9742 public:
9748  uint16_t const& get_line_number() const;
9749  void set_line_number(uint16_t const&);
9751  public:
9756 
9759 
9761  virtual void unparse(std::ostream&) const override;
9762 
9764  void dump(FILE*, const char *prefix, ssize_t idx) const override;
9765 public:
9767  virtual ~SgAsmJvmLineNumberEntry();
9768 
9769 public:
9772 
9773 protected:
9780  void initializeProperties();
9781 #endif // SgAsmJvmLineNumberEntry_OTHERS
9782 #ifdef DOCUMENTATION
9783 };
9784 #endif // DOCUMENTATION
9785 
9786 
9788 // SgAsmJvmInstruction -- MACHINE GENERATED; DO NOT MODIFY --
9790 
9791 DECLARE_LEAF_CLASS(AsmJvmInstruction);
9792 IS_SERIALIZABLE(AsmJvmInstruction);
9793 
9794 DECLARE_HEADERS(AsmJvmInstruction);
9795 #if defined(SgAsmJvmInstruction_HEADERS) || defined(DOCUMENTATION)
9796 #include <Rose/BinaryAnalysis/InstructionEnumsJvm.h>
9797 #endif // SgAsmJvmInstruction_HEADERS
9798 
9799 #ifdef DOCUMENTATION
9800 
9802 #endif // DOCUMENTATION
9803 
9804 #ifndef DOCUMENTATION
9805  AsmJvmInstruction.setDataPrototype(
9806  "Rose::BinaryAnalysis::JvmInstructionKind", "kind", "= Rose::BinaryAnalysis::JvmInstructionKind::unknown",
9807  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
9808 #endif // !DOCUMENTATION
9809 
9810  DECLARE_OTHERS(AsmJvmInstruction);
9811 #if defined(SgAsmJvmInstruction_OTHERS) || defined(DOCUMENTATION)
9812 
9813  //----------------------- Boost serialization for SgAsmJvmInstruction -----------------------
9814 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
9815 private:
9816  friend class boost::serialization::access;
9817 
9818  template<class S>
9819  void serialize(S &s, const unsigned /*version*/) {
9820  debugSerializationBegin("SgAsmJvmInstruction");
9821  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmInstruction);
9822  s & BOOST_SERIALIZATION_NVP(p_kind);
9823  debugSerializationEnd("SgAsmJvmInstruction");
9824  }
9825 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
9826 
9827 public:
9837 public:
9838  // Overrides are documented in the base class
9839  virtual std::string description() const override;
9840  virtual bool terminatesBasicBlock() override;
9841  virtual bool isFunctionCallFast(const std::vector<SgAsmInstruction*> &insns,
9842  rose_addr_t *target/*out*/, rose_addr_t *ret/*out*/) override;
9843  virtual bool isFunctionCallSlow(const std::vector<SgAsmInstruction*>&,
9844  rose_addr_t *target, rose_addr_t *ret) override;
9845  virtual bool isFunctionReturnFast(const std::vector<SgAsmInstruction*> &insns) override;
9846  virtual bool isFunctionReturnSlow(const std::vector<SgAsmInstruction*> &insns) override;
9847  virtual Rose::BinaryAnalysis::AddressSet getSuccessors(bool &complete) override;
9848  virtual bool isUnknown() const override;
9849  virtual Sawyer::Optional<rose_addr_t> branchTarget() override;
9850  virtual unsigned get_anyKind() const override;
9851 public:
9853  virtual ~SgAsmJvmInstruction();
9854 
9855 public:
9858 
9859 public:
9861  SgAsmJvmInstruction(rose_addr_t const& address,
9862  std::string const& mnemonic,
9864 
9865 protected:
9872  void initializeProperties();
9873 #endif // SgAsmJvmInstruction_OTHERS
9874 #ifdef DOCUMENTATION
9875 };
9876 #endif // DOCUMENTATION
9877 
9878 
9880 // SgAsmJvmInnerClasses -- MACHINE GENERATED; DO NOT MODIFY --
9882 
9883 DECLARE_LEAF_CLASS(AsmJvmInnerClasses);
9884 IS_SERIALIZABLE(AsmJvmInnerClasses);
9885 
9886 #ifdef DOCUMENTATION
9887 
9893 #endif // DOCUMENTATION
9894 
9895 #ifndef DOCUMENTATION
9896  AsmJvmInnerClasses.setDataPrototype(
9897  "SgAsmJvmInnerClassesEntryPtrList", "classes", "",
9898  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
9899 #endif // !DOCUMENTATION
9900 
9901  DECLARE_OTHERS(AsmJvmInnerClasses);
9902 #if defined(SgAsmJvmInnerClasses_OTHERS) || defined(DOCUMENTATION)
9903 
9904  //----------------------- Boost serialization for SgAsmJvmInnerClasses -----------------------
9905 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
9906 private:
9907  friend class boost::serialization::access;
9908 
9909  template<class S>
9910  void serialize(S &s, const unsigned /*version*/) {
9911  debugSerializationBegin("SgAsmJvmInnerClasses");
9912  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmJvmAttribute);
9913  s & BOOST_SERIALIZATION_NVP(p_classes);
9914  debugSerializationEnd("SgAsmJvmInnerClasses");
9915  }
9916 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
9917 
9918 public:
9922  SgAsmJvmInnerClassesEntryPtrList const& get_classes() const;
9923  SgAsmJvmInnerClassesEntryPtrList& get_classes();
9924  void set_classes(SgAsmJvmInnerClassesEntryPtrList const&);
9926 public:
9931 
9937 
9939  virtual void unparse(std::ostream&) const override;
9940 
9942  virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
9943 public:
9945  virtual ~SgAsmJvmInnerClasses();
9946 
9947 public:
9950 
9951 protected:
9958  void initializeProperties();
9959 #endif // SgAsmJvmInnerClasses_OTHERS
9960 #ifdef DOCUMENTATION
9961 };
9962 #endif // DOCUMENTATION
9963 
9964 
9966 // SgAsmJvmInnerClassesEntry -- MACHINE GENERATED; DO NOT MODIFY --
9968 
9969 DECLARE_LEAF_CLASS(AsmJvmInnerClassesEntry);
9970 IS_SERIALIZABLE(AsmJvmInnerClassesEntry);
9971 
9972 #ifdef DOCUMENTATION
9973 
9978 #endif // DOCUMENTATION
9979 
9980 #ifndef DOCUMENTATION
9981  AsmJvmInnerClassesEntry.setDataPrototype(
9982  "uint16_t", "inner_class_info_index", "= 0",
9983  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
9984 #endif // !DOCUMENTATION
9985 
9986 #ifndef DOCUMENTATION
9987  AsmJvmInnerClassesEntry.setDataPrototype(
9988  "uint16_t", "outer_class_info_index", "= 0",
9989  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
9990 #endif // !DOCUMENTATION
9991 
9992 #ifndef DOCUMENTATION
9993  AsmJvmInnerClassesEntry.setDataPrototype(
9994  "uint16_t", "inner_name_index", "= 0",
9995  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
9996 #endif // !DOCUMENTATION
9997 
9998 #ifndef DOCUMENTATION
9999  AsmJvmInnerClassesEntry.setDataPrototype(
10000  "uint16_t", "inner_class_access_flags", "= 0",
10001  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
10002 #endif // !DOCUMENTATION
10003 
10004  DECLARE_OTHERS(AsmJvmInnerClassesEntry);
10005 #if defined(SgAsmJvmInnerClassesEntry_OTHERS) || defined(DOCUMENTATION)
10006 
10007  //----------------------- Boost serialization for SgAsmJvmInnerClassesEntry -----------------------
10008 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
10009 private:
10010  friend class boost::serialization::access;
10011 
10012  template<class S>
10013  void serialize(S &s, const unsigned /*version*/) {
10014  debugSerializationBegin("SgAsmJvmInnerClassesEntry");
10015  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmJvmNode);
10016  s & BOOST_SERIALIZATION_NVP(p_inner_class_info_index);
10017  s & BOOST_SERIALIZATION_NVP(p_outer_class_info_index);
10018  s & BOOST_SERIALIZATION_NVP(p_inner_name_index);
10019  s & BOOST_SERIALIZATION_NVP(p_inner_class_access_flags);
10020  debugSerializationEnd("SgAsmJvmInnerClassesEntry");
10021  }
10022 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
10023 
10024 public:
10031  uint16_t const& get_inner_class_info_index() const;
10032  void set_inner_class_info_index(uint16_t const&);
10035 public:
10042  uint16_t const& get_outer_class_info_index() const;
10043  void set_outer_class_info_index(uint16_t const&);
10046 public:
10053  uint16_t const& get_inner_name_index() const;
10054  void set_inner_name_index(uint16_t const&);
10057 public:
10065  uint16_t const& get_inner_class_access_flags() const;
10066  void set_inner_class_access_flags(uint16_t const&);
10068 public:
10073 
10076 
10078  virtual void unparse(std::ostream&) const override;
10079 
10081  void dump(FILE*, const char *prefix, ssize_t idx) const override;
10082 public:
10084  virtual ~SgAsmJvmInnerClassesEntry();
10085 
10086 public:
10089 
10090 protected:
10097  void initializeProperties();
10098 #endif // SgAsmJvmInnerClassesEntry_OTHERS
10099 #ifdef DOCUMENTATION
10100 };
10101 #endif // DOCUMENTATION
10102 
10103 
10105 // SgAsmJvmFileHeader -- MACHINE GENERATED; DO NOT MODIFY --
10107 
10108 DECLARE_LEAF_CLASS(AsmJvmFileHeader);
10109 IS_SERIALIZABLE(AsmJvmFileHeader);
10110 
10111 #ifdef DOCUMENTATION
10112 
10119 #endif // DOCUMENTATION
10120 
10121 #ifndef DOCUMENTATION
10122  AsmJvmFileHeader.setDataPrototype(
10123  "uint16_t", "minor_version", "= 0",
10124  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
10125 #endif // !DOCUMENTATION
10126 
10127 #ifndef DOCUMENTATION
10128  AsmJvmFileHeader.setDataPrototype(
10129  "uint16_t", "major_version", "= 0",
10130  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
10131 #endif // !DOCUMENTATION
10132 
10133 #ifndef DOCUMENTATION
10134  AsmJvmFileHeader.setDataPrototype(
10135  "uint16_t", "access_flags", "= 0",
10136  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
10137 #endif // !DOCUMENTATION
10138 
10139 #ifndef DOCUMENTATION
10140  AsmJvmFileHeader.setDataPrototype(
10141  "uint16_t", "this_class", "= 0",
10142  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
10143 #endif // !DOCUMENTATION
10144 
10145 #ifndef DOCUMENTATION
10146  AsmJvmFileHeader.setDataPrototype(
10147  "uint16_t", "super_class", "= 0",
10148  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
10149 #endif // !DOCUMENTATION
10150 
10151 #ifndef DOCUMENTATION
10152  AsmJvmFileHeader.setDataPrototype(
10153  "SgAsmJvmConstantPool*", "constant_pool", "= nullptr",
10154  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
10155 #endif // !DOCUMENTATION
10156 
10157 #ifndef DOCUMENTATION
10158  AsmJvmFileHeader.setDataPrototype(
10159  "std::list<uint16_t>", "interfaces", "",
10160  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
10161 #endif // !DOCUMENTATION
10162 
10163 #ifndef DOCUMENTATION
10164  AsmJvmFileHeader.setDataPrototype(
10165  "SgAsmJvmFieldTable*", "field_table", "= nullptr",
10166  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
10167 #endif // !DOCUMENTATION
10168 
10169 #ifndef DOCUMENTATION
10170  AsmJvmFileHeader.setDataPrototype(
10171  "SgAsmJvmMethodTable*", "method_table", "= nullptr",
10172  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
10173 #endif // !DOCUMENTATION
10174 
10175 #ifndef DOCUMENTATION
10176  AsmJvmFileHeader.setDataPrototype(
10177  "SgAsmJvmAttributeTable*", "attribute_table", "= nullptr",
10178  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
10179 #endif // !DOCUMENTATION
10180 
10181  DECLARE_OTHERS(AsmJvmFileHeader);
10182 #if defined(SgAsmJvmFileHeader_OTHERS) || defined(DOCUMENTATION)
10183 
10184  //----------------------- Boost serialization for SgAsmJvmFileHeader -----------------------
10185 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
10186 private:
10187  friend class boost::serialization::access;
10188 
10189  template<class S>
10190  void serialize(S &s, const unsigned /*version*/) {
10191  debugSerializationBegin("SgAsmJvmFileHeader");
10192  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmGenericHeader);
10193  s & BOOST_SERIALIZATION_NVP(p_minor_version);
10194  s & BOOST_SERIALIZATION_NVP(p_major_version);
10195  s & BOOST_SERIALIZATION_NVP(p_access_flags);
10196  s & BOOST_SERIALIZATION_NVP(p_this_class);
10197  s & BOOST_SERIALIZATION_NVP(p_super_class);
10198  s & BOOST_SERIALIZATION_NVP(p_constant_pool);
10199  s & BOOST_SERIALIZATION_NVP(p_interfaces);
10200  s & BOOST_SERIALIZATION_NVP(p_field_table);
10201  s & BOOST_SERIALIZATION_NVP(p_method_table);
10202  s & BOOST_SERIALIZATION_NVP(p_attribute_table);
10203  debugSerializationEnd("SgAsmJvmFileHeader");
10204  }
10205 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
10206 
10207 public:
10213  uint16_t const& get_minor_version() const;
10214  void set_minor_version(uint16_t const&);
10217 public:
10223  uint16_t const& get_major_version() const;
10224  void set_major_version(uint16_t const&);
10227 public:
10233  uint16_t const& get_access_flags() const;
10234  void set_access_flags(uint16_t const&);
10237 public:
10243  uint16_t const& get_this_class() const;
10244  void set_this_class(uint16_t const&);
10247 public:
10253  uint16_t const& get_super_class() const;
10254  void set_super_class(uint16_t const&);
10257 public:
10266  SgAsmJvmConstantPool* const& get_constant_pool() const;
10270 public:
10278  std::list<uint16_t> const& get_interfaces() const;
10279  std::list<uint16_t>& get_interfaces();
10280  void set_interfaces(std::list<uint16_t> const&);
10283 public:
10292  SgAsmJvmFieldTable* const& get_field_table() const;
10293  void set_field_table(SgAsmJvmFieldTable* const&);
10296 public:
10305  SgAsmJvmMethodTable* const& get_method_table() const;
10306  void set_method_table(SgAsmJvmMethodTable* const&);
10309 public:
10321 public:
10324 
10330  virtual SgAsmJvmFileHeader* parse() override;
10331 
10333  virtual void unparse(std::ostream&) const override;
10334 
10336  static bool is_JVM(SgAsmGenericFile*);
10337 
10338 protected:
10339  // Some extra clean-up actions on destruction
10340  virtual void destructorHelper() override;
10341 public:
10343  virtual ~SgAsmJvmFileHeader();
10344 
10345 public:
10348 
10349 protected:
10356  void initializeProperties();
10357 #endif // SgAsmJvmFileHeader_OTHERS
10358 #ifdef DOCUMENTATION
10359 };
10360 #endif // DOCUMENTATION
10361 
10362 
10364 // SgAsmJvmFieldTable -- MACHINE GENERATED; DO NOT MODIFY --
10366 
10367 DECLARE_LEAF_CLASS(AsmJvmFieldTable);
10368 IS_SERIALIZABLE(AsmJvmFieldTable);
10369 
10370 #ifdef DOCUMENTATION
10371 
10377 #endif // DOCUMENTATION
10378 
10379 #ifndef DOCUMENTATION
10380  AsmJvmFieldTable.setDataPrototype(
10381  "SgAsmJvmFieldPtrList", "fields", "",
10382  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
10383 #endif // !DOCUMENTATION
10384 
10385  DECLARE_OTHERS(AsmJvmFieldTable);
10386 #if defined(SgAsmJvmFieldTable_OTHERS) || defined(DOCUMENTATION)
10387 
10388  //----------------------- Boost serialization for SgAsmJvmFieldTable -----------------------
10389 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
10390 private:
10391  friend class boost::serialization::access;
10392 
10393  template<class S>
10394  void serialize(S &s, const unsigned /*version*/) {
10395  debugSerializationBegin("SgAsmJvmFieldTable");
10396  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmGenericSection);
10397  s & BOOST_SERIALIZATION_NVP(p_fields);
10398  debugSerializationEnd("SgAsmJvmFieldTable");
10399  }
10400 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
10401 
10402 public:
10406  SgAsmJvmFieldPtrList const& get_fields() const;
10407  SgAsmJvmFieldPtrList& get_fields();
10408  void set_fields(SgAsmJvmFieldPtrList const&);
10410 public:
10415 
10419  virtual SgAsmJvmFieldTable* parse() override;
10420 
10422  virtual void unparse(std::ostream&) const override;
10423 
10425  virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
10426 public:
10428  virtual ~SgAsmJvmFieldTable();
10429 
10430 public:
10433 
10434 protected:
10441  void initializeProperties();
10442 #endif // SgAsmJvmFieldTable_OTHERS
10443 #ifdef DOCUMENTATION
10444 };
10445 #endif // DOCUMENTATION
10446 
10447 
10449 // SgAsmJvmField -- MACHINE GENERATED; DO NOT MODIFY --
10451 
10452 DECLARE_LEAF_CLASS(AsmJvmField);
10453 IS_SERIALIZABLE(AsmJvmField);
10454 
10455 #ifdef DOCUMENTATION
10456 
10460 #endif // DOCUMENTATION
10461 
10462 #ifndef DOCUMENTATION
10463  AsmJvmField.setDataPrototype(
10464  "uint16_t", "access_flags", "= 0",
10465  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
10466 #endif // !DOCUMENTATION
10467 
10468 #ifndef DOCUMENTATION
10469  AsmJvmField.setDataPrototype(
10470  "uint16_t", "name_index", "= 0",
10471  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
10472 #endif // !DOCUMENTATION
10473 
10474 #ifndef DOCUMENTATION
10475  AsmJvmField.setDataPrototype(
10476  "uint16_t", "descriptor_index", "= 0",
10477  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
10478 #endif // !DOCUMENTATION
10479 
10480 #ifndef DOCUMENTATION
10481  AsmJvmField.setDataPrototype(
10482  "SgAsmJvmAttributeTable*", "attribute_table", "= nullptr",
10483  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
10484 #endif // !DOCUMENTATION
10485 
10486  DECLARE_OTHERS(AsmJvmField);
10487 #if defined(SgAsmJvmField_OTHERS) || defined(DOCUMENTATION)
10488 
10489  //----------------------- Boost serialization for SgAsmJvmField -----------------------
10490 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
10491 private:
10492  friend class boost::serialization::access;
10493 
10494  template<class S>
10495  void serialize(S &s, const unsigned /*version*/) {
10496  debugSerializationBegin("SgAsmJvmField");
10497  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmJvmNode);
10498  s & BOOST_SERIALIZATION_NVP(p_access_flags);
10499  s & BOOST_SERIALIZATION_NVP(p_name_index);
10500  s & BOOST_SERIALIZATION_NVP(p_descriptor_index);
10501  s & BOOST_SERIALIZATION_NVP(p_attribute_table);
10502  debugSerializationEnd("SgAsmJvmField");
10503  }
10504 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
10505 
10506 public:
10513  uint16_t const& get_access_flags() const;
10514  void set_access_flags(uint16_t const&);
10517 public:
10523  uint16_t const& get_name_index() const;
10524  void set_name_index(uint16_t const&);
10527 public:
10533  uint16_t const& get_descriptor_index() const;
10534  void set_descriptor_index(uint16_t const&);
10537 public:
10544  public:
10548  explicit SgAsmJvmField(SgAsmJvmFieldTable*);
10549 
10552 
10554  virtual void unparse(std::ostream&) const override;
10555 
10557  void dump(FILE*, const char *prefix, ssize_t idx) const override;
10558 public:
10560  virtual ~SgAsmJvmField();
10561 
10562 public:
10564  SgAsmJvmField();
10565 
10566 protected:
10573  void initializeProperties();
10574 #endif // SgAsmJvmField_OTHERS
10575 #ifdef DOCUMENTATION
10576 };
10577 #endif // DOCUMENTATION
10578 
10579 
10581 // SgAsmJvmExceptionTable -- MACHINE GENERATED; DO NOT MODIFY --
10583 
10584 DECLARE_LEAF_CLASS(AsmJvmExceptionTable);
10585 IS_SERIALIZABLE(AsmJvmExceptionTable);
10586 
10587 #ifdef DOCUMENTATION
10588 
10593 #endif // DOCUMENTATION
10594 
10595 #ifndef DOCUMENTATION
10596  AsmJvmExceptionTable.setDataPrototype(
10597  "SgAsmJvmExceptionHandlerPtrList", "handlers", "",
10598  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
10599 #endif // !DOCUMENTATION
10600 
10601  DECLARE_OTHERS(AsmJvmExceptionTable);
10602 #if defined(SgAsmJvmExceptionTable_OTHERS) || defined(DOCUMENTATION)
10603 
10604  //----------------------- Boost serialization for SgAsmJvmExceptionTable -----------------------
10605 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
10606 private:
10607  friend class boost::serialization::access;
10608 
10609  template<class S>
10610  void serialize(S &s, const unsigned /*version*/) {
10611  debugSerializationBegin("SgAsmJvmExceptionTable");
10612  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmJvmNode);
10613  s & BOOST_SERIALIZATION_NVP(p_handlers);
10614  debugSerializationEnd("SgAsmJvmExceptionTable");
10615  }
10616 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
10617 
10618 public:
10622  SgAsmJvmExceptionHandlerPtrList const& get_handlers() const;
10623  SgAsmJvmExceptionHandlerPtrList& get_handlers();
10624  void set_handlers(SgAsmJvmExceptionHandlerPtrList const&);
10626 public:
10631 
10637 
10639  virtual void unparse(std::ostream&) const override;
10640 
10642  void dump(FILE*, const char *prefix, ssize_t idx) const override;
10643 public:
10645  virtual ~SgAsmJvmExceptionTable();
10646 
10647 public:
10650 
10651 protected:
10658  void initializeProperties();
10659 #endif // SgAsmJvmExceptionTable_OTHERS
10660 #ifdef DOCUMENTATION
10661 };
10662 #endif // DOCUMENTATION
10663 
10664 
10666 // SgAsmJvmExceptions -- MACHINE GENERATED; DO NOT MODIFY --
10668 
10669 DECLARE_LEAF_CLASS(AsmJvmExceptions);
10670 IS_SERIALIZABLE(AsmJvmExceptions);
10671 
10672 #ifdef DOCUMENTATION
10673 
10679 #endif // DOCUMENTATION
10680 
10681 #ifndef DOCUMENTATION
10682  AsmJvmExceptions.setDataPrototype(
10683  "SgUnsigned16List", "exception_index_table", "",
10684  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
10685 #endif // !DOCUMENTATION
10686 
10687  DECLARE_OTHERS(AsmJvmExceptions);
10688 #if defined(SgAsmJvmExceptions_OTHERS) || defined(DOCUMENTATION)
10689 
10690  //----------------------- Boost serialization for SgAsmJvmExceptions -----------------------
10691 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
10692 private:
10693  friend class boost::serialization::access;
10694 
10695  template<class S>
10696  void serialize(S &s, const unsigned /*version*/) {
10697  debugSerializationBegin("SgAsmJvmExceptions");
10698  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmJvmAttribute);
10699  s & BOOST_SERIALIZATION_NVP(p_exception_index_table);
10700  debugSerializationEnd("SgAsmJvmExceptions");
10701  }
10702 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
10703 
10704 public:
10712  SgUnsigned16List const& get_exception_index_table() const;
10713  void set_exception_index_table(SgUnsigned16List const&);
10715  public:
10719  explicit SgAsmJvmExceptions(SgAsmJvmAttributeTable* table);
10720 
10723 
10725  virtual void unparse(std::ostream&) const override;
10726 
10728  void dump(FILE*, const char *prefix, ssize_t idx) const override;
10729 public:
10731  virtual ~SgAsmJvmExceptions();
10732 
10733 public:
10736 
10737 protected:
10744  void initializeProperties();
10745 #endif // SgAsmJvmExceptions_OTHERS
10746 #ifdef DOCUMENTATION
10747 };
10748 #endif // DOCUMENTATION
10749 
10750 
10752 // SgAsmJvmExceptionHandler -- MACHINE GENERATED; DO NOT MODIFY --
10754 
10755 DECLARE_LEAF_CLASS(AsmJvmExceptionHandler);
10756 IS_SERIALIZABLE(AsmJvmExceptionHandler);
10757 
10758 #ifdef DOCUMENTATION
10759 
10763 #endif // DOCUMENTATION
10764 
10765 #ifndef DOCUMENTATION
10766  AsmJvmExceptionHandler.setDataPrototype(
10767  "uint16_t", "start_pc", "= 0",
10768  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
10769 #endif // !DOCUMENTATION
10770 
10771 #ifndef DOCUMENTATION
10772  AsmJvmExceptionHandler.setDataPrototype(
10773  "uint16_t", "end_pc", "= 0",
10774  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
10775 #endif // !DOCUMENTATION
10776 
10777 #ifndef DOCUMENTATION
10778  AsmJvmExceptionHandler.setDataPrototype(
10779  "uint16_t", "handler_pc", "= 0",
10780  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
10781 #endif // !DOCUMENTATION
10782 
10783 #ifndef DOCUMENTATION
10784  AsmJvmExceptionHandler.setDataPrototype(
10785  "uint16_t", "catch_type", "= 0",
10786  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
10787 #endif // !DOCUMENTATION
10788 
10789  DECLARE_OTHERS(AsmJvmExceptionHandler);
10790 #if defined(SgAsmJvmExceptionHandler_OTHERS) || defined(DOCUMENTATION)
10791 
10792  //----------------------- Boost serialization for SgAsmJvmExceptionHandler -----------------------
10793 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
10794 private:
10795  friend class boost::serialization::access;
10796 
10797  template<class S>
10798  void serialize(S &s, const unsigned /*version*/) {
10799  debugSerializationBegin("SgAsmJvmExceptionHandler");
10800  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmJvmNode);
10801  s & BOOST_SERIALIZATION_NVP(p_start_pc);
10802  s & BOOST_SERIALIZATION_NVP(p_end_pc);
10803  s & BOOST_SERIALIZATION_NVP(p_handler_pc);
10804  s & BOOST_SERIALIZATION_NVP(p_catch_type);
10805  debugSerializationEnd("SgAsmJvmExceptionHandler");
10806  }
10807 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
10808 
10809 public:
10816  uint16_t const& get_start_pc() const;
10817  void set_start_pc(uint16_t const&);
10820 public:
10827  uint16_t const& get_end_pc() const;
10828  void set_end_pc(uint16_t const&);
10831 public:
10838  uint16_t const& get_handler_pc() const;
10839  void set_handler_pc(uint16_t const&);
10842 public:
10849  uint16_t const& get_catch_type() const;
10850  void set_catch_type(uint16_t const&);
10852  public:
10857 
10860 
10862  virtual void unparse(std::ostream&) const override;
10863 
10865  void dump(FILE*, const char *prefix, ssize_t idx) const override;
10866 public:
10868  virtual ~SgAsmJvmExceptionHandler();
10869 
10870 public:
10873 
10874 protected:
10881  void initializeProperties();
10882 #endif // SgAsmJvmExceptionHandler_OTHERS
10883 #ifdef DOCUMENTATION
10884 };
10885 #endif // DOCUMENTATION
10886 
10887 
10889 // SgAsmJvmEnclosingMethod -- MACHINE GENERATED; DO NOT MODIFY --
10891 
10892 DECLARE_LEAF_CLASS(AsmJvmEnclosingMethod);
10893 IS_SERIALIZABLE(AsmJvmEnclosingMethod);
10894 
10895 #ifdef DOCUMENTATION
10896 
10901 #endif // DOCUMENTATION
10902 
10903 #ifndef DOCUMENTATION
10904  AsmJvmEnclosingMethod.setDataPrototype(
10905  "uint16_t", "class_index", "= 0",
10906  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
10907 #endif // !DOCUMENTATION
10908 
10909 #ifndef DOCUMENTATION
10910  AsmJvmEnclosingMethod.setDataPrototype(
10911  "uint16_t", "method_index", "= 0",
10912  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
10913 #endif // !DOCUMENTATION
10914 
10915  DECLARE_OTHERS(AsmJvmEnclosingMethod);
10916 #if defined(SgAsmJvmEnclosingMethod_OTHERS) || defined(DOCUMENTATION)
10917 
10918  //----------------------- Boost serialization for SgAsmJvmEnclosingMethod -----------------------
10919 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
10920 private:
10921  friend class boost::serialization::access;
10922 
10923  template<class S>
10924  void serialize(S &s, const unsigned /*version*/) {
10925  debugSerializationBegin("SgAsmJvmEnclosingMethod");
10926  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmJvmAttribute);
10927  s & BOOST_SERIALIZATION_NVP(p_class_index);
10928  s & BOOST_SERIALIZATION_NVP(p_method_index);
10929  debugSerializationEnd("SgAsmJvmEnclosingMethod");
10930  }
10931 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
10932 
10933 public:
10939  uint16_t const& get_class_index() const;
10940  void set_class_index(uint16_t const&);
10943 public:
10949  uint16_t const& get_method_index() const;
10950  void set_method_index(uint16_t const&);
10952 public:
10957 
10959  virtual SgAsmJvmAttribute* parse(SgAsmJvmConstantPool* pool) override;
10960 
10962  virtual void unparse(std::ostream&) const override;
10963 
10965  virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
10966 public:
10968  virtual ~SgAsmJvmEnclosingMethod();
10969 
10970 public:
10973 
10974 protected:
10981  void initializeProperties();
10982 #endif // SgAsmJvmEnclosingMethod_OTHERS
10983 #ifdef DOCUMENTATION
10984 };
10985 #endif // DOCUMENTATION
10986 
10987 
10989 // SgAsmJvmConstantValue -- MACHINE GENERATED; DO NOT MODIFY --
10991 
10992 DECLARE_LEAF_CLASS(AsmJvmConstantValue);
10993 IS_SERIALIZABLE(AsmJvmConstantValue);
10994 
10995 #ifdef DOCUMENTATION
10996 
11001 #endif // DOCUMENTATION
11002 
11003 #ifndef DOCUMENTATION
11004  AsmJvmConstantValue.setDataPrototype(
11005  "uint16_t", "constantvalue_index", "= 0",
11006  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
11007 #endif // !DOCUMENTATION
11008 
11009  DECLARE_OTHERS(AsmJvmConstantValue);
11010 #if defined(SgAsmJvmConstantValue_OTHERS) || defined(DOCUMENTATION)
11011 
11012  //----------------------- Boost serialization for SgAsmJvmConstantValue -----------------------
11013 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
11014 private:
11015  friend class boost::serialization::access;
11016 
11017  template<class S>
11018  void serialize(S &s, const unsigned /*version*/) {
11019  debugSerializationBegin("SgAsmJvmConstantValue");
11020  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmJvmAttribute);
11021  s & BOOST_SERIALIZATION_NVP(p_constantvalue_index);
11022  debugSerializationEnd("SgAsmJvmConstantValue");
11023  }
11024 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
11025 
11026 public:
11032  uint16_t const& get_constantvalue_index() const;
11033  void set_constantvalue_index(uint16_t const&);
11035 public:
11040 
11042  virtual SgAsmJvmAttribute* parse(SgAsmJvmConstantPool* pool) override;
11043 
11045  virtual void unparse(std::ostream&) const override;
11046 
11048  virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
11049 public:
11051  virtual ~SgAsmJvmConstantValue();
11052 
11053 public:
11056 
11057 protected:
11064  void initializeProperties();
11065 #endif // SgAsmJvmConstantValue_OTHERS
11066 #ifdef DOCUMENTATION
11067 };
11068 #endif // DOCUMENTATION
11069 
11070 
11072 // SgAsmJvmConstantPool -- MACHINE GENERATED; DO NOT MODIFY --
11074 
11075 DECLARE_LEAF_CLASS(AsmJvmConstantPool);
11076 IS_SERIALIZABLE(AsmJvmConstantPool);
11077 
11078 #ifdef DOCUMENTATION
11079 
11085 #endif // DOCUMENTATION
11086 
11087 #ifndef DOCUMENTATION
11088  AsmJvmConstantPool.setDataPrototype(
11089  "SgAsmJvmConstantPoolEntryPtrList", "entries", "",
11090  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
11091 #endif // !DOCUMENTATION
11092 
11093  DECLARE_OTHERS(AsmJvmConstantPool);
11094 #if defined(SgAsmJvmConstantPool_OTHERS) || defined(DOCUMENTATION)
11095 
11096  //----------------------- Boost serialization for SgAsmJvmConstantPool -----------------------
11097 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
11098 private:
11099  friend class boost::serialization::access;
11100 
11101  template<class S>
11102  void serialize(S &s, const unsigned /*version*/) {
11103  debugSerializationBegin("SgAsmJvmConstantPool");
11104  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmGenericSection);
11105  s & BOOST_SERIALIZATION_NVP(p_entries);
11106  debugSerializationEnd("SgAsmJvmConstantPool");
11107  }
11108 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
11109 
11110 public:
11114  SgAsmJvmConstantPoolEntryPtrList const& get_entries() const;
11115  SgAsmJvmConstantPoolEntryPtrList& get_entries();
11116  void set_entries(SgAsmJvmConstantPoolEntryPtrList const&);
11118 public:
11121 
11127  virtual SgAsmJvmConstantPool* parse() override;
11128 
11133  SgAsmJvmConstantPoolEntry* get_entry(size_t index) const;
11141  std::string get_utf8_string(size_t index) const;
11142 
11144  virtual void unparse(std::ostream&) const override;
11145 
11147  virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
11148 
11149 protected:
11150  // Some extra clean-up actions on destruction
11151  virtual void destructorHelper() override;
11152 public:
11154  virtual ~SgAsmJvmConstantPool();
11155 
11156 public:
11159 
11160 protected:
11167  void initializeProperties();
11168 #endif // SgAsmJvmConstantPool_OTHERS
11169 #ifdef DOCUMENTATION
11170 };
11171 #endif // DOCUMENTATION
11172 
11173 
11175 // SgAsmJvmConstantPoolEntry -- MACHINE GENERATED; DO NOT MODIFY --
11177 
11178 DECLARE_LEAF_CLASS(AsmJvmConstantPoolEntry);
11179 IS_SERIALIZABLE(AsmJvmConstantPoolEntry);
11180 
11181 #ifdef DOCUMENTATION
11182 
11187 #endif // DOCUMENTATION
11188 
11189 #ifndef DOCUMENTATION
11190  AsmJvmConstantPoolEntry.setDataPrototype(
11191  "SgAsmJvmConstantPoolEntry::Kind", "tag", "= SgAsmJvmConstantPoolEntry::EMPTY",
11192  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
11193 #endif // !DOCUMENTATION
11194 
11195 #ifndef DOCUMENTATION
11196  AsmJvmConstantPoolEntry.setDataPrototype(
11197  "uint32_t", "bytes", "= 0",
11198  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
11199 #endif // !DOCUMENTATION
11200 
11201 #ifndef DOCUMENTATION
11202  AsmJvmConstantPoolEntry.setDataPrototype(
11203  "uint32_t", "hi_bytes", "= 0",
11204  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
11205 #endif // !DOCUMENTATION
11206 
11207 #ifndef DOCUMENTATION
11208  AsmJvmConstantPoolEntry.setDataPrototype(
11209  "uint32_t", "low_bytes", "= 0",
11210  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
11211 #endif // !DOCUMENTATION
11212 
11213 #ifndef DOCUMENTATION
11214  AsmJvmConstantPoolEntry.setDataPrototype(
11215  "uint16_t", "bootstrap_method_attr_index", "= 0",
11216  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
11217 #endif // !DOCUMENTATION
11218 
11219 #ifndef DOCUMENTATION
11220  AsmJvmConstantPoolEntry.setDataPrototype(
11221  "uint16_t", "class_index", "= 0",
11222  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
11223 #endif // !DOCUMENTATION
11224 
11225 #ifndef DOCUMENTATION
11226  AsmJvmConstantPoolEntry.setDataPrototype(
11227  "uint16_t", "descriptor_index", "= 0",
11228  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
11229 #endif // !DOCUMENTATION
11230 
11231 #ifndef DOCUMENTATION
11232  AsmJvmConstantPoolEntry.setDataPrototype(
11233  "uint16_t", "name_index", "= 0",
11234  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
11235 #endif // !DOCUMENTATION
11236 
11237 #ifndef DOCUMENTATION
11238  AsmJvmConstantPoolEntry.setDataPrototype(
11239  "uint16_t", "name_and_type_index", "= 0",
11240  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
11241 #endif // !DOCUMENTATION
11242 
11243 #ifndef DOCUMENTATION
11244  AsmJvmConstantPoolEntry.setDataPrototype(
11245  "uint16_t", "reference_index", "= 0",
11246  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
11247 #endif // !DOCUMENTATION
11248 
11249 #ifndef DOCUMENTATION
11250  AsmJvmConstantPoolEntry.setDataPrototype(
11251  "uint8_t", "reference_kind", "= 0",
11252  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
11253 #endif // !DOCUMENTATION
11254 
11255 #ifndef DOCUMENTATION
11256  AsmJvmConstantPoolEntry.setDataPrototype(
11257  "uint16_t", "string_index", "= 0",
11258  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
11259 #endif // !DOCUMENTATION
11260 
11261 #ifndef DOCUMENTATION
11262  AsmJvmConstantPoolEntry.setDataPrototype(
11263  "uint16_t", "length", "= 0",
11264  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
11265 #endif // !DOCUMENTATION
11266 
11267 #ifndef DOCUMENTATION
11268  AsmJvmConstantPoolEntry.setDataPrototype(
11269  "char*", "utf8_bytes", "= nullptr",
11270  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
11271 #endif // !DOCUMENTATION
11272 
11273  DECLARE_OTHERS(AsmJvmConstantPoolEntry);
11274 #if defined(SgAsmJvmConstantPoolEntry_OTHERS) || defined(DOCUMENTATION)
11275 
11276  //----------------------- Boost serialization for SgAsmJvmConstantPoolEntry -----------------------
11277 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
11278 private:
11279  friend class boost::serialization::access;
11280 
11281  template<class S>
11282  void serialize(S &s, const unsigned /*version*/) {
11283  debugSerializationBegin("SgAsmJvmConstantPoolEntry");
11284  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmJvmNode);
11285  s & BOOST_SERIALIZATION_NVP(p_tag);
11286  s & BOOST_SERIALIZATION_NVP(p_bytes);
11287  s & BOOST_SERIALIZATION_NVP(p_hi_bytes);
11288  s & BOOST_SERIALIZATION_NVP(p_low_bytes);
11289  s & BOOST_SERIALIZATION_NVP(p_bootstrap_method_attr_index);
11290  s & BOOST_SERIALIZATION_NVP(p_class_index);
11291  s & BOOST_SERIALIZATION_NVP(p_descriptor_index);
11292  s & BOOST_SERIALIZATION_NVP(p_name_index);
11293  s & BOOST_SERIALIZATION_NVP(p_name_and_type_index);
11294  s & BOOST_SERIALIZATION_NVP(p_reference_index);
11295  s & BOOST_SERIALIZATION_NVP(p_reference_kind);
11296  s & BOOST_SERIALIZATION_NVP(p_string_index);
11297  s & BOOST_SERIALIZATION_NVP(p_length);
11298  debugSerializationEnd("SgAsmJvmConstantPoolEntry");
11299  }
11300 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
11301  // Local types
11304 public:
11309  enum Kind {
11310  EMPTY = 0,
11311  CONSTANT_Utf8 = 1,
11312  CONSTANT_Integer = 3,
11313  CONSTANT_Float = 4,
11314  CONSTANT_Long = 5,
11315  CONSTANT_Double = 6,
11316  CONSTANT_Class = 7,
11317  CONSTANT_String = 8,
11318  CONSTANT_Fieldref = 9,
11319  CONSTANT_Methodref = 10,
11320  CONSTANT_InterfaceMethodref = 11,
11321  CONSTANT_NameAndType = 12,
11322  CONSTANT_MethodHandle = 15,
11323  CONSTANT_MethodType = 16,
11324  CONSTANT_Dynamic = 17,
11325  CONSTANT_InvokeDynamic = 18,
11326  CONSTANT_Module = 19,
11327  CONSTANT_Package = 20
11328  };
11329 
11330 #ifdef DOCUMENTATION
11331 
11334 #endif
11335 
11337  uint8_t tag;
11338  uint16_t name_index;
11339  };
11340 
11344  uint8_t tag;
11345  uint16_t class_index;
11346  uint16_t name_and_type_index;
11347  };
11349  uint8_t tag;
11350  uint16_t class_index;
11351  uint16_t name_and_type_index;
11352  };
11354  uint8_t tag;
11355  uint16_t class_index;
11356  uint16_t name_and_type_index;
11357  };
11358 
11361  uint8_t tag;
11362  uint16_t string_index;
11363  };
11364 
11367  uint8_t tag;
11368  uint32_t bytes;
11369  };
11371  uint8_t tag;
11372  uint32_t bytes;
11373  };
11375  uint8_t tag;
11376  uint32_t hi_bytes;
11377  uint32_t low_bytes;
11378  };
11380  uint8_t tag;
11381  uint32_t hi_bytes;
11382  uint32_t low_bytes;
11383  };
11384 
11387  uint8_t tag;
11388  uint16_t name_index;
11389  uint16_t descriptor_index;
11390  };
11391 
11394  uint8_t tag;
11395  uint16_t length;
11396  uint8_t* bytes;
11397  };
11398 
11401  uint8_t tag;
11402  uint8_t reference_kind;
11403  uint16_t reference_index;
11404  };
11405 
11408  uint8_t tag;
11409  uint16_t descriptor_index;
11410  };
11411 
11414  uint8_t tag;
11415  uint16_t bootstrap_method_attr_index;
11416  uint16_t name_and_type_index;
11417  };
11419  uint8_t tag;
11420  uint16_t bootstrap_method_attr_index;
11421  uint16_t name_and_type_index;
11422  };
11423 
11426  uint8_t tag;
11427  uint16_t name_index;
11428  };
11429 
11432  uint8_t tag;
11433  uint16_t name_index;
11434  };
11435 
11437  // Properties
11439 public:
11449 public:
11456  uint32_t const& get_bytes() const;
11457  void set_bytes(uint32_t const&);
11460 public:
11468  uint32_t const& get_hi_bytes() const;
11469  void set_hi_bytes(uint32_t const&);
11472 public:
11480  uint32_t const& get_low_bytes() const;
11481  void set_low_bytes(uint32_t const&);
11484 public:
11491  uint16_t const& get_bootstrap_method_attr_index() const;
11492  void set_bootstrap_method_attr_index(uint16_t const&);
11495 public:
11502  uint16_t const& get_class_index() const;
11503  void set_class_index(uint16_t const&);
11506 public:
11513  uint16_t const& get_descriptor_index() const;
11514  void set_descriptor_index(uint16_t const&);
11517 public:
11524  uint16_t const& get_name_index() const;
11525  void set_name_index(uint16_t const&);
11528 public:
11536  uint16_t const& get_name_and_type_index() const;
11537  void set_name_and_type_index(uint16_t const&);
11540 public:
11547  uint16_t const& get_reference_index() const;
11548  void set_reference_index(uint16_t const&);
11551 public:
11558  uint8_t const& get_reference_kind() const;
11559  void set_reference_kind(uint8_t const&);
11562 public:
11569  uint16_t const& get_string_index() const;
11570  void set_string_index(uint16_t const&);
11573 public:
11580  uint16_t const& get_length() const;
11581  void set_length(uint16_t const&);
11583  // [Robb Matzke 2023-03-22]: I (and the serialization) have no idea what this points to, and therefore it cannot be
11584  // serialized. E.g., how many 'chars' should be serialized? Is the length stored in the `length` property? If so, `utf8_bytes`
11585  // should probably be an std::vector instead, which is a serializable thing. Furthermore, the data member cannot be 'const'
11586  // because that prevents it from being initialized by some de-serialization mechanisms (e.g., boost::serialize creates a default
11587  // constructed object and then fills it in).
11588 public:
11594  char* const& get_utf8_bytes() const;
11595  void set_utf8_bytes(char* const&);
11597  // Functions
11600 public:
11603 
11611  virtual void unparse(std::ostream&) const override;
11612 
11614  void dump(FILE*, const char *prefix, ssize_t idx) const override;
11615 
11617  static std::string to_string(SgAsmJvmConstantPoolEntry::Kind);
11618 public:
11620  virtual ~SgAsmJvmConstantPoolEntry();
11621 
11622 public:
11625 
11626 protected:
11633  void initializeProperties();
11634 #endif // SgAsmJvmConstantPoolEntry_OTHERS
11635 #ifdef DOCUMENTATION
11636 };
11637 #endif // DOCUMENTATION
11638 
11639 
11641 // SgAsmJvmCodeAttribute -- MACHINE GENERATED; DO NOT MODIFY --
11643 
11644 DECLARE_LEAF_CLASS(AsmJvmCodeAttribute);
11645 IS_SERIALIZABLE(AsmJvmCodeAttribute);
11646 
11647 #ifdef DOCUMENTATION
11648 
11654 #endif // DOCUMENTATION
11655 
11656 #ifndef DOCUMENTATION
11657  AsmJvmCodeAttribute.setDataPrototype(
11658  "uint16_t", "max_stack", "= 0",
11659  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
11660 #endif // !DOCUMENTATION
11661 
11662 #ifndef DOCUMENTATION
11663  AsmJvmCodeAttribute.setDataPrototype(
11664  "uint16_t", "max_locals", "= 0",
11665  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
11666 #endif // !DOCUMENTATION
11667 
11668 #ifndef DOCUMENTATION
11669  AsmJvmCodeAttribute.setDataPrototype(
11670  "uint32_t", "code_length", "= 0",
11671  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
11672 #endif // !DOCUMENTATION
11673 
11674 #ifndef DOCUMENTATION
11675  AsmJvmCodeAttribute.setDataPrototype(
11676  "const char*", "code", "= nullptr",
11677  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
11678 #endif // !DOCUMENTATION
11679 
11680 #ifndef DOCUMENTATION
11681  AsmJvmCodeAttribute.setDataPrototype(
11682  "SgAsmJvmExceptionTable*", "exception_table", "= nullptr",
11683  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
11684 #endif // !DOCUMENTATION
11685 
11686 #ifndef DOCUMENTATION
11687  AsmJvmCodeAttribute.setDataPrototype(
11688  "SgAsmJvmAttributeTable*", "attribute_table", "= nullptr",
11689  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
11690 #endif // !DOCUMENTATION
11691 
11692 #ifndef DOCUMENTATION
11693  AsmJvmCodeAttribute.setDataPrototype(
11694  "rose_addr_t", "code_offset", "= 0",
11695  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
11696 #endif // !DOCUMENTATION
11697 
11698  DECLARE_OTHERS(AsmJvmCodeAttribute);
11699 #if defined(SgAsmJvmCodeAttribute_OTHERS) || defined(DOCUMENTATION)
11700 
11701  //----------------------- Boost serialization for SgAsmJvmCodeAttribute -----------------------
11702 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
11703 private:
11704  friend class boost::serialization::access;
11705 
11706  template<class S>
11707  void serialize(S &s, const unsigned /*version*/) {
11708  debugSerializationBegin("SgAsmJvmCodeAttribute");
11709  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmJvmAttribute);
11710  s & BOOST_SERIALIZATION_NVP(p_max_stack);
11711  s & BOOST_SERIALIZATION_NVP(p_max_locals);
11712  s & BOOST_SERIALIZATION_NVP(p_code_length);
11713  s & BOOST_SERIALIZATION_NVP(p_exception_table);
11714  s & BOOST_SERIALIZATION_NVP(p_attribute_table);
11715  s & BOOST_SERIALIZATION_NVP(p_code_offset);
11716  debugSerializationEnd("SgAsmJvmCodeAttribute");
11717  }
11718 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
11719 
11720 public:
11727  uint16_t const& get_max_stack() const;
11728  void set_max_stack(uint16_t const&);
11731 public:
11738  uint16_t const& get_max_locals() const;
11739  void set_max_locals(uint16_t const&);
11742 public:
11749  uint32_t const& get_code_length() const;
11750  void set_code_length(uint32_t const&);
11752  // FIXME[Robb Matzke 2023-03-20]: is the no_serialize a bug?
11753 public:
11759  const char* const& get_code() const;
11760  void set_code(const char* const&);
11763 public:
11773 public:
11783 public:
11790  rose_addr_t const& get_code_offset() const;
11791  void set_code_offset(rose_addr_t const&);
11793 public:
11798 
11800  virtual SgAsmJvmAttribute* parse(SgAsmJvmConstantPool* pool) override;
11801 
11803  virtual void unparse(std::ostream&) const override;
11804 
11806  virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
11807 public:
11809  virtual ~SgAsmJvmCodeAttribute();
11810 
11811 public:
11814 
11815 protected:
11822  void initializeProperties();
11823 #endif // SgAsmJvmCodeAttribute_OTHERS
11824 #ifdef DOCUMENTATION
11825 };
11826 #endif // DOCUMENTATION
11827 
11828 
11830 // SgAsmJvmClass -- MACHINE GENERATED; DO NOT MODIFY --
11832 
11833 DECLARE_LEAF_CLASS(AsmJvmClass);
11834 IS_SERIALIZABLE(AsmJvmClass);
11835 
11836 #ifdef DOCUMENTATION
11837 
11841 #endif // DOCUMENTATION
11842 
11843  DECLARE_OTHERS(AsmJvmClass);
11844 #if defined(SgAsmJvmClass_OTHERS) || defined(DOCUMENTATION)
11845 
11846  //----------------------- Boost serialization for SgAsmJvmClass -----------------------
11847 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
11848 private:
11849  friend class boost::serialization::access;
11850 
11851  template<class S>
11852  void serialize(S &s, const unsigned /*version*/) {
11853  debugSerializationBegin("SgAsmJvmClass");
11854  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmJvmNode);
11855  debugSerializationEnd("SgAsmJvmClass");
11856  }
11857 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
11858 
11859 public:
11861  virtual ~SgAsmJvmClass();
11862 
11863 public:
11865  SgAsmJvmClass();
11866 
11867 protected:
11874  void initializeProperties();
11875 #endif // SgAsmJvmClass_OTHERS
11876 #ifdef DOCUMENTATION
11877 };
11878 #endif // DOCUMENTATION
11879 
11880 
11882 // SgAsmJvmBootstrapMethods -- MACHINE GENERATED; DO NOT MODIFY --
11884 
11885 DECLARE_LEAF_CLASS(AsmJvmBootstrapMethods);
11886 IS_SERIALIZABLE(AsmJvmBootstrapMethods);
11887 
11888 #ifdef DOCUMENTATION
11889 
11894 #endif // DOCUMENTATION
11895 
11896 #ifndef DOCUMENTATION
11897  AsmJvmBootstrapMethods.setDataPrototype(
11898  "SgAsmJvmBootstrapMethodPtrList", "bootstrap_methods", "",
11899  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
11900 #endif // !DOCUMENTATION
11901 
11902  DECLARE_OTHERS(AsmJvmBootstrapMethods);
11903 #if defined(SgAsmJvmBootstrapMethods_OTHERS) || defined(DOCUMENTATION)
11904 
11905  //----------------------- Boost serialization for SgAsmJvmBootstrapMethods -----------------------
11906 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
11907 private:
11908  friend class boost::serialization::access;
11909 
11910  template<class S>
11911  void serialize(S &s, const unsigned /*version*/) {
11912  debugSerializationBegin("SgAsmJvmBootstrapMethods");
11913  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmJvmAttribute);
11914  s & BOOST_SERIALIZATION_NVP(p_bootstrap_methods);
11915  debugSerializationEnd("SgAsmJvmBootstrapMethods");
11916  }
11917 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
11918 private:
11920  // Properties
11922 public:
11926  SgAsmJvmBootstrapMethodPtrList const& get_bootstrap_methods() const;
11927  SgAsmJvmBootstrapMethodPtrList& get_bootstrap_methods();
11928  void set_bootstrap_methods(SgAsmJvmBootstrapMethodPtrList const&);
11930  // Functions
11933 public:
11938 
11940  virtual SgAsmJvmBootstrapMethods* parse(SgAsmJvmConstantPool* pool) override;
11941 
11943  virtual void unparse(std::ostream&) const override;
11944 
11946  void dump(FILE*, const char *prefix, ssize_t idx) const override;
11947 public:
11949  virtual ~SgAsmJvmBootstrapMethods();
11950 
11951 public:
11954 
11955 protected:
11962  void initializeProperties();
11963 #endif // SgAsmJvmBootstrapMethods_OTHERS
11964 #ifdef DOCUMENTATION
11965 };
11966 #endif // DOCUMENTATION
11967 
11968 
11970 // SgAsmJvmBootstrapMethod -- MACHINE GENERATED; DO NOT MODIFY --
11972 
11973 DECLARE_LEAF_CLASS(AsmJvmBootstrapMethod);
11974 IS_SERIALIZABLE(AsmJvmBootstrapMethod);
11975 
11976 #ifdef DOCUMENTATION
11977 
11983 #endif // DOCUMENTATION
11984 
11985 #ifndef DOCUMENTATION
11986  AsmJvmBootstrapMethod.setDataPrototype(
11987  "uint16_t", "bootstrap_method_ref", "= 0",
11988  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
11989 #endif // !DOCUMENTATION
11990 
11991 #ifndef DOCUMENTATION
11992  AsmJvmBootstrapMethod.setDataPrototype(
11993  "SgUnsigned16List", "bootstrap_arguments", "",
11994  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
11995 #endif // !DOCUMENTATION
11996 
11997  DECLARE_OTHERS(AsmJvmBootstrapMethod);
11998 #if defined(SgAsmJvmBootstrapMethod_OTHERS) || defined(DOCUMENTATION)
11999 
12000  //----------------------- Boost serialization for SgAsmJvmBootstrapMethod -----------------------
12001 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
12002 private:
12003  friend class boost::serialization::access;
12004 
12005  template<class S>
12006  void serialize(S &s, const unsigned /*version*/) {
12007  debugSerializationBegin("SgAsmJvmBootstrapMethod");
12008  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmJvmNode);
12009  s & BOOST_SERIALIZATION_NVP(p_bootstrap_method_ref);
12010  s & BOOST_SERIALIZATION_NVP(p_bootstrap_arguments);
12011  debugSerializationEnd("SgAsmJvmBootstrapMethod");
12012  }
12013 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
12014 
12015 public:
12022  uint16_t const& get_bootstrap_method_ref() const;
12023  void set_bootstrap_method_ref(uint16_t const&);
12026 public:
12033  SgUnsigned16List const& get_bootstrap_arguments() const;
12034  void set_bootstrap_arguments(SgUnsigned16List const&);
12036  public:
12041 
12044 
12046  virtual void unparse(std::ostream&) const override;
12047 
12049  void dump(FILE*, const char *prefix, ssize_t idx) const override;
12050 public:
12052  virtual ~SgAsmJvmBootstrapMethod();
12053 
12054 public:
12057 
12058 protected:
12065  void initializeProperties();
12066 #endif // SgAsmJvmBootstrapMethod_OTHERS
12067 #ifdef DOCUMENTATION
12068 };
12069 #endif // DOCUMENTATION
12070 
12071 
12073 // SgAsmJvmAttributeTable -- MACHINE GENERATED; DO NOT MODIFY --
12075 
12076 DECLARE_LEAF_CLASS(AsmJvmAttributeTable);
12077 IS_SERIALIZABLE(AsmJvmAttributeTable);
12078 
12079 #ifdef DOCUMENTATION
12080 
12086 #endif // DOCUMENTATION
12087 
12088 #ifndef DOCUMENTATION
12089  AsmJvmAttributeTable.setDataPrototype(
12090  "SgAsmJvmAttributePtrList", "attributes", "",
12091  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
12092 #endif // !DOCUMENTATION
12093 
12094  DECLARE_OTHERS(AsmJvmAttributeTable);
12095 #if defined(SgAsmJvmAttributeTable_OTHERS) || defined(DOCUMENTATION)
12096 
12097  //----------------------- Boost serialization for SgAsmJvmAttributeTable -----------------------
12098 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
12099 private:
12100  friend class boost::serialization::access;
12101 
12102  template<class S>
12103  void serialize(S &s, const unsigned /*version*/) {
12104  debugSerializationBegin("SgAsmJvmAttributeTable");
12105  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmGenericSection);
12106  s & BOOST_SERIALIZATION_NVP(p_attributes);
12107  debugSerializationEnd("SgAsmJvmAttributeTable");
12108  }
12109 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
12110 
12111 public:
12115  SgAsmJvmAttributePtrList const& get_attributes() const;
12116  SgAsmJvmAttributePtrList& get_attributes();
12117  void set_attributes(SgAsmJvmAttributePtrList const&);
12119 public:
12124 
12129  using SgAsmGenericSection::parse; // Removes warning messages on some compilers
12130  // ("hidden virtual overloaded function")
12132 
12134  virtual void unparse(std::ostream&) const override;
12135 
12137  virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
12138 public:
12140  virtual ~SgAsmJvmAttributeTable();
12141 
12142 public:
12145 
12146 protected:
12153  void initializeProperties();
12154 #endif // SgAsmJvmAttributeTable_OTHERS
12155 #ifdef DOCUMENTATION
12156 };
12157 #endif // DOCUMENTATION
12158 
12159 
12161 // SgAsmJvmAttribute -- MACHINE GENERATED; DO NOT MODIFY --
12163 
12164 #ifndef DOCUMENTATION
12165 AstNodeClass& AsmJvmAttribute = nonTerminalConstructor(
12166  "AsmJvmAttribute",
12167  *this,
12168  "AsmJvmAttribute",
12169  "AsmJvmAttributeTag",
12170  SubclassListBuilder()
12171  | AsmJvmBootstrapMethods
12172  | AsmJvmCodeAttribute
12173  | AsmJvmConstantValue
12174  | AsmJvmEnclosingMethod
12175  | AsmJvmExceptions
12176  | AsmJvmInnerClasses
12177  | AsmJvmLineNumberTable
12178  | AsmJvmModuleMainClass
12179  | AsmJvmNestHost
12180  | AsmJvmNestMembers
12181  | AsmJvmSignature
12182  | AsmJvmSourceFile
12183  | AsmJvmStackMapTable
12184  , false);
12185 assert(AsmJvmAttribute.associatedGrammar != nullptr);
12186 AsmJvmAttribute.setCppCondition("!defined(DOCUMENTATION)");
12187 AsmJvmAttribute.isBoostSerializable(true);
12188 AsmJvmAttribute.setAutomaticGenerationOfConstructor(false);
12189 AsmJvmAttribute.setAutomaticGenerationOfDestructor(false);
12190 #endif // !DOCUMENTATION
12191 
12192 #ifdef DOCUMENTATION
12193 
12195 #endif // DOCUMENTATION
12196 
12197 #ifndef DOCUMENTATION
12198  AsmJvmAttribute.setDataPrototype(
12199  "uint16_t", "attribute_name_index", "= 0",
12200  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
12201 #endif // !DOCUMENTATION
12202 
12203 #ifndef DOCUMENTATION
12204  AsmJvmAttribute.setDataPrototype(
12205  "uint32_t", "attribute_length", "= 0",
12206  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
12207 #endif // !DOCUMENTATION
12208 
12209  DECLARE_OTHERS(AsmJvmAttribute);
12210 #if defined(SgAsmJvmAttribute_OTHERS) || defined(DOCUMENTATION)
12211 
12212  //----------------------- Boost serialization for SgAsmJvmAttribute -----------------------
12213 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
12214 private:
12215  friend class boost::serialization::access;
12216 
12217  template<class S>
12218  void serialize(S &s, const unsigned /*version*/) {
12219  debugSerializationBegin("SgAsmJvmAttribute");
12220  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmJvmNode);
12221  s & BOOST_SERIALIZATION_NVP(p_attribute_name_index);
12222  s & BOOST_SERIALIZATION_NVP(p_attribute_length);
12223  debugSerializationEnd("SgAsmJvmAttribute");
12224  }
12225 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
12226 
12227 public:
12233  uint16_t const& get_attribute_name_index() const;
12234  void set_attribute_name_index(uint16_t const&);
12237 public:
12244  uint32_t const& get_attribute_length() const;
12245  void set_attribute_length(uint32_t const&);
12247 public:
12250 
12253 
12255  virtual void unparse(std::ostream&) const override;
12256 
12258  virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
12259 public:
12261  virtual ~SgAsmJvmAttribute();
12262 
12263 protected:
12266 
12267 protected:
12274  void initializeProperties();
12275 #endif // SgAsmJvmAttribute_OTHERS
12276 #ifdef DOCUMENTATION
12277 };
12278 #endif // DOCUMENTATION
12279 
12280 
12282 // SgAsmJvmNode -- MACHINE GENERATED; DO NOT MODIFY --
12284 
12285 #ifndef DOCUMENTATION
12286 AstNodeClass& AsmJvmNode = nonTerminalConstructor(
12287  "AsmJvmNode",
12288  *this,
12289  "AsmJvmNode",
12290  "AsmJvmNodeTag",
12291  SubclassListBuilder()
12292  | AsmJvmAttribute
12293  | AsmJvmBootstrapMethod
12294  | AsmJvmClass
12295  | AsmJvmConstantPoolEntry
12296  | AsmJvmExceptionHandler
12297  | AsmJvmExceptionTable
12298  | AsmJvmField
12299  | AsmJvmInnerClassesEntry
12300  | AsmJvmLineNumberEntry
12301  | AsmJvmMethod
12302  | AsmJvmStackMapFrame
12303  | AsmJvmStackMapVerificationType
12304  , false);
12305 assert(AsmJvmNode.associatedGrammar != nullptr);
12306 AsmJvmNode.setCppCondition("!defined(DOCUMENTATION)");
12307 AsmJvmNode.isBoostSerializable(true);
12308 AsmJvmNode.setAutomaticGenerationOfConstructor(false);
12309 AsmJvmNode.setAutomaticGenerationOfDestructor(false);
12310 #endif // !DOCUMENTATION
12311 
12312 #ifdef DOCUMENTATION
12313 
12314 class SgAsmJvmNode: public SgAsmNode {
12315 #endif // DOCUMENTATION
12316 
12317  DECLARE_OTHERS(AsmJvmNode);
12318 #if defined(SgAsmJvmNode_OTHERS) || defined(DOCUMENTATION)
12319 
12320  //----------------------- Boost serialization for SgAsmJvmNode -----------------------
12321 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
12322 private:
12323  friend class boost::serialization::access;
12324 
12325  template<class S>
12326  void serialize(S &s, const unsigned /*version*/) {
12327  debugSerializationBegin("SgAsmJvmNode");
12328  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmNode);
12329  debugSerializationEnd("SgAsmJvmNode");
12330  }
12331 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
12332 public:
12334  virtual void unparse(std::ostream&) const;
12335 
12337  virtual void dump(FILE*, const char *prefix, ssize_t idx) const;
12338 public:
12340  virtual ~SgAsmJvmNode();
12341 
12342 protected:
12344  SgAsmJvmNode();
12345 
12346 protected:
12353  void initializeProperties();
12354 #endif // SgAsmJvmNode_OTHERS
12355 #ifdef DOCUMENTATION
12356 };
12357 #endif // DOCUMENTATION
12358 
12359 
12361 // SgAsmInterpretationList -- MACHINE GENERATED; DO NOT MODIFY --
12363 
12364 DECLARE_LEAF_CLASS(AsmInterpretationList);
12365 IS_SERIALIZABLE(AsmInterpretationList);
12366 
12367 #ifdef DOCUMENTATION
12369 #endif // DOCUMENTATION
12370 
12371 #ifndef DOCUMENTATION
12372  AsmInterpretationList.setDataPrototype(
12373  "SgAsmInterpretationPtrList", "interpretations", "",
12374  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
12375 #endif // !DOCUMENTATION
12376 
12377  DECLARE_OTHERS(AsmInterpretationList);
12378 #if defined(SgAsmInterpretationList_OTHERS) || defined(DOCUMENTATION)
12379 
12380  //----------------------- Boost serialization for SgAsmInterpretationList -----------------------
12381 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
12382 private:
12383  friend class boost::serialization::access;
12384 
12385  template<class S>
12386  void serialize(S &s, const unsigned /*version*/) {
12387  debugSerializationBegin("SgAsmInterpretationList");
12388  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmNode);
12389  s & BOOST_SERIALIZATION_NVP(p_interpretations);
12390  debugSerializationEnd("SgAsmInterpretationList");
12391  }
12392 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
12393 
12394 public:
12401  SgAsmInterpretationPtrList const& get_interpretations() const;
12402  SgAsmInterpretationPtrList& get_interpretations();
12403  void set_interpretations(SgAsmInterpretationPtrList const&);
12406 public:
12408  virtual ~SgAsmInterpretationList();
12409 
12410 public:
12413 
12414 protected:
12421  void initializeProperties();
12422 #endif // SgAsmInterpretationList_OTHERS
12423 #ifdef DOCUMENTATION
12424 };
12425 #endif // DOCUMENTATION
12426 
12427 
12429 // SgAsmInterpretation -- MACHINE GENERATED; DO NOT MODIFY --
12431 
12432 DECLARE_LEAF_CLASS(AsmInterpretation);
12433 IS_SERIALIZABLE(AsmInterpretation);
12434 
12435 DECLARE_HEADERS(AsmInterpretation);
12436 #if defined(SgAsmInterpretation_HEADERS) || defined(DOCUMENTATION)
12437 #include <Rose/BinaryAnalysis/BasicTypes.h>
12438 #include <Rose/BinaryAnalysis/MemoryMap.h>
12439 #endif // SgAsmInterpretation_HEADERS
12440 
12441 #ifdef DOCUMENTATION
12442 
12449 #endif // DOCUMENTATION
12450 
12451 #ifndef DOCUMENTATION
12452  AsmInterpretation.setDataPrototype(
12453  "SgAsmGenericHeaderList*", "headers", "= createAndParent<SgAsmGenericHeaderList>(this)",
12454  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
12455 #endif // !DOCUMENTATION
12456 
12457 #ifndef DOCUMENTATION
12458  AsmInterpretation.setDataPrototype(
12459  "SgAsmBlock*", "global_block", "= nullptr",
12460  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
12461 #endif // !DOCUMENTATION
12462 
12463 #ifndef DOCUMENTATION
12464  AsmInterpretation.setDataPrototype(
12465  "bool", "coverageComputed", "= false",
12466  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
12467 #endif // !DOCUMENTATION
12468 
12469 #ifndef DOCUMENTATION
12470  AsmInterpretation.setDataPrototype(
12471  "double", "percentageCoverage", "= NAN",
12472  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
12473 #endif // !DOCUMENTATION
12474 
12475  DECLARE_OTHERS(AsmInterpretation);
12476 #if defined(SgAsmInterpretation_OTHERS) || defined(DOCUMENTATION)
12477 
12478  //----------------------- Boost serialization for SgAsmInterpretation -----------------------
12479 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
12480 private:
12481  friend class boost::serialization::access;
12482 
12483  template<class S>
12484  void serialize(S &s, const unsigned /*version*/) {
12485  debugSerializationBegin("SgAsmInterpretation");
12486  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmNode);
12487  s & BOOST_SERIALIZATION_NVP(p_headers);
12488  s & BOOST_SERIALIZATION_NVP(p_global_block);
12489  s & BOOST_SERIALIZATION_NVP(p_map);
12490  s & BOOST_SERIALIZATION_NVP(instruction_map);
12491  s & BOOST_SERIALIZATION_NVP(p_coverageComputed);
12492  s & BOOST_SERIALIZATION_NVP(p_percentageCoverage);
12493  debugSerializationEnd("SgAsmInterpretation");
12494  }
12495 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
12496 
12497 public:
12506  SgAsmGenericHeaderList* const& get_headers() const;
12507  void set_headers(SgAsmGenericHeaderList* const&);
12510 public:
12516  SgAsmBlock* const& get_global_block() const;
12517  void set_global_block(SgAsmBlock* const&);
12519  // ROSETTA doesn't understand this type, but we want this treated like a property whose data member name is "p_map"
12520  // and which has automatically generator accessors and mutators named "get_map" and "set_map" and is serialized.
12521 private:
12523 
12524 public:
12533  // ROSETTA doesn't understand this type, but we want it serialized. Therfore, we'll define it as a property, but we'll
12534  // supply our own accessor and no mutator.
12535 private:
12536  mutable InstructionMap instruction_map;
12537 
12538 public:
12546  // cached instruction map
12547 
12548  InstructionMap& get_instruction_map(bool recompute = false);
12549  void set_instruction_map(const InstructionMap&);
12551 public:
12559  bool const& get_coverageComputed() const;
12560  void set_coverageComputed(bool const&);
12563 public:
12570  double const& get_percentageCoverage() const;
12571  void set_percentageCoverage(double const&);
12573 public:
12578  SgAsmGenericFilePtrList get_files() const;
12579 
12584  void insert_instructions(InstructionMap&/*in,out*/);
12585 
12590  void erase_instructions(InstructionMap&/*in,out*/);
12591 public:
12593  virtual ~SgAsmInterpretation();
12594 
12595 public:
12598 
12599 protected:
12606  void initializeProperties();
12607 #endif // SgAsmInterpretation_OTHERS
12608 #ifdef DOCUMENTATION
12609 };
12610 #endif // DOCUMENTATION
12611 
12612 
12614 // SgAsmIntegerValueExpression -- MACHINE GENERATED; DO NOT MODIFY --
12616 
12617 DECLARE_LEAF_CLASS(AsmIntegerValueExpression);
12618 IS_SERIALIZABLE(AsmIntegerValueExpression);
12619 
12620 #ifdef DOCUMENTATION
12621 
12637 #endif // DOCUMENTATION
12638 
12639 #ifndef DOCUMENTATION
12640  AsmIntegerValueExpression.setDataPrototype(
12641  "SgNode*", "baseNode", "= nullptr",
12642  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
12643 #endif // !DOCUMENTATION
12644 
12645  DECLARE_OTHERS(AsmIntegerValueExpression);
12646 #if defined(SgAsmIntegerValueExpression_OTHERS) || defined(DOCUMENTATION)
12647 
12648  //----------------------- Boost serialization for SgAsmIntegerValueExpression -----------------------
12649 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
12650 private:
12651  friend class boost::serialization::access;
12652 
12653  template<class S>
12654  void serialize(S &s, const unsigned /*version*/) {
12655  debugSerializationBegin("SgAsmIntegerValueExpression");
12656  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmConstantExpression);
12657  s & BOOST_SERIALIZATION_NVP(p_baseNode);
12658  debugSerializationEnd("SgAsmIntegerValueExpression");
12659  }
12660 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
12661 
12662 public:
12673  SgNode* const& get_baseNode() const;
12674  void set_baseNode(SgNode* const&);
12676 public:
12681  SgAsmIntegerValueExpression(uint64_t n, SgAsmType *type);
12682 
12689 
12691  static uint64_t virtualAddress(SgNode*);
12692 
12712  std::string get_label(bool quiet=false) const;
12713 
12715  size_t get_significantBits() const;
12716 
12722  void makeRelativeTo(SgNode *baseNode);
12723 
12728  uint64_t get_baseAddress() const;
12729 
12735  uint64_t get_absoluteValue(size_t nbits=0) const;
12736 
12740  void set_absoluteValue(uint64_t);
12741 
12743  int64_t get_signedValue() const;
12744 
12748  int64_t get_relativeValue() const;
12749 
12754  void set_relativeValue(int64_t v, size_t nbits=64);
12755 
12756  uint64_t get_value() const { return get_absoluteValue(); }
12757 public:
12759  virtual ~SgAsmIntegerValueExpression();
12760 
12761 public:
12764 
12765 protected:
12772  void initializeProperties();
12773 #endif // SgAsmIntegerValueExpression_OTHERS
12774 #ifdef DOCUMENTATION
12775 };
12776 #endif // DOCUMENTATION
12777 
12778 
12780 // SgAsmIntegerType -- MACHINE GENERATED; DO NOT MODIFY --
12782 
12783 DECLARE_LEAF_CLASS(AsmIntegerType);
12784 IS_SERIALIZABLE(AsmIntegerType);
12785 
12786 DECLARE_HEADERS(AsmIntegerType);
12787 #if defined(SgAsmIntegerType_HEADERS) || defined(DOCUMENTATION)
12788 #include <Rose/BinaryAnalysis/ByteOrder.h>
12789 #endif // SgAsmIntegerType_HEADERS
12790 
12791 #ifdef DOCUMENTATION
12792 
12794 #endif // DOCUMENTATION
12795 
12796 #ifndef DOCUMENTATION
12797  AsmIntegerType.setDataPrototype(
12798  "bool", "isSigned", "= false",
12799  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
12800 #endif // !DOCUMENTATION
12801 
12802  DECLARE_OTHERS(AsmIntegerType);
12803 #if defined(SgAsmIntegerType_OTHERS) || defined(DOCUMENTATION)
12804 
12805  //----------------------- Boost serialization for SgAsmIntegerType -----------------------
12806 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
12807 private:
12808  friend class boost::serialization::access;
12809 
12810  template<class S>
12811  void serialize(S &s, const unsigned /*version*/) {
12812  debugSerializationBegin("SgAsmIntegerType");
12813  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmScalarType);
12814  s & BOOST_SERIALIZATION_NVP(p_isSigned);
12815  debugSerializationEnd("SgAsmIntegerType");
12816  }
12817 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
12818 
12819 public:
12825  bool get_isSigned() const;
12828 public:
12832  SgAsmIntegerType(Rose::BinaryAnalysis::ByteOrder::Endianness, size_t nBits, bool isSigned);
12833 
12834  // Overrides documented in base class
12835  virtual void check() const override;
12836  virtual std::string toString() const override;
12837 public:
12839  virtual ~SgAsmIntegerType();
12840 
12841 public:
12843  SgAsmIntegerType();
12844 
12845 protected:
12852  void initializeProperties();
12853 #endif // SgAsmIntegerType_OTHERS
12854 #ifdef DOCUMENTATION
12855 };
12856 #endif // DOCUMENTATION
12857 
12858 
12860 // SgAsmInstructionList -- MACHINE GENERATED; DO NOT MODIFY --
12862 
12863 DECLARE_LEAF_CLASS(AsmInstructionList);
12864 IS_SERIALIZABLE(AsmInstructionList);
12865 
12866 #ifdef DOCUMENTATION
12867 
12869 #endif // DOCUMENTATION
12870 
12871 #ifndef DOCUMENTATION
12872  AsmInstructionList.setDataPrototype(
12873  "SgAsmInstructionPtrList", "instructions", "",
12874  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
12875 #endif // !DOCUMENTATION
12876 
12877  DECLARE_OTHERS(AsmInstructionList);
12878 #if defined(SgAsmInstructionList_OTHERS) || defined(DOCUMENTATION)
12879 
12880  //----------------------- Boost serialization for SgAsmInstructionList -----------------------
12881 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
12882 private:
12883  friend class boost::serialization::access;
12884 
12885  template<class S>
12886  void serialize(S &s, const unsigned /*version*/) {
12887  debugSerializationBegin("SgAsmInstructionList");
12888  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmNode);
12889  s & BOOST_SERIALIZATION_NVP(p_instructions);
12890  debugSerializationEnd("SgAsmInstructionList");
12891  }
12892 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
12893 
12894 public:
12902  SgAsmInstructionPtrList const& get_instructions() const;
12903  SgAsmInstructionPtrList& get_instructions();
12904  void set_instructions(SgAsmInstructionPtrList const&);
12907 public:
12909  virtual ~SgAsmInstructionList();
12910 
12911 public:
12914 
12915 protected:
12922  void initializeProperties();
12923 #endif // SgAsmInstructionList_OTHERS
12924 #ifdef DOCUMENTATION
12925 };
12926 #endif // DOCUMENTATION
12927 
12928 
12930 // SgAsmIndirectRegisterExpression -- MACHINE GENERATED; DO NOT MODIFY --
12932 
12933 DECLARE_LEAF_CLASS(AsmIndirectRegisterExpression);
12934 IS_SERIALIZABLE(AsmIndirectRegisterExpression);
12935 
12936 #ifdef DOCUMENTATION
12937 
12954 #endif // DOCUMENTATION
12955 
12956 #ifndef DOCUMENTATION
12957  AsmIndirectRegisterExpression.setDataPrototype(
12958  "Rose::BinaryAnalysis::RegisterDescriptor", "stride", "",
12959  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
12960 #endif // !DOCUMENTATION
12961 
12962 #ifndef DOCUMENTATION
12963  AsmIndirectRegisterExpression.setDataPrototype(
12964  "Rose::BinaryAnalysis::RegisterDescriptor", "offset", "",
12965  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
12966 #endif // !DOCUMENTATION
12967 
12968 #ifndef DOCUMENTATION
12969  AsmIndirectRegisterExpression.setDataPrototype(
12970  "size_t", "index", "= 0",
12971  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
12972 #endif // !DOCUMENTATION
12973 
12974 #ifndef DOCUMENTATION
12975  AsmIndirectRegisterExpression.setDataPrototype(
12976  "size_t", "modulus", "= 0",
12977  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
12978 #endif // !DOCUMENTATION
12979 
12980  DECLARE_OTHERS(AsmIndirectRegisterExpression);
12981 #if defined(SgAsmIndirectRegisterExpression_OTHERS) || defined(DOCUMENTATION)
12982 
12983  //----------------------- Boost serialization for SgAsmIndirectRegisterExpression -----------------------
12984 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
12985 private:
12986  friend class boost::serialization::access;
12987 
12988  template<class S>
12989  void serialize(S &s, const unsigned /*version*/) {
12990  debugSerializationBegin("SgAsmIndirectRegisterExpression");
12991  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmRegisterReferenceExpression);
12992  s & BOOST_SERIALIZATION_NVP(p_stride);
12993  s & BOOST_SERIALIZATION_NVP(p_offset);
12994  s & BOOST_SERIALIZATION_NVP(p_index);
12995  s & BOOST_SERIALIZATION_NVP(p_modulus);
12996  debugSerializationEnd("SgAsmIndirectRegisterExpression");
12997  }
12998 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
12999 
13000 public:
13010 public:
13020 public:
13026  size_t const& get_index() const;
13027  void set_index(size_t const&);
13030 public:
13036  size_t const& get_modulus() const;
13037  void set_modulus(size_t const&);
13040 public:
13043 
13044 public:
13047 
13048 public:
13053  size_t const& index,
13054  size_t const& modulus);
13055 
13056 protected:
13063  void initializeProperties();
13064 #endif // SgAsmIndirectRegisterExpression_OTHERS
13065 #ifdef DOCUMENTATION
13066 };
13067 #endif // DOCUMENTATION
13068 
13069 
13071 // SgAsmGenericSymbolList -- MACHINE GENERATED; DO NOT MODIFY --
13073 
13074 DECLARE_LEAF_CLASS(AsmGenericSymbolList);
13075 IS_SERIALIZABLE(AsmGenericSymbolList);
13076 
13077 #ifdef DOCUMENTATION
13078 
13083 #endif // DOCUMENTATION
13084 
13085 #ifndef DOCUMENTATION
13086  AsmGenericSymbolList.setDataPrototype(
13087  "SgAsmGenericSymbolPtrList", "symbols", "",
13088  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
13089 #endif // !DOCUMENTATION
13090 
13091  DECLARE_OTHERS(AsmGenericSymbolList);
13092 #if defined(SgAsmGenericSymbolList_OTHERS) || defined(DOCUMENTATION)
13093 
13094  //----------------------- Boost serialization for SgAsmGenericSymbolList -----------------------
13095 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
13096 private:
13097  friend class boost::serialization::access;
13098 
13099  template<class S>
13100  void serialize(S &s, const unsigned /*version*/) {
13101  debugSerializationBegin("SgAsmGenericSymbolList");
13102  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
13103  s & BOOST_SERIALIZATION_NVP(p_symbols);
13104  debugSerializationEnd("SgAsmGenericSymbolList");
13105  }
13106 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
13107 
13108 public:
13112  SgAsmGenericSymbolPtrList const& get_symbols() const;
13113  SgAsmGenericSymbolPtrList& get_symbols();
13114  void set_symbols(SgAsmGenericSymbolPtrList const&);
13117 public:
13119  virtual ~SgAsmGenericSymbolList();
13120 
13121 public:
13124 
13125 protected:
13132  void initializeProperties();
13133 #endif // SgAsmGenericSymbolList_OTHERS
13134 #ifdef DOCUMENTATION
13135 };
13136 #endif // DOCUMENTATION
13137 
13138 
13140 // SgAsmGenericSectionList -- MACHINE GENERATED; DO NOT MODIFY --
13142 
13143 DECLARE_LEAF_CLASS(AsmGenericSectionList);
13144 IS_SERIALIZABLE(AsmGenericSectionList);
13145 
13146 #ifdef DOCUMENTATION
13147 
13152 #endif // DOCUMENTATION
13153 
13154 #ifndef DOCUMENTATION
13155  AsmGenericSectionList.setDataPrototype(
13156  "SgAsmGenericSectionPtrList", "sections", "",
13157  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
13158 #endif // !DOCUMENTATION
13159 
13160  DECLARE_OTHERS(AsmGenericSectionList);
13161 #if defined(SgAsmGenericSectionList_OTHERS) || defined(DOCUMENTATION)
13162 
13163  //----------------------- Boost serialization for SgAsmGenericSectionList -----------------------
13164 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
13165 private:
13166  friend class boost::serialization::access;
13167 
13168  template<class S>
13169  void serialize(S &s, const unsigned /*version*/) {
13170  debugSerializationBegin("SgAsmGenericSectionList");
13171  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
13172  s & BOOST_SERIALIZATION_NVP(p_sections);
13173  debugSerializationEnd("SgAsmGenericSectionList");
13174  }
13175 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
13176 
13177 public:
13181  SgAsmGenericSectionPtrList const& get_sections() const;
13182  SgAsmGenericSectionPtrList& get_sections();
13183  void set_sections(SgAsmGenericSectionPtrList const&);
13186 public:
13188  virtual ~SgAsmGenericSectionList();
13189 
13190 public:
13193 
13194 protected:
13201  void initializeProperties();
13202 #endif // SgAsmGenericSectionList_OTHERS
13203 #ifdef DOCUMENTATION
13204 };
13205 #endif // DOCUMENTATION
13206 
13207 
13209 // SgAsmGenericHeaderList -- MACHINE GENERATED; DO NOT MODIFY --
13211 
13212 DECLARE_LEAF_CLASS(AsmGenericHeaderList);
13213 IS_SERIALIZABLE(AsmGenericHeaderList);
13214 
13215 #ifdef DOCUMENTATION
13216 
13221 #endif // DOCUMENTATION
13222 
13223 #ifndef DOCUMENTATION
13224  AsmGenericHeaderList.setDataPrototype(
13225  "SgAsmGenericHeaderPtrList", "headers", "",
13226  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
13227 #endif // !DOCUMENTATION
13228 
13229  DECLARE_OTHERS(AsmGenericHeaderList);
13230 #if defined(SgAsmGenericHeaderList_OTHERS) || defined(DOCUMENTATION)
13231 
13232  //----------------------- Boost serialization for SgAsmGenericHeaderList -----------------------
13233 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
13234 private:
13235  friend class boost::serialization::access;
13236 
13237  template<class S>
13238  void serialize(S &s, const unsigned /*version*/) {
13239  debugSerializationBegin("SgAsmGenericHeaderList");
13240  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
13241  s & BOOST_SERIALIZATION_NVP(p_headers);
13242  debugSerializationEnd("SgAsmGenericHeaderList");
13243  }
13244 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
13245 
13246 public:
13250  SgAsmGenericHeaderPtrList const& get_headers() const;
13251  SgAsmGenericHeaderPtrList& get_headers();
13252  void set_headers(SgAsmGenericHeaderPtrList const&);
13255 public:
13257  virtual ~SgAsmGenericHeaderList();
13258 
13259 public:
13262 
13263 protected:
13270  void initializeProperties();
13271 #endif // SgAsmGenericHeaderList_OTHERS
13272 #ifdef DOCUMENTATION
13273 };
13274 #endif // DOCUMENTATION
13275 
13276 
13278 // SgAsmGenericFormat -- MACHINE GENERATED; DO NOT MODIFY --
13280 
13281 DECLARE_LEAF_CLASS(AsmGenericFormat);
13282 IS_SERIALIZABLE(AsmGenericFormat);
13283 
13284 DECLARE_HEADERS(AsmGenericFormat);
13285 #if defined(SgAsmGenericFormat_HEADERS) || defined(DOCUMENTATION)
13286 #include <Rose/BinaryAnalysis/ByteOrder.h>
13287 #endif // SgAsmGenericFormat_HEADERS
13288 
13289 #ifdef DOCUMENTATION
13290 
13292 #endif // DOCUMENTATION
13293 
13294 #ifndef DOCUMENTATION
13295  AsmGenericFormat.setDataPrototype(
13296  "SgAsmGenericFormat::ExecFamily", "family", "= SgAsmGenericFormat::FAMILY_UNSPECIFIED",
13297  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
13298 #endif // !DOCUMENTATION
13299 
13300 #ifndef DOCUMENTATION
13301  AsmGenericFormat.setDataPrototype(
13302  "SgAsmGenericFormat::ExecPurpose", "purpose", "= SgAsmGenericFormat::PURPOSE_EXECUTABLE",
13303  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
13304 #endif // !DOCUMENTATION
13305 
13306 #ifndef DOCUMENTATION
13307  AsmGenericFormat.setDataPrototype(
13308  "Rose::BinaryAnalysis::ByteOrder::Endianness", "sex", "= Rose::BinaryAnalysis::ByteOrder::ORDER_UNSPECIFIED",
13309  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
13310 #endif // !DOCUMENTATION
13311 
13312 #ifndef DOCUMENTATION
13313  AsmGenericFormat.setDataPrototype(
13314  "unsigned", "version", "= 0",
13315  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
13316 #endif // !DOCUMENTATION
13317 
13318 #ifndef DOCUMENTATION
13319  AsmGenericFormat.setDataPrototype(
13320  "bool", "is_current_version", "= false",
13321  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
13322 #endif // !DOCUMENTATION
13323 
13324 #ifndef DOCUMENTATION
13325  AsmGenericFormat.setDataPrototype(
13326  "SgAsmGenericFormat::ExecABI", "abi", "= SgAsmGenericFormat::ABI_UNSPECIFIED",
13327  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
13328 #endif // !DOCUMENTATION
13329 
13330 #ifndef DOCUMENTATION
13331  AsmGenericFormat.setDataPrototype(
13332  "unsigned", "abi_version", "= 0",
13333  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
13334 #endif // !DOCUMENTATION
13335 
13336 #ifndef DOCUMENTATION
13337  AsmGenericFormat.setDataPrototype(
13338  "size_t", "word_size", "= 0",
13339  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
13340 #endif // !DOCUMENTATION
13341 
13342  DECLARE_OTHERS(AsmGenericFormat);
13343 #if defined(SgAsmGenericFormat_OTHERS) || defined(DOCUMENTATION)
13344 
13345  //----------------------- Boost serialization for SgAsmGenericFormat -----------------------
13346 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
13347 private:
13348  friend class boost::serialization::access;
13349 
13350  template<class S>
13351  void serialize(S &s, const unsigned /*version*/) {
13352  debugSerializationBegin("SgAsmGenericFormat");
13353  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
13354  s & BOOST_SERIALIZATION_NVP(p_family);
13355  s & BOOST_SERIALIZATION_NVP(p_purpose);
13356  s & BOOST_SERIALIZATION_NVP(p_sex);
13357  s & BOOST_SERIALIZATION_NVP(p_version);
13358  s & BOOST_SERIALIZATION_NVP(p_is_current_version);
13359  s & BOOST_SERIALIZATION_NVP(p_abi);
13360  s & BOOST_SERIALIZATION_NVP(p_abi_version);
13361  s & BOOST_SERIALIZATION_NVP(p_word_size);
13362  debugSerializationEnd("SgAsmGenericFormat");
13363  }
13364 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
13365 
13366 public:
13374 public:
13382 public:
13386  Rose::BinaryAnalysis::ByteOrder::Endianness const& get_sex() const;
13387  void set_sex(Rose::BinaryAnalysis::ByteOrder::Endianness const&);
13390 public:
13394  unsigned const& get_version() const;
13395  void set_version(unsigned const&);
13398 public:
13405  bool const& get_is_current_version() const;
13406  void set_is_current_version(bool const&);
13409 public:
13413  SgAsmGenericFormat::ExecABI const& get_abi() const;
13414  void set_abi(SgAsmGenericFormat::ExecABI const&);
13417 public:
13421  unsigned const& get_abi_version() const;
13422  void set_abi_version(unsigned const&);
13425 public:
13429  size_t const& get_word_size() const;
13430  void set_word_size(size_t const&);
13432 public:
13434  void dump(FILE*, const char *prefix, ssize_t idx) const;
13435 public:
13437  virtual ~SgAsmGenericFormat();
13438 
13439 public:
13442 
13443 protected:
13450  void initializeProperties();
13451 #endif // SgAsmGenericFormat_OTHERS
13452 #ifdef DOCUMENTATION
13453 };
13454 #endif // DOCUMENTATION
13455 
13456 
13458 // SgAsmGenericFileList -- MACHINE GENERATED; DO NOT MODIFY --
13460 
13461 DECLARE_LEAF_CLASS(AsmGenericFileList);
13462 IS_SERIALIZABLE(AsmGenericFileList);
13463 
13464 #ifdef DOCUMENTATION
13465 
13470 #endif // DOCUMENTATION
13471 
13472 #ifndef DOCUMENTATION
13473  AsmGenericFileList.setDataPrototype(
13474  "SgAsmGenericFilePtrList", "files", "",
13475  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
13476 #endif // !DOCUMENTATION
13477 
13478  DECLARE_OTHERS(AsmGenericFileList);
13479 #if defined(SgAsmGenericFileList_OTHERS) || defined(DOCUMENTATION)
13480 
13481  //----------------------- Boost serialization for SgAsmGenericFileList -----------------------
13482 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
13483 private:
13484  friend class boost::serialization::access;
13485 
13486  template<class S>
13487  void serialize(S &s, const unsigned /*version*/) {
13488  debugSerializationBegin("SgAsmGenericFileList");
13489  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmNode);
13490  s & BOOST_SERIALIZATION_NVP(p_files);
13491  debugSerializationEnd("SgAsmGenericFileList");
13492  }
13493 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
13494 
13495 public:
13499  SgAsmGenericFilePtrList const& get_files() const;
13500  SgAsmGenericFilePtrList& get_files();
13501  void set_files(SgAsmGenericFilePtrList const&);
13504 public:
13506  virtual ~SgAsmGenericFileList();
13507 
13508 public:
13511 
13512 protected:
13519  void initializeProperties();
13520 #endif // SgAsmGenericFileList_OTHERS
13521 #ifdef DOCUMENTATION
13522 };
13523 #endif // DOCUMENTATION
13524 
13525 
13527 // SgAsmGenericFile -- MACHINE GENERATED; DO NOT MODIFY --
13529 
13530 DECLARE_LEAF_CLASS(AsmGenericFile);
13531 IS_SERIALIZABLE(AsmGenericFile);
13532 
13533 DECLARE_HEADERS(AsmGenericFile);
13534 #if defined(SgAsmGenericFile_HEADERS) || defined(DOCUMENTATION)
13535 #include <Rose/BinaryAnalysis/MemoryMap.h>
13536 #include "DataConversion.h"
13537 #include "StatSerializer.h" // non-intrusive serialization of struct stat
13538 #endif // SgAsmGenericFile_HEADERS
13539 
13540 #ifdef DOCUMENTATION
13541 
13543 #endif // DOCUMENTATION
13544 
13545 #ifndef DOCUMENTATION
13546  AsmGenericFile.setDataPrototype(
13547  "SgAsmDwarfCompilationUnitList*", "dwarf_info", "= nullptr",
13548  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
13549 #endif // !DOCUMENTATION
13550 
13551 #ifndef DOCUMENTATION
13552  AsmGenericFile.setDataPrototype(
13553  "std::string", "name", "",
13554  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
13555 #endif // !DOCUMENTATION
13556 
13557 #ifndef DOCUMENTATION
13558  AsmGenericFile.setDataPrototype(
13559  "int", "fd", "= -1",
13560  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
13561 #endif // !DOCUMENTATION
13562 
13563 #ifndef DOCUMENTATION
13564  AsmGenericFile.setDataPrototype(
13565  "struct stat", "sb", "",
13566  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
13567 #endif // !DOCUMENTATION
13568 
13569 #ifndef DOCUMENTATION
13570  AsmGenericFile.setDataPrototype(
13571  "SgFileContentList", "data", "",
13572  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
13573 #endif // !DOCUMENTATION
13574 
13575 #ifndef DOCUMENTATION
13576  AsmGenericFile.setDataPrototype(
13577  "SgAsmGenericHeaderList*", "headers", "= createAndParent<SgAsmGenericHeaderList>(this)",
13578  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
13579 #endif // !DOCUMENTATION
13580 
13581 #ifndef DOCUMENTATION
13582  AsmGenericFile.setDataPrototype(
13583  "SgAsmGenericSectionList*", "holes", "= createAndParent<SgAsmGenericSectionList>(this)",
13584  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
13585 #endif // !DOCUMENTATION
13586 
13587 #ifndef DOCUMENTATION
13588  AsmGenericFile.setDataPrototype(
13589  "bool", "truncate_zeros", "= false",
13590  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
13591 #endif // !DOCUMENTATION
13592 
13593 #ifndef DOCUMENTATION
13594  AsmGenericFile.setDataPrototype(
13595  "bool", "tracking_references", "= true",
13596  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
13597 #endif // !DOCUMENTATION
13598 
13599 #ifndef DOCUMENTATION
13600  AsmGenericFile.setDataPrototype(
13601  "AddressIntervalSet", "referenced_extents", "",
13602  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
13603 #endif // !DOCUMENTATION
13604 
13605 #ifndef DOCUMENTATION
13606  AsmGenericFile.setDataPrototype(
13607  "bool", "neuter", "= false",
13608  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
13609 #endif // !DOCUMENTATION
13610 
13611  DECLARE_OTHERS(AsmGenericFile);
13612 #if defined(SgAsmGenericFile_OTHERS) || defined(DOCUMENTATION)
13613 
13614  //----------------------- Boost serialization for SgAsmGenericFile -----------------------
13615 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
13616 private:
13617  friend class boost::serialization::access;
13618 
13619  template<class S>
13620  void serialize(S &s, const unsigned /*version*/) {
13621  debugSerializationBegin("SgAsmGenericFile");
13622  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
13623  s & BOOST_SERIALIZATION_NVP(p_dwarf_info);
13624  s & BOOST_SERIALIZATION_NVP(p_name);
13625  s & BOOST_SERIALIZATION_NVP(p_sb);
13626  s & BOOST_SERIALIZATION_NVP(p_data);
13627  s & BOOST_SERIALIZATION_NVP(p_headers);
13628  s & BOOST_SERIALIZATION_NVP(p_holes);
13629  s & BOOST_SERIALIZATION_NVP(p_truncate_zeros);
13630  s & BOOST_SERIALIZATION_NVP(p_tracking_references);
13631  s & BOOST_SERIALIZATION_NVP(p_referenced_extents);
13632  s & BOOST_SERIALIZATION_NVP(p_neuter);
13633  debugSerializationEnd("SgAsmGenericFile");
13634  }
13635 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
13636  // Local types
13639 public:
13642  ADDRSP_MEMORY = 0x0001,
13643  ADDRSP_FILE = 0x0002,
13644  ADDRSP_ALL = 0x0003
13645  };
13646 
13648  enum Elasticity {
13652  };
13653 
13655  // Properties
13657 public:
13665 public:
13669  std::string const& get_name() const;
13670  void set_name(std::string const&);
13673 public:
13679  int const& get_fd() const;
13680  void set_fd(int const&);
13683 public:
13684  struct stat const& get_sb() const;
13685 
13686 public:
13690  SgFileContentList const& get_data() const;
13691  void set_data(SgFileContentList const&);
13694 public:
13700  SgAsmGenericHeaderList* const& get_headers() const;
13701  void set_headers(SgAsmGenericHeaderList* const&);
13704 public:
13711  SgAsmGenericSectionList* const& get_holes() const;
13712  void set_holes(SgAsmGenericSectionList* const&);
13715 public:
13719  bool const& get_truncate_zeros() const;
13720  void set_truncate_zeros(bool const&);
13723 public:
13727  bool const& get_tracking_references() const;
13728  void set_tracking_references(bool const&);
13731 public:
13739 public:
13743  bool const& get_neuter() const;
13744  void set_neuter(bool const&);
13746  // Non-property data members
13749 private:
13750  mutable AddressIntervalSet *p_unreferenced_cache = nullptr;
13751  DataConverter *p_data_converter = nullptr;
13752 
13754  // Functions
13756 public:
13758  SgAsmGenericFile* parse(std::string file_name);
13759 
13761  void reallocate();
13762 
13769  void unparse(std::ostream&) const;
13770 
13772  void extend_to_eof(std::ostream&) const;
13773 
13775  void dump(FILE*) const;
13776 
13783  void dump_all(bool in_cwd=true, const char *ext=NULL);
13784 
13786  void dump_all(const std::string& dumpname);
13787 
13790 
13792  void mark_referenced_extent(rose_addr_t start_rva, rose_addr_t size);
13793 
13799  void set_data_converter(DataConverter* dc) {p_data_converter=dc;}
13800  DataConverter* get_data_converter() const {return p_data_converter;}
13804  rose_addr_t get_current_size() const;
13805 
13807  rose_addr_t get_orig_size() const;
13808 
13816  size_t read_content(rose_addr_t offset, void *dst_buf, rose_addr_t size, bool strict=true);
13817 
13825  size_t read_content(const Rose::BinaryAnalysis::MemoryMap::Ptr&, rose_addr_t va, void *dst_buf,
13826  rose_addr_t size, bool strict=true);
13827 
13835  std::string read_content_str(const Rose::BinaryAnalysis::MemoryMap::Ptr&, rose_addr_t va, bool strict=true);
13836 
13844  std::string read_content_str(rose_addr_t abs_offset, bool strict=true);
13845 
13847  const SgFileContentList& content() { return p_data; }
13848 
13855  SgFileContentList content(rose_addr_t offset, rose_addr_t size);
13856 
13858  SgAsmGenericSectionPtrList get_mapped_sections() const;
13859 
13861  SgAsmGenericSectionPtrList get_sections(bool include_holes=true) const;
13862 
13864  SgAsmGenericSectionPtrList get_sections_by_id(int id) const;
13865 
13867  SgAsmGenericSectionPtrList get_sections_by_name(std::string, char sep='\0') const;
13868 
13873  SgAsmGenericSectionPtrList get_sections_by_offset(rose_addr_t offset, rose_addr_t size) const;
13874 
13879  SgAsmGenericSectionPtrList get_sections_by_rva(rose_addr_t rva) const;
13880 
13885  SgAsmGenericSectionPtrList get_sections_by_va(rose_addr_t va) const;
13886 
13891  SgAsmGenericSection *get_section_by_id(int id, size_t *nfound=0) const;
13892 
13898  SgAsmGenericSection *get_section_by_name(const std::string&, char sep=0, size_t *nfound=0) const;
13899 
13904  SgAsmGenericSection *get_section_by_offset(rose_addr_t offset, rose_addr_t size, size_t *nfound=0) const;
13905 
13910  SgAsmGenericSection *get_section_by_rva(rose_addr_t rva, size_t *nfound=0) const;
13911 
13916  SgAsmGenericSection *get_section_by_va(rose_addr_t va, size_t *nfound=0) const;
13917 
13923  SgAsmGenericSection *get_best_section_by_va(rose_addr_t va, size_t *nfound=0) const;
13924 
13935  static SgAsmGenericSection *best_section_by_va(const SgAsmGenericSectionPtrList &sections, rose_addr_t va);
13936 
13976  void shift_extend(SgAsmGenericSection*, rose_addr_t sa, rose_addr_t sn, AddressSpace, Elasticity);
13977  void shift_extend(SgAsmGenericSection *s, rose_addr_t sa, rose_addr_t sn) {
13978  shift_extend(s, sa, sn, ADDRSP_ALL, ELASTIC_UNREF);
13979  }
13986  rose_addr_t get_next_section_offset(rose_addr_t offset);
13987 
13992 
13995 
14001  void fill_holes();
14002 
14006  void unfill_holes();
14007 
14012 
14015 
14018 
14023  const char *format_name() const;
14024 
14025 protected:
14026  // Some extra clean-up actions on destruction
14027  virtual void destructorHelper() override;
14028 public:
14030  virtual ~SgAsmGenericFile();
14031 
14032 public:
14034  SgAsmGenericFile();
14035 
14036 protected:
14043  void initializeProperties();
14044 #endif // SgAsmGenericFile_OTHERS
14045 #ifdef DOCUMENTATION
14046 };
14047 #endif // DOCUMENTATION
14048 
14049 
14051 // SgAsmGenericDLLList -- MACHINE GENERATED; DO NOT MODIFY --
14053 
14054 DECLARE_LEAF_CLASS(AsmGenericDLLList);
14055 IS_SERIALIZABLE(AsmGenericDLLList);
14056 
14057 #ifdef DOCUMENTATION
14058 
14063 #endif // DOCUMENTATION
14064 
14065 #ifndef DOCUMENTATION
14066  AsmGenericDLLList.setDataPrototype(
14067  "SgAsmGenericDLLPtrList", "dlls", "",
14068  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
14069 #endif // !DOCUMENTATION
14070 
14071  DECLARE_OTHERS(AsmGenericDLLList);
14072 #if defined(SgAsmGenericDLLList_OTHERS) || defined(DOCUMENTATION)
14073 
14074  //----------------------- Boost serialization for SgAsmGenericDLLList -----------------------
14075 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
14076 private:
14077  friend class boost::serialization::access;
14078 
14079  template<class S>
14080  void serialize(S &s, const unsigned /*version*/) {
14081  debugSerializationBegin("SgAsmGenericDLLList");
14082  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
14083  s & BOOST_SERIALIZATION_NVP(p_dlls);
14084  debugSerializationEnd("SgAsmGenericDLLList");
14085  }
14086 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
14087 
14088 public:
14092  SgAsmGenericDLLPtrList const& get_dlls() const;
14093  SgAsmGenericDLLPtrList& get_dlls();
14094  void set_dlls(SgAsmGenericDLLPtrList const&);
14097 public:
14099  virtual ~SgAsmGenericDLLList();
14100 
14101 public:
14104 
14105 protected:
14112  void initializeProperties();
14113 #endif // SgAsmGenericDLLList_OTHERS
14114 #ifdef DOCUMENTATION
14115 };
14116 #endif // DOCUMENTATION
14117 
14118 
14120 // SgAsmGenericDLL -- MACHINE GENERATED; DO NOT MODIFY --
14122 
14123 DECLARE_LEAF_CLASS(AsmGenericDLL);
14124 IS_SERIALIZABLE(AsmGenericDLL);
14125 
14126 #ifdef DOCUMENTATION
14127 
14129 #endif // DOCUMENTATION
14130 
14131 #ifndef DOCUMENTATION
14132  AsmGenericDLL.setDataPrototype(
14133  "SgAsmGenericString*", "name", "= createAndParent<SgAsmBasicString>(this)",
14134  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
14135 #endif // !DOCUMENTATION
14136 
14137 #ifndef DOCUMENTATION
14138  AsmGenericDLL.setDataPrototype(
14139  "SgStringList", "symbols", "",
14140  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
14141 #endif // !DOCUMENTATION
14142 
14143  DECLARE_OTHERS(AsmGenericDLL);
14144 #if defined(SgAsmGenericDLL_OTHERS) || defined(DOCUMENTATION)
14145 
14146  //----------------------- Boost serialization for SgAsmGenericDLL -----------------------
14147 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
14148 private:
14149  friend class boost::serialization::access;
14150 
14151  template<class S>
14152  void serialize(S &s, const unsigned /*version*/) {
14153  debugSerializationBegin("SgAsmGenericDLL");
14154  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
14155  s & BOOST_SERIALIZATION_NVP(p_name);
14156  s & BOOST_SERIALIZATION_NVP(p_symbols);
14157  debugSerializationEnd("SgAsmGenericDLL");
14158  }
14159 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
14160 
14161 public:
14165  SgAsmGenericString* const& get_name() const;
14166  void set_name(SgAsmGenericString *s);
14168 public:
14172  SgStringList const& get_symbols() const;
14173  void set_symbols(SgStringList const&);
14175 public:
14177  explicit SgAsmGenericDLL(SgAsmGenericString *s);
14178 
14180  virtual void dump(FILE*, const char *prefix, ssize_t idx) const;
14181 
14183  void add_symbol(const std::string &s) {
14184  p_symbols.push_back(s);
14185  }
14186 public:
14188  virtual ~SgAsmGenericDLL();
14189 
14190 public:
14192  SgAsmGenericDLL();
14193 
14194 protected:
14201  void initializeProperties();
14202 #endif // SgAsmGenericDLL_OTHERS
14203 #ifdef DOCUMENTATION
14204 };
14205 #endif // DOCUMENTATION
14206 
14207 
14209 // SgAsmFunction -- MACHINE GENERATED; DO NOT MODIFY --
14211 
14212 DECLARE_LEAF_CLASS(AsmFunction);
14213 IS_SERIALIZABLE(AsmFunction);
14214 
14215 #ifdef DOCUMENTATION
14216 
14232 #endif // DOCUMENTATION
14233 
14234 #ifndef DOCUMENTATION
14235  AsmFunction.setDataPrototype(
14236  "std::string", "name", "",
14237  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
14238 #endif // !DOCUMENTATION
14239 
14240 #ifndef DOCUMENTATION
14241  AsmFunction.setDataPrototype(
14242  "unsigned", "reason", "= SgAsmFunction::FUNC_NONE",
14243  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
14244 #endif // !DOCUMENTATION
14245 
14246 #ifndef DOCUMENTATION
14247  AsmFunction.setDataPrototype(
14248  "std::string", "reasonComment", "",
14249  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
14250 #endif // !DOCUMENTATION
14251 
14252 #ifndef DOCUMENTATION
14253  AsmFunction.setDataPrototype(
14254  "SgAsmFunction::function_kind_enum", "function_kind", "= SgAsmFunction::e_unknown",
14255  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
14256 #endif // !DOCUMENTATION
14257 
14258 #ifndef DOCUMENTATION
14259  AsmFunction.setDataPrototype(
14260  "SgAsmFunction::MayReturn", "may_return", "= SgAsmFunction::RET_UNKNOWN",
14261  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
14262 #endif // !DOCUMENTATION
14263 
14264 #ifndef DOCUMENTATION
14265  AsmFunction.setDataPrototype(
14266  "std::string", "name_md5", "",
14267  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
14268 #endif // !DOCUMENTATION
14269 
14270 #ifndef DOCUMENTATION
14271  AsmFunction.setDataPrototype(
14272  "SgAsmStatementPtrList", "statementList", "",
14273  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
14274 #endif // !DOCUMENTATION
14275 
14276 #ifndef DOCUMENTATION
14277  AsmFunction.setDataPrototype(
14278  "SgAsmStatementPtrList", "dest", "",
14279  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
14280 #endif // !DOCUMENTATION
14281 
14282 #ifndef DOCUMENTATION
14283  AsmFunction.setDataPrototype(
14284  "rose_addr_t", "entry_va", "= 0",
14285  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
14286 #endif // !DOCUMENTATION
14287 
14288 #ifndef DOCUMENTATION
14289  AsmFunction.setDataPrototype(
14290  "SgSymbolTable*", "symbol_table", "= nullptr",
14291  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
14292 #endif // !DOCUMENTATION
14293 
14294 #ifndef DOCUMENTATION
14295  AsmFunction.setDataPrototype(
14296  "size_t", "cached_vertex", "= (size_t)(-1)",
14297  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
14298 #endif // !DOCUMENTATION
14299 
14300 #ifndef DOCUMENTATION
14301  AsmFunction.setDataPrototype(
14302  "int64_t", "stackDelta", "= SgAsmInstruction::INVALID_STACK_DELTA",
14303  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
14304 #endif // !DOCUMENTATION
14305 
14306 #ifndef DOCUMENTATION
14307  AsmFunction.setDataPrototype(
14308  "std::string", "callingConvention", "",
14309  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
14310 #endif // !DOCUMENTATION
14311 
14312  DECLARE_OTHERS(AsmFunction);
14313 #if defined(SgAsmFunction_OTHERS) || defined(DOCUMENTATION)
14314 
14315  //----------------------- Boost serialization for SgAsmFunction -----------------------
14316 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
14317 private:
14318  friend class boost::serialization::access;
14319 
14320  template<class S>
14321  void serialize(S &s, const unsigned /*version*/) {
14322  debugSerializationBegin("SgAsmFunction");
14323  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmSynthesizedDeclaration);
14324  s & BOOST_SERIALIZATION_NVP(p_name);
14325  s & BOOST_SERIALIZATION_NVP(p_reason);
14326  s & BOOST_SERIALIZATION_NVP(p_reasonComment);
14327  s & BOOST_SERIALIZATION_NVP(p_function_kind);
14328  s & BOOST_SERIALIZATION_NVP(p_may_return);
14329  s & BOOST_SERIALIZATION_NVP(p_name_md5);
14330  s & BOOST_SERIALIZATION_NVP(p_statementList);
14331  s & BOOST_SERIALIZATION_NVP(p_dest);
14332  s & BOOST_SERIALIZATION_NVP(p_entry_va);
14333  s & BOOST_SERIALIZATION_NVP(p_cached_vertex);
14334  s & BOOST_SERIALIZATION_NVP(p_stackDelta);
14335  s & BOOST_SERIALIZATION_NVP(p_callingConvention);
14336  debugSerializationEnd("SgAsmFunction");
14337  }
14338 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
14339  // Local types
14342 public:
14344  enum MayReturn {
14349  };
14350 
14355  // NOTE: If you add more here, then fix Partitioner::parse_switches()
14356  // Also fix SgAsmFunction::reason_key()
14357  FUNC_NONE = 0x00000000,
14358  FUNC_THUNK_TARGET= 0x00004000,
14360  = 0x00008000,
14361  FUNC_ENTRY_POINT = 0x00010000,
14362  FUNC_CALL_TARGET = 0x00020000,
14365  FUNC_CALL_INSN = 0x00040000,
14371  FUNC_EH_FRAME = 0x00080000,
14372  FUNC_SYMBOL = 0x00100000,
14373  FUNC_PATTERN = 0x00200000,
14378  FUNC_GRAPH = 0x00400000,
14382  FUNC_USERDEF = 0x00800000,
14383  FUNC_PADDING = 0x01000000,
14388  FUNC_DISCONT = 0x02000000,
14391  FUNC_INSNHEAD = 0x04000000,
14392  FUNC_IMPORT = 0x08000000,
14395  FUNC_LEFTOVERS = 0x10000000,
14399  FUNC_INTRABLOCK = 0x20000000,
14407  FUNC_THUNK = 0x40000000,
14416  FUNC_EXPORT = 0x80000000,
14418  FUNC_DEFAULT = 0xefff80ff,
14420  /*========= Miscellaneous Reasons ===========================================================================
14421  * The first half of the range (1-127, inclusive) is used for algorithms defined by ROSE. The second half is
14422  * availalble for users to use as they see fit. */
14423  FUNC_MISCMASK = 0x000000ff,
14438  };
14439 
14442  e_unknown = 0,
14443  e_standard = 1,
14444  e_library = 2,
14445  e_imported = 3,
14446  e_thunk = 4,
14447  e_last
14448  };
14449 
14451  // Properties
14453 public:
14459  std::string const& get_name() const;
14460  void set_name(std::string const&);
14463 public:
14470  unsigned const& get_reason() const;
14471  void set_reason(unsigned const&);
14474 public:
14482  std::string const& get_reasonComment() const;
14483  void set_reasonComment(std::string const&);
14486 public:
14496 public:
14504 public:
14510  std::string const& get_name_md5() const;
14511  void set_name_md5(std::string const&);
14514 public:
14520  SgAsmStatementPtrList const& get_statementList() const;
14521  SgAsmStatementPtrList& get_statementList();
14522  void set_statementList(SgAsmStatementPtrList const&);
14524  // FIXME[Robb P Matzke 2017-02-13]: unused?
14525 public:
14526  SgAsmStatementPtrList const& get_dest() const;
14527  void set_dest(SgAsmStatementPtrList const&);
14528 
14529 public:
14536  rose_addr_t const& get_entry_va() const;
14537  void set_entry_va(rose_addr_t const&);
14540 public:
14547  SgSymbolTable* const& get_symbol_table() const;
14548  void set_symbol_table(SgSymbolTable* const&);
14550  // FIXME[Robb P Matzke 2017-02-13]: what is this?
14551 public:
14552  size_t const& get_cached_vertex() const;
14553  void set_cached_vertex(size_t const&);
14554 
14555 public:
14565  int64_t const& get_stackDelta() const;
14566  void set_stackDelta(int64_t const&);
14569 public:
14578  std::string const& get_callingConvention() const;
14579  void set_callingConvention(std::string const&);
14581  // Functions
14584 public:
14587 
14591  void remove_statement(SgAsmStatement* statement);
14592 
14597  SgAsmBlock* get_entry_block() const;
14598 
14602  static std::string reason_key(const std::string &prefix="");
14603 
14605  std::string reason_str(bool pad) const;
14606 
14610  static std::string reason_str(bool pad, unsigned reason);
14611 
14614  public:
14615  virtual ~NodeSelector() {}
14616  virtual bool operator()(SgNode*) = 0;
14617  };
14618 
14658  size_t get_extent(AddressIntervalSet *emap=NULL, rose_addr_t *lo_addr=NULL, rose_addr_t *hi_addr=NULL,
14659  NodeSelector *selector=NULL);
14660 
14666  bool get_sha1(uint8_t digest[20]/*out*/, NodeSelector *selector=NULL);
14667 public:
14669  virtual ~SgAsmFunction();
14670 
14671 public:
14673  SgAsmFunction();
14674 
14675 public:
14677  SgAsmFunction(rose_addr_t const& address,
14678  std::string const& name,
14679  unsigned const& reason,
14680  SgAsmFunction::function_kind_enum const& function_kind);
14681 
14682 protected:
14689  void initializeProperties();
14690 #endif // SgAsmFunction_OTHERS
14691 #ifdef DOCUMENTATION
14692 };
14693 #endif // DOCUMENTATION
14694 
14695 
14697 // SgAsmSynthesizedDeclaration -- MACHINE GENERATED; DO NOT MODIFY --
14699 
14700 #ifndef DOCUMENTATION
14701 AstNodeClass& AsmSynthesizedDeclaration = nonTerminalConstructor(
14702  "AsmSynthesizedDeclaration",
14703  *this,
14704  "AsmSynthesizedDeclaration",
14705  "AsmSynthesizedDeclarationTag",
14706  SubclassListBuilder()
14707  | AsmFunction
14708  | AsmSynthesizedDataStructureDeclaration
14709  | AsmSynthesizedFieldDeclaration
14710  , false);
14711 assert(AsmSynthesizedDeclaration.associatedGrammar != nullptr);
14712 AsmSynthesizedDeclaration.setCppCondition("!defined(DOCUMENTATION)");
14713 AsmSynthesizedDeclaration.isBoostSerializable(true);
14714 AsmSynthesizedDeclaration.setAutomaticGenerationOfConstructor(false);
14715 AsmSynthesizedDeclaration.setAutomaticGenerationOfDestructor(false);
14716 #endif // !DOCUMENTATION
14717 
14718 #ifdef DOCUMENTATION
14719 
14726 #endif // DOCUMENTATION
14727 
14728  DECLARE_OTHERS(AsmSynthesizedDeclaration);
14729 #if defined(SgAsmSynthesizedDeclaration_OTHERS) || defined(DOCUMENTATION)
14730 
14731  //----------------------- Boost serialization for SgAsmSynthesizedDeclaration -----------------------
14732 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
14733 private:
14734  friend class boost::serialization::access;
14735 
14736  template<class S>
14737  void serialize(S &s, const unsigned /*version*/) {
14738  debugSerializationBegin("SgAsmSynthesizedDeclaration");
14739  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmStatement);
14740  debugSerializationEnd("SgAsmSynthesizedDeclaration");
14741  }
14742 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
14743 
14744 public:
14746  virtual ~SgAsmSynthesizedDeclaration();
14747 
14748 protected:
14751 
14752 protected:
14754  explicit SgAsmSynthesizedDeclaration(rose_addr_t const& address);
14755 
14756 protected:
14763  void initializeProperties();
14764 #endif // SgAsmSynthesizedDeclaration_OTHERS
14765 #ifdef DOCUMENTATION
14766 };
14767 #endif // DOCUMENTATION
14768 
14769 
14771 // SgAsmFloatValueExpression -- MACHINE GENERATED; DO NOT MODIFY --
14773 
14774 DECLARE_LEAF_CLASS(AsmFloatValueExpression);
14775 IS_SERIALIZABLE(AsmFloatValueExpression);
14776 
14777 #ifdef DOCUMENTATION
14778 
14783 #endif // DOCUMENTATION
14784 
14785  DECLARE_OTHERS(AsmFloatValueExpression);
14786 #if defined(SgAsmFloatValueExpression_OTHERS) || defined(DOCUMENTATION)
14787 
14788  //----------------------- Boost serialization for SgAsmFloatValueExpression -----------------------
14789 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
14790 private:
14791  friend class boost::serialization::access;
14792 
14793  template<class S>
14794  void serialize(S &s, const unsigned /*version*/) {
14795  debugSerializationBegin("SgAsmFloatValueExpression");
14796  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmConstantExpression);
14797  s & BOOST_SERIALIZATION_NVP(p_nativeValue);
14798  s & BOOST_SERIALIZATION_NVP(p_nativeValueIsValid);
14799  debugSerializationEnd("SgAsmFloatValueExpression");
14800  }
14801 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
14802 private:
14803  // This node stores its primary representation of the value in the p_bitVector of a parent class. However, since we
14804  // often access the value as a native "double", and since converting to/from a bit vector is costly, we want to cache
14805  // the native double value whenever we compute it. ROSETTA does not need to be aware of the cached value since it can
14806  // be recomputed from the bit vector, and in fact, ROSETTA can't handle cache data members because it doesn't
14807  // understand "mutable".
14808  //
14809  // However, Rosebud handles this just fine.
14810 private:
14811  mutable double p_nativeValue;
14812 
14813 public:
14814 
14815 private:
14816  mutable bool p_nativeValueIsValid;
14817 
14818 public:
14819 public:
14828  SgAsmFloatValueExpression(double nativeValue, SgAsmType*);
14829 
14836 
14838  void set_nativeValue(double);
14839 
14841  double get_nativeValue() const;
14842 
14847  void updateBitVector();
14848 
14853  void updateNativeValue() const;
14854 public:
14856  virtual ~SgAsmFloatValueExpression();
14857 
14858 public:
14861 
14862 protected:
14869  void initializeProperties();
14870 #endif // SgAsmFloatValueExpression_OTHERS
14871 #ifdef DOCUMENTATION
14872 };
14873 #endif // DOCUMENTATION
14874 
14875 
14877 // SgAsmFloatType -- MACHINE GENERATED; DO NOT MODIFY --
14879 
14880 DECLARE_LEAF_CLASS(AsmFloatType);
14881 IS_SERIALIZABLE(AsmFloatType);
14882 
14883 DECLARE_HEADERS(AsmFloatType);
14884 #if defined(SgAsmFloatType_HEADERS) || defined(DOCUMENTATION)
14885 #include <Sawyer/BitVector.h>
14886 #include <Rose/BitFlags.h>
14887 #include <Rose/BinaryAnalysis/ByteOrder.h>
14888 #endif // SgAsmFloatType_HEADERS
14889 
14890 #ifdef DOCUMENTATION
14891 
14893 #endif // DOCUMENTATION
14894 
14895 #ifndef DOCUMENTATION
14896  AsmFloatType.setDataPrototype(
14897  "size_t", "significandOffset", "= (size_t)(-1)",
14898  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
14899 #endif // !DOCUMENTATION
14900 
14901 #ifndef DOCUMENTATION
14902  AsmFloatType.setDataPrototype(
14903  "size_t", "significandNBits", "= (size_t)(-1)",
14904  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
14905 #endif // !DOCUMENTATION
14906 
14907 #ifndef DOCUMENTATION
14908  AsmFloatType.setDataPrototype(
14909  "size_t", "signBitOffset", "= (size_t)(-1)",
14910  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
14911 #endif // !DOCUMENTATION
14912 
14913 #ifndef DOCUMENTATION
14914  AsmFloatType.setDataPrototype(
14915  "size_t", "exponentOffset", "= (size_t)(-1)",
14916  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
14917 #endif // !DOCUMENTATION
14918 
14919 #ifndef DOCUMENTATION
14920  AsmFloatType.setDataPrototype(
14921  "size_t", "exponentNBits", "= (size_t)(-1)",
14922  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
14923 #endif // !DOCUMENTATION
14924 
14925 #ifndef DOCUMENTATION
14926  AsmFloatType.setDataPrototype(
14927  "uint64_t", "exponentBias", "= 0",
14928  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
14929 #endif // !DOCUMENTATION
14930 
14931 #ifndef DOCUMENTATION
14932  AsmFloatType.setDataPrototype(
14933  "unsigned", "flags", "= 0",
14934  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
14935 #endif // !DOCUMENTATION
14936 
14937  DECLARE_OTHERS(AsmFloatType);
14938 #if defined(SgAsmFloatType_OTHERS) || defined(DOCUMENTATION)
14939 
14940  //----------------------- Boost serialization for SgAsmFloatType -----------------------
14941 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
14942 private:
14943  friend class boost::serialization::access;
14944 
14945  template<class S>
14946  void serialize(S &s, const unsigned /*version*/) {
14947  debugSerializationBegin("SgAsmFloatType");
14948  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmScalarType);
14949  s & BOOST_SERIALIZATION_NVP(p_significandOffset);
14950  s & BOOST_SERIALIZATION_NVP(p_significandNBits);
14951  s & BOOST_SERIALIZATION_NVP(p_signBitOffset);
14952  s & BOOST_SERIALIZATION_NVP(p_exponentOffset);
14953  s & BOOST_SERIALIZATION_NVP(p_exponentNBits);
14954  s & BOOST_SERIALIZATION_NVP(p_exponentBias);
14955  s & BOOST_SERIALIZATION_NVP(p_flags);
14956  debugSerializationEnd("SgAsmFloatType");
14957  }
14958 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
14959 public:
14961  enum Flag {
14962  GRADUAL_UNDERFLOW = 0x00000001,
14964  };
14965 
14968 
14971 public:
14972 
14973 public:
14974 
14975 public:
14976 
14977 public:
14978 
14979 public:
14980 
14981 public:
14982 
14983 public:
14984 public:
14986  SgAsmFloatType(Rose::BinaryAnalysis::ByteOrder::Endianness, size_t nBits,
14987  const BitRange &significandBits, const BitRange exponentBits, size_t signBit,
14988  uint64_t exponentBias, Flags flags);
14989 
14991  BitRange significandBits() const;
14992 
14994  BitRange exponentBits() const;
14995 
14997  size_t signBit() const;
14998 
15000  uint64_t exponentBias() const;
15001 
15003  Flags flags() const;
15004 
15009  static Flags ieeeFlags();
15010 
15016  bool gradualUnderflow() const;
15017 
15023  bool implicitBitConvention() const;
15024 
15025  // Overrides documented in base class
15026  virtual void check() const override;
15027  virtual std::string toString() const override;
15028 public:
15030  virtual ~SgAsmFloatType();
15031 
15032 public:
15034  SgAsmFloatType();
15035 
15036 protected:
15043  void initializeProperties();
15044 #endif // SgAsmFloatType_OTHERS
15045 #ifdef DOCUMENTATION
15046 };
15047 #endif // DOCUMENTATION
15048 
15049 
15051 // SgAsmScalarType -- MACHINE GENERATED; DO NOT MODIFY --
15053 
15054 #ifndef DOCUMENTATION
15055 AstNodeClass& AsmScalarType = nonTerminalConstructor(
15056  "AsmScalarType",
15057  *this,
15058  "AsmScalarType",
15059  "AsmScalarTypeTag",
15060  SubclassListBuilder()
15061  | AsmFloatType
15062  | AsmIntegerType
15063  , false);
15064 assert(AsmScalarType.associatedGrammar != nullptr);
15065 AsmScalarType.setCppCondition("!defined(DOCUMENTATION)");
15066 AsmScalarType.isBoostSerializable(true);
15067 AsmScalarType.setAutomaticGenerationOfConstructor(false);
15068 AsmScalarType.setAutomaticGenerationOfDestructor(false);
15069 #endif // !DOCUMENTATION
15070 
15071 DECLARE_HEADERS(AsmScalarType);
15072 #if defined(SgAsmScalarType_HEADERS) || defined(DOCUMENTATION)
15073 #include <Rose/BinaryAnalysis/ByteOrder.h>
15074 #endif // SgAsmScalarType_HEADERS
15075 
15076 #ifdef DOCUMENTATION
15077 
15079 #endif // DOCUMENTATION
15080 
15081 #ifndef DOCUMENTATION
15082  AsmScalarType.setDataPrototype(
15083  "Rose::BinaryAnalysis::ByteOrder::Endianness", "minorOrder", "= Rose::BinaryAnalysis::ByteOrder::ORDER_UNSPECIFIED",
15084  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
15085 #endif // !DOCUMENTATION
15086 
15087 #ifndef DOCUMENTATION
15088  AsmScalarType.setDataPrototype(
15089  "Rose::BinaryAnalysis::ByteOrder::Endianness", "majorOrder", "= Rose::BinaryAnalysis::ByteOrder::ORDER_UNSPECIFIED",
15090  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
15091 #endif // !DOCUMENTATION
15092 
15093 #ifndef DOCUMENTATION
15094  AsmScalarType.setDataPrototype(
15095  "size_t", "majorNBytes", "= 0",
15096  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
15097 #endif // !DOCUMENTATION
15098 
15099 #ifndef DOCUMENTATION
15100  AsmScalarType.setDataPrototype(
15101  "size_t", "nBits", "= 0",
15102  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
15103 #endif // !DOCUMENTATION
15104 
15105  DECLARE_OTHERS(AsmScalarType);
15106 #if defined(SgAsmScalarType_OTHERS) || defined(DOCUMENTATION)
15107 
15108  //----------------------- Boost serialization for SgAsmScalarType -----------------------
15109 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
15110 private:
15111  friend class boost::serialization::access;
15112 
15113  template<class S>
15114  void serialize(S &s, const unsigned /*version*/) {
15115  debugSerializationBegin("SgAsmScalarType");
15116  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmType);
15117  s & BOOST_SERIALIZATION_NVP(p_minorOrder);
15118  s & BOOST_SERIALIZATION_NVP(p_majorOrder);
15119  s & BOOST_SERIALIZATION_NVP(p_majorNBytes);
15120  s & BOOST_SERIALIZATION_NVP(p_nBits);
15121  debugSerializationEnd("SgAsmScalarType");
15122  }
15123 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
15124 
15125 public:
15126 
15127 public:
15133 public:
15139 public:
15144 protected:
15149  SgAsmScalarType(Rose::BinaryAnalysis::ByteOrder::Endianness, size_t nBits);
15150 
15151 public:
15153  virtual size_t get_nBits() const override;
15154 
15156  Rose::BinaryAnalysis::ByteOrder::Endianness get_minorOrder() const;
15157 
15159  Rose::BinaryAnalysis::ByteOrder::Endianness get_majorOrder() const;
15160 
15162  size_t get_majorNBytes() const;
15163 
15164  // Overrides documented in base class
15165  virtual void check() const override;
15166  virtual std::string toString() const override;
15167 public:
15169  virtual ~SgAsmScalarType();
15170 
15171 protected:
15173  SgAsmScalarType();
15174 
15175 protected:
15182  void initializeProperties();
15183 #endif // SgAsmScalarType_OTHERS
15184 #ifdef DOCUMENTATION
15185 };
15186 #endif // DOCUMENTATION
15187 
15188 
15190 // SgAsmType -- MACHINE GENERATED; DO NOT MODIFY --
15192 
15193 #ifndef DOCUMENTATION
15194 AstNodeClass& AsmType = nonTerminalConstructor(
15195  "AsmType",
15196  *this,
15197  "AsmType",
15198  "AsmTypeTag",
15199  SubclassListBuilder()
15200  | AsmScalarType
15201  | AsmVectorType
15202  , false);
15203 assert(AsmType.associatedGrammar != nullptr);
15204 AsmType.setCppCondition("!defined(DOCUMENTATION)");
15205 AsmType.isBoostSerializable(true);
15206 AsmType.setAutomaticGenerationOfConstructor(false);
15207 AsmType.setAutomaticGenerationOfDestructor(false);
15208 #endif // !DOCUMENTATION
15209 
15210 #ifdef DOCUMENTATION
15211 
15212 class SgAsmType: public SgAsmNode {
15213 #endif // DOCUMENTATION
15214 
15215  DECLARE_OTHERS(AsmType);
15216 #if defined(SgAsmType_OTHERS) || defined(DOCUMENTATION)
15217 
15218  //----------------------- Boost serialization for SgAsmType -----------------------
15219 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
15220 private:
15221  friend class boost::serialization::access;
15222 
15223  template<class S>
15224  void serialize(S &s, const unsigned /*version*/) {
15225  debugSerializationBegin("SgAsmType");
15226  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmNode);
15227  debugSerializationEnd("SgAsmType");
15228  }
15229 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
15230 private:
15232 
15233 public:
15241  virtual void check() const;
15242 
15248  virtual std::string toString() const {
15249  abort(); // ROSETTA limitation: intended pure virtual
15250  return NULL; // Windows limitation: return value required [Too, 2014-08-11]
15251  }
15252 
15254  virtual size_t get_nBits() const {
15255  abort(); // ROSETTA limitation: intended pure virtual
15256  return (size_t)-1; // Windows limitation: return value required [Too, 2014-08-11]
15257  }
15258 
15260  virtual size_t get_nBytes() const;
15261 
15267  template<class Type> // Type is a subclass of SgAsmType
15268  static Type* registerOrDelete(Type *toInsert) {
15269  ASSERT_not_null(toInsert);
15270  std::string key = toInsert->toString();
15271  Type *retval = dynamic_cast<Type*>(p_typeRegistry.insertMaybe(key, toInsert));
15272  ASSERT_not_null(retval);
15273  if (retval!=toInsert)
15274  delete toInsert;
15275  return retval;
15276  }
15277 public:
15279  virtual ~SgAsmType();
15280 
15281 protected:
15283  SgAsmType();
15284 
15285 protected:
15292  void initializeProperties();
15293 #endif // SgAsmType_OTHERS
15294 #ifdef DOCUMENTATION
15295 };
15296 #endif // DOCUMENTATION
15297 
15298 
15300 // SgAsmExprListExp -- MACHINE GENERATED; DO NOT MODIFY --
15302 
15303 DECLARE_LEAF_CLASS(AsmExprListExp);
15304 IS_SERIALIZABLE(AsmExprListExp);
15305 
15306 #ifdef DOCUMENTATION
15307 
15309 #endif // DOCUMENTATION
15310 
15311 #ifndef DOCUMENTATION
15312  AsmExprListExp.setDataPrototype(
15313  "SgAsmExpressionPtrList", "expressions", "",
15314  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
15315 #endif // !DOCUMENTATION
15316 
15317  DECLARE_OTHERS(AsmExprListExp);
15318 #if defined(SgAsmExprListExp_OTHERS) || defined(DOCUMENTATION)
15319 
15320  //----------------------- Boost serialization for SgAsmExprListExp -----------------------
15321 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
15322 private:
15323  friend class boost::serialization::access;
15324 
15325  template<class S>
15326  void serialize(S &s, const unsigned /*version*/) {
15327  debugSerializationBegin("SgAsmExprListExp");
15328  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExpression);
15329  s & BOOST_SERIALIZATION_NVP(p_expressions);
15330  debugSerializationEnd("SgAsmExprListExp");
15331  }
15332 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
15333 
15334 public:
15341  SgAsmExpressionPtrList const& get_expressions() const;
15342  SgAsmExpressionPtrList& get_expressions();
15343  void set_expressions(SgAsmExpressionPtrList const&);
15346 public:
15348  virtual ~SgAsmExprListExp();
15349 
15350 public:
15352  SgAsmExprListExp();
15353 
15354 protected:
15361  void initializeProperties();
15362 #endif // SgAsmExprListExp_OTHERS
15363 #ifdef DOCUMENTATION
15364 };
15365 #endif // DOCUMENTATION
15366 
15367 
15369 // SgAsmElfSymverSection -- MACHINE GENERATED; DO NOT MODIFY --
15371 
15372 DECLARE_LEAF_CLASS(AsmElfSymverSection);
15373 IS_SERIALIZABLE(AsmElfSymverSection);
15374 
15375 #ifdef DOCUMENTATION
15376 
15381 #endif // DOCUMENTATION
15382 
15383 #ifndef DOCUMENTATION
15384  AsmElfSymverSection.setDataPrototype(
15385  "SgAsmElfSymverEntryList*", "entries", "= createAndParent<SgAsmElfSymverEntryList>(this)",
15386  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
15387 #endif // !DOCUMENTATION
15388 
15389  DECLARE_OTHERS(AsmElfSymverSection);
15390 #if defined(SgAsmElfSymverSection_OTHERS) || defined(DOCUMENTATION)
15391 
15392  //----------------------- Boost serialization for SgAsmElfSymverSection -----------------------
15393 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
15394 private:
15395  friend class boost::serialization::access;
15396 
15397  template<class S>
15398  void serialize(S &s, const unsigned /*version*/) {
15399  debugSerializationBegin("SgAsmElfSymverSection");
15400  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmElfSection);
15401  s & BOOST_SERIALIZATION_NVP(p_entries);
15402  debugSerializationEnd("SgAsmElfSymverSection");
15403  }
15404 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
15405 
15406 public:
15413  SgAsmElfSymverEntryList* const& get_entries() const;
15414  void set_entries(SgAsmElfSymverEntryList* const&);
15416 public:
15419 
15421  virtual SgAsmElfSymverSection* parse() override;
15422 
15427  virtual rose_addr_t calculate_sizes(size_t *total, size_t *required, size_t *optional, size_t *nentries) const override;
15428 
15430  virtual void unparse(std::ostream&) const override;
15431 
15433  virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
15434 public:
15436  virtual ~SgAsmElfSymverSection();
15437 
15438 public:
15441 
15442 protected:
15449  void initializeProperties();
15450 #endif // SgAsmElfSymverSection_OTHERS
15451 #ifdef DOCUMENTATION
15452 };
15453 #endif // DOCUMENTATION
15454 
15455 
15457 // SgAsmElfSymverNeededSection -- MACHINE GENERATED; DO NOT MODIFY --
15459 
15460 DECLARE_LEAF_CLASS(AsmElfSymverNeededSection);
15461 IS_SERIALIZABLE(AsmElfSymverNeededSection);
15462 
15463 #ifdef DOCUMENTATION
15464 
15470 #endif // DOCUMENTATION
15471 
15472 #ifndef DOCUMENTATION
15473  AsmElfSymverNeededSection.setDataPrototype(
15474  "SgAsmElfSymverNeededEntryList*", "entries", "= createAndParent<SgAsmElfSymverNeededEntryList>(this)",
15475  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
15476 #endif // !DOCUMENTATION
15477 
15478  DECLARE_OTHERS(AsmElfSymverNeededSection);
15479 #if defined(SgAsmElfSymverNeededSection_OTHERS) || defined(DOCUMENTATION)
15480 
15481  //----------------------- Boost serialization for SgAsmElfSymverNeededSection -----------------------
15482 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
15483 private:
15484  friend class boost::serialization::access;
15485 
15486  template<class S>
15487  void serialize(S &s, const unsigned /*version*/) {
15488  debugSerializationBegin("SgAsmElfSymverNeededSection");
15489  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmElfSection);
15490  s & BOOST_SERIALIZATION_NVP(p_entries);
15491  debugSerializationEnd("SgAsmElfSymverNeededSection");
15492  }
15493 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
15494 
15495 public:
15505 public:
15510 
15520  virtual SgAsmElfSymverNeededSection* parse() override;
15521 
15526  virtual rose_addr_t calculate_sizes(size_t *total, size_t *required, size_t *optional, size_t *nentries) const override;
15527 
15531  virtual void unparse(std::ostream&) const override;
15532 
15534  virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
15535 public:
15537  virtual ~SgAsmElfSymverNeededSection();
15538 
15539 public:
15542 
15543 protected:
15550  void initializeProperties();
15551 #endif // SgAsmElfSymverNeededSection_OTHERS
15552 #ifdef DOCUMENTATION
15553 };
15554 #endif // DOCUMENTATION
15555 
15556 
15558 // SgAsmElfSymverNeededEntryList -- MACHINE GENERATED; DO NOT MODIFY --
15560 
15561 DECLARE_LEAF_CLASS(AsmElfSymverNeededEntryList);
15562 IS_SERIALIZABLE(AsmElfSymverNeededEntryList);
15563 
15564 #ifdef DOCUMENTATION
15565 
15570 #endif // DOCUMENTATION
15571 
15572 #ifndef DOCUMENTATION
15573  AsmElfSymverNeededEntryList.setDataPrototype(
15574  "SgAsmElfSymverNeededEntryPtrList", "entries", "",
15575  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
15576 #endif // !DOCUMENTATION
15577 
15578  DECLARE_OTHERS(AsmElfSymverNeededEntryList);
15579 #if defined(SgAsmElfSymverNeededEntryList_OTHERS) || defined(DOCUMENTATION)
15580 
15581  //----------------------- Boost serialization for SgAsmElfSymverNeededEntryList -----------------------
15582 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
15583 private:
15584  friend class boost::serialization::access;
15585 
15586  template<class S>
15587  void serialize(S &s, const unsigned /*version*/) {
15588  debugSerializationBegin("SgAsmElfSymverNeededEntryList");
15589  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
15590  s & BOOST_SERIALIZATION_NVP(p_entries);
15591  debugSerializationEnd("SgAsmElfSymverNeededEntryList");
15592  }
15593 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
15594 
15595 public:
15599  SgAsmElfSymverNeededEntryPtrList const& get_entries() const;
15600  SgAsmElfSymverNeededEntryPtrList& get_entries();
15601  void set_entries(SgAsmElfSymverNeededEntryPtrList const&);
15604 public:
15607 
15608 public:
15611 
15612 protected:
15619  void initializeProperties();
15620 #endif // SgAsmElfSymverNeededEntryList_OTHERS
15621 #ifdef DOCUMENTATION
15622 };
15623 #endif // DOCUMENTATION
15624 
15625 
15627 // SgAsmElfSymverNeededEntry -- MACHINE GENERATED; DO NOT MODIFY --
15629 
15630 DECLARE_LEAF_CLASS(AsmElfSymverNeededEntry);
15631 IS_SERIALIZABLE(AsmElfSymverNeededEntry);
15632 
15633 DECLARE_HEADERS(AsmElfSymverNeededEntry);
15634 #if defined(SgAsmElfSymverNeededEntry_HEADERS) || defined(DOCUMENTATION)
15635 #include <Rose/BinaryAnalysis/ByteOrder.h>
15636 #endif // SgAsmElfSymverNeededEntry_HEADERS
15637 
15638 #ifdef DOCUMENTATION
15639 
15641 #endif // DOCUMENTATION
15642 
15643 #ifndef DOCUMENTATION
15644  AsmElfSymverNeededEntry.setDataPrototype(
15645  "size_t", "version", "= 0",
15646  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
15647 #endif // !DOCUMENTATION
15648 
15649 #ifndef DOCUMENTATION
15650  AsmElfSymverNeededEntry.setDataPrototype(
15651  "SgAsmGenericString*", "file_name", "= nullptr",
15652  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
15653 #endif // !DOCUMENTATION
15654 
15655 #ifndef DOCUMENTATION
15656  AsmElfSymverNeededEntry.setDataPrototype(
15657  "SgAsmElfSymverNeededAuxList*", "entries", "= createAndParent<SgAsmElfSymverNeededAuxList>(this)",
15658  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
15659 #endif // !DOCUMENTATION
15660 
15661  DECLARE_OTHERS(AsmElfSymverNeededEntry);
15662 #if defined(SgAsmElfSymverNeededEntry_OTHERS) || defined(DOCUMENTATION)
15663 
15664  //----------------------- Boost serialization for SgAsmElfSymverNeededEntry -----------------------
15665 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
15666 private:
15667  friend class boost::serialization::access;
15668 
15669  template<class S>
15670  void serialize(S &s, const unsigned /*version*/) {
15671  debugSerializationBegin("SgAsmElfSymverNeededEntry");
15672  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
15673  s & BOOST_SERIALIZATION_NVP(p_version);
15674  s & BOOST_SERIALIZATION_NVP(p_file_name);
15675  s & BOOST_SERIALIZATION_NVP(p_entries);
15676  debugSerializationEnd("SgAsmElfSymverNeededEntry");
15677  }
15678 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
15679  // Local types
15682 public:
15683 #ifdef _MSC_VER
15684 # pragma pack (1)
15685 #endif
15686 
15689  uint16_t vn_version;
15690  uint16_t vn_cnt;
15691  uint32_t vn_file;
15692  uint32_t vn_aux;
15693  uint32_t vn_next;
15694  }
15695 #if !defined(SWIG) && !defined(_MSC_VER)
15696  __attribute__((packed))
15697 #endif
15698  ;
15699 
15700 #ifdef _MSC_VER
15701 # pragma pack ()
15702 #endif
15703 
15705  // Properties
15707 public:
15713  size_t const& get_version() const;
15714  void set_version(size_t const&);
15717 public:
15721  SgAsmGenericString* const& get_file_name() const;
15722  void set_file_name(SgAsmGenericString* const&);
15725 public:
15732  SgAsmElfSymverNeededAuxList* const& get_entries() const;
15735  // Functions
15738 public:
15741 
15743  void parse(Rose::BinaryAnalysis::ByteOrder::Endianness, const SgAsmElfSymverNeededEntry::ElfSymverNeededEntry_disk*);
15744 
15746  void *encode(Rose::BinaryAnalysis::ByteOrder::Endianness, SgAsmElfSymverNeededEntry::ElfSymverNeededEntry_disk*) const;
15747 
15749  virtual void dump(FILE *f, const char *prefix, ssize_t idx) const;
15750 public:
15752  virtual ~SgAsmElfSymverNeededEntry();
15753 
15754 public:
15757 
15758 protected:
15765  void initializeProperties();
15766 #endif // SgAsmElfSymverNeededEntry_OTHERS
15767 #ifdef DOCUMENTATION
15768 };
15769 #endif // DOCUMENTATION
15770 
15771 
15773 // SgAsmElfSymverNeededAuxList -- MACHINE GENERATED; DO NOT MODIFY --
15775 
15776 DECLARE_LEAF_CLASS(AsmElfSymverNeededAuxList);
15777 IS_SERIALIZABLE(AsmElfSymverNeededAuxList);
15778 
15779 #ifdef DOCUMENTATION
15780 
15785 #endif // DOCUMENTATION
15786 
15787 #ifndef DOCUMENTATION
15788  AsmElfSymverNeededAuxList.setDataPrototype(
15789  "SgAsmElfSymverNeededAuxPtrList", "entries", "",
15790  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
15791 #endif // !DOCUMENTATION
15792 
15793  DECLARE_OTHERS(AsmElfSymverNeededAuxList);
15794 #if defined(SgAsmElfSymverNeededAuxList_OTHERS) || defined(DOCUMENTATION)
15795 
15796  //----------------------- Boost serialization for SgAsmElfSymverNeededAuxList -----------------------
15797 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
15798 private:
15799  friend class boost::serialization::access;
15800 
15801  template<class S>
15802  void serialize(S &s, const unsigned /*version*/) {
15803  debugSerializationBegin("SgAsmElfSymverNeededAuxList");
15804  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
15805  s & BOOST_SERIALIZATION_NVP(p_entries);
15806  debugSerializationEnd("SgAsmElfSymverNeededAuxList");
15807  }
15808 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
15809 
15810 public:
15814  SgAsmElfSymverNeededAuxPtrList const& get_entries() const;
15815  SgAsmElfSymverNeededAuxPtrList& get_entries();
15816  void set_entries(SgAsmElfSymverNeededAuxPtrList const&);
15819 public:
15821  virtual ~SgAsmElfSymverNeededAuxList();
15822 
15823 public:
15826 
15827 protected:
15834  void initializeProperties();
15835 #endif // SgAsmElfSymverNeededAuxList_OTHERS
15836 #ifdef DOCUMENTATION
15837 };
15838 #endif // DOCUMENTATION
15839 
15840 
15842 // SgAsmElfSymverNeededAux -- MACHINE GENERATED; DO NOT MODIFY --
15844 
15845 DECLARE_LEAF_CLASS(AsmElfSymverNeededAux);
15846 IS_SERIALIZABLE(AsmElfSymverNeededAux);
15847 
15848 DECLARE_HEADERS(AsmElfSymverNeededAux);
15849 #if defined(SgAsmElfSymverNeededAux_HEADERS) || defined(DOCUMENTATION)
15850 #include <Rose/BinaryAnalysis/ByteOrder.h>
15851 #endif // SgAsmElfSymverNeededAux_HEADERS
15852 
15853 #ifdef DOCUMENTATION
15854 
15856 #endif // DOCUMENTATION
15857 
15858 #ifndef DOCUMENTATION
15859  AsmElfSymverNeededAux.setDataPrototype(
15860  "uint32_t", "hash", "= 0",
15861  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
15862 #endif // !DOCUMENTATION
15863 
15864 #ifndef DOCUMENTATION
15865  AsmElfSymverNeededAux.setDataPrototype(
15866  "int", "flags", "= 0",
15867  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
15868 #endif // !DOCUMENTATION
15869 
15870 #ifndef DOCUMENTATION
15871  AsmElfSymverNeededAux.setDataPrototype(
15872  "size_t", "other", "= 0",
15873  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
15874 #endif // !DOCUMENTATION
15875 
15876 #ifndef DOCUMENTATION
15877  AsmElfSymverNeededAux.setDataPrototype(
15878  "SgAsmGenericString*", "name", "= 0",
15879  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
15880 #endif // !DOCUMENTATION
15881 
15882  DECLARE_OTHERS(AsmElfSymverNeededAux);
15883 #if defined(SgAsmElfSymverNeededAux_OTHERS) || defined(DOCUMENTATION)
15884 
15885  //----------------------- Boost serialization for SgAsmElfSymverNeededAux -----------------------
15886 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
15887 private:
15888  friend class boost::serialization::access;
15889 
15890  template<class S>
15891  void serialize(S &s, const unsigned /*version*/) {
15892  debugSerializationBegin("SgAsmElfSymverNeededAux");
15893  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
15894  s & BOOST_SERIALIZATION_NVP(p_hash);
15895  s & BOOST_SERIALIZATION_NVP(p_flags);
15896  s & BOOST_SERIALIZATION_NVP(p_other);
15897  s & BOOST_SERIALIZATION_NVP(p_name);
15898  debugSerializationEnd("SgAsmElfSymverNeededAux");
15899  }
15900 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
15901  // Local types
15904 public:
15905 #ifdef _MSC_VER
15906 # pragma pack (1)
15907 #endif
15908 
15911  uint32_t vna_hash;
15912  uint16_t vna_flags;
15913  uint16_t vna_other;
15914  uint32_t vna_name;
15915  uint32_t vna_next;
15916  }
15917 #if !defined(SWIG) && !defined(_MSC_VER)
15918  __attribute__((packed))
15919 #endif
15920  ;
15921 
15922 #ifdef _MSC_VER
15923 # pragma pack ()
15924 #endif
15925 
15927  // Properties
15929 public:
15935  uint32_t const& get_hash() const;
15936  void set_hash(uint32_t const&);
15939 public:
15945  int const& get_flags() const;
15946  void set_flags(int const&);
15949 public:
15955  size_t const& get_other() const;
15956  void set_other(size_t const&);
15959 public:
15963  SgAsmGenericString* const& get_name() const;
15964  void set_name(SgAsmGenericString* const&);
15966  // Functions
15969 public:
15975 
15977  void parse(Rose::BinaryAnalysis::ByteOrder::Endianness, const SgAsmElfSymverNeededAux::ElfSymverNeededAux_disk*);
15978 
15980  void *encode(Rose::BinaryAnalysis::ByteOrder::Endianness, SgAsmElfSymverNeededAux::ElfSymverNeededAux_disk*) const;
15981 
15987  virtual void dump(FILE *f, const char *prefix, ssize_t idx) const;
15988 public:
15990  virtual ~SgAsmElfSymverNeededAux();
15991 
15992 public:
15995 
15996 protected:
16003  void initializeProperties();
16004 #endif // SgAsmElfSymverNeededAux_OTHERS
16005 #ifdef DOCUMENTATION
16006 };
16007 #endif // DOCUMENTATION
16008 
16009 
16011 // SgAsmElfSymverEntryList -- MACHINE GENERATED; DO NOT MODIFY --
16013 
16014 DECLARE_LEAF_CLASS(AsmElfSymverEntryList);
16015 IS_SERIALIZABLE(AsmElfSymverEntryList);
16016 
16017 #ifdef DOCUMENTATION
16018 
16023 #endif // DOCUMENTATION
16024 
16025 #ifndef DOCUMENTATION
16026  AsmElfSymverEntryList.setDataPrototype(
16027  "SgAsmElfSymverEntryPtrList", "entries", "",
16028  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
16029 #endif // !DOCUMENTATION
16030 
16031  DECLARE_OTHERS(AsmElfSymverEntryList);
16032 #if defined(SgAsmElfSymverEntryList_OTHERS) || defined(DOCUMENTATION)
16033 
16034  //----------------------- Boost serialization for SgAsmElfSymverEntryList -----------------------
16035 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
16036 private:
16037  friend class boost::serialization::access;
16038 
16039  template<class S>
16040  void serialize(S &s, const unsigned /*version*/) {
16041  debugSerializationBegin("SgAsmElfSymverEntryList");
16042  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
16043  s & BOOST_SERIALIZATION_NVP(p_entries);
16044  debugSerializationEnd("SgAsmElfSymverEntryList");
16045  }
16046 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
16047 
16048 public:
16052  SgAsmElfSymverEntryPtrList const& get_entries() const;
16053  SgAsmElfSymverEntryPtrList& get_entries();
16054  void set_entries(SgAsmElfSymverEntryPtrList const&);
16057 public:
16059  virtual ~SgAsmElfSymverEntryList();
16060 
16061 public:
16064 
16065 protected:
16072  void initializeProperties();
16073 #endif // SgAsmElfSymverEntryList_OTHERS
16074 #ifdef DOCUMENTATION
16075 };
16076 #endif // DOCUMENTATION
16077 
16078 
16080 // SgAsmElfSymverEntry -- MACHINE GENERATED; DO NOT MODIFY --
16082 
16083 DECLARE_LEAF_CLASS(AsmElfSymverEntry);
16084 IS_SERIALIZABLE(AsmElfSymverEntry);
16085 
16086 #ifdef DOCUMENTATION
16087 
16089 #endif // DOCUMENTATION
16090 
16091 #ifndef DOCUMENTATION
16092  AsmElfSymverEntry.setDataPrototype(
16093  "size_t", "value", "= 0",
16094  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
16095 #endif // !DOCUMENTATION
16096 
16097  DECLARE_OTHERS(AsmElfSymverEntry);
16098 #if defined(SgAsmElfSymverEntry_OTHERS) || defined(DOCUMENTATION)
16099 
16100  //----------------------- Boost serialization for SgAsmElfSymverEntry -----------------------
16101 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
16102 private:
16103  friend class boost::serialization::access;
16104 
16105  template<class S>
16106  void serialize(S &s, const unsigned /*version*/) {
16107  debugSerializationBegin("SgAsmElfSymverEntry");
16108  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
16109  s & BOOST_SERIALIZATION_NVP(p_value);
16110  debugSerializationEnd("SgAsmElfSymverEntry");
16111  }
16112 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
16113 
16114 public:
16120  size_t const& get_value() const;
16121  void set_value(size_t const&);
16123 public:
16126 
16128  virtual void dump(FILE *f, const char *prefix, ssize_t idx) const;
16129 public:
16131  virtual ~SgAsmElfSymverEntry();
16132 
16133 public:
16136 
16137 protected:
16144  void initializeProperties();
16145 #endif // SgAsmElfSymverEntry_OTHERS
16146 #ifdef DOCUMENTATION
16147 };
16148 #endif // DOCUMENTATION
16149 
16150 
16152 // SgAsmElfSymverDefinedSection -- MACHINE GENERATED; DO NOT MODIFY --
16154 
16155 DECLARE_LEAF_CLASS(AsmElfSymverDefinedSection);
16156 IS_SERIALIZABLE(AsmElfSymverDefinedSection);
16157 
16158 #ifdef DOCUMENTATION
16159 
16165 #endif // DOCUMENTATION
16166 
16167 #ifndef DOCUMENTATION
16168  AsmElfSymverDefinedSection.setDataPrototype(
16169  "SgAsmElfSymverDefinedEntryList*", "entries", "= createAndParent<SgAsmElfSymverDefinedEntryList>(this)",
16170  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
16171 #endif // !DOCUMENTATION
16172 
16173  DECLARE_OTHERS(AsmElfSymverDefinedSection);
16174 #if defined(SgAsmElfSymverDefinedSection_OTHERS) || defined(DOCUMENTATION)
16175 
16176  //----------------------- Boost serialization for SgAsmElfSymverDefinedSection -----------------------
16177 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
16178 private:
16179  friend class boost::serialization::access;
16180 
16181  template<class S>
16182  void serialize(S &s, const unsigned /*version*/) {
16183  debugSerializationBegin("SgAsmElfSymverDefinedSection");
16184  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmElfSection);
16185  s & BOOST_SERIALIZATION_NVP(p_entries);
16186  debugSerializationEnd("SgAsmElfSymverDefinedSection");
16187  }
16188 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
16189 
16190 public:
16200 public:
16203 
16272  virtual SgAsmElfSymverDefinedSection* parse() override;
16273 
16276  virtual rose_addr_t calculate_sizes(size_t *total, size_t *required, size_t *optional, size_t *nentries) const override;
16277 
16281  virtual void unparse(std::ostream&) const override;
16282 
16284  virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
16285 public:
16288 
16289 public:
16292 
16293 protected:
16300  void initializeProperties();
16301 #endif // SgAsmElfSymverDefinedSection_OTHERS
16302 #ifdef DOCUMENTATION
16303 };
16304 #endif // DOCUMENTATION
16305 
16306 
16308 // SgAsmElfSymverDefinedEntryList -- MACHINE GENERATED; DO NOT MODIFY --
16310 
16311 DECLARE_LEAF_CLASS(AsmElfSymverDefinedEntryList);
16312 IS_SERIALIZABLE(AsmElfSymverDefinedEntryList);
16313 
16314 #ifdef DOCUMENTATION
16315 
16320 #endif // DOCUMENTATION
16321 
16322 #ifndef DOCUMENTATION
16323  AsmElfSymverDefinedEntryList.setDataPrototype(
16324  "SgAsmElfSymverDefinedEntryPtrList", "entries", "",
16325  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
16326 #endif // !DOCUMENTATION
16327 
16328  DECLARE_OTHERS(AsmElfSymverDefinedEntryList);
16329 #if defined(SgAsmElfSymverDefinedEntryList_OTHERS) || defined(DOCUMENTATION)
16330 
16331  //----------------------- Boost serialization for SgAsmElfSymverDefinedEntryList -----------------------
16332 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
16333 private:
16334  friend class boost::serialization::access;
16335 
16336  template<class S>
16337  void serialize(S &s, const unsigned /*version*/) {
16338  debugSerializationBegin("SgAsmElfSymverDefinedEntryList");
16339  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
16340  s & BOOST_SERIALIZATION_NVP(p_entries);
16341  debugSerializationEnd("SgAsmElfSymverDefinedEntryList");
16342  }
16343 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
16344 
16345 public:
16349  SgAsmElfSymverDefinedEntryPtrList const& get_entries() const;
16350  SgAsmElfSymverDefinedEntryPtrList& get_entries();
16351  void set_entries(SgAsmElfSymverDefinedEntryPtrList const&);
16354 public:
16357 
16358 public:
16361 
16362 protected:
16369  void initializeProperties();
16370 #endif // SgAsmElfSymverDefinedEntryList_OTHERS
16371 #ifdef DOCUMENTATION
16372 };
16373 #endif // DOCUMENTATION
16374 
16375 
16377 // SgAsmElfSymverDefinedEntry -- MACHINE GENERATED; DO NOT MODIFY --
16379 
16380 DECLARE_LEAF_CLASS(AsmElfSymverDefinedEntry);
16381 IS_SERIALIZABLE(AsmElfSymverDefinedEntry);
16382 
16383 DECLARE_HEADERS(AsmElfSymverDefinedEntry);
16384 #if defined(SgAsmElfSymverDefinedEntry_HEADERS) || defined(DOCUMENTATION)
16385 #include <Rose/BinaryAnalysis/ByteOrder.h>
16386 #endif // SgAsmElfSymverDefinedEntry_HEADERS
16387 
16388 #ifdef DOCUMENTATION
16389 
16391 #endif // DOCUMENTATION
16392 
16393 #ifndef DOCUMENTATION
16394  AsmElfSymverDefinedEntry.setDataPrototype(
16395  "size_t", "version", "= 0",
16396  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
16397 #endif // !DOCUMENTATION
16398 
16399 #ifndef DOCUMENTATION
16400  AsmElfSymverDefinedEntry.setDataPrototype(
16401  "int", "flags", "= 0",
16402  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
16403 #endif // !DOCUMENTATION
16404 
16405 #ifndef DOCUMENTATION
16406  AsmElfSymverDefinedEntry.setDataPrototype(
16407  "size_t", "index", "= 0",
16408  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
16409 #endif // !DOCUMENTATION
16410 
16411 #ifndef DOCUMENTATION
16412  AsmElfSymverDefinedEntry.setDataPrototype(
16413  "uint32_t", "hash", "= 0",
16414  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
16415 #endif // !DOCUMENTATION
16416 
16417 #ifndef DOCUMENTATION
16418  AsmElfSymverDefinedEntry.setDataPrototype(
16419  "SgAsmElfSymverDefinedAuxList*", "entries", "= createAndParent<SgAsmElfSymverDefinedAuxList>(this)",
16420  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
16421 #endif // !DOCUMENTATION
16422 
16423  DECLARE_OTHERS(AsmElfSymverDefinedEntry);
16424 #if defined(SgAsmElfSymverDefinedEntry_OTHERS) || defined(DOCUMENTATION)
16425 
16426  //----------------------- Boost serialization for SgAsmElfSymverDefinedEntry -----------------------
16427 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
16428 private:
16429  friend class boost::serialization::access;
16430 
16431  template<class S>
16432  void serialize(S &s, const unsigned /*version*/) {
16433  debugSerializationBegin("SgAsmElfSymverDefinedEntry");
16434  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
16435  s & BOOST_SERIALIZATION_NVP(p_version);
16436  s & BOOST_SERIALIZATION_NVP(p_flags);
16437  s & BOOST_SERIALIZATION_NVP(p_index);
16438  s & BOOST_SERIALIZATION_NVP(p_hash);
16439  s & BOOST_SERIALIZATION_NVP(p_entries);
16440  debugSerializationEnd("SgAsmElfSymverDefinedEntry");
16441  }
16442 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
16443  // Local types
16446 public:
16447 #ifdef _MSC_VER
16448 # pragma pack (1)
16449 #endif
16450 
16452  uint16_t vd_version;
16453  uint16_t vd_flags;
16454  uint16_t vd_ndx;
16455  uint16_t vd_cnt;
16456  uint32_t vd_hash;
16457  uint32_t vd_aux;
16458  uint32_t vd_next;
16459  }
16460 #if !defined(SWIG) && !defined(_MSC_VER)
16461  __attribute__((packed))
16462 #endif
16463  ;
16464 
16465 #ifdef _MSC_VER
16466 # pragma pack ()
16467 #endif
16468 
16470  // Properties
16472 public:
16478  size_t const& get_version() const;
16479  void set_version(size_t const&);
16482 public:
16488  int const& get_flags() const;
16489  void set_flags(int const&);
16492 public:
16498  size_t const& get_index() const;
16499  void set_index(size_t const&);
16502 public:
16508  uint32_t const& get_hash() const;
16509  void set_hash(uint32_t const&);
16512 public:
16519  SgAsmElfSymverDefinedAuxList* const& get_entries() const;
16522  // Functions
16525 public:
16527  explicit SgAsmElfSymverDefinedEntry(SgAsmElfSymverDefinedSection *symver_defined);
16528 
16530  void parse(Rose::BinaryAnalysis::ByteOrder::Endianness, const SgAsmElfSymverDefinedEntry::ElfSymverDefinedEntry_disk*);
16531 
16533  void *encode(Rose::BinaryAnalysis::ByteOrder::Endianness, SgAsmElfSymverDefinedEntry::ElfSymverDefinedEntry_disk*) const;
16534 
16536  virtual void dump(FILE *f, const char *prefix, ssize_t idx) const;
16537 public:
16539  virtual ~SgAsmElfSymverDefinedEntry();
16540 
16541 public:
16544 
16545 protected:
16552  void initializeProperties();
16553 #endif // SgAsmElfSymverDefinedEntry_OTHERS
16554 #ifdef DOCUMENTATION
16555 };
16556 #endif // DOCUMENTATION
16557 
16558 
16560 // SgAsmElfSymverDefinedAuxList -- MACHINE GENERATED; DO NOT MODIFY --
16562 
16563 DECLARE_LEAF_CLASS(AsmElfSymverDefinedAuxList);
16564 IS_SERIALIZABLE(AsmElfSymverDefinedAuxList);
16565 
16566 #ifdef DOCUMENTATION
16567 
16572 #endif // DOCUMENTATION
16573 
16574 #ifndef DOCUMENTATION
16575  AsmElfSymverDefinedAuxList.setDataPrototype(
16576  "SgAsmElfSymverDefinedAuxPtrList", "entries", "",
16577  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
16578 #endif // !DOCUMENTATION
16579 
16580  DECLARE_OTHERS(AsmElfSymverDefinedAuxList);
16581 #if defined(SgAsmElfSymverDefinedAuxList_OTHERS) || defined(DOCUMENTATION)
16582 
16583  //----------------------- Boost serialization for SgAsmElfSymverDefinedAuxList -----------------------
16584 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
16585 private:
16586  friend class boost::serialization::access;
16587 
16588  template<class S>
16589  void serialize(S &s, const unsigned /*version*/) {
16590  debugSerializationBegin("SgAsmElfSymverDefinedAuxList");
16591  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
16592  s & BOOST_SERIALIZATION_NVP(p_entries);
16593  debugSerializationEnd("SgAsmElfSymverDefinedAuxList");
16594  }
16595 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
16596 
16597 public:
16601  SgAsmElfSymverDefinedAuxPtrList const& get_entries() const;
16602  SgAsmElfSymverDefinedAuxPtrList& get_entries();
16603  void set_entries(SgAsmElfSymverDefinedAuxPtrList const&);
16606 public:
16609 
16610 public:
16613 
16614 protected:
16621  void initializeProperties();
16622 #endif // SgAsmElfSymverDefinedAuxList_OTHERS
16623 #ifdef DOCUMENTATION
16624 };
16625 #endif // DOCUMENTATION
16626 
16627 
16629 // SgAsmElfSymverDefinedAux -- MACHINE GENERATED; DO NOT MODIFY --
16631 
16632 DECLARE_LEAF_CLASS(AsmElfSymverDefinedAux);
16633 IS_SERIALIZABLE(AsmElfSymverDefinedAux);
16634 
16635 DECLARE_HEADERS(AsmElfSymverDefinedAux);
16636 #if defined(SgAsmElfSymverDefinedAux_HEADERS) || defined(DOCUMENTATION)
16637 #include <Rose/BinaryAnalysis/ByteOrder.h>
16638 #endif // SgAsmElfSymverDefinedAux_HEADERS
16639 
16640 #ifdef DOCUMENTATION
16642 #endif // DOCUMENTATION
16643 
16644 #ifndef DOCUMENTATION
16645  AsmElfSymverDefinedAux.setDataPrototype(
16646  "SgAsmGenericString*", "name", "= 0",
16647  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
16648 #endif // !DOCUMENTATION
16649 
16650  DECLARE_OTHERS(AsmElfSymverDefinedAux);
16651 #if defined(SgAsmElfSymverDefinedAux_OTHERS) || defined(DOCUMENTATION)
16652 
16653  //----------------------- Boost serialization for SgAsmElfSymverDefinedAux -----------------------
16654 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
16655 private:
16656  friend class boost::serialization::access;
16657 
16658  template<class S>
16659  void serialize(S &s, const unsigned /*version*/) {
16660  debugSerializationBegin("SgAsmElfSymverDefinedAux");
16661  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
16662  s & BOOST_SERIALIZATION_NVP(p_name);
16663  debugSerializationEnd("SgAsmElfSymverDefinedAux");
16664  }
16665 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
16666  // Local types
16669 public:
16670 #ifdef _MSC_VER
16671 # pragma pack (1)
16672 #endif
16673 
16676  uint32_t vda_name;
16677  uint32_t vda_next;
16678  }
16679 #if !defined(SWIG) && !defined(_MSC_VER)
16680  __attribute__((packed))
16681 #endif
16682  ;
16683 
16684 #ifdef _MSC_VER
16685 # pragma pack ()
16686 #endif
16687 
16689  // Properties
16691 public:
16695  SgAsmGenericString* const& get_name() const;
16696  void set_name(SgAsmGenericString* const&);
16698  // Functions
16701 public:
16705  explicit SgAsmElfSymverDefinedAux(SgAsmElfSymverDefinedEntry *symver_def_entry, SgAsmElfSymverDefinedSection *symver_def_sec);
16706 
16708  void parse(Rose::BinaryAnalysis::ByteOrder::Endianness, const SgAsmElfSymverDefinedAux::ElfSymverDefinedAux_disk*);
16709 
16711  void *encode(Rose::BinaryAnalysis::ByteOrder::Endianness, SgAsmElfSymverDefinedAux::ElfSymverDefinedAux_disk*) const;
16712 
16718  virtual void dump(FILE *f, const char *prefix, ssize_t idx) const;
16719 public:
16721  virtual ~SgAsmElfSymverDefinedAux();
16722 
16723 public:
16726 
16727 protected:
16734  void initializeProperties();
16735 #endif // SgAsmElfSymverDefinedAux_OTHERS
16736 #ifdef DOCUMENTATION
16737 };
16738 #endif // DOCUMENTATION
16739 
16740 
16742 // SgAsmElfSymbolSection -- MACHINE GENERATED; DO NOT MODIFY --
16744 
16745 DECLARE_LEAF_CLASS(AsmElfSymbolSection);
16746 IS_SERIALIZABLE(AsmElfSymbolSection);
16747 
16748 #ifdef DOCUMENTATION
16749 
16751 #endif // DOCUMENTATION
16752 
16753 #ifndef DOCUMENTATION
16754  AsmElfSymbolSection.setDataPrototype(
16755  "bool", "is_dynamic", "= false",
16756  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
16757 #endif // !DOCUMENTATION
16758 
16759 #ifndef DOCUMENTATION
16760  AsmElfSymbolSection.setDataPrototype(
16761  "SgAsmElfSymbolList*", "symbols", "= createAndParent<SgAsmElfSymbolList>(this)",
16762  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
16763 #endif // !DOCUMENTATION
16764 
16765  DECLARE_OTHERS(AsmElfSymbolSection);
16766 #if defined(SgAsmElfSymbolSection_OTHERS) || defined(DOCUMENTATION)
16767 
16768  //----------------------- Boost serialization for SgAsmElfSymbolSection -----------------------
16769 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
16770 private:
16771  friend class boost::serialization::access;
16772 
16773  template<class S>
16774  void serialize(S &s, const unsigned /*version*/) {
16775  debugSerializationBegin("SgAsmElfSymbolSection");
16776  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmElfSection);
16777  s & BOOST_SERIALIZATION_NVP(p_is_dynamic);
16778  s & BOOST_SERIALIZATION_NVP(p_symbols);
16779  debugSerializationEnd("SgAsmElfSymbolSection");
16780  }
16781 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
16782 
16783 public:
16787  bool const& get_is_dynamic() const;
16788  void set_is_dynamic(bool const&);
16791 public:
16798  SgAsmElfSymbolList* const& get_symbols() const;
16799  void set_symbols(SgAsmElfSymbolList* const&);
16801 public:
16804 
16806  virtual SgAsmElfSymbolSection* parse() override;
16807 
16820  virtual void finish_parsing() override;
16821 
16823  size_t index_of(SgAsmElfSymbol*);
16824 
16829  virtual rose_addr_t calculate_sizes(size_t *total, size_t *required, size_t *optional, size_t *nentries) const override;
16830 
16834  virtual bool reallocate() override;
16835 
16837  virtual void unparse(std::ostream&) const override;
16838 
16840  virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
16841 public:
16843  virtual ~SgAsmElfSymbolSection();
16844 
16845 public:
16848 
16849 protected:
16856  void initializeProperties();
16857 #endif // SgAsmElfSymbolSection_OTHERS
16858 #ifdef DOCUMENTATION
16859 };
16860 #endif // DOCUMENTATION
16861 
16862 
16864 // SgAsmElfSymbolList -- MACHINE GENERATED; DO NOT MODIFY --
16866 
16867 DECLARE_LEAF_CLASS(AsmElfSymbolList);
16868 IS_SERIALIZABLE(AsmElfSymbolList);
16869 
16870 #ifdef DOCUMENTATION
16872 #endif // DOCUMENTATION
16873 
16874 #ifndef DOCUMENTATION
16875  AsmElfSymbolList.setDataPrototype(
16876  "SgAsmElfSymbolPtrList", "symbols", "",
16877  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
16878 #endif // !DOCUMENTATION
16879 
16880  DECLARE_OTHERS(AsmElfSymbolList);
16881 #if defined(SgAsmElfSymbolList_OTHERS) || defined(DOCUMENTATION)
16882 
16883  //----------------------- Boost serialization for SgAsmElfSymbolList -----------------------
16884 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
16885 private:
16886  friend class boost::serialization::access;
16887 
16888  template<class S>
16889  void serialize(S &s, const unsigned /*version*/) {
16890  debugSerializationBegin("SgAsmElfSymbolList");
16891  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
16892  s & BOOST_SERIALIZATION_NVP(p_symbols);
16893  debugSerializationEnd("SgAsmElfSymbolList");
16894  }
16895 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
16896 
16897 public:
16904  SgAsmElfSymbolPtrList const& get_symbols() const;
16905  SgAsmElfSymbolPtrList& get_symbols();
16906  void set_symbols(SgAsmElfSymbolPtrList const&);
16909 public:
16911  virtual ~SgAsmElfSymbolList();
16912 
16913 public:
16916 
16917 protected:
16924  void initializeProperties();
16925 #endif // SgAsmElfSymbolList_OTHERS
16926 #ifdef DOCUMENTATION
16927 };
16928 #endif // DOCUMENTATION
16929 
16930 
16932 // SgAsmElfSymbol -- MACHINE GENERATED; DO NOT MODIFY --
16934 
16935 DECLARE_LEAF_CLASS(AsmElfSymbol);
16936 IS_SERIALIZABLE(AsmElfSymbol);
16937 
16938 DECLARE_HEADERS(AsmElfSymbol);
16939 #if defined(SgAsmElfSymbol_HEADERS) || defined(DOCUMENTATION)
16940 #include <Rose/BinaryAnalysis/ByteOrder.h>
16941 #endif // SgAsmElfSymbol_HEADERS
16942 
16943 #ifdef DOCUMENTATION
16944 
16949 #endif // DOCUMENTATION
16950 
16951 #ifndef DOCUMENTATION
16952  AsmElfSymbol.setDataPrototype(
16953  "unsigned char", "st_info", "= 0",
16954  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
16955 #endif // !DOCUMENTATION
16956 
16957 #ifndef DOCUMENTATION
16958  AsmElfSymbol.setDataPrototype(
16959  "unsigned char", "st_res1", "= 0",
16960  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
16961 #endif // !DOCUMENTATION
16962 
16963 #ifndef DOCUMENTATION
16964  AsmElfSymbol.setDataPrototype(
16965  "unsigned", "st_shndx", "= 0",
16966  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
16967 #endif // !DOCUMENTATION
16968 
16969 #ifndef DOCUMENTATION
16970  AsmElfSymbol.setDataPrototype(
16971  "rose_addr_t", "st_size", "= 0",
16972  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
16973 #endif // !DOCUMENTATION
16974 
16975 #ifndef DOCUMENTATION
16976  AsmElfSymbol.setDataPrototype(
16977  "SgUnsignedCharList", "extra", "",
16978  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
16979 #endif // !DOCUMENTATION
16980 
16981  DECLARE_OTHERS(AsmElfSymbol);
16982 #if defined(SgAsmElfSymbol_OTHERS) || defined(DOCUMENTATION)
16983 
16984  //----------------------- Boost serialization for SgAsmElfSymbol -----------------------
16985 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
16986 private:
16987  friend class boost::serialization::access;
16988 
16989  template<class S>
16990  void serialize(S &s, const unsigned /*version*/) {
16991  debugSerializationBegin("SgAsmElfSymbol");
16992  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmGenericSymbol);
16993  s & BOOST_SERIALIZATION_NVP(p_st_info);
16994  s & BOOST_SERIALIZATION_NVP(p_st_res1);
16995  s & BOOST_SERIALIZATION_NVP(p_st_shndx);
16996  s & BOOST_SERIALIZATION_NVP(p_st_size);
16997  s & BOOST_SERIALIZATION_NVP(p_extra);
16998  debugSerializationEnd("SgAsmElfSymbol");
16999  }
17000 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
17001  // Local types
17004 public:
17005  enum ElfSymBinding {
17006  STB_LOCAL=0,
17007  STB_GLOBAL=1,
17008  STB_WEAK=2
17009  };
17010 
17011  enum ElfSymType {
17014  STT_FUNC = 2,
17016  STT_FILE = 4,
17018  STT_TLS = 6,
17020  };
17021 
17022 #ifdef _MSC_VER
17023 # pragma pack (1)
17024 #endif
17025 
17028  uint32_t st_name;
17029  uint32_t st_value;
17030  uint32_t st_size;
17031  unsigned char st_info;
17032  unsigned char st_res1;
17033  uint16_t st_shndx;
17034  }
17035 #if !defined(SWIG) && !defined(_MSC_VER)
17036  __attribute__((packed))
17037 #endif
17038  ;
17039 
17041  uint32_t st_name;
17042  unsigned char st_info;
17043  unsigned char st_res1;
17044  uint16_t st_shndx;
17045  uint64_t st_value;
17046  uint64_t st_size;
17047  }
17048 #if !defined(SWIG) && !defined(_MSC_VER)
17049  __attribute__((packed))
17050 #endif
17051  ;
17052 
17053 #ifdef _MSC_VER
17054 # pragma pack ()
17055 #endif
17056 
17058  // Properties
17060 public:
17066  unsigned char const& get_st_info() const;
17067  void set_st_info(unsigned char const&);
17070 public:
17076  unsigned char const& get_st_res1() const;
17077  void set_st_res1(unsigned char const&);
17080 public:
17086  unsigned const& get_st_shndx() const;
17087  void set_st_shndx(unsigned const&);
17090 public:
17096  rose_addr_t const& get_st_size() const;
17097  void set_st_size(rose_addr_t const&);
17100 public:
17106  SgUnsignedCharList const& get_extra() const;
17107  SgUnsignedCharList& get_extra();
17108  void set_extra(SgUnsignedCharList const&);
17110  // Functions
17113 public:
17116 
17120  void parse(Rose::BinaryAnalysis::ByteOrder::Endianness, const SgAsmElfSymbol::Elf32SymbolEntry_disk*);
17121 
17125  void parse(Rose::BinaryAnalysis::ByteOrder::Endianness, const SgAsmElfSymbol::Elf64SymbolEntry_disk*);
17126 
17130  void *encode(Rose::BinaryAnalysis::ByteOrder::Endianness, SgAsmElfSymbol::Elf32SymbolEntry_disk*) const;
17131  void *encode(Rose::BinaryAnalysis::ByteOrder::Endianness, SgAsmElfSymbol::Elf64SymbolEntry_disk*) const;
17139  virtual void dump(FILE *f, const char *prefix, ssize_t idx) const override;
17140  void dump(FILE*, const char *prefix, ssize_t idx, SgAsmGenericSection*) const;
17144  SgAsmElfSymbol::ElfSymBinding get_elf_binding() const;
17145 
17148 
17150  static std::string to_string(SgAsmElfSymbol::ElfSymBinding);
17151 
17153  static std::string to_string(SgAsmElfSymbol::ElfSymType);
17154 
17155 private:
17156  void parse_common(); // initialization common to all parse() methods
17157 public:
17159  virtual ~SgAsmElfSymbol();
17160 
17161 public:
17163  SgAsmElfSymbol();
17164 
17165 protected:
17172  void initializeProperties();
17173 #endif // SgAsmElfSymbol_OTHERS
17174 #ifdef DOCUMENTATION
17175 };
17176 #endif // DOCUMENTATION
17177 
17178 
17180 // SgAsmElfStrtab -- MACHINE GENERATED; DO NOT MODIFY --
17182 
17183 DECLARE_LEAF_CLASS(AsmElfStrtab);
17184 IS_SERIALIZABLE(AsmElfStrtab);
17185 
17186 #ifdef DOCUMENTATION
17187 
17189 #endif // DOCUMENTATION
17190 
17191  DECLARE_OTHERS(AsmElfStrtab);
17192 #if defined(SgAsmElfStrtab_OTHERS) || defined(DOCUMENTATION)
17193 
17194  //----------------------- Boost serialization for SgAsmElfStrtab -----------------------
17195 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
17196 private:
17197  friend class boost::serialization::access;
17198 
17199  template<class S>
17200  void serialize(S &s, const unsigned /*version*/) {
17201  debugSerializationBegin("SgAsmElfStrtab");
17202  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmGenericStrtab);
17203  debugSerializationEnd("SgAsmElfStrtab");
17204  }
17205 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
17206 public:
17210  explicit SgAsmElfStrtab(class SgAsmElfSection *containing_section);
17211 
17218  void destructorHelper() override;
17219 
17223  virtual SgAsmElfStrtab *parse() override;
17224 
17228  virtual void unparse(std::ostream&) const;
17229 
17235  virtual SgAsmStringStorage *create_storage(rose_addr_t offset, bool shared) override;
17236 
17240  virtual rose_addr_t get_storage_size(const SgAsmStringStorage*) override;
17241 
17251  virtual void allocate_overlap(SgAsmStringStorage*) override;
17252 
17254  virtual void rebind(SgAsmStringStorage*, rose_addr_t) override;
17255 public:
17257  virtual ~SgAsmElfStrtab();
17258 
17259 public:
17261  SgAsmElfStrtab();
17262 
17263 protected:
17270  void initializeProperties();
17271 #endif // SgAsmElfStrtab_OTHERS
17272 #ifdef DOCUMENTATION
17273 };
17274 #endif // DOCUMENTATION
17275 
17276 
17278 // SgAsmElfStringSection -- MACHINE GENERATED; DO NOT MODIFY --
17280 
17281 DECLARE_LEAF_CLASS(AsmElfStringSection);
17282 IS_SERIALIZABLE(AsmElfStringSection);
17283 
17284 #ifdef DOCUMENTATION
17285 
17289 #endif // DOCUMENTATION
17290 
17291 #ifndef DOCUMENTATION
17292  AsmElfStringSection.setDataPrototype(
17293  "SgAsmElfStrtab*", "strtab", "= nullptr",
17294  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
17295 #endif // !DOCUMENTATION
17296 
17297  DECLARE_OTHERS(AsmElfStringSection);
17298 #if defined(SgAsmElfStringSection_OTHERS) || defined(DOCUMENTATION)
17299 
17300  //----------------------- Boost serialization for SgAsmElfStringSection -----------------------
17301 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
17302 private:
17303  friend class boost::serialization::access;
17304 
17305  template<class S>
17306  void serialize(S &s, const unsigned /*version*/) {
17307  debugSerializationBegin("SgAsmElfStringSection");
17308  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmElfSection);
17309  s & BOOST_SERIALIZATION_NVP(p_strtab);
17310  debugSerializationEnd("SgAsmElfStringSection");
17311  }
17312 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
17313 
17314 public:
17320  SgAsmElfStrtab* const& get_strtab() const;
17321  void set_strtab(SgAsmElfStrtab* const&);
17323 public:
17326 
17328  virtual SgAsmElfStringSection *parse() override;
17329 
17331  virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
17332 
17337  virtual void set_size(rose_addr_t newsize) override;
17338 
17345  virtual bool reallocate() override;
17346 
17348  virtual void unparse(std::ostream&) const override;
17349 public:
17351  virtual ~SgAsmElfStringSection();
17352 
17353 public:
17356 
17357 protected:
17364  void initializeProperties();
17365 #endif // SgAsmElfStringSection_OTHERS
17366 #ifdef DOCUMENTATION
17367 };
17368 #endif // DOCUMENTATION
17369 
17370 
17372 // SgAsmElfSegmentTable -- MACHINE GENERATED; DO NOT MODIFY --
17374 
17375 DECLARE_LEAF_CLASS(AsmElfSegmentTable);
17376 IS_SERIALIZABLE(AsmElfSegmentTable);
17377 
17378 #ifdef DOCUMENTATION
17379 
17386 #endif // DOCUMENTATION
17387 
17388  DECLARE_OTHERS(AsmElfSegmentTable);
17389 #if defined(SgAsmElfSegmentTable_OTHERS) || defined(DOCUMENTATION)
17390 
17391  //----------------------- Boost serialization for SgAsmElfSegmentTable -----------------------
17392 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
17393 private:
17394  friend class boost::serialization::access;
17395 
17396  template<class S>
17397  void serialize(S &s, const unsigned /*version*/) {
17398  debugSerializationBegin("SgAsmElfSegmentTable");
17399  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmGenericSection);
17400  debugSerializationEnd("SgAsmElfSegmentTable");
17401  }
17402 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
17403 public:
17406 
17411  virtual SgAsmElfSegmentTable *parse() override;
17412 
17427 
17431  rose_addr_t calculate_sizes(size_t *entsize, size_t *required, size_t *optional, size_t *entcount) const;
17432 
17434  virtual bool reallocate() override;
17435 
17437  virtual void unparse(std::ostream&) const override;
17438 
17440  virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
17441 public:
17443  virtual ~SgAsmElfSegmentTable();
17444 
17445 public:
17448 
17449 protected:
17456  void initializeProperties();
17457 #endif // SgAsmElfSegmentTable_OTHERS
17458 #ifdef DOCUMENTATION
17459 };
17460 #endif // DOCUMENTATION
17461 
17462 
17464 // SgAsmElfSegmentTableEntryList -- MACHINE GENERATED; DO NOT MODIFY --
17466 
17467 DECLARE_LEAF_CLASS(AsmElfSegmentTableEntryList);
17468 IS_SERIALIZABLE(AsmElfSegmentTableEntryList);
17469 
17470 #ifdef DOCUMENTATION
17472 #endif // DOCUMENTATION
17473 
17474 #ifndef DOCUMENTATION
17475  AsmElfSegmentTableEntryList.setDataPrototype(
17476  "SgAsmElfSegmentTableEntryPtrList", "entries", "",
17477  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
17478 #endif // !DOCUMENTATION
17479 
17480  DECLARE_OTHERS(AsmElfSegmentTableEntryList);
17481 #if defined(SgAsmElfSegmentTableEntryList_OTHERS) || defined(DOCUMENTATION)
17482 
17483  //----------------------- Boost serialization for SgAsmElfSegmentTableEntryList -----------------------
17484 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
17485 private:
17486  friend class boost::serialization::access;
17487 
17488  template<class S>
17489  void serialize(S &s, const unsigned /*version*/) {
17490  debugSerializationBegin("SgAsmElfSegmentTableEntryList");
17491  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
17492  s & BOOST_SERIALIZATION_NVP(p_entries);
17493  debugSerializationEnd("SgAsmElfSegmentTableEntryList");
17494  }
17495 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
17496 
17497 public:
17504  SgAsmElfSegmentTableEntryPtrList const& get_entries() const;
17505  SgAsmElfSegmentTableEntryPtrList& get_entries();
17506  void set_entries(SgAsmElfSegmentTableEntryPtrList const&);
17509 public:
17512 
17513 public:
17516 
17517 protected:
17524  void initializeProperties();
17525 #endif // SgAsmElfSegmentTableEntryList_OTHERS
17526 #ifdef DOCUMENTATION
17527 };
17528 #endif // DOCUMENTATION
17529 
17530 
17532 // SgAsmElfSegmentTableEntry -- MACHINE GENERATED; DO NOT MODIFY --
17534 
17535 DECLARE_LEAF_CLASS(AsmElfSegmentTableEntry);
17536 IS_SERIALIZABLE(AsmElfSegmentTableEntry);
17537 
17538 DECLARE_HEADERS(AsmElfSegmentTableEntry);
17539 #if defined(SgAsmElfSegmentTableEntry_HEADERS) || defined(DOCUMENTATION)
17540 #include <Rose/BinaryAnalysis/ByteOrder.h>
17541 #endif // SgAsmElfSegmentTableEntry_HEADERS
17542 
17543 #ifdef DOCUMENTATION
17544 
17546 #endif // DOCUMENTATION
17547 
17548 #ifndef DOCUMENTATION
17549  AsmElfSegmentTableEntry.setDataPrototype(
17550  "size_t", "index", "= 0",
17551  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
17552 #endif // !DOCUMENTATION
17553 
17554 #ifndef DOCUMENTATION
17555  AsmElfSegmentTableEntry.setDataPrototype(
17556  "SgAsmElfSegmentTableEntry::SegmentType", "type", "= SgAsmElfSegmentTableEntry::PT_LOAD",
17557  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
17558 #endif // !DOCUMENTATION
17559 
17560 #ifndef DOCUMENTATION
17561  AsmElfSegmentTableEntry.setDataPrototype(
17562  "SgAsmElfSegmentTableEntry::SegmentFlags", "flags", "= SgAsmElfSegmentTableEntry::PF_NONE",
17563  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
17564 #endif // !DOCUMENTATION
17565 
17566 #ifndef DOCUMENTATION
17567  AsmElfSegmentTableEntry.setDataPrototype(
17568  "rose_addr_t", "offset", "= 0",
17569  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
17570 #endif // !DOCUMENTATION
17571 
17572 #ifndef DOCUMENTATION
17573  AsmElfSegmentTableEntry.setDataPrototype(
17574  "rose_addr_t", "vaddr", "= 0",
17575  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
17576 #endif // !DOCUMENTATION
17577 
17578 #ifndef DOCUMENTATION
17579  AsmElfSegmentTableEntry.setDataPrototype(
17580  "rose_addr_t", "paddr", "= 0",
17581  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
17582 #endif // !DOCUMENTATION
17583 
17584 #ifndef DOCUMENTATION
17585  AsmElfSegmentTableEntry.setDataPrototype(
17586  "rose_addr_t", "filesz", "= 0",
17587  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
17588 #endif // !DOCUMENTATION
17589 
17590 #ifndef DOCUMENTATION
17591  AsmElfSegmentTableEntry.setDataPrototype(
17592  "rose_addr_t", "memsz", "= 0",
17593  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
17594 #endif // !DOCUMENTATION
17595 
17596 #ifndef DOCUMENTATION
17597  AsmElfSegmentTableEntry.setDataPrototype(
17598  "rose_addr_t", "align", "= 0",
17599  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
17600 #endif // !DOCUMENTATION
17601 
17602 #ifndef DOCUMENTATION
17603  AsmElfSegmentTableEntry.setDataPrototype(
17604  "SgUnsignedCharList", "extra", "",
17605  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
17606 #endif // !DOCUMENTATION
17607 
17608  DECLARE_OTHERS(AsmElfSegmentTableEntry);
17609 #if defined(SgAsmElfSegmentTableEntry_OTHERS) || defined(DOCUMENTATION)
17610 
17611  //----------------------- Boost serialization for SgAsmElfSegmentTableEntry -----------------------
17612 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
17613 private:
17614  friend class boost::serialization::access;
17615 
17616  template<class S>
17617  void serialize(S &s, const unsigned /*version*/) {
17618  debugSerializationBegin("SgAsmElfSegmentTableEntry");
17619  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
17620  s & BOOST_SERIALIZATION_NVP(p_index);
17621  s & BOOST_SERIALIZATION_NVP(p_type);
17622  s & BOOST_SERIALIZATION_NVP(p_flags);
17623  s & BOOST_SERIALIZATION_NVP(p_offset);
17624  s & BOOST_SERIALIZATION_NVP(p_vaddr);
17625  s & BOOST_SERIALIZATION_NVP(p_paddr);
17626  s & BOOST_SERIALIZATION_NVP(p_filesz);
17627  s & BOOST_SERIALIZATION_NVP(p_memsz);
17628  s & BOOST_SERIALIZATION_NVP(p_align);
17629  s & BOOST_SERIALIZATION_NVP(p_extra);
17630  debugSerializationEnd("SgAsmElfSegmentTableEntry");
17631  }
17632 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
17633  // Local types
17636 public:
17639  PT_NULL = 0,
17640  PT_LOAD = 1,
17643  PT_NOTE = 4,
17644  PT_SHLIB = 5,
17645  PT_PHDR = 6,
17646  PT_TLS = 7,
17648  // OS- and Processor-specific ranges
17649  PT_LOOS = 0x60000000,
17650  PT_HIOS = 0x6fffffff,
17651  PT_LOPROC = 0x70000000,
17652  PT_HIPROC = 0x7fffffff,
17653 
17654  // OS-specific values for GNU/Linux
17655  PT_GNU_EH_FRAME = 0x6474e550,
17656  PT_GNU_STACK = 0x6474e551,
17657  PT_GNU_RELRO = 0x6474e552,
17658  PT_PAX_FLAGS = 0x65041580,
17660  // OS-specific values for Sun
17661  PT_SUNWBSS = 0x6ffffffa,
17662  PT_SUNWSTACK = 0x6ffffffb
17663  };
17664 
17667  PF_NONE = 0,
17668  PF_RESERVED = 0x000ffff8,
17669  PF_XPERM = 0x00000001,
17670  PF_WPERM = 0x00000002,
17671  PF_RPERM = 0x00000004,
17672  PF_OS_MASK = 0x0ff00000,
17673  PF_PROC_MASK = 0xf0000000
17674  };
17675 
17676 #ifdef _MSC_VER
17677 # pragma pack (1)
17678 #endif
17679 
17687  uint32_t p_type;
17688  uint32_t p_offset;
17689  uint32_t p_vaddr;
17690  uint32_t p_paddr;
17691  uint32_t p_filesz;
17692  uint32_t p_memsz;
17693  uint32_t p_flags;
17694  uint32_t p_align;
17695  } /* 0x30 */
17696 #if !defined(SWIG) && !defined(_MSC_VER)
17697  __attribute__((packed))
17698 #endif
17699  ;
17700 
17702  uint32_t p_type; /* 0x00 */
17703  uint32_t p_flags; /* 0x04 */
17704  uint64_t p_offset; /* 0x08 */
17705  uint64_t p_vaddr; /* 0x10 */
17706  uint64_t p_paddr; /* 0x18 */
17707  uint64_t p_filesz; /* 0x20 */
17708  uint64_t p_memsz; /* 0x28 */
17709  uint64_t p_align; /* 0x30 */
17710  } /* 0x38 */
17711 #if !defined(SWIG) && !defined(_MSC_VER)
17712  __attribute__((packed))
17713 #endif
17714  ;
17715 #ifdef _MSC_VER
17716 # pragma pack ()
17717 #endif
17718 
17720  // Properties
17722 public:
17728  size_t const& get_index() const;
17729  void set_index(size_t const&);
17732 public:
17740 public:
17748 public:
17754  rose_addr_t const& get_offset() const;
17755  void set_offset(rose_addr_t const&);
17758 public:
17765  rose_addr_t const& get_vaddr() const;
17766  void set_vaddr(rose_addr_t const&);
17769 public:
17775  rose_addr_t const& get_paddr() const;
17776  void set_paddr(rose_addr_t const&);
17779 public:
17785  rose_addr_t const& get_filesz() const;
17786  void set_filesz(rose_addr_t const&);
17789 public:
17795  rose_addr_t const& get_memsz() const;
17796  void set_memsz(rose_addr_t const&);
17799 public:
17805  rose_addr_t const& get_align() const;
17806  void set_align(rose_addr_t const&);
17809 public:
17815  SgUnsignedCharList const& get_extra() const;
17816  SgUnsignedCharList& get_extra();
17817  void set_extra(SgUnsignedCharList const&);
17819  // Functions
17822 public:
17824  SgAsmElfSegmentTableEntry(Rose::BinaryAnalysis::ByteOrder::Endianness sex,
17826 
17828  SgAsmElfSegmentTableEntry(Rose::BinaryAnalysis::ByteOrder::Endianness sex,
17830 
17834  void *encode(Rose::BinaryAnalysis::ByteOrder::Endianness, SgAsmElfSegmentTableEntry::Elf32SegmentTableEntry_disk*) const;
17835  void *encode(Rose::BinaryAnalysis::ByteOrder::Endianness, SgAsmElfSegmentTableEntry::Elf64SegmentTableEntry_disk*) const;
17840 
17842  virtual void dump(FILE*, const char *prefix, ssize_t idx) const;
17843 
17846 
17849 public:
17851  virtual ~SgAsmElfSegmentTableEntry();
17852 
17853 public:
17856 
17857 protected:
17864  void initializeProperties();
17865 #endif // SgAsmElfSegmentTableEntry_OTHERS
17866 #ifdef DOCUMENTATION
17867 };
17868 #endif // DOCUMENTATION
17869 
17870 
17872 // SgAsmElfSectionTable -- MACHINE GENERATED; DO NOT MODIFY --
17874 
17875 DECLARE_LEAF_CLASS(AsmElfSectionTable);
17876 IS_SERIALIZABLE(AsmElfSectionTable);
17877 
17878 #ifdef DOCUMENTATION
17879 
17885 #endif // DOCUMENTATION
17886 
17887  DECLARE_OTHERS(AsmElfSectionTable);
17888 #if defined(SgAsmElfSectionTable_OTHERS) || defined(DOCUMENTATION)
17889 
17890  //----------------------- Boost serialization for SgAsmElfSectionTable -----------------------
17891 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
17892 private:
17893  friend class boost::serialization::access;
17894 
17895  template<class S>
17896  void serialize(S &s, const unsigned /*version*/) {
17897  debugSerializationBegin("SgAsmElfSectionTable");
17898  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmGenericSection);
17899  debugSerializationEnd("SgAsmElfSectionTable");
17900  }
17901 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
17902 public:
17905 
17911  virtual SgAsmElfSectionTable *parse() override;
17912 
17924 
17928  rose_addr_t calculate_sizes(size_t *entsize, size_t *required, size_t *optional, size_t *entcount) const;
17929 
17931  virtual bool reallocate() override;
17932 
17934  virtual void unparse(std::ostream&) const override;
17935 
17937  virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
17938 public:
17940  virtual ~SgAsmElfSectionTable();
17941 
17942 public:
17945 
17946 protected:
17953  void initializeProperties();
17954 #endif // SgAsmElfSectionTable_OTHERS
17955 #ifdef DOCUMENTATION
17956 };
17957 #endif // DOCUMENTATION
17958 
17959 
17961 // SgAsmElfSectionTableEntry -- MACHINE GENERATED; DO NOT MODIFY --
17963 
17964 DECLARE_LEAF_CLASS(AsmElfSectionTableEntry);
17965 IS_SERIALIZABLE(AsmElfSectionTableEntry);
17966 
17967 DECLARE_HEADERS(AsmElfSectionTableEntry);
17968 #if defined(SgAsmElfSectionTableEntry_HEADERS) || defined(DOCUMENTATION)
17969 #include <Rose/BinaryAnalysis/ByteOrder.h>
17970 #endif // SgAsmElfSectionTableEntry_HEADERS
17971 
17972 #ifdef DOCUMENTATION
17973 
17975 #endif // DOCUMENTATION
17976 
17977 #ifndef DOCUMENTATION
17978  AsmElfSectionTableEntry.setDataPrototype(
17979  "unsigned", "sh_name", "= 0",
17980  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
17981 #endif // !DOCUMENTATION
17982 
17983 #ifndef DOCUMENTATION
17984  AsmElfSectionTableEntry.setDataPrototype(
17985  "SgAsmElfSectionTableEntry::SectionType", "sh_type", "= SHT_PROGBITS",
17986  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
17987 #endif // !DOCUMENTATION
17988 
17989 #ifndef DOCUMENTATION
17990  AsmElfSectionTableEntry.setDataPrototype(
17991  "unsigned long", "sh_link", "= 0",
17992  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
17993 #endif // !DOCUMENTATION
17994 
17995 #ifndef DOCUMENTATION
17996  AsmElfSectionTableEntry.setDataPrototype(
17997  "unsigned long", "sh_info", "= 0",
17998  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
17999 #endif // !DOCUMENTATION
18000 
18001 #ifndef DOCUMENTATION
18002  AsmElfSectionTableEntry.setDataPrototype(
18003  "uint64_t", "sh_flags", "= 0",
18004  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
18005 #endif // !DOCUMENTATION
18006 
18007 #ifndef DOCUMENTATION
18008  AsmElfSectionTableEntry.setDataPrototype(
18009  "rose_addr_t", "sh_addr", "= 0",
18010  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
18011 #endif // !DOCUMENTATION
18012 
18013 #ifndef DOCUMENTATION
18014  AsmElfSectionTableEntry.setDataPrototype(
18015  "rose_addr_t", "sh_offset", "= 0",
18016  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
18017 #endif // !DOCUMENTATION
18018 
18019 #ifndef DOCUMENTATION
18020  AsmElfSectionTableEntry.setDataPrototype(
18021  "rose_addr_t", "sh_size", "= 0",
18022  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
18023 #endif // !DOCUMENTATION
18024 
18025 #ifndef DOCUMENTATION
18026  AsmElfSectionTableEntry.setDataPrototype(
18027  "rose_addr_t", "sh_addralign", "= 0",
18028  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
18029 #endif // !DOCUMENTATION
18030 
18031 #ifndef DOCUMENTATION
18032  AsmElfSectionTableEntry.setDataPrototype(
18033  "rose_addr_t", "sh_entsize", "= 0",
18034  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
18035 #endif // !DOCUMENTATION
18036 
18037 #ifndef DOCUMENTATION
18038  AsmElfSectionTableEntry.setDataPrototype(
18039  "SgUnsignedCharList", "extra", "",
18040  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
18041 #endif // !DOCUMENTATION
18042 
18043  DECLARE_OTHERS(AsmElfSectionTableEntry);
18044 #if defined(SgAsmElfSectionTableEntry_OTHERS) || defined(DOCUMENTATION)
18045 
18046  //----------------------- Boost serialization for SgAsmElfSectionTableEntry -----------------------
18047 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
18048 private:
18049  friend class boost::serialization::access;
18050 
18051  template<class S>
18052  void serialize(S &s, const unsigned /*version*/) {
18053  debugSerializationBegin("SgAsmElfSectionTableEntry");
18054  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
18055  s & BOOST_SERIALIZATION_NVP(p_sh_name);
18056  s & BOOST_SERIALIZATION_NVP(p_sh_type);
18057  s & BOOST_SERIALIZATION_NVP(p_sh_link);
18058  s & BOOST_SERIALIZATION_NVP(p_sh_info);
18059  s & BOOST_SERIALIZATION_NVP(p_sh_flags);
18060  s & BOOST_SERIALIZATION_NVP(p_sh_addr);
18061  s & BOOST_SERIALIZATION_NVP(p_sh_offset);
18062  s & BOOST_SERIALIZATION_NVP(p_sh_size);
18063  s & BOOST_SERIALIZATION_NVP(p_sh_addralign);
18064  s & BOOST_SERIALIZATION_NVP(p_sh_entsize);
18065  s & BOOST_SERIALIZATION_NVP(p_extra);
18066  debugSerializationEnd("SgAsmElfSectionTableEntry");
18067  }
18068 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
18069  // Local types
18072 public:
18075  SHT_NULL = 0,
18079  SHT_RELA = 4,
18080  SHT_HASH = 5,
18082  SHT_NOTE = 7,
18084  SHT_REL = 9,
18085  SHT_SHLIB = 10,
18086  SHT_DYNSYM = 11,
18088  SHT_LOOS = 0x60000000,
18089  SHT_GNU_verdef = 0x6ffffffd,
18090  SHT_GNU_verneed = 0x6ffffffe,
18091  SHT_GNU_versym = 0x6fffffff,
18092  SHT_HIOS = 0x6fffffff, /*NO_STRINGIFY*/
18093 
18094  SHT_LOPROC = 0x70000000, /* Processor specific semantics */
18095  SHT_HIPROC = 0x7fffffff,
18096  SHT_LOUSER = 0x80000000, /* Application specific semantics */
18097  SHT_HIUSER = 0xffffffff
18098  };
18099 
18103  SHF_WRITE= (1 << 0),
18104  SHF_ALLOC= (1 << 1),
18105  SHF_EXECINSTR= (1 << 2),
18106  SHF_MERGE= (1 << 4),
18107  SHF_STRINGS= (1 << 5),
18108  SHF_INFO_LINK= (1 << 6),
18109  SHF_LINK_ORDER= (1 << 7),
18111  SHF_GROUP= (1 << 9),
18112  SHF_TLS= (1 << 10),
18113  SHF_MASKOS= 0x0ff00000,
18114  SHF_MASKPROC= 0xf0000000
18115  };
18116 
18123 #ifdef _MSC_VER
18124 # pragma pack (1)
18125 #endif
18127  uint32_t sh_name; /* 0x00 Section name; index into section header string table */
18128  uint32_t sh_type; /* 0x04 Section contents and semantics (see SectionType enum) */
18129  uint32_t sh_flags; /* 0x08 Bit flags */
18130  uint32_t sh_addr; /* 0x0c Desired mapped address */
18131  uint32_t sh_offset; /* 0x10 Section location in file unless sh_type==SHT_NOBITS */
18132  uint32_t sh_size; /* 0x14 Section size in bytes */
18133  uint32_t sh_link; /* 0x18 Section ID of another section; meaning depends on section type */
18134  uint32_t sh_info; /* 0x1c Extra info depending on section type */
18135  uint32_t sh_addralign; /* 0x20 Mapped alignment (0 and 1=>byte aligned); sh_addr must be aligned*/
18136  uint32_t sh_entsize; /* 0x24 If non-zero, size in bytes of each array member in the section */
18137  } /* 0x28 */
18138 #if !defined(SWIG) && !defined(_MSC_VER)
18139  __attribute__((packed))
18140 #endif
18141  ;
18142 
18144  uint32_t sh_name; /* 0x00 see Elf32SectionTableEntry_disk */
18145  uint32_t sh_type; /* 0x04 */
18146  uint64_t sh_flags; /* 0x08 */
18147  uint64_t sh_addr; /* 0x10 */
18148  uint64_t sh_offset; /* 0x18 */
18149  uint64_t sh_size; /* 0x20 */
18150  uint32_t sh_link; /* 0x28 */
18151  uint32_t sh_info; /* 0x2c */
18152  uint64_t sh_addralign; /* 0x30 */
18153  uint64_t sh_entsize; /* 0x38 */
18154  } /* 0x40 */
18155 #if !defined(SWIG) && !defined(_MSC_VER)
18156  __attribute__((packed))
18157 #endif
18158  ;
18159 #ifdef _MSC_VER
18160 # pragma pack ()
18161 #endif
18162 
18164  // Properties
18166 public:
18172  unsigned const& get_sh_name() const;
18173  void set_sh_name(unsigned const&);
18176 public:
18186 public:
18192  unsigned long const& get_sh_link() const;
18193  void set_sh_link(unsigned long const&);
18196 public:
18202  unsigned long const& get_sh_info() const;
18203  void set_sh_info(unsigned long const&);
18206 public:
18212  uint64_t const& get_sh_flags() const;
18213  void set_sh_flags(uint64_t const&);
18216 public:
18222  rose_addr_t const& get_sh_addr() const;
18223  void set_sh_addr(rose_addr_t const&);
18226 public:
18232  rose_addr_t const& get_sh_offset() const;
18233  void set_sh_offset(rose_addr_t const&);
18236 public:
18242  rose_addr_t const& get_sh_size() const;
18243  void set_sh_size(rose_addr_t const&);
18246 public:
18252  rose_addr_t const& get_sh_addralign() const;
18253  void set_sh_addralign(rose_addr_t const&);
18256 public:
18262  rose_addr_t const& get_sh_entsize() const;
18263  void set_sh_entsize(rose_addr_t const&);
18266 public:
18272  SgUnsignedCharList const& get_extra() const;
18273  SgUnsignedCharList& get_extra();
18274  void set_extra(SgUnsignedCharList const&);
18276  // Functions
18279 public:
18281  SgAsmElfSectionTableEntry(Rose::BinaryAnalysis::ByteOrder::Endianness sex,
18283 
18285  SgAsmElfSectionTableEntry(Rose::BinaryAnalysis::ByteOrder::Endianness sex,
18287 
18291  void *encode(Rose::BinaryAnalysis::ByteOrder::Endianness sex,
18293  void *encode(Rose::BinaryAnalysis::ByteOrder::Endianness sex,
18299 
18301  virtual void dump(FILE*, const char *prefix, ssize_t idx) const;
18302 
18303  // Use Rose::stringify... function instead.
18304  static std::string to_string(SgAsmElfSectionTableEntry::SectionType);
18305  static std::string to_string(SgAsmElfSectionTableEntry::SectionFlags);
18306 public:
18308  virtual ~SgAsmElfSectionTableEntry();
18309 
18310 public:
18313 
18314 protected:
18321  void initializeProperties();
18322 #endif // SgAsmElfSectionTableEntry_OTHERS
18323 #ifdef DOCUMENTATION
18324 };
18325 #endif // DOCUMENTATION
18326 
18327 
18329 // SgAsmElfRelocSection -- MACHINE GENERATED; DO NOT MODIFY --
18331 
18332 DECLARE_LEAF_CLASS(AsmElfRelocSection);
18333 IS_SERIALIZABLE(AsmElfRelocSection);
18334 
18335 #ifdef DOCUMENTATION
18336 
18338 #endif // DOCUMENTATION
18339 
18340 #ifndef DOCUMENTATION
18341  AsmElfRelocSection.setDataPrototype(
18342  "bool", "uses_addend", "= true",
18343  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
18344 #endif // !DOCUMENTATION
18345 
18346 #ifndef DOCUMENTATION
18347  AsmElfRelocSection.setDataPrototype(
18348  "SgAsmElfSection*", "target_section", "= nullptr",
18349  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
18350 #endif // !DOCUMENTATION
18351 
18352 #ifndef DOCUMENTATION
18353  AsmElfRelocSection.setDataPrototype(
18354  "SgAsmElfRelocEntryList*", "entries", "= createAndParent<SgAsmElfRelocEntryList>(this)",
18355  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
18356 #endif // !DOCUMENTATION
18357 
18358  DECLARE_OTHERS(AsmElfRelocSection);
18359 #if defined(SgAsmElfRelocSection_OTHERS) || defined(DOCUMENTATION)
18360 
18361  //----------------------- Boost serialization for SgAsmElfRelocSection -----------------------
18362 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
18363 private:
18364  friend class boost::serialization::access;
18365 
18366  template<class S>
18367  void serialize(S &s, const unsigned /*version*/) {
18368  debugSerializationBegin("SgAsmElfRelocSection");
18369  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmElfSection);
18370  s & BOOST_SERIALIZATION_NVP(p_uses_addend);
18371  s & BOOST_SERIALIZATION_NVP(p_target_section);
18372  s & BOOST_SERIALIZATION_NVP(p_entries);
18373  debugSerializationEnd("SgAsmElfRelocSection");
18374  }
18375 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
18376 
18377 public:
18381  bool const& get_uses_addend() const;
18382  void set_uses_addend(bool const&);
18385 public:
18389  SgAsmElfSection* const& get_target_section() const;
18390  void set_target_section(SgAsmElfSection* const&);
18393 public:
18399  SgAsmElfRelocEntryList* const& get_entries() const;
18400  void set_entries(SgAsmElfRelocEntryList* const&);
18402 public:
18404 
18407  virtual SgAsmElfRelocSection *parse() override;
18408 
18410  virtual rose_addr_t calculate_sizes(size_t *total, size_t *required, size_t *optional, size_t *entcount) const override;
18411 
18413  virtual bool reallocate() override;
18414 
18416  virtual void unparse(std::ostream&) const override;
18417 
18419  virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
18420 public:
18422  virtual ~SgAsmElfRelocSection();
18423 
18424 public:
18427 
18428 protected:
18435  void initializeProperties();
18436 #endif // SgAsmElfRelocSection_OTHERS
18437 #ifdef DOCUMENTATION
18438 };
18439 #endif // DOCUMENTATION
18440 
18441 
18443 // SgAsmElfRelocEntryList -- MACHINE GENERATED; DO NOT MODIFY --
18445 
18446 DECLARE_LEAF_CLASS(AsmElfRelocEntryList);
18447 IS_SERIALIZABLE(AsmElfRelocEntryList);
18448 
18449 #ifdef DOCUMENTATION
18450 
18455 #endif // DOCUMENTATION
18456 
18457 #ifndef DOCUMENTATION
18458  AsmElfRelocEntryList.setDataPrototype(
18459  "SgAsmElfRelocEntryPtrList", "entries", "",
18460  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
18461 #endif // !DOCUMENTATION
18462 
18463  DECLARE_OTHERS(AsmElfRelocEntryList);
18464 #if defined(SgAsmElfRelocEntryList_OTHERS) || defined(DOCUMENTATION)
18465 
18466  //----------------------- Boost serialization for SgAsmElfRelocEntryList -----------------------
18467 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
18468 private:
18469  friend class boost::serialization::access;
18470 
18471  template<class S>
18472  void serialize(S &s, const unsigned /*version*/) {
18473  debugSerializationBegin("SgAsmElfRelocEntryList");
18474  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
18475  s & BOOST_SERIALIZATION_NVP(p_entries);
18476  debugSerializationEnd("SgAsmElfRelocEntryList");
18477  }
18478 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
18479 
18480 public:
18484  SgAsmElfRelocEntryPtrList const& get_entries() const;
18485  SgAsmElfRelocEntryPtrList& get_entries();
18486  void set_entries(SgAsmElfRelocEntryPtrList const&);
18489 public:
18491  virtual ~SgAsmElfRelocEntryList();
18492 
18493 public:
18496 
18497 protected:
18504  void initializeProperties();
18505 #endif // SgAsmElfRelocEntryList_OTHERS
18506 #ifdef DOCUMENTATION
18507 };
18508 #endif // DOCUMENTATION
18509 
18510 
18512 // SgAsmElfRelocEntry -- MACHINE GENERATED; DO NOT MODIFY --
18514 
18515 DECLARE_LEAF_CLASS(AsmElfRelocEntry);
18516 IS_SERIALIZABLE(AsmElfRelocEntry);
18517 
18518 DECLARE_HEADERS(AsmElfRelocEntry);
18519 #if defined(SgAsmElfRelocEntry_HEADERS) || defined(DOCUMENTATION)
18520 #include <Rose/BinaryAnalysis/ByteOrder.h>
18521 #endif // SgAsmElfRelocEntry_HEADERS
18522 
18523 #ifdef DOCUMENTATION
18524 
18526 #endif // DOCUMENTATION
18527 
18528 #ifndef DOCUMENTATION
18529  AsmElfRelocEntry.setDataPrototype(
18530  "rose_addr_t", "r_offset", "= 0",
18531  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
18532 #endif // !DOCUMENTATION
18533 
18534 #ifndef DOCUMENTATION
18535  AsmElfRelocEntry.setDataPrototype(
18536  "rose_addr_t", "r_addend", "= 0",
18537  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
18538 #endif // !DOCUMENTATION
18539 
18540 #ifndef DOCUMENTATION
18541  AsmElfRelocEntry.setDataPrototype(
18542  "unsigned long", "sym", "= 0",
18543  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
18544 #endif // !DOCUMENTATION
18545 
18546 #ifndef DOCUMENTATION
18547  AsmElfRelocEntry.setDataPrototype(
18548  "SgAsmElfRelocEntry::RelocType", "type", "= R_386_NONE",
18549  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
18550 #endif // !DOCUMENTATION
18551 
18552 #ifndef DOCUMENTATION
18553  AsmElfRelocEntry.setDataPrototype(
18554  "SgUnsignedCharList", "extra", "",
18555  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
18556 #endif // !DOCUMENTATION
18557 
18558  DECLARE_OTHERS(AsmElfRelocEntry);
18559 #if defined(SgAsmElfRelocEntry_OTHERS) || defined(DOCUMENTATION)
18560 
18561  //----------------------- Boost serialization for SgAsmElfRelocEntry -----------------------
18562 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
18563 private:
18564  friend class boost::serialization::access;
18565 
18566  template<class S>
18567  void serialize(S &s, const unsigned /*version*/) {
18568  debugSerializationBegin("SgAsmElfRelocEntry");
18569  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
18570  s & BOOST_SERIALIZATION_NVP(p_r_offset);
18571  s & BOOST_SERIALIZATION_NVP(p_r_addend);
18572  s & BOOST_SERIALIZATION_NVP(p_sym);
18573  s & BOOST_SERIALIZATION_NVP(p_type);
18574  s & BOOST_SERIALIZATION_NVP(p_extra);
18575  debugSerializationEnd("SgAsmElfRelocEntry");
18576  }
18577 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
18578  // Local types
18581 public:
18584  // Intel 80386 specific definitions.
18596  R_386_32PLT =11,
18603  R_386_16 =20,
18604  R_386_PC16 =21,
18605  R_386_8 =22,
18606  R_386_PC8 =23,
18622  // First Entry for X86-64
18637  R_X86_64_8 =114,
18647  };
18648 
18649 #ifdef _MSC_VER
18650 # pragma pack (1)
18651 #endif
18652 
18654  uint32_t r_offset;
18655  uint32_t r_info;
18656  uint32_t r_addend;
18657  }
18658 #if !defined(SWIG) && !defined(_MSC_VER)
18659  __attribute__((packed))
18660 #endif
18661  ;
18662 
18664  uint64_t r_offset;
18665  uint64_t r_info;
18666  uint64_t r_addend;
18667  }
18668 #if !defined(SWIG) && !defined(_MSC_VER)
18669  __attribute__((packed))
18670 #endif
18671  ;
18672 
18674  uint32_t r_offset;
18675  uint32_t r_info;
18676  }
18677 #if !defined(SWIG) && !defined(_MSC_VER)
18678  __attribute__((packed))
18679 #endif
18680  ;
18681 
18683  uint64_t r_offset;
18684  uint64_t r_info;
18685  }
18686 #if !defined(SWIG) && !defined(_MSC_VER)
18687  __attribute__((packed))
18688 #endif
18689  ;
18690 
18691 #ifdef _MSC_VER
18692 # pragma pack ()
18693 #endif
18694 
18696  // Properties
18698 public:
18704  rose_addr_t const& get_r_offset() const;
18705  void set_r_offset(rose_addr_t const&);
18708 public:
18714  rose_addr_t const& get_r_addend() const;
18715  void set_r_addend(rose_addr_t const&);
18718 public:
18724  unsigned long const& get_sym() const;
18725  void set_sym(unsigned long const&);
18728 public:
18734  SgAsmElfRelocEntry::RelocType const& get_type() const;
18738 public:
18742  SgUnsignedCharList const& get_extra() const;
18743  SgUnsignedCharList& get_extra();
18744  void set_extra(SgUnsignedCharList const&);
18746  // Functions
18749 public:
18752 
18756  void parse(Rose::BinaryAnalysis::ByteOrder::Endianness sex, const SgAsmElfRelocEntry::Elf32RelaEntry_disk *disk);
18757  void parse(Rose::BinaryAnalysis::ByteOrder::Endianness sex, const SgAsmElfRelocEntry::Elf64RelaEntry_disk *disk);
18758  void parse(Rose::BinaryAnalysis::ByteOrder::Endianness sex, const SgAsmElfRelocEntry::Elf32RelEntry_disk *disk);
18759  void parse(Rose::BinaryAnalysis::ByteOrder::Endianness sex, const SgAsmElfRelocEntry::Elf64RelEntry_disk *disk);
18765  void *encode(Rose::BinaryAnalysis::ByteOrder::Endianness, SgAsmElfRelocEntry::Elf32RelaEntry_disk*) const;
18766  void *encode(Rose::BinaryAnalysis::ByteOrder::Endianness, SgAsmElfRelocEntry::Elf64RelaEntry_disk*) const;
18767  void *encode(Rose::BinaryAnalysis::ByteOrder::Endianness, SgAsmElfRelocEntry::Elf32RelEntry_disk*) const;
18768  void *encode(Rose::BinaryAnalysis::ByteOrder::Endianness, SgAsmElfRelocEntry::Elf64RelEntry_disk*) const;
18774  void dump(FILE *f, const char *prefix, ssize_t idx, SgAsmElfSymbolSection *symtab) const;
18775  virtual void dump(FILE *f, const char *prefix, ssize_t idx) const {
18776  dump(f, prefix, idx, NULL);
18777  }
18781  std::string reloc_name() const;
18782 public:
18784  virtual ~SgAsmElfRelocEntry();
18785 
18786 public:
18789 
18790 protected:
18797  void initializeProperties();
18798 #endif // SgAsmElfRelocEntry_OTHERS
18799 #ifdef DOCUMENTATION
18800 };
18801 #endif // DOCUMENTATION
18802 
18803 
18805 // SgAsmElfNoteSection -- MACHINE GENERATED; DO NOT MODIFY --
18807 
18808 DECLARE_LEAF_CLASS(AsmElfNoteSection);
18809 IS_SERIALIZABLE(AsmElfNoteSection);
18810 
18811 #ifdef DOCUMENTATION
18813 #endif // DOCUMENTATION
18814 
18815 #ifndef DOCUMENTATION
18816  AsmElfNoteSection.setDataPrototype(
18817  "SgAsmElfNoteEntryList*", "entries", "= createAndParent<SgAsmElfNoteEntryList>(this)",
18818  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
18819 #endif // !DOCUMENTATION
18820 
18821  DECLARE_OTHERS(AsmElfNoteSection);
18822 #if defined(SgAsmElfNoteSection_OTHERS) || defined(DOCUMENTATION)
18823 
18824  //----------------------- Boost serialization for SgAsmElfNoteSection -----------------------
18825 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
18826 private:
18827  friend class boost::serialization::access;
18828 
18829  template<class S>
18830  void serialize(S &s, const unsigned /*version*/) {
18831  debugSerializationBegin("SgAsmElfNoteSection");
18832  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmElfSection);
18833  s & BOOST_SERIALIZATION_NVP(p_entries);
18834  debugSerializationEnd("SgAsmElfNoteSection");
18835  }
18836 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
18837 
18838 public:
18845  SgAsmElfNoteEntryList* const& get_entries() const;
18846  void set_entries(SgAsmElfNoteEntryList* const&);
18848 public:
18851 
18852  virtual SgAsmElfNoteSection *parse() override;
18853 
18855  virtual bool reallocate() override;
18856 
18858  virtual void unparse(std::ostream&) const override;
18859 
18861  virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
18862 public:
18864  virtual ~SgAsmElfNoteSection();
18865 
18866 public:
18869 
18870 protected:
18877  void initializeProperties();
18878 #endif // SgAsmElfNoteSection_OTHERS
18879 #ifdef DOCUMENTATION
18880 };
18881 #endif // DOCUMENTATION
18882 
18883 
18885 // SgAsmElfNoteEntryList -- MACHINE GENERATED; DO NOT MODIFY --
18887 
18888 DECLARE_LEAF_CLASS(AsmElfNoteEntryList);
18889 IS_SERIALIZABLE(AsmElfNoteEntryList);
18890 
18891 #ifdef DOCUMENTATION
18892 
18897 #endif // DOCUMENTATION
18898 
18899 #ifndef DOCUMENTATION
18900  AsmElfNoteEntryList.setDataPrototype(
18901  "SgAsmElfNoteEntryPtrList", "entries", "",
18902  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
18903 #endif // !DOCUMENTATION
18904 
18905  DECLARE_OTHERS(AsmElfNoteEntryList);
18906 #if defined(SgAsmElfNoteEntryList_OTHERS) || defined(DOCUMENTATION)
18907 
18908  //----------------------- Boost serialization for SgAsmElfNoteEntryList -----------------------
18909 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
18910 private:
18911  friend class boost::serialization::access;
18912 
18913  template<class S>
18914  void serialize(S &s, const unsigned /*version*/) {
18915  debugSerializationBegin("SgAsmElfNoteEntryList");
18916  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
18917  s & BOOST_SERIALIZATION_NVP(p_entries);
18918  debugSerializationEnd("SgAsmElfNoteEntryList");
18919  }
18920 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
18921 
18922 public:
18926  SgAsmElfNoteEntryPtrList const& get_entries() const;
18927  SgAsmElfNoteEntryPtrList& get_entries();
18928  void set_entries(SgAsmElfNoteEntryPtrList const&);
18931 public:
18933  virtual ~SgAsmElfNoteEntryList();
18934 
18935 public:
18938 
18939 protected:
18946  void initializeProperties();
18947 #endif // SgAsmElfNoteEntryList_OTHERS
18948 #ifdef DOCUMENTATION
18949 };
18950 #endif // DOCUMENTATION
18951 
18952 
18954 // SgAsmElfNoteEntry -- MACHINE GENERATED; DO NOT MODIFY --
18956 
18957 DECLARE_LEAF_CLASS(AsmElfNoteEntry);
18958 IS_SERIALIZABLE(AsmElfNoteEntry);
18959 
18960 #ifdef DOCUMENTATION
18961 
18963 #endif // DOCUMENTATION
18964 
18965 #ifndef DOCUMENTATION
18966  AsmElfNoteEntry.setDataPrototype(
18967  "unsigned", "type", "= 0",
18968  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
18969 #endif // !DOCUMENTATION
18970 
18971 #ifndef DOCUMENTATION
18972  AsmElfNoteEntry.setDataPrototype(
18973  "SgAsmGenericString*", "name", "= createAndParent<SgAsmBasicString>(this)",
18974  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
18975 #endif // !DOCUMENTATION
18976 
18977 #ifndef DOCUMENTATION
18978  AsmElfNoteEntry.setDataPrototype(
18979  "SgUnsignedCharList", "payload", "",
18980  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
18981 #endif // !DOCUMENTATION
18982 
18983  DECLARE_OTHERS(AsmElfNoteEntry);
18984 #if defined(SgAsmElfNoteEntry_OTHERS) || defined(DOCUMENTATION)
18985 
18986  //----------------------- Boost serialization for SgAsmElfNoteEntry -----------------------
18987 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
18988 private:
18989  friend class boost::serialization::access;
18990 
18991  template<class S>
18992  void serialize(S &s, const unsigned /*version*/) {
18993  debugSerializationBegin("SgAsmElfNoteEntry");
18994  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
18995  s & BOOST_SERIALIZATION_NVP(p_type);
18996  s & BOOST_SERIALIZATION_NVP(p_name);
18997  s & BOOST_SERIALIZATION_NVP(p_payload);
18998  debugSerializationEnd("SgAsmElfNoteEntry");
18999  }
19000 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
19001 
19002 public:
19008  unsigned const& get_type() const;
19009  void set_type(unsigned const&);
19012 public:
19021 public:
19027  SgUnsignedCharList const& get_payload() const;
19028  SgUnsignedCharList& get_payload();
19029  void set_payload(SgUnsignedCharList const&);
19031 public:
19034 
19041  SgAsmGenericString *get_name() const;
19042  void set_name(SgAsmGenericString *name);
19048  rose_addr_t parse(rose_addr_t starting_offset);
19049 
19053  rose_addr_t unparse(std::ostream &f, rose_addr_t starting_offset);
19054 
19056  virtual void dump(FILE*, const char *prefix, ssize_t idx) const;
19057 
19061  void set_payload(const void*, size_t nbytes);
19062 
19064  rose_addr_t calculate_size() const;
19065 public:
19067  virtual ~SgAsmElfNoteEntry();
19068 
19069 public:
19072 
19073 protected:
19080  void initializeProperties();
19081 #endif // SgAsmElfNoteEntry_OTHERS
19082 #ifdef DOCUMENTATION
19083 };
19084 #endif // DOCUMENTATION
19085 
19086 
19088 // SgAsmElfFileHeader -- MACHINE GENERATED; DO NOT MODIFY --
19090 
19091 DECLARE_LEAF_CLASS(AsmElfFileHeader);
19092 IS_SERIALIZABLE(AsmElfFileHeader);
19093 
19094 DECLARE_HEADERS(AsmElfFileHeader);
19095 #if defined(SgAsmElfFileHeader_HEADERS) || defined(DOCUMENTATION)
19096 #include <Rose/BinaryAnalysis/ByteOrder.h>
19097 #endif // SgAsmElfFileHeader_HEADERS
19098 
19099 #ifdef DOCUMENTATION
19100 
19109 #endif // DOCUMENTATION
19110 
19111 #ifndef DOCUMENTATION
19112  AsmElfFileHeader.setDataPrototype(
19113  "unsigned char", "e_ident_file_class", "= 0",
19114  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
19115 #endif // !DOCUMENTATION
19116 
19117 #ifndef DOCUMENTATION
19118  AsmElfFileHeader.setDataPrototype(
19119  "unsigned char", "e_ident_data_encoding", "= 0",
19120  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
19121 #endif // !DOCUMENTATION
19122 
19123 #ifndef DOCUMENTATION
19124  AsmElfFileHeader.setDataPrototype(
19125  "unsigned char", "e_ident_file_version", "= 0",
19126  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
19127 #endif // !DOCUMENTATION
19128 
19129 #ifndef DOCUMENTATION
19130  AsmElfFileHeader.setDataPrototype(
19131  "SgUnsignedCharList", "e_ident_padding", "",
19132  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
19133 #endif // !DOCUMENTATION
19134 
19135 #ifndef DOCUMENTATION
19136  AsmElfFileHeader.setDataPrototype(
19137  "unsigned long", "e_type", "= 0",
19138  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
19139 #endif // !DOCUMENTATION
19140 
19141 #ifndef DOCUMENTATION
19142  AsmElfFileHeader.setDataPrototype(
19143  "unsigned long", "e_machine", "= 0",
19144  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
19145 #endif // !DOCUMENTATION
19146 
19147 #ifndef DOCUMENTATION
19148  AsmElfFileHeader.setDataPrototype(
19149  "unsigned long", "e_flags", "= 0",
19150  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
19151 #endif // !DOCUMENTATION
19152 
19153 #ifndef DOCUMENTATION
19154  AsmElfFileHeader.setDataPrototype(
19155  "unsigned long", "e_ehsize", "= 0",
19156  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
19157 #endif // !DOCUMENTATION
19158 
19159 #ifndef DOCUMENTATION
19160  AsmElfFileHeader.setDataPrototype(
19161  "unsigned long", "phextrasz", "= 0",
19162  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
19163 #endif // !DOCUMENTATION
19164 
19165 #ifndef DOCUMENTATION
19166  AsmElfFileHeader.setDataPrototype(
19167  "unsigned long", "e_phnum", "= 0",
19168  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
19169 #endif // !DOCUMENTATION
19170 
19171 #ifndef DOCUMENTATION
19172  AsmElfFileHeader.setDataPrototype(
19173  "unsigned long", "shextrasz", "= 0",
19174  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
19175 #endif // !DOCUMENTATION
19176 
19177 #ifndef DOCUMENTATION
19178  AsmElfFileHeader.setDataPrototype(
19179  "unsigned long", "e_shnum", "= 0",
19180  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
19181 #endif // !DOCUMENTATION
19182 
19183 #ifndef DOCUMENTATION
19184  AsmElfFileHeader.setDataPrototype(
19185  "unsigned long", "e_shstrndx", "= 0",
19186  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
19187 #endif // !DOCUMENTATION
19188 
19189 #ifndef DOCUMENTATION
19190  AsmElfFileHeader.setDataPrototype(
19191  "SgAsmElfSectionTable*", "section_table", "= nullptr",
19192  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
19193 #endif // !DOCUMENTATION
19194 
19195 #ifndef DOCUMENTATION
19196  AsmElfFileHeader.setDataPrototype(
19197  "SgAsmElfSegmentTable*", "segment_table", "= nullptr",
19198  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
19199 #endif // !DOCUMENTATION
19200 
19201  DECLARE_OTHERS(AsmElfFileHeader);
19202 #if defined(SgAsmElfFileHeader_OTHERS) || defined(DOCUMENTATION)
19203 
19204  //----------------------- Boost serialization for SgAsmElfFileHeader -----------------------
19205 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
19206 private:
19207  friend class boost::serialization::access;
19208 
19209  template<class S>
19210  void serialize(S &s, const unsigned /*version*/) {
19211  debugSerializationBegin("SgAsmElfFileHeader");
19212  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmGenericHeader);
19213  s & BOOST_SERIALIZATION_NVP(p_e_ident_file_class);
19214  s & BOOST_SERIALIZATION_NVP(p_e_ident_data_encoding);
19215  s & BOOST_SERIALIZATION_NVP(p_e_ident_file_version);
19216  s & BOOST_SERIALIZATION_NVP(p_e_ident_padding);
19217  s & BOOST_SERIALIZATION_NVP(p_e_type);
19218  s & BOOST_SERIALIZATION_NVP(p_e_machine);
19219  s & BOOST_SERIALIZATION_NVP(p_e_flags);
19220  s & BOOST_SERIALIZATION_NVP(p_e_ehsize);
19221  s & BOOST_SERIALIZATION_NVP(p_phextrasz);
19222  s & BOOST_SERIALIZATION_NVP(p_e_phnum);
19223  s & BOOST_SERIALIZATION_NVP(p_shextrasz);
19224  s & BOOST_SERIALIZATION_NVP(p_e_shnum);
19225  s & BOOST_SERIALIZATION_NVP(p_e_shstrndx);
19226  s & BOOST_SERIALIZATION_NVP(p_section_table);
19227  s & BOOST_SERIALIZATION_NVP(p_segment_table);
19228  debugSerializationEnd("SgAsmElfFileHeader");
19229  }
19230 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
19231  // Local types
19234 public:
19236  enum ObjectType {
19237  ET_NONE = 0
19238  ,ET_REL = 1
19239  ,ET_EXEC = 2
19240  ,ET_DYN = 3
19241  ,ET_CORE = 4
19243  ,ET_LOOS = 0xfe00
19244  ,ET_HIOS = 0xfeff
19245  ,ET_LOPROC = 0xff00
19246  ,ET_HIPROC = 0xffff
19247  };
19248 
19249  // Some structures are used to represent certain things whose layout is very precise in binary files, thus we need to
19250  // make sure the compiler doesn't insert alignment padding between the struct members. ROSE can be compiled on an
19251  // architecture that has different alignment constraints than the architecture that these structs describe. GNU
19252  // compilers have long used the attribute mechanism. Microsoft compilers on the other hand use pragmas. GCC versions
19253  // 4.0 and earlier do not recognize the Microsoft pragmas and issue compiler errors when one is encountered.
19254 #ifdef _MSC_VER
19255 # pragma pack (1)
19256 #endif
19257 
19264  unsigned char e_ident_magic[4];
19265  unsigned char e_ident_file_class;
19266  unsigned char e_ident_data_encoding;
19267  unsigned char e_ident_file_version;
19268  unsigned char e_ident_padding[9];
19269  uint16_t e_type;
19270  uint16_t e_machine;
19271  uint32_t e_version;
19272  uint32_t e_entry;
19273  uint32_t e_phoff;
19274  uint32_t e_shoff;
19275  uint32_t e_flags;
19276  uint16_t e_ehsize;
19277  uint16_t e_phentsize;
19278  uint16_t e_phnum;
19279  uint16_t e_shentsize;
19280  uint16_t e_shnum;
19281  uint16_t e_shstrndx;
19282  }
19283 #if !defined(SWIG) && !defined(_MSC_VER)
19284  __attribute__((packed))
19285 #endif
19286  ;
19287 
19289  unsigned char e_ident_magic[4];
19290  unsigned char e_ident_file_class;
19291  unsigned char e_ident_data_encoding;
19292  unsigned char e_ident_file_version;
19293  unsigned char e_ident_padding[9];
19294  uint16_t e_type;
19295  uint16_t e_machine;
19296  uint32_t e_version;
19297  uint64_t e_entry;
19298  uint64_t e_phoff;
19299  uint64_t e_shoff;
19300  uint32_t e_flags;
19301  uint16_t e_ehsize;
19302  uint16_t e_phentsize;
19303  uint16_t e_phnum;
19304  uint16_t e_shentsize;
19305  uint16_t e_shnum;
19306  uint16_t e_shstrndx;
19307  }
19308 #if !defined(SWIG) && !defined(_MSC_VER)
19309  __attribute__((packed))
19310 #endif
19311  ;
19312 
19313 #ifdef _MSC_VER
19314 # pragma pack ()
19315 #endif
19316 
19318  // Properties
19320 public:
19326  unsigned char const& get_e_ident_file_class() const;
19327  void set_e_ident_file_class(unsigned char const&);
19330 public:
19336  unsigned char const& get_e_ident_data_encoding() const;
19337  void set_e_ident_data_encoding(unsigned char const&);
19340 public:
19346  unsigned char const& get_e_ident_file_version() const;
19347  void set_e_ident_file_version(unsigned char const&);
19350 public:
19356  SgUnsignedCharList const& get_e_ident_padding() const;
19357  void set_e_ident_padding(SgUnsignedCharList const&);
19360 public:
19366  unsigned long const& get_e_type() const;
19367  void set_e_type(unsigned long const&);
19370 public:
19376  unsigned long const& get_e_machine() const;
19377  void set_e_machine(unsigned long const&);
19380 public:
19386  unsigned long const& get_e_flags() const;
19387  void set_e_flags(unsigned long const&);
19390 public:
19396  unsigned long const& get_e_ehsize() const;
19397  void set_e_ehsize(unsigned long const&);
19400 public:
19406  unsigned long const& get_phextrasz() const;
19407  void set_phextrasz(unsigned long const&);
19410 public:
19416  unsigned long const& get_e_phnum() const;
19417  void set_e_phnum(unsigned long const&);
19420 public:
19426  unsigned long const& get_shextrasz() const;
19427  void set_shextrasz(unsigned long const&);
19430 public:
19436  unsigned long const& get_e_shnum() const;
19437  void set_e_shnum(unsigned long const&);
19440 public:
19446  unsigned long const& get_e_shstrndx() const;
19447  void set_e_shstrndx(unsigned long const&);
19450 public:
19458  SgAsmElfSectionTable* const& get_section_table() const;
19462 public:
19469  SgAsmElfSegmentTable* const& get_segment_table() const;
19472  // Functions
19475 public:
19483 
19489  uint64_t max_page_size();
19490 
19493 
19496 
19502  virtual SgAsmElfFileHeader *parse() override;
19503 
19505  virtual bool reallocate() override;
19506 
19508  virtual void unparse(std::ostream&) const override;
19509 
19511  virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
19512 
19514  static bool is_ELF(SgAsmGenericFile*);
19515 
19517  SgAsmGenericSectionPtrList get_sectab_sections();
19518 
19520  SgAsmGenericSectionPtrList get_segtab_sections();
19521 
19522  // Overrides documented in base class
19523  virtual const char *format_name() const override;
19524 
19525 private:
19526  void *encode(Rose::BinaryAnalysis::ByteOrder::Endianness, SgAsmElfFileHeader::Elf32FileHeader_disk*) const;
19527  void *encode(Rose::BinaryAnalysis::ByteOrder::Endianness, SgAsmElfFileHeader::Elf64FileHeader_disk*) const;
19528 public:
19530  virtual ~SgAsmElfFileHeader();
19531 
19532 public:
19535 
19536 protected:
19543  void initializeProperties();
19544 #endif // SgAsmElfFileHeader_OTHERS
19545 #ifdef DOCUMENTATION
19546 };
19547 #endif // DOCUMENTATION
19548 
19549 
19551 // SgAsmElfEHFrameSection -- MACHINE GENERATED; DO NOT MODIFY --
19553 
19554 DECLARE_LEAF_CLASS(AsmElfEHFrameSection);
19555 IS_SERIALIZABLE(AsmElfEHFrameSection);
19556 
19557 #ifdef DOCUMENTATION
19558 
19560 #endif // DOCUMENTATION
19561 
19562 #ifndef DOCUMENTATION
19563  AsmElfEHFrameSection.setDataPrototype(
19564  "SgAsmElfEHFrameEntryCIList*", "ci_entries", "= createAndParent<SgAsmElfEHFrameEntryCIList>(this)",
19565  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
19566 #endif // !DOCUMENTATION
19567 
19568  DECLARE_OTHERS(AsmElfEHFrameSection);
19569 #if defined(SgAsmElfEHFrameSection_OTHERS) || defined(DOCUMENTATION)
19570 
19571  //----------------------- Boost serialization for SgAsmElfEHFrameSection -----------------------
19572 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
19573 private:
19574  friend class boost::serialization::access;
19575 
19576  template<class S>
19577  void serialize(S &s, const unsigned /*version*/) {
19578  debugSerializationBegin("SgAsmElfEHFrameSection");
19579  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmElfSection);
19580  s & BOOST_SERIALIZATION_NVP(p_ci_entries);
19581  debugSerializationEnd("SgAsmElfEHFrameSection");
19582  }
19583 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
19584 
19585 public:
19595 public:
19598 
19600  virtual SgAsmElfEHFrameSection *parse() override;
19601 
19606  virtual rose_addr_t calculate_sizes(size_t *total, size_t *required, size_t *optional, size_t *entcount) const override;
19607 
19609  virtual void unparse(std::ostream&) const override;
19610 
19615  rose_addr_t unparse(std::ostream*) const;
19616 
19618  virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
19619 public:
19621  virtual ~SgAsmElfEHFrameSection();
19622 
19623 public:
19626 
19627 protected:
19634  void initializeProperties();
19635 #endif // SgAsmElfEHFrameSection_OTHERS
19636 #ifdef DOCUMENTATION
19637 };
19638 #endif // DOCUMENTATION
19639 
19640 
19642 // SgAsmElfEHFrameEntryFDList -- MACHINE GENERATED; DO NOT MODIFY --
19644 
19645 DECLARE_LEAF_CLASS(AsmElfEHFrameEntryFDList);
19646 IS_SERIALIZABLE(AsmElfEHFrameEntryFDList);
19647 
19648 #ifdef DOCUMENTATION
19649 
19654 #endif // DOCUMENTATION
19655 
19656 #ifndef DOCUMENTATION
19657  AsmElfEHFrameEntryFDList.setDataPrototype(
19658  "SgAsmElfEHFrameEntryFDPtrList", "entries", "",
19659  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
19660 #endif // !DOCUMENTATION
19661 
19662  DECLARE_OTHERS(AsmElfEHFrameEntryFDList);
19663 #if defined(SgAsmElfEHFrameEntryFDList_OTHERS) || defined(DOCUMENTATION)
19664 
19665  //----------------------- Boost serialization for SgAsmElfEHFrameEntryFDList -----------------------
19666 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
19667 private:
19668  friend class boost::serialization::access;
19669 
19670  template<class S>
19671  void serialize(S &s, const unsigned /*version*/) {
19672  debugSerializationBegin("SgAsmElfEHFrameEntryFDList");
19673  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
19674  s & BOOST_SERIALIZATION_NVP(p_entries);
19675  debugSerializationEnd("SgAsmElfEHFrameEntryFDList");
19676  }
19677 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
19678 
19679 public:
19683  SgAsmElfEHFrameEntryFDPtrList const& get_entries() const;
19684  SgAsmElfEHFrameEntryFDPtrList& get_entries();
19685  void set_entries(SgAsmElfEHFrameEntryFDPtrList const&);
19688 public:
19690  virtual ~SgAsmElfEHFrameEntryFDList();
19691 
19692 public:
19695 
19696 protected:
19703  void initializeProperties();
19704 #endif // SgAsmElfEHFrameEntryFDList_OTHERS
19705 #ifdef DOCUMENTATION
19706 };
19707 #endif // DOCUMENTATION
19708 
19709 
19711 // SgAsmElfEHFrameEntryFD -- MACHINE GENERATED; DO NOT MODIFY --
19713 
19714 DECLARE_LEAF_CLASS(AsmElfEHFrameEntryFD);
19715 IS_SERIALIZABLE(AsmElfEHFrameEntryFD);
19716 
19717 #ifdef DOCUMENTATION
19718 
19720 #endif // DOCUMENTATION
19721 
19722 #ifndef DOCUMENTATION
19723  AsmElfEHFrameEntryFD.setDataPrototype(
19724  "rose_rva_t", "begin_rva", "= 0",
19725  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
19726 #endif // !DOCUMENTATION
19727 
19728 #ifndef DOCUMENTATION
19729  AsmElfEHFrameEntryFD.setDataPrototype(
19730  "rose_addr_t", "size", "= 0",
19731  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
19732 #endif // !DOCUMENTATION
19733 
19734 #ifndef DOCUMENTATION
19735  AsmElfEHFrameEntryFD.setDataPrototype(
19736  "SgUnsignedCharList", "augmentation_data", "",
19737  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
19738 #endif // !DOCUMENTATION
19739 
19740 #ifndef DOCUMENTATION
19741  AsmElfEHFrameEntryFD.setDataPrototype(
19742  "SgUnsignedCharList", "instructions", "",
19743  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
19744 #endif // !DOCUMENTATION
19745 
19746  DECLARE_OTHERS(AsmElfEHFrameEntryFD);
19747 #if defined(SgAsmElfEHFrameEntryFD_OTHERS) || defined(DOCUMENTATION)
19748 
19749  //----------------------- Boost serialization for SgAsmElfEHFrameEntryFD -----------------------
19750 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
19751 private:
19752  friend class boost::serialization::access;
19753 
19754  template<class S>
19755  void serialize(S &s, const unsigned /*version*/) {
19756  debugSerializationBegin("SgAsmElfEHFrameEntryFD");
19757  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
19758  s & BOOST_SERIALIZATION_NVP(p_begin_rva);
19759  s & BOOST_SERIALIZATION_NVP(p_size);
19760  s & BOOST_SERIALIZATION_NVP(p_augmentation_data);
19761  s & BOOST_SERIALIZATION_NVP(p_instructions);
19762  debugSerializationEnd("SgAsmElfEHFrameEntryFD");
19763  }
19764 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
19765 
19766 public:
19772  rose_rva_t const& get_begin_rva() const;
19774  void set_begin_rva(rose_rva_t const&);
19777 public:
19783  rose_addr_t const& get_size() const;
19784  void set_size(rose_addr_t const&);
19787 public:
19793  SgUnsignedCharList const& get_augmentation_data() const;
19794  SgUnsignedCharList& get_augmentation_data();
19795  void set_augmentation_data(SgUnsignedCharList const&);
19798 public:
19804  SgUnsignedCharList const& get_instructions() const;
19805  SgUnsignedCharList& get_instructions();
19806  void set_instructions(SgUnsignedCharList const&);
19808 public:
19811 
19813  virtual void dump(FILE*, const char *prefix, ssize_t idx) const;
19814 
19819  std::string unparse(const SgAsmElfEHFrameSection*, SgAsmElfEHFrameEntryCI*) const;
19820 public:
19822  virtual ~SgAsmElfEHFrameEntryFD();
19823 
19824 public:
19827 
19828 protected:
19835  void initializeProperties();
19836 #endif // SgAsmElfEHFrameEntryFD_OTHERS
19837 #ifdef DOCUMENTATION
19838 };
19839 #endif // DOCUMENTATION
19840 
19841 
19843 // SgAsmElfEHFrameEntryCIList -- MACHINE GENERATED; DO NOT MODIFY --
19845 
19846 DECLARE_LEAF_CLASS(AsmElfEHFrameEntryCIList);
19847 IS_SERIALIZABLE(AsmElfEHFrameEntryCIList);
19848 
19849 #ifdef DOCUMENTATION
19850 
19855 #endif // DOCUMENTATION
19856 
19857 #ifndef DOCUMENTATION
19858  AsmElfEHFrameEntryCIList.setDataPrototype(
19859  "SgAsmElfEHFrameEntryCIPtrList", "entries", "",
19860  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
19861 #endif // !DOCUMENTATION
19862 
19863  DECLARE_OTHERS(AsmElfEHFrameEntryCIList);
19864 #if defined(SgAsmElfEHFrameEntryCIList_OTHERS) || defined(DOCUMENTATION)
19865 
19866  //----------------------- Boost serialization for SgAsmElfEHFrameEntryCIList -----------------------
19867 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
19868 private:
19869  friend class boost::serialization::access;
19870 
19871  template<class S>
19872  void serialize(S &s, const unsigned /*version*/) {
19873  debugSerializationBegin("SgAsmElfEHFrameEntryCIList");
19874  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
19875  s & BOOST_SERIALIZATION_NVP(p_entries);
19876  debugSerializationEnd("SgAsmElfEHFrameEntryCIList");
19877  }
19878 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
19879 
19880 public:
19884  SgAsmElfEHFrameEntryCIPtrList const& get_entries() const;
19885  SgAsmElfEHFrameEntryCIPtrList& get_entries();
19886  void set_entries(SgAsmElfEHFrameEntryCIPtrList const&);
19889 public:
19891  virtual ~SgAsmElfEHFrameEntryCIList();
19892 
19893 public:
19896 
19897 protected:
19904  void initializeProperties();
19905 #endif // SgAsmElfEHFrameEntryCIList_OTHERS
19906 #ifdef DOCUMENTATION
19907 };
19908 #endif // DOCUMENTATION
19909 
19910 
19912 // SgAsmElfEHFrameEntryCI -- MACHINE GENERATED; DO NOT MODIFY --
19914 
19915 DECLARE_LEAF_CLASS(AsmElfEHFrameEntryCI);
19916 IS_SERIALIZABLE(AsmElfEHFrameEntryCI);
19917 
19918 #ifdef DOCUMENTATION
19919 
19923 #endif // DOCUMENTATION
19924 
19925 #ifndef DOCUMENTATION
19926  AsmElfEHFrameEntryCI.setDataPrototype(
19927  "int", "version", "= 0",
19928  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
19929 #endif // !DOCUMENTATION
19930 
19931 #ifndef DOCUMENTATION
19932  AsmElfEHFrameEntryCI.setDataPrototype(
19933  "std::string", "augmentation_string", "",
19934  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
19935 #endif // !DOCUMENTATION
19936 
19937 #ifndef DOCUMENTATION
19938  AsmElfEHFrameEntryCI.setDataPrototype(
19939  "uint64_t", "eh_data", "= 0",
19940  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
19941 #endif // !DOCUMENTATION
19942 
19943 #ifndef DOCUMENTATION
19944  AsmElfEHFrameEntryCI.setDataPrototype(
19945  "uint64_t", "code_alignment_factor", "= 0",
19946  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
19947 #endif // !DOCUMENTATION
19948 
19949 #ifndef DOCUMENTATION
19950  AsmElfEHFrameEntryCI.setDataPrototype(
19951  "int64_t", "data_alignment_factor", "= 0",
19952  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
19953 #endif // !DOCUMENTATION
19954 
19955 #ifndef DOCUMENTATION
19956  AsmElfEHFrameEntryCI.setDataPrototype(
19957  "uint64_t", "augmentation_data_length", "= 0",
19958  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
19959 #endif // !DOCUMENTATION
19960 
19961 #ifndef DOCUMENTATION
19962  AsmElfEHFrameEntryCI.setDataPrototype(
19963  "int", "lsda_encoding", "= -1",
19964  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
19965 #endif // !DOCUMENTATION
19966 
19967 #ifndef DOCUMENTATION
19968  AsmElfEHFrameEntryCI.setDataPrototype(
19969  "int", "prh_encoding", "= -1",
19970  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
19971 #endif // !DOCUMENTATION
19972 
19973 #ifndef DOCUMENTATION
19974  AsmElfEHFrameEntryCI.setDataPrototype(
19975  "unsigned", "prh_arg", "= 0",
19976  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
19977 #endif // !DOCUMENTATION
19978 
19979 #ifndef DOCUMENTATION
19980  AsmElfEHFrameEntryCI.setDataPrototype(
19981  "rose_addr_t", "prh_addr", "= 0",
19982  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
19983 #endif // !DOCUMENTATION
19984 
19985 #ifndef DOCUMENTATION
19986  AsmElfEHFrameEntryCI.setDataPrototype(
19987  "int", "addr_encoding", "= -1",
19988  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
19989 #endif // !DOCUMENTATION
19990 
19991 #ifndef DOCUMENTATION
19992  AsmElfEHFrameEntryCI.setDataPrototype(
19993  "bool", "sig_frame", "= false",
19994  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
19995 #endif // !DOCUMENTATION
19996 
19997 #ifndef DOCUMENTATION
19998  AsmElfEHFrameEntryCI.setDataPrototype(
19999  "SgUnsignedCharList", "instructions", "",
20000  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
20001 #endif // !DOCUMENTATION
20002 
20003 #ifndef DOCUMENTATION
20004  AsmElfEHFrameEntryCI.setDataPrototype(
20005  "SgAsmElfEHFrameEntryFDList*", "fd_entries", "= createAndParent<SgAsmElfEHFrameEntryFDList>(this)",
20006  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
20007 #endif // !DOCUMENTATION
20008 
20009  DECLARE_OTHERS(AsmElfEHFrameEntryCI);
20010 #if defined(SgAsmElfEHFrameEntryCI_OTHERS) || defined(DOCUMENTATION)
20011 
20012  //----------------------- Boost serialization for SgAsmElfEHFrameEntryCI -----------------------
20013 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
20014 private:
20015  friend class boost::serialization::access;
20016 
20017  template<class S>
20018  void serialize(S &s, const unsigned /*version*/) {
20019  debugSerializationBegin("SgAsmElfEHFrameEntryCI");
20020  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
20021  s & BOOST_SERIALIZATION_NVP(p_version);
20022  s & BOOST_SERIALIZATION_NVP(p_augmentation_string);
20023  s & BOOST_SERIALIZATION_NVP(p_eh_data);
20024  s & BOOST_SERIALIZATION_NVP(p_code_alignment_factor);
20025  s & BOOST_SERIALIZATION_NVP(p_data_alignment_factor);
20026  s & BOOST_SERIALIZATION_NVP(p_augmentation_data_length);
20027  s & BOOST_SERIALIZATION_NVP(p_lsda_encoding);
20028  s & BOOST_SERIALIZATION_NVP(p_prh_encoding);
20029  s & BOOST_SERIALIZATION_NVP(p_prh_arg);
20030  s & BOOST_SERIALIZATION_NVP(p_prh_addr);
20031  s & BOOST_SERIALIZATION_NVP(p_addr_encoding);
20032  s & BOOST_SERIALIZATION_NVP(p_sig_frame);
20033  s & BOOST_SERIALIZATION_NVP(p_instructions);
20034  s & BOOST_SERIALIZATION_NVP(p_fd_entries);
20035  debugSerializationEnd("SgAsmElfEHFrameEntryCI");
20036  }
20037 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
20038 
20039 public:
20045  int const& get_version() const;
20046  void set_version(int const&);
20049 public:
20055  std::string const& get_augmentation_string() const;
20056  void set_augmentation_string(std::string const&);
20059 public:
20065  uint64_t const& get_eh_data() const;
20066  void set_eh_data(uint64_t const&);
20069 public:
20075  uint64_t const& get_code_alignment_factor() const;
20076  void set_code_alignment_factor(uint64_t const&);
20079 public:
20085  int64_t const& get_data_alignment_factor() const;
20086  void set_data_alignment_factor(int64_t const&);
20089 public:
20095  uint64_t const& get_augmentation_data_length() const;
20096  void set_augmentation_data_length(uint64_t const&);
20099 public:
20105  int const& get_lsda_encoding() const;
20106  void set_lsda_encoding(int const&);
20109 public:
20115  int const& get_prh_encoding() const;
20116  void set_prh_encoding(int const&);
20119 public:
20125  unsigned const& get_prh_arg() const;
20126  void set_prh_arg(unsigned const&);
20129 public:
20135  rose_addr_t const& get_prh_addr() const;
20136  void set_prh_addr(rose_addr_t const&);
20139 public:
20145  int const& get_addr_encoding() const;
20146  void set_addr_encoding(int const&);
20149 public:
20155  bool const& get_sig_frame() const;
20156  void set_sig_frame(bool const&);
20159 public:
20165  SgUnsignedCharList const& get_instructions() const;
20166  SgUnsignedCharList& get_instructions();
20167  void set_instructions(SgUnsignedCharList const&);
20170 public:
20180 public:
20183 
20185  virtual void dump(FILE*, const char *prefix, ssize_t idx) const;
20186 
20191  std::string unparse(const SgAsmElfEHFrameSection*) const;
20192 public:
20194  virtual ~SgAsmElfEHFrameEntryCI();
20195 
20196 public:
20199 
20200 protected:
20207  void initializeProperties();
20208 #endif // SgAsmElfEHFrameEntryCI_OTHERS
20209 #ifdef DOCUMENTATION
20210 };
20211 #endif // DOCUMENTATION
20212 
20213 
20215 // SgAsmElfDynamicSection -- MACHINE GENERATED; DO NOT MODIFY --
20217 
20218 DECLARE_LEAF_CLASS(AsmElfDynamicSection);
20219 IS_SERIALIZABLE(AsmElfDynamicSection);
20220 
20221 #ifdef DOCUMENTATION
20222 
20224 #endif // DOCUMENTATION
20225 
20226 #ifndef DOCUMENTATION
20227  AsmElfDynamicSection.setDataPrototype(
20228  "SgAsmElfDynamicEntryList*", "entries", "= createAndParent<SgAsmElfDynamicEntryList>(this)",
20229  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
20230 #endif // !DOCUMENTATION
20231 
20232  DECLARE_OTHERS(AsmElfDynamicSection);
20233 #if defined(SgAsmElfDynamicSection_OTHERS) || defined(DOCUMENTATION)
20234 
20235  //----------------------- Boost serialization for SgAsmElfDynamicSection -----------------------
20236 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
20237 private:
20238  friend class boost::serialization::access;
20239 
20240  template<class S>
20241  void serialize(S &s, const unsigned /*version*/) {
20242  debugSerializationBegin("SgAsmElfDynamicSection");
20243  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmElfSection);
20244  s & BOOST_SERIALIZATION_NVP(p_entries);
20245  debugSerializationEnd("SgAsmElfDynamicSection");
20246  }
20247 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
20248 
20249 public:
20256  SgAsmElfDynamicEntryList* const& get_entries() const;
20257  void set_entries(SgAsmElfDynamicEntryList* const&);
20259 public:
20262 
20264  virtual SgAsmElfDynamicSection* parse() override;
20265 
20267  virtual void finish_parsing() override;
20268 
20271  virtual rose_addr_t calculate_sizes(size_t *total, size_t *required, size_t *optional, size_t *entcount) const override;
20272 
20274  virtual bool reallocate() override;
20275 
20277  virtual void unparse(std::ostream&) const override;
20278 
20280  virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
20281 public:
20283  virtual ~SgAsmElfDynamicSection();
20284 
20285 public:
20288 
20289 protected:
20296  void initializeProperties();
20297 #endif // SgAsmElfDynamicSection_OTHERS
20298 #ifdef DOCUMENTATION
20299 };
20300 #endif // DOCUMENTATION
20301 
20302 
20304 // SgAsmElfSection -- MACHINE GENERATED; DO NOT MODIFY --
20306 
20307 #ifndef DOCUMENTATION
20308 AstNodeClass& AsmElfSection = nonTerminalConstructor(
20309  "AsmElfSection",
20310  *this,
20311  "AsmElfSection",
20312  "AsmElfSectionTag",
20313  SubclassListBuilder()
20314  | AsmElfDynamicSection
20315  | AsmElfEHFrameSection
20316  | AsmElfNoteSection
20317  | AsmElfRelocSection
20318  | AsmElfStringSection
20319  | AsmElfSymbolSection
20320  | AsmElfSymverDefinedSection
20321  | AsmElfSymverNeededSection
20322  | AsmElfSymverSection
20323  , true);
20324 assert(AsmElfSection.associatedGrammar != nullptr);
20325 AsmElfSection.setCppCondition("!defined(DOCUMENTATION)");
20326 AsmElfSection.isBoostSerializable(true);
20327 AsmElfSection.setAutomaticGenerationOfConstructor(false);
20328 AsmElfSection.setAutomaticGenerationOfDestructor(false);
20329 #endif // !DOCUMENTATION
20330 
20331 #ifdef DOCUMENTATION
20332 
20334 #endif // DOCUMENTATION
20335 
20336 #ifndef DOCUMENTATION
20337  AsmElfSection.setDataPrototype(
20338  "SgAsmElfSection*", "linked_section", "= nullptr",
20339  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
20340 #endif // !DOCUMENTATION
20341 
20342 #ifndef DOCUMENTATION
20343  AsmElfSection.setDataPrototype(
20344  "SgAsmElfSectionTableEntry*", "section_entry", "= nullptr",
20345  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
20346 #endif // !DOCUMENTATION
20347 
20348 #ifndef DOCUMENTATION
20349  AsmElfSection.setDataPrototype(
20350  "SgAsmElfSegmentTableEntry*", "segment_entry", "= nullptr",
20351  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
20352 #endif // !DOCUMENTATION
20353 
20354  DECLARE_OTHERS(AsmElfSection);
20355 #if defined(SgAsmElfSection_OTHERS) || defined(DOCUMENTATION)
20356 
20357  //----------------------- Boost serialization for SgAsmElfSection -----------------------
20358 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
20359 private:
20360  friend class boost::serialization::access;
20361 
20362  template<class S>
20363  void serialize(S &s, const unsigned /*version*/) {
20364  debugSerializationBegin("SgAsmElfSection");
20365  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmGenericSection);
20366  s & BOOST_SERIALIZATION_NVP(p_linked_section);
20367  s & BOOST_SERIALIZATION_NVP(p_section_entry);
20368  s & BOOST_SERIALIZATION_NVP(p_segment_entry);
20369  debugSerializationEnd("SgAsmElfSection");
20370  }
20371 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
20372 
20373 public:
20380  virtual void set_linked_section(SgAsmElfSection*);
20382 public:
20390 public:
20397 public:
20403 
20411 
20416 
20437  rose_addr_t calculate_sizes(size_t r32size, size_t r64size, const std::vector<size_t> &optsizes,
20438  size_t *entsize, size_t *required, size_t *optional, size_t *entcount) const;
20439 
20440  virtual void finish_parsing() {}
20441 
20458  virtual rose_addr_t calculate_sizes(size_t *entsize, size_t *required, size_t *optional, size_t *entcount) const;
20459 
20461  virtual bool reallocate() override;
20462 
20464  virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
20465 
20468 
20473 public:
20475  virtual ~SgAsmElfSection();
20476 
20477 public:
20479  SgAsmElfSection();
20480 
20481 protected:
20488  void initializeProperties();
20489 #endif // SgAsmElfSection_OTHERS
20490 #ifdef DOCUMENTATION
20491 };
20492 #endif // DOCUMENTATION
20493 
20494 
20496 // SgAsmElfDynamicEntryList -- MACHINE GENERATED; DO NOT MODIFY --
20498 
20499 DECLARE_LEAF_CLASS(AsmElfDynamicEntryList);
20500 IS_SERIALIZABLE(AsmElfDynamicEntryList);
20501 
20502 #ifdef DOCUMENTATION
20503 
20508 #endif // DOCUMENTATION
20509 
20510 #ifndef DOCUMENTATION
20511  AsmElfDynamicEntryList.setDataPrototype(
20512  "SgAsmElfDynamicEntryPtrList", "entries", "",
20513  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
20514 #endif // !DOCUMENTATION
20515 
20516  DECLARE_OTHERS(AsmElfDynamicEntryList);
20517 #if defined(SgAsmElfDynamicEntryList_OTHERS) || defined(DOCUMENTATION)
20518 
20519  //----------------------- Boost serialization for SgAsmElfDynamicEntryList -----------------------
20520 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
20521 private:
20522  friend class boost::serialization::access;
20523 
20524  template<class S>
20525  void serialize(S &s, const unsigned /*version*/) {
20526  debugSerializationBegin("SgAsmElfDynamicEntryList");
20527  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
20528  s & BOOST_SERIALIZATION_NVP(p_entries);
20529  debugSerializationEnd("SgAsmElfDynamicEntryList");
20530  }
20531 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
20532 
20533 public:
20537  SgAsmElfDynamicEntryPtrList const& get_entries() const;
20538  SgAsmElfDynamicEntryPtrList& get_entries();
20539  void set_entries(SgAsmElfDynamicEntryPtrList const&);
20542 public:
20544  virtual ~SgAsmElfDynamicEntryList();
20545 
20546 public:
20549 
20550 protected:
20557  void initializeProperties();
20558 #endif // SgAsmElfDynamicEntryList_OTHERS
20559 #ifdef DOCUMENTATION
20560 };
20561 #endif // DOCUMENTATION
20562 
20563 
20565 // SgAsmElfDynamicEntry -- MACHINE GENERATED; DO NOT MODIFY --
20567 
20568 DECLARE_LEAF_CLASS(AsmElfDynamicEntry);
20569 IS_SERIALIZABLE(AsmElfDynamicEntry);
20570 
20571 DECLARE_HEADERS(AsmElfDynamicEntry);
20572 #if defined(SgAsmElfDynamicEntry_HEADERS) || defined(DOCUMENTATION)
20573 #include <Rose/BinaryAnalysis/ByteOrder.h>
20574 #endif // SgAsmElfDynamicEntry_HEADERS
20575 
20576 #ifdef DOCUMENTATION
20577 
20579 #endif // DOCUMENTATION
20580 
20581 #ifndef DOCUMENTATION
20582  AsmElfDynamicEntry.setDataPrototype(
20583  "SgAsmElfDynamicEntry::EntryType", "d_tag", "= SgAsmElfDynamicEntry::DT_NULL",
20584  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
20585 #endif // !DOCUMENTATION
20586 
20587 #ifndef DOCUMENTATION
20588  AsmElfDynamicEntry.setDataPrototype(
20589  "rose_rva_t", "d_val", "",
20590  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
20591 #endif // !DOCUMENTATION
20592 
20593 #ifndef DOCUMENTATION
20594  AsmElfDynamicEntry.setDataPrototype(
20595  "SgAsmGenericString*", "name", "= nullptr",
20596  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
20597 #endif // !DOCUMENTATION
20598 
20599 #ifndef DOCUMENTATION
20600  AsmElfDynamicEntry.setDataPrototype(
20601  "SgUnsignedCharList", "extra", "",
20602  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
20603 #endif // !DOCUMENTATION
20604 
20605  DECLARE_OTHERS(AsmElfDynamicEntry);
20606 #if defined(SgAsmElfDynamicEntry_OTHERS) || defined(DOCUMENTATION)
20607 
20608  //----------------------- Boost serialization for SgAsmElfDynamicEntry -----------------------
20609 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
20610 private:
20611  friend class boost::serialization::access;
20612 
20613  template<class S>
20614  void serialize(S &s, const unsigned /*version*/) {
20615  debugSerializationBegin("SgAsmElfDynamicEntry");
20616  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
20617  s & BOOST_SERIALIZATION_NVP(p_d_tag);
20618  s & BOOST_SERIALIZATION_NVP(p_d_val);
20619  s & BOOST_SERIALIZATION_NVP(p_name);
20620  s & BOOST_SERIALIZATION_NVP(p_extra);
20621  debugSerializationEnd("SgAsmElfDynamicEntry");
20622  }
20623 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
20624  // Local types
20627 public:
20628  enum EntryType { /* Type Executable SharedObj Purpose */
20629  DT_NULL = 0, /* ignored mandatory mandatory Marks end of dynamic array */
20630  DT_NEEDED = 1, /* value optional optional Name of needed library */
20631  DT_PLTRELSZ = 2, /* value optional optional Size of reloc entries associated with PLT */
20632  DT_PLTGOT = 3, /* pointer optional optional PLT and/or GOT */
20633  DT_HASH = 4, /* pointer mandatory mandatory Symbol hash table */
20634  DT_STRTAB = 5, /* pointer mandatory mandatory String table for symbols, lib names, etc. */
20635  DT_SYMTAB = 6, /* pointer mandatory mandatory Symbol table */
20636  DT_RELA = 7, /* pointer mandatory optional Relocation table */
20637  DT_RELASZ = 8, /* value mandatory optional Size of RELA relocation table */
20638  DT_RELAENT = 9, /* value mandatory optional Size of each RELA table entry */
20639  DT_STRSZ = 10, /* value mandatory mandatory Size of string table */
20640  DT_SYMENT = 11, /* value mandatory mandatory Size of symbol table entry */
20641  DT_INIT = 12, /* pointer optional optional Initialization function */
20642  DT_FINI = 13, /* pointer optional optional Termination function */
20643  DT_SONAME = 14, /* value ignored optional Name of shared object */
20644  DT_RPATH = 15, /* value optional ignored NUL-term library search path */
20645  DT_SYMBOLIC = 16, /* ignored ignored optional Bool determines dynamic linker symbol resolution */
20646  DT_REL = 17, /* pointer mandatory optional Relocation table */
20647  DT_RELSZ = 18, /* value mandatory optional Size of REL relocation table */
20648  DT_RELENT = 19, /* value mandatory optional Size of each REL table entry */
20649  DT_PLTREL = 20, /* value optional optional Reloc type for PLT; value is DT_RELA or DT_REL */
20650  DT_DEBUG = 21, /* pointer optional ignored Contents are not specified at ABI level */
20651  DT_TEXTREL = 22, /* ignored optional optional presence => relocs to nonwritable segments OK */
20652  DT_JMPREL = 23, /* pointer optional optional Addr of relocation entries for PLT */
20653  DT_BIND_NOW = 24, /* ignored optional optional Shall dynlinker do relocs before xfering control?*/
20654  DT_INIT_ARRAY = 25, /* pointer optional ? Array with addresses of init fct */
20655  DT_FINI_ARRAY = 26, /* pointer optional ? Array with address of fini fct */
20656  DT_INIT_ARRAYSZ = 27, /* value optional ? Size in bytes of DT_INIT_ARRAY */
20657  DT_FINI_ARRAYSZ = 28, /* value optional ? Size in bytes of DT_FINI_ARRAY */
20658  DT_RUNPATH = 29, /* ? optional ? Library search path (how diff from DT_RPATH?) */
20659  DT_FLAGS = 30, /* value optional ? Bit flags */
20660  DT_PREINIT_ARRAY = 32, /* pointer optional ? Array with addrs of preinit fct (aka DT_ENCODING)*/
20661  DT_PREINIT_ARRAYSZ = 33,/* value optional ? size in bytes of DT_PREINIT_ARRAY */
20662  DT_NUM = 34, /* ? ? ? "number used"? */
20663 
20664  DT_GNU_PRELINKED =0x6ffffdf5,/*value ? ? Prelinking time stamp */
20665  DT_GNU_CONFLICTSZ=0x6ffffdf6,/*value ? ? Size of conflict section */
20666  DT_GNU_LIBLISTSZ=0x6ffffdf7,/*value ? ? Size of library list */
20667  DT_CHECKSUM = 0x6ffffdf8, /* value ? ? ? */
20668  DT_PLTPADSZ = 0x6ffffdf9, /* value ? ? ? */
20669  DT_MOVEENT = 0x6ffffdfa, /* value ? ? ? */
20670  DT_MOVESZ = 0x6ffffdfb, /* value ? ? ? */
20671  DT_FEATURE_1= 0x6ffffdfc, /* value ? ? Feature selection (DTF_*) */
20672  DT_POSFLAG_1= 0x6ffffdfd, /* value ? ? Flag for DT_* entries affecting next entry */
20673  DT_SYMINSZ = 0x6ffffdfe, /* value ? ? Size of syminfo table in bytes */
20674  DT_SYMINENT = 0x6ffffdff, /* value ? ? Size of each syminfo table entry */
20675 
20676  DT_GNU_HASH = 0x6ffffef5, /* pointer ? ? GNU-style hash table */
20677  DT_TLSDESC_PLT=0x6ffffef6,/* pointer ? ? ? */
20678  DT_TLSDESC_GOT=0x6ffffef7,/* pointer ? ? ? */
20679  DT_GNU_CONFLICT=0x6ffffef8,/*pointer ? ? Start of conflict section */
20680  DT_GNU_LIBLIST=0x6ffffef9,/* pointer ? ? Library list */
20681  DT_CONFIG = 0x6ffffefa, /* pointer ? ? Configuration information */
20682  DT_DEPAUDIT = 0x6ffffefb, /* pointer ? ? Dependency auditing */
20683  DT_AUDIT = 0x6ffffefc, /* pointer ? ? Object auditing */
20684  DT_PLTPAD = 0x6ffffefd, /* pointer ? ? PLT padding */
20685  DT_MOVETAB = 0x6ffffefe, /* pointer ? ? Move table */
20686  DT_SYMINFO = 0x6ffffeff, /* pointer ? ? Syminfo table */
20687 
20688  DT_VERSYM = 0x6ffffff0, /* pointer ? ? ? */
20689  DT_RELACOUNT= 0x6ffffff9, /* value ? ? ? */
20690  DT_RELCOUNT = 0x6ffffffa, /* value ? ? ? */
20691  DT_FLAGS_1 = 0x6ffffffb, /* value ? ? Sun state flags */
20692  DT_VERDEF = 0x6ffffffc, /* pointer ? ? Sun version definition table */
20693  DT_VERDEFNUM= 0x6ffffffd, /* value ? ? Sun number of version definitions */
20694  DT_VERNEED = 0x6ffffffe, /* pointer ? ? Sun needed versions table */
20695  DT_VERNEEDNUM=0x6fffffff, /* value ? ? Sun number of needed versions */
20696 
20697  DT_AUXILIARY= 0x7ffffffd, /* pointer ? ? Sun shared obj to load before self */
20698  DT_FILTER = 0x7fffffff /* pointer ? ? Shared object ot get values from */
20699  };
20700 
20701 #ifdef _MSC_VER
20702 # pragma pack (1)
20703 #endif
20704 
20707  uint32_t d_tag;
20708  uint32_t d_val;
20709  }
20710 #if !defined(SWIG) && !defined(_MSC_VER)
20711  __attribute__((packed))
20712 #endif
20713  ;
20714 
20716  uint64_t d_tag;
20717  uint64_t d_val;
20718  }
20719 #if !defined(SWIG) && !defined(_MSC_VER)
20720  __attribute__((packed))
20721 #endif
20722  ;
20723 
20724 #ifdef _MSC_VER
20725 # pragma pack ()
20726 #endif
20727 
20729  // Properties
20731 public:
20737  SgAsmElfDynamicEntry::EntryType const& get_d_tag() const;
20738  void set_d_tag(SgAsmElfDynamicEntry::EntryType const&);
20741 public:
20747  rose_rva_t const& get_d_val() const;
20748  rose_rva_t& get_d_val();
20749  void set_d_val(rose_rva_t const&);
20752 public:
20756  SgAsmGenericString* const& get_name() const;
20759 public:
20763  SgUnsignedCharList const& get_extra() const;
20764  SgUnsignedCharList& get_extra();
20765  void set_extra(SgUnsignedCharList const&);
20767  // Functions
20770 public:
20772  explicit SgAsmElfDynamicEntry(SgAsmElfDynamicSection *dynsec);
20773 
20777  void parse(Rose::BinaryAnalysis::ByteOrder::Endianness, const SgAsmElfDynamicEntry::Elf32DynamicEntry_disk*);
20778  void parse(Rose::BinaryAnalysis::ByteOrder::Endianness, const SgAsmElfDynamicEntry::Elf64DynamicEntry_disk*);
20784  void *encode(Rose::BinaryAnalysis::ByteOrder::Endianness, SgAsmElfDynamicEntry::Elf32DynamicEntry_disk*) const;
20785  void *encode(Rose::BinaryAnalysis::ByteOrder::Endianness, SgAsmElfDynamicEntry::Elf64DynamicEntry_disk*) const;
20789  virtual void dump(FILE*, const char *prefix, ssize_t idx) const;
20790 
20792  static std::string to_string(SgAsmElfDynamicEntry::EntryType);
20793 public:
20795  virtual ~SgAsmElfDynamicEntry();
20796 
20797 public:
20800 
20801 protected:
20808  void initializeProperties();
20809 #endif // SgAsmElfDynamicEntry_OTHERS
20810 #ifdef DOCUMENTATION
20811 };
20812 #endif // DOCUMENTATION
20813 
20814 
20816 // SgAsmDwarfWithStmt -- MACHINE GENERATED; DO NOT MODIFY --
20818 
20819 DECLARE_LEAF_CLASS(AsmDwarfWithStmt);
20820 IS_SERIALIZABLE(AsmDwarfWithStmt);
20821 
20822 #ifdef DOCUMENTATION
20824 #endif // DOCUMENTATION
20825 
20826  DECLARE_OTHERS(AsmDwarfWithStmt);
20827 #if defined(SgAsmDwarfWithStmt_OTHERS) || defined(DOCUMENTATION)
20828 
20829  //----------------------- Boost serialization for SgAsmDwarfWithStmt -----------------------
20830 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
20831 private:
20832  friend class boost::serialization::access;
20833 
20834  template<class S>
20835  void serialize(S &s, const unsigned /*version*/) {
20836  debugSerializationBegin("SgAsmDwarfWithStmt");
20837  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
20838  debugSerializationEnd("SgAsmDwarfWithStmt");
20839  }
20840 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
20841 
20842 public:
20844  virtual ~SgAsmDwarfWithStmt();
20845 
20846 public:
20849 
20850 public:
20852  SgAsmDwarfWithStmt(int const& nesting_level,
20853  uint64_t const& offset,
20854  uint64_t const& overall_offset);
20855 
20856 protected:
20863  void initializeProperties();
20864 #endif // SgAsmDwarfWithStmt_OTHERS
20865 #ifdef DOCUMENTATION
20866 };
20867 #endif // DOCUMENTATION
20868 
20869 
20871 // SgAsmDwarfVariantPart -- MACHINE GENERATED; DO NOT MODIFY --
20873 
20874 DECLARE_LEAF_CLASS(AsmDwarfVariantPart);
20875 IS_SERIALIZABLE(AsmDwarfVariantPart);
20876 
20877 #ifdef DOCUMENTATION
20879 #endif // DOCUMENTATION
20880 
20881  DECLARE_OTHERS(AsmDwarfVariantPart);
20882 #if defined(SgAsmDwarfVariantPart_OTHERS) || defined(DOCUMENTATION)
20883 
20884  //----------------------- Boost serialization for SgAsmDwarfVariantPart -----------------------
20885 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
20886 private:
20887  friend class boost::serialization::access;
20888 
20889  template<class S>
20890  void serialize(S &s, const unsigned /*version*/) {
20891  debugSerializationBegin("SgAsmDwarfVariantPart");
20892  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
20893  debugSerializationEnd("SgAsmDwarfVariantPart");
20894  }
20895 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
20896 
20897 public:
20899  virtual ~SgAsmDwarfVariantPart();
20900 
20901 public:
20904 
20905 public:
20907  SgAsmDwarfVariantPart(int const& nesting_level,
20908  uint64_t const& offset,
20909  uint64_t const& overall_offset);
20910 
20911 protected:
20918  void initializeProperties();
20919 #endif // SgAsmDwarfVariantPart_OTHERS
20920 #ifdef DOCUMENTATION
20921 };
20922 #endif // DOCUMENTATION
20923 
20924 
20926 // SgAsmDwarfVariant -- MACHINE GENERATED; DO NOT MODIFY --
20928 
20929 DECLARE_LEAF_CLASS(AsmDwarfVariant);
20930 IS_SERIALIZABLE(AsmDwarfVariant);
20931 
20932 #ifdef DOCUMENTATION
20934 #endif // DOCUMENTATION
20935 
20936  DECLARE_OTHERS(AsmDwarfVariant);
20937 #if defined(SgAsmDwarfVariant_OTHERS) || defined(DOCUMENTATION)
20938 
20939  //----------------------- Boost serialization for SgAsmDwarfVariant -----------------------
20940 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
20941 private:
20942  friend class boost::serialization::access;
20943 
20944  template<class S>
20945  void serialize(S &s, const unsigned /*version*/) {
20946  debugSerializationBegin("SgAsmDwarfVariant");
20947  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
20948  debugSerializationEnd("SgAsmDwarfVariant");
20949  }
20950 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
20951 
20952 public:
20954  virtual ~SgAsmDwarfVariant();
20955 
20956 public:
20959 
20960 public:
20962  SgAsmDwarfVariant(int const& nesting_level,
20963  uint64_t const& offset,
20964  uint64_t const& overall_offset);
20965 
20966 protected:
20973  void initializeProperties();
20974 #endif // SgAsmDwarfVariant_OTHERS
20975 #ifdef DOCUMENTATION
20976 };
20977 #endif // DOCUMENTATION
20978 
20979 
20981 // SgAsmDwarfVariable -- MACHINE GENERATED; DO NOT MODIFY --
20983 
20984 DECLARE_LEAF_CLASS(AsmDwarfVariable);
20985 IS_SERIALIZABLE(AsmDwarfVariable);
20986 
20987 #ifdef DOCUMENTATION
20989 #endif // DOCUMENTATION
20990 
20991  DECLARE_OTHERS(AsmDwarfVariable);
20992 #if defined(SgAsmDwarfVariable_OTHERS) || defined(DOCUMENTATION)
20993 
20994  //----------------------- Boost serialization for SgAsmDwarfVariable -----------------------
20995 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
20996 private:
20997  friend class boost::serialization::access;
20998 
20999  template<class S>
21000  void serialize(S &s, const unsigned /*version*/) {
21001  debugSerializationBegin("SgAsmDwarfVariable");
21002  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
21003  debugSerializationEnd("SgAsmDwarfVariable");
21004  }
21005 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
21006 
21007 public:
21009  virtual ~SgAsmDwarfVariable();
21010 
21011 public:
21014 
21015 public:
21017  SgAsmDwarfVariable(int const& nesting_level,
21018  uint64_t const& offset,
21019  uint64_t const& overall_offset);
21020 
21021 protected:
21028  void initializeProperties();
21029 #endif // SgAsmDwarfVariable_OTHERS
21030 #ifdef DOCUMENTATION
21031 };
21032 #endif // DOCUMENTATION
21033 
21034 
21036 // SgAsmDwarfUpcStrictType -- MACHINE GENERATED; DO NOT MODIFY --
21038 
21039 DECLARE_LEAF_CLASS(AsmDwarfUpcStrictType);
21040 IS_SERIALIZABLE(AsmDwarfUpcStrictType);
21041 
21042 #ifdef DOCUMENTATION
21044 #endif // DOCUMENTATION
21045 
21046  DECLARE_OTHERS(AsmDwarfUpcStrictType);
21047 #if defined(SgAsmDwarfUpcStrictType_OTHERS) || defined(DOCUMENTATION)
21048 
21049  //----------------------- Boost serialization for SgAsmDwarfUpcStrictType -----------------------
21050 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
21051 private:
21052  friend class boost::serialization::access;
21053 
21054  template<class S>
21055  void serialize(S &s, const unsigned /*version*/) {
21056  debugSerializationBegin("SgAsmDwarfUpcStrictType");
21057  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
21058  debugSerializationEnd("SgAsmDwarfUpcStrictType");
21059  }
21060 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
21061 
21062 public:
21064  virtual ~SgAsmDwarfUpcStrictType();
21065 
21066 public:
21069 
21070 public:
21072  SgAsmDwarfUpcStrictType(int const& nesting_level,
21073  uint64_t const& offset,
21074  uint64_t const& overall_offset);
21075 
21076 protected:
21083  void initializeProperties();
21084 #endif // SgAsmDwarfUpcStrictType_OTHERS
21085 #ifdef DOCUMENTATION
21086 };
21087 #endif // DOCUMENTATION
21088 
21089 
21091 // SgAsmDwarfUpcSharedType -- MACHINE GENERATED; DO NOT MODIFY --
21093 
21094 DECLARE_LEAF_CLASS(AsmDwarfUpcSharedType);
21095 IS_SERIALIZABLE(AsmDwarfUpcSharedType);
21096 
21097 #ifdef DOCUMENTATION
21099 #endif // DOCUMENTATION
21100 
21101  DECLARE_OTHERS(AsmDwarfUpcSharedType);
21102 #if defined(SgAsmDwarfUpcSharedType_OTHERS) || defined(DOCUMENTATION)
21103 
21104  //----------------------- Boost serialization for SgAsmDwarfUpcSharedType -----------------------
21105 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
21106 private:
21107  friend class boost::serialization::access;
21108 
21109  template<class S>
21110  void serialize(S &s, const unsigned /*version*/) {
21111  debugSerializationBegin("SgAsmDwarfUpcSharedType");
21112  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
21113  debugSerializationEnd("SgAsmDwarfUpcSharedType");
21114  }
21115 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
21116 
21117 public:
21119  virtual ~SgAsmDwarfUpcSharedType();
21120 
21121 public:
21124 
21125 public:
21127  SgAsmDwarfUpcSharedType(int const& nesting_level,
21128  uint64_t const& offset,
21129  uint64_t const& overall_offset);
21130 
21131 protected:
21138  void initializeProperties();
21139 #endif // SgAsmDwarfUpcSharedType_OTHERS
21140 #ifdef DOCUMENTATION
21141 };
21142 #endif // DOCUMENTATION
21143 
21144 
21146 // SgAsmDwarfUpcRelaxedType -- MACHINE GENERATED; DO NOT MODIFY --
21148 
21149 DECLARE_LEAF_CLASS(AsmDwarfUpcRelaxedType);
21150 IS_SERIALIZABLE(AsmDwarfUpcRelaxedType);
21151 
21152 #ifdef DOCUMENTATION
21154 #endif // DOCUMENTATION
21155 
21156  DECLARE_OTHERS(AsmDwarfUpcRelaxedType);
21157 #if defined(SgAsmDwarfUpcRelaxedType_OTHERS) || defined(DOCUMENTATION)
21158 
21159  //----------------------- Boost serialization for SgAsmDwarfUpcRelaxedType -----------------------
21160 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
21161 private:
21162  friend class boost::serialization::access;
21163 
21164  template<class S>
21165  void serialize(S &s, const unsigned /*version*/) {
21166  debugSerializationBegin("SgAsmDwarfUpcRelaxedType");
21167  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
21168  debugSerializationEnd("SgAsmDwarfUpcRelaxedType");
21169  }
21170 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
21171 
21172 public:
21174  virtual ~SgAsmDwarfUpcRelaxedType();
21175 
21176 public:
21179 
21180 public:
21182  SgAsmDwarfUpcRelaxedType(int const& nesting_level,
21183  uint64_t const& offset,
21184  uint64_t const& overall_offset);
21185 
21186 protected:
21193  void initializeProperties();
21194 #endif // SgAsmDwarfUpcRelaxedType_OTHERS
21195 #ifdef DOCUMENTATION
21196 };
21197 #endif // DOCUMENTATION
21198 
21199 
21201 // SgAsmDwarfUnspecifiedType -- MACHINE GENERATED; DO NOT MODIFY --
21203 
21204 DECLARE_LEAF_CLASS(AsmDwarfUnspecifiedType);
21205 IS_SERIALIZABLE(AsmDwarfUnspecifiedType);
21206 
21207 #ifdef DOCUMENTATION
21209 #endif // DOCUMENTATION
21210 
21211  DECLARE_OTHERS(AsmDwarfUnspecifiedType);
21212 #if defined(SgAsmDwarfUnspecifiedType_OTHERS) || defined(DOCUMENTATION)
21213 
21214  //----------------------- Boost serialization for SgAsmDwarfUnspecifiedType -----------------------
21215 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
21216 private:
21217  friend class boost::serialization::access;
21218 
21219  template<class S>
21220  void serialize(S &s, const unsigned /*version*/) {
21221  debugSerializationBegin("SgAsmDwarfUnspecifiedType");
21222  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
21223  debugSerializationEnd("SgAsmDwarfUnspecifiedType");
21224  }
21225 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
21226 
21227 public:
21229  virtual ~SgAsmDwarfUnspecifiedType();
21230 
21231 public:
21234 
21235 public:
21237  SgAsmDwarfUnspecifiedType(int const& nesting_level,
21238  uint64_t const& offset,
21239  uint64_t const& overall_offset);
21240 
21241 protected:
21248  void initializeProperties();
21249 #endif // SgAsmDwarfUnspecifiedType_OTHERS
21250 #ifdef DOCUMENTATION
21251 };
21252 #endif // DOCUMENTATION
21253 
21254 
21256 // SgAsmDwarfUnspecifiedParameters -- MACHINE GENERATED; DO NOT MODIFY --
21258 
21259 DECLARE_LEAF_CLASS(AsmDwarfUnspecifiedParameters);
21260 IS_SERIALIZABLE(AsmDwarfUnspecifiedParameters);
21261 
21262 #ifdef DOCUMENTATION
21264 #endif // DOCUMENTATION
21265 
21266  DECLARE_OTHERS(AsmDwarfUnspecifiedParameters);
21267 #if defined(SgAsmDwarfUnspecifiedParameters_OTHERS) || defined(DOCUMENTATION)
21268 
21269  //----------------------- Boost serialization for SgAsmDwarfUnspecifiedParameters -----------------------
21270 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
21271 private:
21272  friend class boost::serialization::access;
21273 
21274  template<class S>
21275  void serialize(S &s, const unsigned /*version*/) {
21276  debugSerializationBegin("SgAsmDwarfUnspecifiedParameters");
21277  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
21278  debugSerializationEnd("SgAsmDwarfUnspecifiedParameters");
21279  }
21280 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
21281 
21282 public:
21285 
21286 public:
21289 
21290 public:
21292  SgAsmDwarfUnspecifiedParameters(int const& nesting_level,
21293  uint64_t const& offset,
21294  uint64_t const& overall_offset);
21295 
21296 protected:
21303  void initializeProperties();
21304 #endif // SgAsmDwarfUnspecifiedParameters_OTHERS
21305 #ifdef DOCUMENTATION
21306 };
21307 #endif // DOCUMENTATION
21308 
21309 
21311 // SgAsmDwarfUnknownConstruct -- MACHINE GENERATED; DO NOT MODIFY --
21313 
21314 DECLARE_LEAF_CLASS(AsmDwarfUnknownConstruct);
21315 IS_SERIALIZABLE(AsmDwarfUnknownConstruct);
21316 
21317 #ifdef DOCUMENTATION
21319 #endif // DOCUMENTATION
21320 
21321  DECLARE_OTHERS(AsmDwarfUnknownConstruct);
21322 #if defined(SgAsmDwarfUnknownConstruct_OTHERS) || defined(DOCUMENTATION)
21323 
21324  //----------------------- Boost serialization for SgAsmDwarfUnknownConstruct -----------------------
21325 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
21326 private:
21327  friend class boost::serialization::access;
21328 
21329  template<class S>
21330  void serialize(S &s, const unsigned /*version*/) {
21331  debugSerializationBegin("SgAsmDwarfUnknownConstruct");
21332  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
21333  debugSerializationEnd("SgAsmDwarfUnknownConstruct");
21334  }
21335 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
21336 
21337 public:
21339  virtual ~SgAsmDwarfUnknownConstruct();
21340 
21341 public:
21344 
21345 public:
21347  SgAsmDwarfUnknownConstruct(int const& nesting_level,
21348  uint64_t const& offset,
21349  uint64_t const& overall_offset);
21350 
21351 protected:
21358  void initializeProperties();
21359 #endif // SgAsmDwarfUnknownConstruct_OTHERS
21360 #ifdef DOCUMENTATION
21361 };
21362 #endif // DOCUMENTATION
21363 
21364 
21366 // SgAsmDwarfUnionType -- MACHINE GENERATED; DO NOT MODIFY --
21368 
21369 DECLARE_LEAF_CLASS(AsmDwarfUnionType);
21370 IS_SERIALIZABLE(AsmDwarfUnionType);
21371 
21372 #ifdef DOCUMENTATION
21374 #endif // DOCUMENTATION
21375 
21376 #ifndef DOCUMENTATION
21377  AsmDwarfUnionType.setDataPrototype(
21378  "SgAsmDwarfConstructList*", "body", "= NULL",
21379  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
21380 #endif // !DOCUMENTATION
21381 
21382  DECLARE_OTHERS(AsmDwarfUnionType);
21383 #if defined(SgAsmDwarfUnionType_OTHERS) || defined(DOCUMENTATION)
21384 
21385  //----------------------- Boost serialization for SgAsmDwarfUnionType -----------------------
21386 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
21387 private:
21388  friend class boost::serialization::access;
21389 
21390  template<class S>
21391  void serialize(S &s, const unsigned /*version*/) {
21392  debugSerializationBegin("SgAsmDwarfUnionType");
21393  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
21394  s & BOOST_SERIALIZATION_NVP(p_body);
21395  debugSerializationEnd("SgAsmDwarfUnionType");
21396  }
21397 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
21398 
21399 public:
21400  SgAsmDwarfConstructList* const& get_body() const;
21401  void set_body(SgAsmDwarfConstructList* const&);
21402 public:
21403  SgAsmDwarfConstructList* get_children() override;
21404 public:
21406  virtual ~SgAsmDwarfUnionType();
21407 
21408 public:
21411 
21412 public:
21414  SgAsmDwarfUnionType(int const& nesting_level,
21415  uint64_t const& offset,
21416  uint64_t const& overall_offset);
21417 
21418 protected:
21425  void initializeProperties();
21426 #endif // SgAsmDwarfUnionType_OTHERS
21427 #ifdef DOCUMENTATION
21428 };
21429 #endif // DOCUMENTATION
21430 
21431 
21433 // SgAsmDwarfTypedef -- MACHINE GENERATED; DO NOT MODIFY --
21435 
21436 DECLARE_LEAF_CLASS(AsmDwarfTypedef);
21437 IS_SERIALIZABLE(AsmDwarfTypedef);
21438 
21439 #ifdef DOCUMENTATION
21441 #endif // DOCUMENTATION
21442 
21443  DECLARE_OTHERS(AsmDwarfTypedef);
21444 #if defined(SgAsmDwarfTypedef_OTHERS) || defined(DOCUMENTATION)
21445 
21446  //----------------------- Boost serialization for SgAsmDwarfTypedef -----------------------
21447 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
21448 private:
21449  friend class boost::serialization::access;
21450 
21451  template<class S>
21452  void serialize(S &s, const unsigned /*version*/) {
21453  debugSerializationBegin("SgAsmDwarfTypedef");
21454  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
21455  debugSerializationEnd("SgAsmDwarfTypedef");
21456  }
21457 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
21458 
21459 public:
21461  virtual ~SgAsmDwarfTypedef();
21462 
21463 public:
21466 
21467 public:
21469  SgAsmDwarfTypedef(int const& nesting_level,
21470  uint64_t const& offset,
21471  uint64_t const& overall_offset);
21472 
21473 protected:
21480  void initializeProperties();
21481 #endif // SgAsmDwarfTypedef_OTHERS
21482 #ifdef DOCUMENTATION
21483 };
21484 #endif // DOCUMENTATION
21485 
21486 
21488 // SgAsmDwarfTryBlock -- MACHINE GENERATED; DO NOT MODIFY --
21490 
21491 DECLARE_LEAF_CLASS(AsmDwarfTryBlock);
21492 IS_SERIALIZABLE(AsmDwarfTryBlock);
21493 
21494 #ifdef DOCUMENTATION
21496 #endif // DOCUMENTATION
21497 
21498  DECLARE_OTHERS(AsmDwarfTryBlock);
21499 #if defined(SgAsmDwarfTryBlock_OTHERS) || defined(DOCUMENTATION)
21500 
21501  //----------------------- Boost serialization for SgAsmDwarfTryBlock -----------------------
21502 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
21503 private:
21504  friend class boost::serialization::access;
21505 
21506  template<class S>
21507  void serialize(S &s, const unsigned /*version*/) {
21508  debugSerializationBegin("SgAsmDwarfTryBlock");
21509  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
21510  debugSerializationEnd("SgAsmDwarfTryBlock");
21511  }
21512 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
21513 
21514 public:
21516  virtual ~SgAsmDwarfTryBlock();
21517 
21518 public:
21521 
21522 public:
21524  SgAsmDwarfTryBlock(int const& nesting_level,
21525  uint64_t const& offset,
21526  uint64_t const& overall_offset);
21527 
21528 protected:
21535  void initializeProperties();
21536 #endif // SgAsmDwarfTryBlock_OTHERS
21537 #ifdef DOCUMENTATION
21538 };
21539 #endif // DOCUMENTATION
21540 
21541 
21543 // SgAsmDwarfThrownType -- MACHINE GENERATED; DO NOT MODIFY --
21545 
21546 DECLARE_LEAF_CLASS(AsmDwarfThrownType);
21547 IS_SERIALIZABLE(AsmDwarfThrownType);
21548 
21549 #ifdef DOCUMENTATION
21551 #endif // DOCUMENTATION
21552 
21553  DECLARE_OTHERS(AsmDwarfThrownType);
21554 #if defined(SgAsmDwarfThrownType_OTHERS) || defined(DOCUMENTATION)
21555 
21556  //----------------------- Boost serialization for SgAsmDwarfThrownType -----------------------
21557 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
21558 private:
21559  friend class boost::serialization::access;
21560 
21561  template<class S>
21562  void serialize(S &s, const unsigned /*version*/) {
21563  debugSerializationBegin("SgAsmDwarfThrownType");
21564  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
21565  debugSerializationEnd("SgAsmDwarfThrownType");
21566  }
21567 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
21568 
21569 public:
21571  virtual ~SgAsmDwarfThrownType();
21572 
21573 public:
21576 
21577 public:
21579  SgAsmDwarfThrownType(int const& nesting_level,
21580  uint64_t const& offset,
21581  uint64_t const& overall_offset);
21582 
21583 protected:
21590  void initializeProperties();
21591 #endif // SgAsmDwarfThrownType_OTHERS
21592 #ifdef DOCUMENTATION
21593 };
21594 #endif // DOCUMENTATION
21595 
21596 
21598 // SgAsmDwarfTemplateValueParameter -- MACHINE GENERATED; DO NOT MODIFY --
21600 
21601 DECLARE_LEAF_CLASS(AsmDwarfTemplateValueParameter);
21602 IS_SERIALIZABLE(AsmDwarfTemplateValueParameter);
21603 
21604 #ifdef DOCUMENTATION
21606 #endif // DOCUMENTATION
21607 
21608  DECLARE_OTHERS(AsmDwarfTemplateValueParameter);
21609 #if defined(SgAsmDwarfTemplateValueParameter_OTHERS) || defined(DOCUMENTATION)
21610 
21611  //----------------------- Boost serialization for SgAsmDwarfTemplateValueParameter -----------------------
21612 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
21613 private:
21614  friend class boost::serialization::access;
21615 
21616  template<class S>
21617  void serialize(S &s, const unsigned /*version*/) {
21618  debugSerializationBegin("SgAsmDwarfTemplateValueParameter");
21619  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
21620  debugSerializationEnd("SgAsmDwarfTemplateValueParameter");
21621  }
21622 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
21623 
21624 public:
21627 
21628 public:
21631 
21632 public:
21634  SgAsmDwarfTemplateValueParameter(int const& nesting_level,
21635  uint64_t const& offset,
21636  uint64_t const& overall_offset);
21637 
21638 protected:
21645  void initializeProperties();
21646 #endif // SgAsmDwarfTemplateValueParameter_OTHERS
21647 #ifdef DOCUMENTATION
21648 };
21649 #endif // DOCUMENTATION
21650 
21651 
21653 // SgAsmDwarfTemplateTypeParameter -- MACHINE GENERATED; DO NOT MODIFY --
21655 
21656 DECLARE_LEAF_CLASS(AsmDwarfTemplateTypeParameter);
21657 IS_SERIALIZABLE(AsmDwarfTemplateTypeParameter);
21658 
21659 #ifdef DOCUMENTATION
21661 #endif // DOCUMENTATION
21662 
21663  DECLARE_OTHERS(AsmDwarfTemplateTypeParameter);
21664 #if defined(SgAsmDwarfTemplateTypeParameter_OTHERS) || defined(DOCUMENTATION)
21665 
21666  //----------------------- Boost serialization for SgAsmDwarfTemplateTypeParameter -----------------------
21667 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
21668 private:
21669  friend class boost::serialization::access;
21670 
21671  template<class S>
21672  void serialize(S &s, const unsigned /*version*/) {
21673  debugSerializationBegin("SgAsmDwarfTemplateTypeParameter");
21674  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
21675  debugSerializationEnd("SgAsmDwarfTemplateTypeParameter");
21676  }
21677 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
21678 
21679 public:
21682 
21683 public:
21686 
21687 public:
21689  SgAsmDwarfTemplateTypeParameter(int const& nesting_level,
21690  uint64_t const& offset,
21691  uint64_t const& overall_offset);
21692 
21693 protected:
21700  void initializeProperties();
21701 #endif // SgAsmDwarfTemplateTypeParameter_OTHERS
21702 #ifdef DOCUMENTATION
21703 };
21704 #endif // DOCUMENTATION
21705 
21706 
21708 // SgAsmDwarfSubroutineType -- MACHINE GENERATED; DO NOT MODIFY --
21710 
21711 DECLARE_LEAF_CLASS(AsmDwarfSubroutineType);
21712 IS_SERIALIZABLE(AsmDwarfSubroutineType);
21713 
21714 #ifdef DOCUMENTATION
21716 #endif // DOCUMENTATION
21717 
21718 #ifndef DOCUMENTATION
21719  AsmDwarfSubroutineType.setDataPrototype(
21720  "SgAsmDwarfConstructList*", "body", "= nullptr",
21721  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
21722 #endif // !DOCUMENTATION
21723 
21724  DECLARE_OTHERS(AsmDwarfSubroutineType);
21725 #if defined(SgAsmDwarfSubroutineType_OTHERS) || defined(DOCUMENTATION)
21726 
21727  //----------------------- Boost serialization for SgAsmDwarfSubroutineType -----------------------
21728 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
21729 private:
21730  friend class boost::serialization::access;
21731 
21732  template<class S>
21733  void serialize(S &s, const unsigned /*version*/) {
21734  debugSerializationBegin("SgAsmDwarfSubroutineType");
21735  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
21736  s & BOOST_SERIALIZATION_NVP(p_body);
21737  debugSerializationEnd("SgAsmDwarfSubroutineType");
21738  }
21739 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
21740 
21741 public:
21742  SgAsmDwarfConstructList* const& get_body() const;
21743  void set_body(SgAsmDwarfConstructList* const&);
21744 public:
21745  SgAsmDwarfConstructList* get_children() override;
21746 public:
21748  virtual ~SgAsmDwarfSubroutineType();
21749 
21750 public:
21753 
21754 public:
21756  SgAsmDwarfSubroutineType(int const& nesting_level,
21757  uint64_t const& offset,
21758  uint64_t const& overall_offset);
21759 
21760 protected:
21767  void initializeProperties();
21768 #endif // SgAsmDwarfSubroutineType_OTHERS
21769 #ifdef DOCUMENTATION
21770 };
21771 #endif // DOCUMENTATION
21772 
21773 
21775 // SgAsmDwarfSubrangeType -- MACHINE GENERATED; DO NOT MODIFY --
21777 
21778 DECLARE_LEAF_CLASS(AsmDwarfSubrangeType);
21779 IS_SERIALIZABLE(AsmDwarfSubrangeType);
21780 
21781 #ifdef DOCUMENTATION
21783 #endif // DOCUMENTATION
21784 
21785  DECLARE_OTHERS(AsmDwarfSubrangeType);
21786 #if defined(SgAsmDwarfSubrangeType_OTHERS) || defined(DOCUMENTATION)
21787 
21788  //----------------------- Boost serialization for SgAsmDwarfSubrangeType -----------------------
21789 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
21790 private:
21791  friend class boost::serialization::access;
21792 
21793  template<class S>
21794  void serialize(S &s, const unsigned /*version*/) {
21795  debugSerializationBegin("SgAsmDwarfSubrangeType");
21796  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
21797  debugSerializationEnd("SgAsmDwarfSubrangeType");
21798  }
21799 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
21800 
21801 public:
21803  virtual ~SgAsmDwarfSubrangeType();
21804 
21805 public:
21808 
21809 public:
21811  SgAsmDwarfSubrangeType(int const& nesting_level,
21812  uint64_t const& offset,
21813  uint64_t const& overall_offset);
21814 
21815 protected:
21822  void initializeProperties();
21823 #endif // SgAsmDwarfSubrangeType_OTHERS
21824 #ifdef DOCUMENTATION
21825 };
21826 #endif // DOCUMENTATION
21827 
21828 
21830 // SgAsmDwarfSubprogram -- MACHINE GENERATED; DO NOT MODIFY --
21832 
21833 DECLARE_LEAF_CLASS(AsmDwarfSubprogram);
21834 IS_SERIALIZABLE(AsmDwarfSubprogram);
21835 
21836 #ifdef DOCUMENTATION
21838 #endif // DOCUMENTATION
21839 
21840 #ifndef DOCUMENTATION
21841  AsmDwarfSubprogram.setDataPrototype(
21842  "SgAsmDwarfConstructList*", "body", "= NULL",
21843  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
21844 #endif // !DOCUMENTATION
21845 
21846  DECLARE_OTHERS(AsmDwarfSubprogram);
21847 #if defined(SgAsmDwarfSubprogram_OTHERS) || defined(DOCUMENTATION)
21848 
21849  //----------------------- Boost serialization for SgAsmDwarfSubprogram -----------------------
21850 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
21851 private:
21852  friend class boost::serialization::access;
21853 
21854  template<class S>
21855  void serialize(S &s, const unsigned /*version*/) {
21856  debugSerializationBegin("SgAsmDwarfSubprogram");
21857  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
21858  s & BOOST_SERIALIZATION_NVP(p_body);
21859  debugSerializationEnd("SgAsmDwarfSubprogram");
21860  }
21861 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
21862 
21863 public:
21864  SgAsmDwarfConstructList* const& get_body() const;
21865  void set_body(SgAsmDwarfConstructList* const&);
21866 public:
21867  SgAsmDwarfConstructList* get_children() override;
21868 public:
21870  virtual ~SgAsmDwarfSubprogram();
21871 
21872 public:
21875 
21876 public:
21878  SgAsmDwarfSubprogram(int const& nesting_level,
21879  uint64_t const& offset,
21880  uint64_t const& overall_offset);
21881 
21882 protected:
21889  void initializeProperties();
21890 #endif // SgAsmDwarfSubprogram_OTHERS
21891 #ifdef DOCUMENTATION
21892 };
21893 #endif // DOCUMENTATION
21894 
21895 
21897 // SgAsmDwarfStructureType -- MACHINE GENERATED; DO NOT MODIFY --
21899 
21900 DECLARE_LEAF_CLASS(AsmDwarfStructureType);
21901 IS_SERIALIZABLE(AsmDwarfStructureType);
21902 
21903 #ifdef DOCUMENTATION
21905 #endif // DOCUMENTATION
21906 
21907 #ifndef DOCUMENTATION
21908  AsmDwarfStructureType.setDataPrototype(
21909  "SgAsmDwarfConstructList*", "body", "= nullptr",
21910  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
21911 #endif // !DOCUMENTATION
21912 
21913  DECLARE_OTHERS(AsmDwarfStructureType);
21914 #if defined(SgAsmDwarfStructureType_OTHERS) || defined(DOCUMENTATION)
21915 
21916  //----------------------- Boost serialization for SgAsmDwarfStructureType -----------------------
21917 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
21918 private:
21919  friend class boost::serialization::access;
21920 
21921  template<class S>
21922  void serialize(S &s, const unsigned /*version*/) {
21923  debugSerializationBegin("SgAsmDwarfStructureType");
21924  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
21925  s & BOOST_SERIALIZATION_NVP(p_body);
21926  debugSerializationEnd("SgAsmDwarfStructureType");
21927  }
21928 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
21929 
21930 public:
21931  SgAsmDwarfConstructList* const& get_body() const;
21932  void set_body(SgAsmDwarfConstructList* const&);
21933 public:
21934  SgAsmDwarfConstructList* get_children() override;
21935 public:
21937  virtual ~SgAsmDwarfStructureType();
21938 
21939 public:
21942 
21943 public:
21945  SgAsmDwarfStructureType(int const& nesting_level,
21946  uint64_t const& offset,
21947  uint64_t const& overall_offset);
21948 
21949 protected:
21956  void initializeProperties();
21957 #endif // SgAsmDwarfStructureType_OTHERS
21958 #ifdef DOCUMENTATION
21959 };
21960 #endif // DOCUMENTATION
21961 
21962 
21964 // SgAsmDwarfStringType -- MACHINE GENERATED; DO NOT MODIFY --
21966 
21967 DECLARE_LEAF_CLASS(AsmDwarfStringType);
21968 IS_SERIALIZABLE(AsmDwarfStringType);
21969 
21970 #ifdef DOCUMENTATION
21972 #endif // DOCUMENTATION
21973 
21974  DECLARE_OTHERS(AsmDwarfStringType);
21975 #if defined(SgAsmDwarfStringType_OTHERS) || defined(DOCUMENTATION)
21976 
21977  //----------------------- Boost serialization for SgAsmDwarfStringType -----------------------
21978 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
21979 private:
21980  friend class boost::serialization::access;
21981 
21982  template<class S>
21983  void serialize(S &s, const unsigned /*version*/) {
21984  debugSerializationBegin("SgAsmDwarfStringType");
21985  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
21986  debugSerializationEnd("SgAsmDwarfStringType");
21987  }
21988 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
21989 
21990 public:
21992  virtual ~SgAsmDwarfStringType();
21993 
21994 public:
21997 
21998 public:
22000  SgAsmDwarfStringType(int const& nesting_level,
22001  uint64_t const& offset,
22002  uint64_t const& overall_offset);
22003 
22004 protected:
22011  void initializeProperties();
22012 #endif // SgAsmDwarfStringType_OTHERS
22013 #ifdef DOCUMENTATION
22014 };
22015 #endif // DOCUMENTATION
22016 
22017 
22019 // SgAsmDwarfSharedType -- MACHINE GENERATED; DO NOT MODIFY --
22021 
22022 DECLARE_LEAF_CLASS(AsmDwarfSharedType);
22023 IS_SERIALIZABLE(AsmDwarfSharedType);
22024 
22025 #ifdef DOCUMENTATION
22027 #endif // DOCUMENTATION
22028 
22029  DECLARE_OTHERS(AsmDwarfSharedType);
22030 #if defined(SgAsmDwarfSharedType_OTHERS) || defined(DOCUMENTATION)
22031 
22032  //----------------------- Boost serialization for SgAsmDwarfSharedType -----------------------
22033 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
22034 private:
22035  friend class boost::serialization::access;
22036 
22037  template<class S>
22038  void serialize(S &s, const unsigned /*version*/) {
22039  debugSerializationBegin("SgAsmDwarfSharedType");
22040  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
22041  debugSerializationEnd("SgAsmDwarfSharedType");
22042  }
22043 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
22044 
22045 public:
22047  virtual ~SgAsmDwarfSharedType();
22048 
22049 public:
22052 
22053 public:
22055  SgAsmDwarfSharedType(int const& nesting_level,
22056  uint64_t const& offset,
22057  uint64_t const& overall_offset);
22058 
22059 protected:
22066  void initializeProperties();
22067 #endif // SgAsmDwarfSharedType_OTHERS
22068 #ifdef DOCUMENTATION
22069 };
22070 #endif // DOCUMENTATION
22071 
22072 
22074 // SgAsmDwarfSetType -- MACHINE GENERATED; DO NOT MODIFY --
22076 
22077 DECLARE_LEAF_CLASS(AsmDwarfSetType);
22078 IS_SERIALIZABLE(AsmDwarfSetType);
22079 
22080 #ifdef DOCUMENTATION
22082 #endif // DOCUMENTATION
22083 
22084  DECLARE_OTHERS(AsmDwarfSetType);
22085 #if defined(SgAsmDwarfSetType_OTHERS) || defined(DOCUMENTATION)
22086 
22087  //----------------------- Boost serialization for SgAsmDwarfSetType -----------------------
22088 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
22089 private:
22090  friend class boost::serialization::access;
22091 
22092  template<class S>
22093  void serialize(S &s, const unsigned /*version*/) {
22094  debugSerializationBegin("SgAsmDwarfSetType");
22095  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
22096  debugSerializationEnd("SgAsmDwarfSetType");
22097  }
22098 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
22099 
22100 public:
22102  virtual ~SgAsmDwarfSetType();
22103 
22104 public:
22107 
22108 public:
22110  SgAsmDwarfSetType(int const& nesting_level,
22111  uint64_t const& offset,
22112  uint64_t const& overall_offset);
22113 
22114 protected:
22121  void initializeProperties();
22122 #endif // SgAsmDwarfSetType_OTHERS
22123 #ifdef DOCUMENTATION
22124 };
22125 #endif // DOCUMENTATION
22126 
22127 
22129 // SgAsmDwarfRestrictType -- MACHINE GENERATED; DO NOT MODIFY --
22131 
22132 DECLARE_LEAF_CLASS(AsmDwarfRestrictType);
22133 IS_SERIALIZABLE(AsmDwarfRestrictType);
22134 
22135 #ifdef DOCUMENTATION
22137 #endif // DOCUMENTATION
22138 
22139  DECLARE_OTHERS(AsmDwarfRestrictType);
22140 #if defined(SgAsmDwarfRestrictType_OTHERS) || defined(DOCUMENTATION)
22141 
22142  //----------------------- Boost serialization for SgAsmDwarfRestrictType -----------------------
22143 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
22144 private:
22145  friend class boost::serialization::access;
22146 
22147  template<class S>
22148  void serialize(S &s, const unsigned /*version*/) {
22149  debugSerializationBegin("SgAsmDwarfRestrictType");
22150  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
22151  debugSerializationEnd("SgAsmDwarfRestrictType");
22152  }
22153 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
22154 
22155 public:
22157  virtual ~SgAsmDwarfRestrictType();
22158 
22159 public:
22162 
22163 public:
22165  SgAsmDwarfRestrictType(int const& nesting_level,
22166  uint64_t const& offset,
22167  uint64_t const& overall_offset);
22168 
22169 protected:
22176  void initializeProperties();
22177 #endif // SgAsmDwarfRestrictType_OTHERS
22178 #ifdef DOCUMENTATION
22179 };
22180 #endif // DOCUMENTATION
22181 
22182 
22184 // SgAsmDwarfReferenceType -- MACHINE GENERATED; DO NOT MODIFY --
22186 
22187 DECLARE_LEAF_CLASS(AsmDwarfReferenceType);
22188 IS_SERIALIZABLE(AsmDwarfReferenceType);
22189 
22190 #ifdef DOCUMENTATION
22192 #endif // DOCUMENTATION
22193 
22194  DECLARE_OTHERS(AsmDwarfReferenceType);
22195 #if defined(SgAsmDwarfReferenceType_OTHERS) || defined(DOCUMENTATION)
22196 
22197  //----------------------- Boost serialization for SgAsmDwarfReferenceType -----------------------
22198 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
22199 private:
22200  friend class boost::serialization::access;
22201 
22202  template<class S>
22203  void serialize(S &s, const unsigned /*version*/) {
22204  debugSerializationBegin("SgAsmDwarfReferenceType");
22205  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
22206  debugSerializationEnd("SgAsmDwarfReferenceType");
22207  }
22208 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
22209 
22210 public:
22212  virtual ~SgAsmDwarfReferenceType();
22213 
22214 public:
22217 
22218 public:
22220  SgAsmDwarfReferenceType(int const& nesting_level,
22221  uint64_t const& offset,
22222  uint64_t const& overall_offset);
22223 
22224 protected:
22231  void initializeProperties();
22232 #endif // SgAsmDwarfReferenceType_OTHERS
22233 #ifdef DOCUMENTATION
22234 };
22235 #endif // DOCUMENTATION
22236 
22237 
22239 // SgAsmDwarfPtrToMemberType -- MACHINE GENERATED; DO NOT MODIFY --
22241 
22242 DECLARE_LEAF_CLASS(AsmDwarfPtrToMemberType);
22243 IS_SERIALIZABLE(AsmDwarfPtrToMemberType);
22244 
22245 #ifdef DOCUMENTATION
22247 #endif // DOCUMENTATION
22248 
22249  DECLARE_OTHERS(AsmDwarfPtrToMemberType);
22250 #if defined(SgAsmDwarfPtrToMemberType_OTHERS) || defined(DOCUMENTATION)
22251 
22252  //----------------------- Boost serialization for SgAsmDwarfPtrToMemberType -----------------------
22253 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
22254 private:
22255  friend class boost::serialization::access;
22256 
22257  template<class S>
22258  void serialize(S &s, const unsigned /*version*/) {
22259  debugSerializationBegin("SgAsmDwarfPtrToMemberType");
22260  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
22261  debugSerializationEnd("SgAsmDwarfPtrToMemberType");
22262  }
22263 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
22264 
22265 public:
22267  virtual ~SgAsmDwarfPtrToMemberType();
22268 
22269 public:
22272 
22273 public:
22275  SgAsmDwarfPtrToMemberType(int const& nesting_level,
22276  uint64_t const& offset,
22277  uint64_t const& overall_offset);
22278 
22279 protected:
22286  void initializeProperties();
22287 #endif // SgAsmDwarfPtrToMemberType_OTHERS
22288 #ifdef DOCUMENTATION
22289 };
22290 #endif // DOCUMENTATION
22291 
22292 
22294 // SgAsmDwarfPointerType -- MACHINE GENERATED; DO NOT MODIFY --
22296 
22297 DECLARE_LEAF_CLASS(AsmDwarfPointerType);
22298 IS_SERIALIZABLE(AsmDwarfPointerType);
22299 
22300 #ifdef DOCUMENTATION
22302 #endif // DOCUMENTATION
22303 
22304  DECLARE_OTHERS(AsmDwarfPointerType);
22305 #if defined(SgAsmDwarfPointerType_OTHERS) || defined(DOCUMENTATION)
22306 
22307  //----------------------- Boost serialization for SgAsmDwarfPointerType -----------------------
22308 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
22309 private:
22310  friend class boost::serialization::access;
22311 
22312  template<class S>
22313  void serialize(S &s, const unsigned /*version*/) {
22314  debugSerializationBegin("SgAsmDwarfPointerType");
22315  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
22316  debugSerializationEnd("SgAsmDwarfPointerType");
22317  }
22318 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
22319 
22320 public:
22322  virtual ~SgAsmDwarfPointerType();
22323 
22324 public:
22327 
22328 public:
22330  SgAsmDwarfPointerType(int const& nesting_level,
22331  uint64_t const& offset,
22332  uint64_t const& overall_offset);
22333 
22334 protected:
22341  void initializeProperties();
22342 #endif // SgAsmDwarfPointerType_OTHERS
22343 #ifdef DOCUMENTATION
22344 };
22345 #endif // DOCUMENTATION
22346 
22347 
22349 // SgAsmDwarfPartialUnit -- MACHINE GENERATED; DO NOT MODIFY --
22351 
22352 DECLARE_LEAF_CLASS(AsmDwarfPartialUnit);
22353 IS_SERIALIZABLE(AsmDwarfPartialUnit);
22354 
22355 #ifdef DOCUMENTATION
22357 #endif // DOCUMENTATION
22358 
22359  DECLARE_OTHERS(AsmDwarfPartialUnit);
22360 #if defined(SgAsmDwarfPartialUnit_OTHERS) || defined(DOCUMENTATION)
22361 
22362  //----------------------- Boost serialization for SgAsmDwarfPartialUnit -----------------------
22363 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
22364 private:
22365  friend class boost::serialization::access;
22366 
22367  template<class S>
22368  void serialize(S &s, const unsigned /*version*/) {
22369  debugSerializationBegin("SgAsmDwarfPartialUnit");
22370  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
22371  debugSerializationEnd("SgAsmDwarfPartialUnit");
22372  }
22373 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
22374 
22375 public:
22377  virtual ~SgAsmDwarfPartialUnit();
22378 
22379 public:
22382 
22383 public:
22385  SgAsmDwarfPartialUnit(int const& nesting_level,
22386  uint64_t const& offset,
22387  uint64_t const& overall_offset);
22388 
22389 protected:
22396  void initializeProperties();
22397 #endif // SgAsmDwarfPartialUnit_OTHERS
22398 #ifdef DOCUMENTATION
22399 };
22400 #endif // DOCUMENTATION
22401 
22402 
22404 // SgAsmDwarfPackedType -- MACHINE GENERATED; DO NOT MODIFY --
22406 
22407 DECLARE_LEAF_CLASS(AsmDwarfPackedType);
22408 IS_SERIALIZABLE(AsmDwarfPackedType);
22409 
22410 #ifdef DOCUMENTATION
22412 #endif // DOCUMENTATION
22413 
22414  DECLARE_OTHERS(AsmDwarfPackedType);
22415 #if defined(SgAsmDwarfPackedType_OTHERS) || defined(DOCUMENTATION)
22416 
22417  //----------------------- Boost serialization for SgAsmDwarfPackedType -----------------------
22418 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
22419 private:
22420  friend class boost::serialization::access;
22421 
22422  template<class S>
22423  void serialize(S &s, const unsigned /*version*/) {
22424  debugSerializationBegin("SgAsmDwarfPackedType");
22425  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
22426  debugSerializationEnd("SgAsmDwarfPackedType");
22427  }
22428 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
22429 
22430 public:
22432  virtual ~SgAsmDwarfPackedType();
22433 
22434 public:
22437 
22438 public:
22440  SgAsmDwarfPackedType(int const& nesting_level,
22441  uint64_t const& offset,
22442  uint64_t const& overall_offset);
22443 
22444 protected:
22451  void initializeProperties();
22452 #endif // SgAsmDwarfPackedType_OTHERS
22453 #ifdef DOCUMENTATION
22454 };
22455 #endif // DOCUMENTATION
22456 
22457 
22459 // SgAsmDwarfNamespace -- MACHINE GENERATED; DO NOT MODIFY --
22461 
22462 DECLARE_LEAF_CLASS(AsmDwarfNamespace);
22463 IS_SERIALIZABLE(AsmDwarfNamespace);
22464 
22465 #ifdef DOCUMENTATION
22467 #endif // DOCUMENTATION
22468 
22469 #ifndef DOCUMENTATION
22470  AsmDwarfNamespace.setDataPrototype(
22471  "SgAsmDwarfConstructList*", "body", "= NULL",
22472  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
22473 #endif // !DOCUMENTATION
22474 
22475  DECLARE_OTHERS(AsmDwarfNamespace);
22476 #if defined(SgAsmDwarfNamespace_OTHERS) || defined(DOCUMENTATION)
22477 
22478  //----------------------- Boost serialization for SgAsmDwarfNamespace -----------------------
22479 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
22480 private:
22481  friend class boost::serialization::access;
22482 
22483  template<class S>
22484  void serialize(S &s, const unsigned /*version*/) {
22485  debugSerializationBegin("SgAsmDwarfNamespace");
22486  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
22487  s & BOOST_SERIALIZATION_NVP(p_body);
22488  debugSerializationEnd("SgAsmDwarfNamespace");
22489  }
22490 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
22491 
22492 public:
22493  SgAsmDwarfConstructList* const& get_body() const;
22494  void set_body(SgAsmDwarfConstructList* const&);
22495 public:
22496  SgAsmDwarfConstructList* get_children() override;
22497 public:
22499  virtual ~SgAsmDwarfNamespace();
22500 
22501 public:
22504 
22505 public:
22507  SgAsmDwarfNamespace(int const& nesting_level,
22508  uint64_t const& offset,
22509  uint64_t const& overall_offset);
22510 
22511 protected:
22518  void initializeProperties();
22519 #endif // SgAsmDwarfNamespace_OTHERS
22520 #ifdef DOCUMENTATION
22521 };
22522 #endif // DOCUMENTATION
22523 
22524 
22526 // SgAsmDwarfNamelistItem -- MACHINE GENERATED; DO NOT MODIFY --
22528 
22529 DECLARE_LEAF_CLASS(AsmDwarfNamelistItem);
22530 IS_SERIALIZABLE(AsmDwarfNamelistItem);
22531 
22532 #ifdef DOCUMENTATION
22534 #endif // DOCUMENTATION
22535 
22536  DECLARE_OTHERS(AsmDwarfNamelistItem);
22537 #if defined(SgAsmDwarfNamelistItem_OTHERS) || defined(DOCUMENTATION)
22538 
22539  //----------------------- Boost serialization for SgAsmDwarfNamelistItem -----------------------
22540 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
22541 private:
22542  friend class boost::serialization::access;
22543 
22544  template<class S>
22545  void serialize(S &s, const unsigned /*version*/) {
22546  debugSerializationBegin("SgAsmDwarfNamelistItem");
22547  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
22548  debugSerializationEnd("SgAsmDwarfNamelistItem");
22549  }
22550 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
22551 
22552 public:
22554  virtual ~SgAsmDwarfNamelistItem();
22555 
22556 public:
22559 
22560 public:
22562  SgAsmDwarfNamelistItem(int const& nesting_level,
22563  uint64_t const& offset,
22564  uint64_t const& overall_offset);
22565 
22566 protected:
22573  void initializeProperties();
22574 #endif // SgAsmDwarfNamelistItem_OTHERS
22575 #ifdef DOCUMENTATION
22576 };
22577 #endif // DOCUMENTATION
22578 
22579 
22581 // SgAsmDwarfNamelist -- MACHINE GENERATED; DO NOT MODIFY --
22583 
22584 DECLARE_LEAF_CLASS(AsmDwarfNamelist);
22585 IS_SERIALIZABLE(AsmDwarfNamelist);
22586 
22587 #ifdef DOCUMENTATION
22589 #endif // DOCUMENTATION
22590 
22591  DECLARE_OTHERS(AsmDwarfNamelist);
22592 #if defined(SgAsmDwarfNamelist_OTHERS) || defined(DOCUMENTATION)
22593 
22594  //----------------------- Boost serialization for SgAsmDwarfNamelist -----------------------
22595 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
22596 private:
22597  friend class boost::serialization::access;
22598 
22599  template<class S>
22600  void serialize(S &s, const unsigned /*version*/) {
22601  debugSerializationBegin("SgAsmDwarfNamelist");
22602  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
22603  debugSerializationEnd("SgAsmDwarfNamelist");
22604  }
22605 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
22606 
22607 public:
22609  virtual ~SgAsmDwarfNamelist();
22610 
22611 public:
22614 
22615 public:
22617  SgAsmDwarfNamelist(int const& nesting_level,
22618  uint64_t const& offset,
22619  uint64_t const& overall_offset);
22620 
22621 protected:
22628  void initializeProperties();
22629 #endif // SgAsmDwarfNamelist_OTHERS
22630 #ifdef DOCUMENTATION
22631 };
22632 #endif // DOCUMENTATION
22633 
22634 
22636 // SgAsmDwarfMutableType -- MACHINE GENERATED; DO NOT MODIFY --
22638 
22639 DECLARE_LEAF_CLASS(AsmDwarfMutableType);
22640 IS_SERIALIZABLE(AsmDwarfMutableType);
22641 
22642 #ifdef DOCUMENTATION
22644 #endif // DOCUMENTATION
22645 
22646  DECLARE_OTHERS(AsmDwarfMutableType);
22647 #if defined(SgAsmDwarfMutableType_OTHERS) || defined(DOCUMENTATION)
22648 
22649  //----------------------- Boost serialization for SgAsmDwarfMutableType -----------------------
22650 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
22651 private:
22652  friend class boost::serialization::access;
22653 
22654  template<class S>
22655  void serialize(S &s, const unsigned /*version*/) {
22656  debugSerializationBegin("SgAsmDwarfMutableType");
22657  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
22658  debugSerializationEnd("SgAsmDwarfMutableType");
22659  }
22660 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
22661 
22662 public:
22664  virtual ~SgAsmDwarfMutableType();
22665 
22666 public:
22669 
22670 public:
22672  SgAsmDwarfMutableType(int const& nesting_level,
22673  uint64_t const& offset,
22674  uint64_t const& overall_offset);
22675 
22676 protected:
22683  void initializeProperties();
22684 #endif // SgAsmDwarfMutableType_OTHERS
22685 #ifdef DOCUMENTATION
22686 };
22687 #endif // DOCUMENTATION
22688 
22689 
22691 // SgAsmDwarfModule -- MACHINE GENERATED; DO NOT MODIFY --
22693 
22694 DECLARE_LEAF_CLASS(AsmDwarfModule);
22695 IS_SERIALIZABLE(AsmDwarfModule);
22696 
22697 #ifdef DOCUMENTATION
22699 #endif // DOCUMENTATION
22700 
22701  DECLARE_OTHERS(AsmDwarfModule);
22702 #if defined(SgAsmDwarfModule_OTHERS) || defined(DOCUMENTATION)
22703 
22704  //----------------------- Boost serialization for SgAsmDwarfModule -----------------------
22705 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
22706 private:
22707  friend class boost::serialization::access;
22708 
22709  template<class S>
22710  void serialize(S &s, const unsigned /*version*/) {
22711  debugSerializationBegin("SgAsmDwarfModule");
22712  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
22713  debugSerializationEnd("SgAsmDwarfModule");
22714  }
22715 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
22716 
22717 public:
22719  virtual ~SgAsmDwarfModule();
22720 
22721 public:
22723  SgAsmDwarfModule();
22724 
22725 public:
22727  SgAsmDwarfModule(int const& nesting_level,
22728  uint64_t const& offset,
22729  uint64_t const& overall_offset);
22730 
22731 protected:
22738  void initializeProperties();
22739 #endif // SgAsmDwarfModule_OTHERS
22740 #ifdef DOCUMENTATION
22741 };
22742 #endif // DOCUMENTATION
22743 
22744 
22746 // SgAsmDwarfMember -- MACHINE GENERATED; DO NOT MODIFY --
22748 
22749 DECLARE_LEAF_CLASS(AsmDwarfMember);
22750 IS_SERIALIZABLE(AsmDwarfMember);
22751 
22752 #ifdef DOCUMENTATION
22754 #endif // DOCUMENTATION
22755 
22756  DECLARE_OTHERS(AsmDwarfMember);
22757 #if defined(SgAsmDwarfMember_OTHERS) || defined(DOCUMENTATION)
22758 
22759  //----------------------- Boost serialization for SgAsmDwarfMember -----------------------
22760 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
22761 private:
22762  friend class boost::serialization::access;
22763 
22764  template<class S>
22765  void serialize(S &s, const unsigned /*version*/) {
22766  debugSerializationBegin("SgAsmDwarfMember");
22767  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
22768  debugSerializationEnd("SgAsmDwarfMember");
22769  }
22770 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
22771 
22772 public:
22774  virtual ~SgAsmDwarfMember();
22775 
22776 public:
22778  SgAsmDwarfMember();
22779 
22780 public:
22782  SgAsmDwarfMember(int const& nesting_level,
22783  uint64_t const& offset,
22784  uint64_t const& overall_offset);
22785 
22786 protected:
22793  void initializeProperties();
22794 #endif // SgAsmDwarfMember_OTHERS
22795 #ifdef DOCUMENTATION
22796 };
22797 #endif // DOCUMENTATION
22798 
22799 
22801 // SgAsmDwarfMacroList -- MACHINE GENERATED; DO NOT MODIFY --
22803 
22804 DECLARE_LEAF_CLASS(AsmDwarfMacroList);
22805 IS_SERIALIZABLE(AsmDwarfMacroList);
22806 
22807 #ifdef DOCUMENTATION
22809 #endif // DOCUMENTATION
22810 
22811 #ifndef DOCUMENTATION
22812  AsmDwarfMacroList.setDataPrototype(
22813  "SgAsmDwarfMacroPtrList", "macro_list", "",
22814  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
22815 #endif // !DOCUMENTATION
22816 
22817  DECLARE_OTHERS(AsmDwarfMacroList);
22818 #if defined(SgAsmDwarfMacroList_OTHERS) || defined(DOCUMENTATION)
22819 
22820  //----------------------- Boost serialization for SgAsmDwarfMacroList -----------------------
22821 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
22822 private:
22823  friend class boost::serialization::access;
22824 
22825  template<class S>
22826  void serialize(S &s, const unsigned /*version*/) {
22827  debugSerializationBegin("SgAsmDwarfMacroList");
22828  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfInformation);
22829  s & BOOST_SERIALIZATION_NVP(p_macro_list);
22830  debugSerializationEnd("SgAsmDwarfMacroList");
22831  }
22832 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
22833 
22834 public:
22835  SgAsmDwarfMacroPtrList const& get_macro_list() const;
22836  void set_macro_list(SgAsmDwarfMacroPtrList const&);
22837 
22838 public:
22840  virtual ~SgAsmDwarfMacroList();
22841 
22842 public:
22845 
22846 protected:
22853  void initializeProperties();
22854 #endif // SgAsmDwarfMacroList_OTHERS
22855 #ifdef DOCUMENTATION
22856 };
22857 #endif // DOCUMENTATION
22858 
22859 
22861 // SgAsmDwarfMacro -- MACHINE GENERATED; DO NOT MODIFY --
22863 
22864 DECLARE_LEAF_CLASS(AsmDwarfMacro);
22865 IS_SERIALIZABLE(AsmDwarfMacro);
22866 
22867 #ifdef DOCUMENTATION
22869 #endif // DOCUMENTATION
22870 
22871 #ifndef DOCUMENTATION
22872  AsmDwarfMacro.setDataPrototype(
22873  "std::string", "macro_string", "",
22874  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
22875 #endif // !DOCUMENTATION
22876 
22877  DECLARE_OTHERS(AsmDwarfMacro);
22878 #if defined(SgAsmDwarfMacro_OTHERS) || defined(DOCUMENTATION)
22879 
22880  //----------------------- Boost serialization for SgAsmDwarfMacro -----------------------
22881 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
22882 private:
22883  friend class boost::serialization::access;
22884 
22885  template<class S>
22886  void serialize(S &s, const unsigned /*version*/) {
22887  debugSerializationBegin("SgAsmDwarfMacro");
22888  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfInformation);
22889  s & BOOST_SERIALIZATION_NVP(p_macro_string);
22890  debugSerializationEnd("SgAsmDwarfMacro");
22891  }
22892 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
22893 
22894 public:
22895  std::string const& get_macro_string() const;
22896  void set_macro_string(std::string const&);
22897 
22898 public:
22900  virtual ~SgAsmDwarfMacro();
22901 
22902 public:
22904  SgAsmDwarfMacro();
22905 
22906 protected:
22913  void initializeProperties();
22914 #endif // SgAsmDwarfMacro_OTHERS
22915 #ifdef DOCUMENTATION
22916 };
22917 #endif // DOCUMENTATION
22918 
22919 
22921 // SgAsmDwarfLineList -- MACHINE GENERATED; DO NOT MODIFY --
22923 
22924 DECLARE_LEAF_CLASS(AsmDwarfLineList);
22925 IS_SERIALIZABLE(AsmDwarfLineList);
22926 
22927 #ifdef DOCUMENTATION
22929 #endif // DOCUMENTATION
22930 
22931 #ifndef DOCUMENTATION
22932  AsmDwarfLineList.setDataPrototype(
22933  "SgAsmDwarfLinePtrList", "line_list", "",
22934  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
22935 #endif // !DOCUMENTATION
22936 
22937  DECLARE_OTHERS(AsmDwarfLineList);
22938 #if defined(SgAsmDwarfLineList_OTHERS) || defined(DOCUMENTATION)
22939 
22940  //----------------------- Boost serialization for SgAsmDwarfLineList -----------------------
22941 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
22942 private:
22943  friend class boost::serialization::access;
22944 
22945  template<class S>
22946  void serialize(S &s, const unsigned /*version*/) {
22947  debugSerializationBegin("SgAsmDwarfLineList");
22948  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfInformation);
22949  s & BOOST_SERIALIZATION_NVP(p_line_list);
22950  debugSerializationEnd("SgAsmDwarfLineList");
22951  }
22952 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
22953 
22954 public:
22955  SgAsmDwarfLinePtrList const& get_line_list() const;
22956  SgAsmDwarfLinePtrList& get_line_list();
22957  void set_line_list(SgAsmDwarfLinePtrList const&);
22958 #if 0
22959  // I [DQ] am having trouble making these proper data members so just use function to return them, so that they are
22960  // computed dynamically.
22961  AsmDwarfLineList.setDataPrototype("SgInstructionAddressSourcePositionMapPtrList", "instructionToSourceMap", "",
22962  NO_CONSTRUCTOR_PARAMETER, BUILD_LIST_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
22963  AsmDwarfLineList.setDataPrototype("SgSourcePositionInstructionAddressMapPtrList", "sourceToInstructionMap", "",
22964  NO_CONSTRUCTOR_PARAMETER, BUILD_LIST_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
22965 #endif
22966 
22967 public:
22968  // Once the maps are setup using a valid SgAsmDwarfCompilationUnit, NULL is an acceptable value.
22970  static DwarfInstructionSourceMapReturnType buildInstructionAddressSourcePositionMaps( SgAsmDwarfCompilationUnit* dwarf_cu = NULL );
22971 
22973  void display( const std::string & label );
22974 
22975  static std::pair<uint64_t,uint64_t> instructionRange();
22976  static std::pair<LineColumnFilePosition,LineColumnFilePosition> sourceCodeRange( int file_id );
22977 
22978  static uint64_t sourceCodeToAddress ( FileIdLineColumnFilePosition sourcePosition );
22979  static FileIdLineColumnFilePosition addressToSourceCode ( uint64_t address );
22980 public:
22982  virtual ~SgAsmDwarfLineList();
22983 
22984 public:
22987 
22988 protected:
22995  void initializeProperties();
22996 #endif // SgAsmDwarfLineList_OTHERS
22997 #ifdef DOCUMENTATION
22998 };
22999 #endif // DOCUMENTATION
23000 
23001 
23003 // SgAsmDwarfLine -- MACHINE GENERATED; DO NOT MODIFY --
23005 
23006 DECLARE_LEAF_CLASS(AsmDwarfLine);
23007 IS_SERIALIZABLE(AsmDwarfLine);
23008 
23009 #ifdef DOCUMENTATION
23011 #endif // DOCUMENTATION
23012 
23013 #ifndef DOCUMENTATION
23014  AsmDwarfLine.setDataPrototype(
23015  "uint64_t", "address", "= 0",
23016  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
23017 #endif // !DOCUMENTATION
23018 
23019 #ifndef DOCUMENTATION
23020  AsmDwarfLine.setDataPrototype(
23021  "int", "file_id", "= Sg_File_Info::NULL_FILE_ID",
23022  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
23023 #endif // !DOCUMENTATION
23024 
23025 #ifndef DOCUMENTATION
23026  AsmDwarfLine.setDataPrototype(
23027  "int", "line", "= 0",
23028  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
23029 #endif // !DOCUMENTATION
23030 
23031 #ifndef DOCUMENTATION
23032  AsmDwarfLine.setDataPrototype(
23033  "int", "column", "= 0",
23034  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
23035 #endif // !DOCUMENTATION
23036 
23037  DECLARE_OTHERS(AsmDwarfLine);
23038 #if defined(SgAsmDwarfLine_OTHERS) || defined(DOCUMENTATION)
23039 
23040  //----------------------- Boost serialization for SgAsmDwarfLine -----------------------
23041 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
23042 private:
23043  friend class boost::serialization::access;
23044 
23045  template<class S>
23046  void serialize(S &s, const unsigned /*version*/) {
23047  debugSerializationBegin("SgAsmDwarfLine");
23048  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfInformation);
23049  s & BOOST_SERIALIZATION_NVP(p_address);
23050  s & BOOST_SERIALIZATION_NVP(p_file_id);
23051  s & BOOST_SERIALIZATION_NVP(p_line);
23052  s & BOOST_SERIALIZATION_NVP(p_column);
23053  debugSerializationEnd("SgAsmDwarfLine");
23054  }
23055 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
23056 
23057 public:
23058  uint64_t const& get_address() const;
23059  void set_address(uint64_t const&);
23060 
23061 public:
23062  int const& get_file_id() const;
23063  void set_file_id(int const&);
23064 
23065 public:
23066  int const& get_line() const;
23067  void set_line(int const&);
23068 
23069 public:
23070  int const& get_column() const;
23071  void set_column(int const&);
23072 
23073 public:
23075  virtual ~SgAsmDwarfLine();
23076 
23077 public:
23079  SgAsmDwarfLine();
23080 
23081 public:
23083  SgAsmDwarfLine(uint64_t const& address,
23084  int const& file_id,
23085  int const& line,
23086  int const& column);
23087 
23088 protected:
23095  void initializeProperties();
23096 #endif // SgAsmDwarfLine_OTHERS
23097 #ifdef DOCUMENTATION
23098 };
23099 #endif // DOCUMENTATION
23100 
23101 
23103 // SgAsmDwarfLexicalBlock -- MACHINE GENERATED; DO NOT MODIFY --
23105 
23106 DECLARE_LEAF_CLASS(AsmDwarfLexicalBlock);
23107 IS_SERIALIZABLE(AsmDwarfLexicalBlock);
23108 
23109 #ifdef DOCUMENTATION
23111 #endif // DOCUMENTATION
23112 
23113 #ifndef DOCUMENTATION
23114  AsmDwarfLexicalBlock.setDataPrototype(
23115  "SgAsmDwarfConstructList*", "body", "= nullptr",
23116  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
23117 #endif // !DOCUMENTATION
23118 
23119  DECLARE_OTHERS(AsmDwarfLexicalBlock);
23120 #if defined(SgAsmDwarfLexicalBlock_OTHERS) || defined(DOCUMENTATION)
23121 
23122  //----------------------- Boost serialization for SgAsmDwarfLexicalBlock -----------------------
23123 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
23124 private:
23125  friend class boost::serialization::access;
23126 
23127  template<class S>
23128  void serialize(S &s, const unsigned /*version*/) {
23129  debugSerializationBegin("SgAsmDwarfLexicalBlock");
23130  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
23131  s & BOOST_SERIALIZATION_NVP(p_body);
23132  debugSerializationEnd("SgAsmDwarfLexicalBlock");
23133  }
23134 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
23135 
23136 public:
23137  SgAsmDwarfConstructList* const& get_body() const;
23138  void set_body(SgAsmDwarfConstructList* const&);
23139 public:
23140  SgAsmDwarfConstructList* get_children() override;
23141 public:
23143  virtual ~SgAsmDwarfLexicalBlock();
23144 
23145 public:
23148 
23149 public:
23151  SgAsmDwarfLexicalBlock(int const& nesting_level,
23152  uint64_t const& offset,
23153  uint64_t const& overall_offset);
23154 
23155 protected:
23162  void initializeProperties();
23163 #endif // SgAsmDwarfLexicalBlock_OTHERS
23164 #ifdef DOCUMENTATION
23165 };
23166 #endif // DOCUMENTATION
23167 
23168 
23170 // SgAsmDwarfLabel -- MACHINE GENERATED; DO NOT MODIFY --
23172 
23173 DECLARE_LEAF_CLASS(AsmDwarfLabel);
23174 IS_SERIALIZABLE(AsmDwarfLabel);
23175 
23176 #ifdef DOCUMENTATION
23178 #endif // DOCUMENTATION
23179 
23180  DECLARE_OTHERS(AsmDwarfLabel);
23181 #if defined(SgAsmDwarfLabel_OTHERS) || defined(DOCUMENTATION)
23182 
23183  //----------------------- Boost serialization for SgAsmDwarfLabel -----------------------
23184 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
23185 private:
23186  friend class boost::serialization::access;
23187 
23188  template<class S>
23189  void serialize(S &s, const unsigned /*version*/) {
23190  debugSerializationBegin("SgAsmDwarfLabel");
23191  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
23192  debugSerializationEnd("SgAsmDwarfLabel");
23193  }
23194 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
23195 
23196 public:
23198  virtual ~SgAsmDwarfLabel();
23199 
23200 public:
23202  SgAsmDwarfLabel();
23203 
23204 public:
23206  SgAsmDwarfLabel(int const& nesting_level,
23207  uint64_t const& offset,
23208  uint64_t const& overall_offset);
23209 
23210 protected:
23217  void initializeProperties();
23218 #endif // SgAsmDwarfLabel_OTHERS
23219 #ifdef DOCUMENTATION
23220 };
23221 #endif // DOCUMENTATION
23222 
23223 
23225 // SgAsmDwarfInterfaceType -- MACHINE GENERATED; DO NOT MODIFY --
23227 
23228 DECLARE_LEAF_CLASS(AsmDwarfInterfaceType);
23229 IS_SERIALIZABLE(AsmDwarfInterfaceType);
23230 
23231 #ifdef DOCUMENTATION
23233 #endif // DOCUMENTATION
23234 
23235  DECLARE_OTHERS(AsmDwarfInterfaceType);
23236 #if defined(SgAsmDwarfInterfaceType_OTHERS) || defined(DOCUMENTATION)
23237 
23238  //----------------------- Boost serialization for SgAsmDwarfInterfaceType -----------------------
23239 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
23240 private:
23241  friend class boost::serialization::access;
23242 
23243  template<class S>
23244  void serialize(S &s, const unsigned /*version*/) {
23245  debugSerializationBegin("SgAsmDwarfInterfaceType");
23246  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
23247  debugSerializationEnd("SgAsmDwarfInterfaceType");
23248  }
23249 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
23250 
23251 public:
23253  virtual ~SgAsmDwarfInterfaceType();
23254 
23255 public:
23258 
23259 public:
23261  SgAsmDwarfInterfaceType(int const& nesting_level,
23262  uint64_t const& offset,
23263  uint64_t const& overall_offset);
23264 
23265 protected:
23272  void initializeProperties();
23273 #endif // SgAsmDwarfInterfaceType_OTHERS
23274 #ifdef DOCUMENTATION
23275 };
23276 #endif // DOCUMENTATION
23277 
23278 
23280 // SgAsmDwarfInlinedSubroutine -- MACHINE GENERATED; DO NOT MODIFY --
23282 
23283 DECLARE_LEAF_CLASS(AsmDwarfInlinedSubroutine);
23284 IS_SERIALIZABLE(AsmDwarfInlinedSubroutine);
23285 
23286 #ifdef DOCUMENTATION
23288 #endif // DOCUMENTATION
23289 
23290 #ifndef DOCUMENTATION
23291  AsmDwarfInlinedSubroutine.setDataPrototype(
23292  "SgAsmDwarfConstructList*", "body", "= nullptr",
23293  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
23294 #endif // !DOCUMENTATION
23295 
23296  DECLARE_OTHERS(AsmDwarfInlinedSubroutine);
23297 #if defined(SgAsmDwarfInlinedSubroutine_OTHERS) || defined(DOCUMENTATION)
23298 
23299  //----------------------- Boost serialization for SgAsmDwarfInlinedSubroutine -----------------------
23300 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
23301 private:
23302  friend class boost::serialization::access;
23303 
23304  template<class S>
23305  void serialize(S &s, const unsigned /*version*/) {
23306  debugSerializationBegin("SgAsmDwarfInlinedSubroutine");
23307  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
23308  s & BOOST_SERIALIZATION_NVP(p_body);
23309  debugSerializationEnd("SgAsmDwarfInlinedSubroutine");
23310  }
23311 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
23312 
23313 public:
23314  SgAsmDwarfConstructList* const& get_body() const;
23315  void set_body(SgAsmDwarfConstructList* const&);
23316 public:
23317  SgAsmDwarfConstructList* get_children() override;
23318 public:
23320  virtual ~SgAsmDwarfInlinedSubroutine();
23321 
23322 public:
23325 
23326 public:
23328  SgAsmDwarfInlinedSubroutine(int const& nesting_level,
23329  uint64_t const& offset,
23330  uint64_t const& overall_offset);
23331 
23332 protected:
23339  void initializeProperties();
23340 #endif // SgAsmDwarfInlinedSubroutine_OTHERS
23341 #ifdef DOCUMENTATION
23342 };
23343 #endif // DOCUMENTATION
23344 
23345 
23347 // SgAsmDwarfInheritance -- MACHINE GENERATED; DO NOT MODIFY --
23349 
23350 DECLARE_LEAF_CLASS(AsmDwarfInheritance);
23351 IS_SERIALIZABLE(AsmDwarfInheritance);
23352 
23353 #ifdef DOCUMENTATION
23355 #endif // DOCUMENTATION
23356 
23357  DECLARE_OTHERS(AsmDwarfInheritance);
23358 #if defined(SgAsmDwarfInheritance_OTHERS) || defined(DOCUMENTATION)
23359 
23360  //----------------------- Boost serialization for SgAsmDwarfInheritance -----------------------
23361 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
23362 private:
23363  friend class boost::serialization::access;
23364 
23365  template<class S>
23366  void serialize(S &s, const unsigned /*version*/) {
23367  debugSerializationBegin("SgAsmDwarfInheritance");
23368  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
23369  debugSerializationEnd("SgAsmDwarfInheritance");
23370  }
23371 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
23372 
23373 public:
23375  virtual ~SgAsmDwarfInheritance();
23376 
23377 public:
23380 
23381 public:
23383  SgAsmDwarfInheritance(int const& nesting_level,
23384  uint64_t const& offset,
23385  uint64_t const& overall_offset);
23386 
23387 protected:
23394  void initializeProperties();
23395 #endif // SgAsmDwarfInheritance_OTHERS
23396 #ifdef DOCUMENTATION
23397 };
23398 #endif // DOCUMENTATION
23399 
23400 
23402 // SgAsmDwarfImportedUnit -- MACHINE GENERATED; DO NOT MODIFY --
23404 
23405 DECLARE_LEAF_CLASS(AsmDwarfImportedUnit);
23406 IS_SERIALIZABLE(AsmDwarfImportedUnit);
23407 
23408 #ifdef DOCUMENTATION
23410 #endif // DOCUMENTATION
23411 
23412  DECLARE_OTHERS(AsmDwarfImportedUnit);
23413 #if defined(SgAsmDwarfImportedUnit_OTHERS) || defined(DOCUMENTATION)
23414 
23415  //----------------------- Boost serialization for SgAsmDwarfImportedUnit -----------------------
23416 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
23417 private:
23418  friend class boost::serialization::access;
23419 
23420  template<class S>
23421  void serialize(S &s, const unsigned /*version*/) {
23422  debugSerializationBegin("SgAsmDwarfImportedUnit");
23423  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
23424  debugSerializationEnd("SgAsmDwarfImportedUnit");
23425  }
23426 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
23427 
23428 public:
23430  virtual ~SgAsmDwarfImportedUnit();
23431 
23432 public:
23435 
23436 public:
23438  SgAsmDwarfImportedUnit(int const& nesting_level,
23439  uint64_t const& offset,
23440  uint64_t const& overall_offset);
23441 
23442 protected:
23449  void initializeProperties();
23450 #endif // SgAsmDwarfImportedUnit_OTHERS
23451 #ifdef DOCUMENTATION
23452 };
23453 #endif // DOCUMENTATION
23454 
23455 
23457 // SgAsmDwarfImportedModule -- MACHINE GENERATED; DO NOT MODIFY --
23459 
23460 DECLARE_LEAF_CLASS(AsmDwarfImportedModule);
23461 IS_SERIALIZABLE(AsmDwarfImportedModule);
23462 
23463 #ifdef DOCUMENTATION
23465 #endif // DOCUMENTATION
23466 
23467  DECLARE_OTHERS(AsmDwarfImportedModule);
23468 #if defined(SgAsmDwarfImportedModule_OTHERS) || defined(DOCUMENTATION)
23469 
23470  //----------------------- Boost serialization for SgAsmDwarfImportedModule -----------------------
23471 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
23472 private:
23473  friend class boost::serialization::access;
23474 
23475  template<class S>
23476  void serialize(S &s, const unsigned /*version*/) {
23477  debugSerializationBegin("SgAsmDwarfImportedModule");
23478  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
23479  debugSerializationEnd("SgAsmDwarfImportedModule");
23480  }
23481 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
23482 
23483 public:
23485  virtual ~SgAsmDwarfImportedModule();
23486 
23487 public:
23490 
23491 public:
23493  SgAsmDwarfImportedModule(int const& nesting_level,
23494  uint64_t const& offset,
23495  uint64_t const& overall_offset);
23496 
23497 protected:
23504  void initializeProperties();
23505 #endif // SgAsmDwarfImportedModule_OTHERS
23506 #ifdef DOCUMENTATION
23507 };
23508 #endif // DOCUMENTATION
23509 
23510 
23512 // SgAsmDwarfImportedDeclaration -- MACHINE GENERATED; DO NOT MODIFY --
23514 
23515 DECLARE_LEAF_CLASS(AsmDwarfImportedDeclaration);
23516 IS_SERIALIZABLE(AsmDwarfImportedDeclaration);
23517 
23518 #ifdef DOCUMENTATION
23520 #endif // DOCUMENTATION
23521 
23522  DECLARE_OTHERS(AsmDwarfImportedDeclaration);
23523 #if defined(SgAsmDwarfImportedDeclaration_OTHERS) || defined(DOCUMENTATION)
23524 
23525  //----------------------- Boost serialization for SgAsmDwarfImportedDeclaration -----------------------
23526 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
23527 private:
23528  friend class boost::serialization::access;
23529 
23530  template<class S>
23531  void serialize(S &s, const unsigned /*version*/) {
23532  debugSerializationBegin("SgAsmDwarfImportedDeclaration");
23533  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
23534  debugSerializationEnd("SgAsmDwarfImportedDeclaration");
23535  }
23536 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
23537 
23538 public:
23541 
23542 public:
23545 
23546 public:
23548  SgAsmDwarfImportedDeclaration(int const& nesting_level,
23549  uint64_t const& offset,
23550  uint64_t const& overall_offset);
23551 
23552 protected:
23559  void initializeProperties();
23560 #endif // SgAsmDwarfImportedDeclaration_OTHERS
23561 #ifdef DOCUMENTATION
23562 };
23563 #endif // DOCUMENTATION
23564 
23565 
23567 // SgAsmDwarfFunctionTemplate -- MACHINE GENERATED; DO NOT MODIFY --
23569 
23570 DECLARE_LEAF_CLASS(AsmDwarfFunctionTemplate);
23571 IS_SERIALIZABLE(AsmDwarfFunctionTemplate);
23572 
23573 #ifdef DOCUMENTATION
23575 #endif // DOCUMENTATION
23576 
23577  DECLARE_OTHERS(AsmDwarfFunctionTemplate);
23578 #if defined(SgAsmDwarfFunctionTemplate_OTHERS) || defined(DOCUMENTATION)
23579 
23580  //----------------------- Boost serialization for SgAsmDwarfFunctionTemplate -----------------------
23581 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
23582 private:
23583  friend class boost::serialization::access;
23584 
23585  template<class S>
23586  void serialize(S &s, const unsigned /*version*/) {
23587  debugSerializationBegin("SgAsmDwarfFunctionTemplate");
23588  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
23589  debugSerializationEnd("SgAsmDwarfFunctionTemplate");
23590  }
23591 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
23592 
23593 public:
23595  virtual ~SgAsmDwarfFunctionTemplate();
23596 
23597 public:
23600 
23601 public:
23603  SgAsmDwarfFunctionTemplate(int const& nesting_level,
23604  uint64_t const& offset,
23605  uint64_t const& overall_offset);
23606 
23607 protected:
23614  void initializeProperties();
23615 #endif // SgAsmDwarfFunctionTemplate_OTHERS
23616 #ifdef DOCUMENTATION
23617 };
23618 #endif // DOCUMENTATION
23619 
23620 
23622 // SgAsmDwarfFriend -- MACHINE GENERATED; DO NOT MODIFY --
23624 
23625 DECLARE_LEAF_CLASS(AsmDwarfFriend);
23626 IS_SERIALIZABLE(AsmDwarfFriend);
23627 
23628 #ifdef DOCUMENTATION
23630 #endif // DOCUMENTATION
23631 
23632  DECLARE_OTHERS(AsmDwarfFriend);
23633 #if defined(SgAsmDwarfFriend_OTHERS) || defined(DOCUMENTATION)
23634 
23635  //----------------------- Boost serialization for SgAsmDwarfFriend -----------------------
23636 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
23637 private:
23638  friend class boost::serialization::access;
23639 
23640  template<class S>
23641  void serialize(S &s, const unsigned /*version*/) {
23642  debugSerializationBegin("SgAsmDwarfFriend");
23643  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
23644  debugSerializationEnd("SgAsmDwarfFriend");
23645  }
23646 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
23647 
23648 public:
23650  virtual ~SgAsmDwarfFriend();
23651 
23652 public:
23654  SgAsmDwarfFriend();
23655 
23656 public:
23658  SgAsmDwarfFriend(int const& nesting_level,
23659  uint64_t const& offset,
23660  uint64_t const& overall_offset);
23661 
23662 protected:
23669  void initializeProperties();
23670 #endif // SgAsmDwarfFriend_OTHERS
23671 #ifdef DOCUMENTATION
23672 };
23673 #endif // DOCUMENTATION
23674 
23675 
23677 // SgAsmDwarfFormatLabel -- MACHINE GENERATED; DO NOT MODIFY --
23679 
23680 DECLARE_LEAF_CLASS(AsmDwarfFormatLabel);
23681 IS_SERIALIZABLE(AsmDwarfFormatLabel);
23682 
23683 #ifdef DOCUMENTATION
23685 #endif // DOCUMENTATION
23686 
23687  DECLARE_OTHERS(AsmDwarfFormatLabel);
23688 #if defined(SgAsmDwarfFormatLabel_OTHERS) || defined(DOCUMENTATION)
23689 
23690  //----------------------- Boost serialization for SgAsmDwarfFormatLabel -----------------------
23691 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
23692 private:
23693  friend class boost::serialization::access;
23694 
23695  template<class S>
23696  void serialize(S &s, const unsigned /*version*/) {
23697  debugSerializationBegin("SgAsmDwarfFormatLabel");
23698  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
23699  debugSerializationEnd("SgAsmDwarfFormatLabel");
23700  }
23701 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
23702 
23703 public:
23705  virtual ~SgAsmDwarfFormatLabel();
23706 
23707 public:
23710 
23711 public:
23713  SgAsmDwarfFormatLabel(int const& nesting_level,
23714  uint64_t const& offset,
23715  uint64_t const& overall_offset);
23716 
23717 protected:
23724  void initializeProperties();
23725 #endif // SgAsmDwarfFormatLabel_OTHERS
23726 #ifdef DOCUMENTATION
23727 };
23728 #endif // DOCUMENTATION
23729 
23730 
23732 // SgAsmDwarfFormalParameter -- MACHINE GENERATED; DO NOT MODIFY --
23734 
23735 DECLARE_LEAF_CLASS(AsmDwarfFormalParameter);
23736 IS_SERIALIZABLE(AsmDwarfFormalParameter);
23737 
23738 #ifdef DOCUMENTATION
23740 #endif // DOCUMENTATION
23741 
23742  DECLARE_OTHERS(AsmDwarfFormalParameter);
23743 #if defined(SgAsmDwarfFormalParameter_OTHERS) || defined(DOCUMENTATION)
23744 
23745  //----------------------- Boost serialization for SgAsmDwarfFormalParameter -----------------------
23746 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
23747 private:
23748  friend class boost::serialization::access;
23749 
23750  template<class S>
23751  void serialize(S &s, const unsigned /*version*/) {
23752  debugSerializationBegin("SgAsmDwarfFormalParameter");
23753  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
23754  debugSerializationEnd("SgAsmDwarfFormalParameter");
23755  }
23756 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
23757 
23758 public:
23760  virtual ~SgAsmDwarfFormalParameter();
23761 
23762 public:
23765 
23766 public:
23768  SgAsmDwarfFormalParameter(int const& nesting_level,
23769  uint64_t const& offset,
23770  uint64_t const& overall_offset);
23771 
23772 protected:
23779  void initializeProperties();
23780 #endif // SgAsmDwarfFormalParameter_OTHERS
23781 #ifdef DOCUMENTATION
23782 };
23783 #endif // DOCUMENTATION
23784 
23785 
23787 // SgAsmDwarfFileType -- MACHINE GENERATED; DO NOT MODIFY --
23789 
23790 DECLARE_LEAF_CLASS(AsmDwarfFileType);
23791 IS_SERIALIZABLE(AsmDwarfFileType);
23792 
23793 #ifdef DOCUMENTATION
23795 #endif // DOCUMENTATION
23796 
23797  DECLARE_OTHERS(AsmDwarfFileType);
23798 #if defined(SgAsmDwarfFileType_OTHERS) || defined(DOCUMENTATION)
23799 
23800  //----------------------- Boost serialization for SgAsmDwarfFileType -----------------------
23801 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
23802 private:
23803  friend class boost::serialization::access;
23804 
23805  template<class S>
23806  void serialize(S &s, const unsigned /*version*/) {
23807  debugSerializationBegin("SgAsmDwarfFileType");
23808  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
23809  debugSerializationEnd("SgAsmDwarfFileType");
23810  }
23811 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
23812 
23813 public:
23815  virtual ~SgAsmDwarfFileType();
23816 
23817 public:
23820 
23821 public:
23823  SgAsmDwarfFileType(int const& nesting_level,
23824  uint64_t const& offset,
23825  uint64_t const& overall_offset);
23826 
23827 protected:
23834  void initializeProperties();
23835 #endif // SgAsmDwarfFileType_OTHERS
23836 #ifdef DOCUMENTATION
23837 };
23838 #endif // DOCUMENTATION
23839 
23840 
23842 // SgAsmDwarfEnumerator -- MACHINE GENERATED; DO NOT MODIFY --
23844 
23845 DECLARE_LEAF_CLASS(AsmDwarfEnumerator);
23846 IS_SERIALIZABLE(AsmDwarfEnumerator);
23847 
23848 #ifdef DOCUMENTATION
23850 #endif // DOCUMENTATION
23851 
23852  DECLARE_OTHERS(AsmDwarfEnumerator);
23853 #if defined(SgAsmDwarfEnumerator_OTHERS) || defined(DOCUMENTATION)
23854 
23855  //----------------------- Boost serialization for SgAsmDwarfEnumerator -----------------------
23856 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
23857 private:
23858  friend class boost::serialization::access;
23859 
23860  template<class S>
23861  void serialize(S &s, const unsigned /*version*/) {
23862  debugSerializationBegin("SgAsmDwarfEnumerator");
23863  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
23864  debugSerializationEnd("SgAsmDwarfEnumerator");
23865  }
23866 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
23867 
23868 public:
23870  virtual ~SgAsmDwarfEnumerator();
23871 
23872 public:
23875 
23876 public:
23878  SgAsmDwarfEnumerator(int const& nesting_level,
23879  uint64_t const& offset,
23880  uint64_t const& overall_offset);
23881 
23882 protected:
23889  void initializeProperties();
23890 #endif // SgAsmDwarfEnumerator_OTHERS
23891 #ifdef DOCUMENTATION
23892 };
23893 #endif // DOCUMENTATION
23894 
23895 
23897 // SgAsmDwarfEnumerationType -- MACHINE GENERATED; DO NOT MODIFY --
23899 
23900 DECLARE_LEAF_CLASS(AsmDwarfEnumerationType);
23901 IS_SERIALIZABLE(AsmDwarfEnumerationType);
23902 
23903 #ifdef DOCUMENTATION
23905 #endif // DOCUMENTATION
23906 
23907 #ifndef DOCUMENTATION
23908  AsmDwarfEnumerationType.setDataPrototype(
23909  "SgAsmDwarfConstructList*", "body", "= NULL",
23910  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
23911 #endif // !DOCUMENTATION
23912 
23913  DECLARE_OTHERS(AsmDwarfEnumerationType);
23914 #if defined(SgAsmDwarfEnumerationType_OTHERS) || defined(DOCUMENTATION)
23915 
23916  //----------------------- Boost serialization for SgAsmDwarfEnumerationType -----------------------
23917 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
23918 private:
23919  friend class boost::serialization::access;
23920 
23921  template<class S>
23922  void serialize(S &s, const unsigned /*version*/) {
23923  debugSerializationBegin("SgAsmDwarfEnumerationType");
23924  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
23925  s & BOOST_SERIALIZATION_NVP(p_body);
23926  debugSerializationEnd("SgAsmDwarfEnumerationType");
23927  }
23928 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
23929 
23930 public:
23931  SgAsmDwarfConstructList* const& get_body() const;
23932  void set_body(SgAsmDwarfConstructList* const&);
23933 public:
23934  SgAsmDwarfConstructList* get_children() override;
23935 public:
23937  virtual ~SgAsmDwarfEnumerationType();
23938 
23939 public:
23942 
23943 public:
23945  SgAsmDwarfEnumerationType(int const& nesting_level,
23946  uint64_t const& offset,
23947  uint64_t const& overall_offset);
23948 
23949 protected:
23956  void initializeProperties();
23957 #endif // SgAsmDwarfEnumerationType_OTHERS
23958 #ifdef DOCUMENTATION
23959 };
23960 #endif // DOCUMENTATION
23961 
23962 
23964 // SgAsmDwarfEntryPoint -- MACHINE GENERATED; DO NOT MODIFY --
23966 
23967 DECLARE_LEAF_CLASS(AsmDwarfEntryPoint);
23968 IS_SERIALIZABLE(AsmDwarfEntryPoint);
23969 
23970 #ifdef DOCUMENTATION
23972 #endif // DOCUMENTATION
23973 
23974  DECLARE_OTHERS(AsmDwarfEntryPoint);
23975 #if defined(SgAsmDwarfEntryPoint_OTHERS) || defined(DOCUMENTATION)
23976 
23977  //----------------------- Boost serialization for SgAsmDwarfEntryPoint -----------------------
23978 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
23979 private:
23980  friend class boost::serialization::access;
23981 
23982  template<class S>
23983  void serialize(S &s, const unsigned /*version*/) {
23984  debugSerializationBegin("SgAsmDwarfEntryPoint");
23985  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
23986  debugSerializationEnd("SgAsmDwarfEntryPoint");
23987  }
23988 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
23989 
23990 public:
23992  virtual ~SgAsmDwarfEntryPoint();
23993 
23994 public:
23997 
23998 public:
24000  SgAsmDwarfEntryPoint(int const& nesting_level,
24001  uint64_t const& offset,
24002  uint64_t const& overall_offset);
24003 
24004 protected:
24011  void initializeProperties();
24012 #endif // SgAsmDwarfEntryPoint_OTHERS
24013 #ifdef DOCUMENTATION
24014 };
24015 #endif // DOCUMENTATION
24016 
24017 
24019 // SgAsmDwarfDwarfProcedure -- MACHINE GENERATED; DO NOT MODIFY --
24021 
24022 DECLARE_LEAF_CLASS(AsmDwarfDwarfProcedure);
24023 IS_SERIALIZABLE(AsmDwarfDwarfProcedure);
24024 
24025 #ifdef DOCUMENTATION
24027 #endif // DOCUMENTATION
24028 
24029  DECLARE_OTHERS(AsmDwarfDwarfProcedure);
24030 #if defined(SgAsmDwarfDwarfProcedure_OTHERS) || defined(DOCUMENTATION)
24031 
24032  //----------------------- Boost serialization for SgAsmDwarfDwarfProcedure -----------------------
24033 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
24034 private:
24035  friend class boost::serialization::access;
24036 
24037  template<class S>
24038  void serialize(S &s, const unsigned /*version*/) {
24039  debugSerializationBegin("SgAsmDwarfDwarfProcedure");
24040  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
24041  debugSerializationEnd("SgAsmDwarfDwarfProcedure");
24042  }
24043 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
24044 
24045 public:
24047  virtual ~SgAsmDwarfDwarfProcedure();
24048 
24049 public:
24052 
24053 public:
24055  SgAsmDwarfDwarfProcedure(int const& nesting_level,
24056  uint64_t const& offset,
24057  uint64_t const& overall_offset);
24058 
24059 protected:
24066  void initializeProperties();
24067 #endif // SgAsmDwarfDwarfProcedure_OTHERS
24068 #ifdef DOCUMENTATION
24069 };
24070 #endif // DOCUMENTATION
24071 
24072 
24074 // SgAsmDwarfConstType -- MACHINE GENERATED; DO NOT MODIFY --
24076 
24077 DECLARE_LEAF_CLASS(AsmDwarfConstType);
24078 IS_SERIALIZABLE(AsmDwarfConstType);
24079 
24080 #ifdef DOCUMENTATION
24082 #endif // DOCUMENTATION
24083 
24084  DECLARE_OTHERS(AsmDwarfConstType);
24085 #if defined(SgAsmDwarfConstType_OTHERS) || defined(DOCUMENTATION)
24086 
24087  //----------------------- Boost serialization for SgAsmDwarfConstType -----------------------
24088 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
24089 private:
24090  friend class boost::serialization::access;
24091 
24092  template<class S>
24093  void serialize(S &s, const unsigned /*version*/) {
24094  debugSerializationBegin("SgAsmDwarfConstType");
24095  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
24096  debugSerializationEnd("SgAsmDwarfConstType");
24097  }
24098 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
24099 
24100 public:
24102  virtual ~SgAsmDwarfConstType();
24103 
24104 public:
24107 
24108 public:
24110  SgAsmDwarfConstType(int const& nesting_level,
24111  uint64_t const& offset,
24112  uint64_t const& overall_offset);
24113 
24114 protected:
24121  void initializeProperties();
24122 #endif // SgAsmDwarfConstType_OTHERS
24123 #ifdef DOCUMENTATION
24124 };
24125 #endif // DOCUMENTATION
24126 
24127 
24129 // SgAsmDwarfConstructList -- MACHINE GENERATED; DO NOT MODIFY --
24131 
24132 DECLARE_LEAF_CLASS(AsmDwarfConstructList);
24133 IS_SERIALIZABLE(AsmDwarfConstructList);
24134 
24135 #ifdef DOCUMENTATION
24137 #endif // DOCUMENTATION
24138 
24139 #ifndef DOCUMENTATION
24140  AsmDwarfConstructList.setDataPrototype(
24141  "SgAsmDwarfConstructPtrList", "list", "",
24142  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
24143 #endif // !DOCUMENTATION
24144 
24145  DECLARE_OTHERS(AsmDwarfConstructList);
24146 #if defined(SgAsmDwarfConstructList_OTHERS) || defined(DOCUMENTATION)
24147 
24148  //----------------------- Boost serialization for SgAsmDwarfConstructList -----------------------
24149 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
24150 private:
24151  friend class boost::serialization::access;
24152 
24153  template<class S>
24154  void serialize(S &s, const unsigned /*version*/) {
24155  debugSerializationBegin("SgAsmDwarfConstructList");
24156  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfInformation);
24157  s & BOOST_SERIALIZATION_NVP(p_list);
24158  debugSerializationEnd("SgAsmDwarfConstructList");
24159  }
24160 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
24161 
24162 public:
24163  SgAsmDwarfConstructPtrList const& get_list() const;
24164  SgAsmDwarfConstructPtrList& get_list();
24165  void set_list(SgAsmDwarfConstructPtrList const&);
24166 
24167 public:
24169  virtual ~SgAsmDwarfConstructList();
24170 
24171 public:
24174 
24175 protected:
24182  void initializeProperties();
24183 #endif // SgAsmDwarfConstructList_OTHERS
24184 #ifdef DOCUMENTATION
24185 };
24186 #endif // DOCUMENTATION
24187 
24188 
24190 // SgAsmDwarfConstant -- MACHINE GENERATED; DO NOT MODIFY --
24192 
24193 DECLARE_LEAF_CLASS(AsmDwarfConstant);
24194 IS_SERIALIZABLE(AsmDwarfConstant);
24195 
24196 #ifdef DOCUMENTATION
24198 #endif // DOCUMENTATION
24199 
24200  DECLARE_OTHERS(AsmDwarfConstant);
24201 #if defined(SgAsmDwarfConstant_OTHERS) || defined(DOCUMENTATION)
24202 
24203  //----------------------- Boost serialization for SgAsmDwarfConstant -----------------------
24204 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
24205 private:
24206  friend class boost::serialization::access;
24207 
24208  template<class S>
24209  void serialize(S &s, const unsigned /*version*/) {
24210  debugSerializationBegin("SgAsmDwarfConstant");
24211  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
24212  debugSerializationEnd("SgAsmDwarfConstant");
24213  }
24214 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
24215 
24216 public:
24218  virtual ~SgAsmDwarfConstant();
24219 
24220 public:
24223 
24224 public:
24226  SgAsmDwarfConstant(int const& nesting_level,
24227  uint64_t const& offset,
24228  uint64_t const& overall_offset);
24229 
24230 protected:
24237  void initializeProperties();
24238 #endif // SgAsmDwarfConstant_OTHERS
24239 #ifdef DOCUMENTATION
24240 };
24241 #endif // DOCUMENTATION
24242 
24243 
24245 // SgAsmDwarfCondition -- MACHINE GENERATED; DO NOT MODIFY --
24247 
24248 DECLARE_LEAF_CLASS(AsmDwarfCondition);
24249 IS_SERIALIZABLE(AsmDwarfCondition);
24250 
24251 #ifdef DOCUMENTATION
24253 #endif // DOCUMENTATION
24254 
24255  DECLARE_OTHERS(AsmDwarfCondition);
24256 #if defined(SgAsmDwarfCondition_OTHERS) || defined(DOCUMENTATION)
24257 
24258  //----------------------- Boost serialization for SgAsmDwarfCondition -----------------------
24259 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
24260 private:
24261  friend class boost::serialization::access;
24262 
24263  template<class S>
24264  void serialize(S &s, const unsigned /*version*/) {
24265  debugSerializationBegin("SgAsmDwarfCondition");
24266  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
24267  debugSerializationEnd("SgAsmDwarfCondition");
24268  }
24269 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
24270 
24271 public:
24273  virtual ~SgAsmDwarfCondition();
24274 
24275 public:
24278 
24279 public:
24281  SgAsmDwarfCondition(int const& nesting_level,
24282  uint64_t const& offset,
24283  uint64_t const& overall_offset);
24284 
24285 protected:
24292  void initializeProperties();
24293 #endif // SgAsmDwarfCondition_OTHERS
24294 #ifdef DOCUMENTATION
24295 };
24296 #endif // DOCUMENTATION
24297 
24298 
24300 // SgAsmDwarfCompilationUnitList -- MACHINE GENERATED; DO NOT MODIFY --
24302 
24303 DECLARE_LEAF_CLASS(AsmDwarfCompilationUnitList);
24304 IS_SERIALIZABLE(AsmDwarfCompilationUnitList);
24305 
24306 #ifdef DOCUMENTATION
24308 #endif // DOCUMENTATION
24309 
24310 #ifndef DOCUMENTATION
24311  AsmDwarfCompilationUnitList.setDataPrototype(
24312  "SgAsmDwarfCompilationUnitPtrList", "cu_list", "",
24313  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
24314 #endif // !DOCUMENTATION
24315 
24316  DECLARE_OTHERS(AsmDwarfCompilationUnitList);
24317 #if defined(SgAsmDwarfCompilationUnitList_OTHERS) || defined(DOCUMENTATION)
24318 
24319  //----------------------- Boost serialization for SgAsmDwarfCompilationUnitList -----------------------
24320 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
24321 private:
24322  friend class boost::serialization::access;
24323 
24324  template<class S>
24325  void serialize(S &s, const unsigned /*version*/) {
24326  debugSerializationBegin("SgAsmDwarfCompilationUnitList");
24327  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfInformation);
24328  s & BOOST_SERIALIZATION_NVP(p_cu_list);
24329  debugSerializationEnd("SgAsmDwarfCompilationUnitList");
24330  }
24331 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
24332 
24333 public:
24334  SgAsmDwarfCompilationUnitPtrList const& get_cu_list() const;
24335  SgAsmDwarfCompilationUnitPtrList& get_cu_list();
24336  void set_cu_list(SgAsmDwarfCompilationUnitPtrList const&);
24337 
24338 public:
24341 
24342 public:
24345 
24346 protected:
24353  void initializeProperties();
24354 #endif // SgAsmDwarfCompilationUnitList_OTHERS
24355 #ifdef DOCUMENTATION
24356 };
24357 #endif // DOCUMENTATION
24358 
24359 
24361 // SgAsmDwarfCompilationUnit -- MACHINE GENERATED; DO NOT MODIFY --
24363 
24364 DECLARE_LEAF_CLASS(AsmDwarfCompilationUnit);
24365 IS_SERIALIZABLE(AsmDwarfCompilationUnit);
24366 
24367 #ifdef DOCUMENTATION
24369 #endif // DOCUMENTATION
24370 
24371 #ifndef DOCUMENTATION
24372  AsmDwarfCompilationUnit.setDataPrototype(
24373  "std::string", "producer", "",
24374  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
24375 #endif // !DOCUMENTATION
24376 
24377 #ifndef DOCUMENTATION
24378  AsmDwarfCompilationUnit.setDataPrototype(
24379  "std::string", "language", "",
24380  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
24381 #endif // !DOCUMENTATION
24382 
24383 #ifndef DOCUMENTATION
24384  AsmDwarfCompilationUnit.setDataPrototype(
24385  "uint64_t", "low_pc", "= 0",
24386  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
24387 #endif // !DOCUMENTATION
24388 
24389 #ifndef DOCUMENTATION
24390  AsmDwarfCompilationUnit.setDataPrototype(
24391  "uint64_t", "hi_pc", "= 0",
24392  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
24393 #endif // !DOCUMENTATION
24394 
24395 #ifndef DOCUMENTATION
24396  AsmDwarfCompilationUnit.setDataPrototype(
24397  "int", "version_stamp", "= 0",
24398  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
24399 #endif // !DOCUMENTATION
24400 
24401 #ifndef DOCUMENTATION
24402  AsmDwarfCompilationUnit.setDataPrototype(
24403  "uint64_t", "abbrev_offset", "= 0",
24404  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
24405 #endif // !DOCUMENTATION
24406 
24407 #ifndef DOCUMENTATION
24408  AsmDwarfCompilationUnit.setDataPrototype(
24409  "uint64_t", "address_size", "= 0",
24410  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
24411 #endif // !DOCUMENTATION
24412 
24413 #ifndef DOCUMENTATION
24414  AsmDwarfCompilationUnit.setDataPrototype(
24415  "uint64_t", "offset_length", "= 0",
24416  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
24417 #endif // !DOCUMENTATION
24418 
24419 #ifndef DOCUMENTATION
24420  AsmDwarfCompilationUnit.setDataPrototype(
24421  "SgAsmDwarfLineList*", "line_info", "= nullptr",
24422  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
24423 #endif // !DOCUMENTATION
24424 
24425 #ifndef DOCUMENTATION
24426  AsmDwarfCompilationUnit.setDataPrototype(
24427  "SgAsmDwarfConstructList*", "language_constructs", "= nullptr",
24428  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
24429 #endif // !DOCUMENTATION
24430 
24431 #ifndef DOCUMENTATION
24432  AsmDwarfCompilationUnit.setDataPrototype(
24433  "SgAsmDwarfMacroList*", "macro_info", "= nullptr",
24434  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
24435 #endif // !DOCUMENTATION
24436 
24437  DECLARE_OTHERS(AsmDwarfCompilationUnit);
24438 #if defined(SgAsmDwarfCompilationUnit_OTHERS) || defined(DOCUMENTATION)
24439 
24440  //----------------------- Boost serialization for SgAsmDwarfCompilationUnit -----------------------
24441 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
24442 private:
24443  friend class boost::serialization::access;
24444 
24445  template<class S>
24446  void serialize(S &s, const unsigned /*version*/) {
24447  debugSerializationBegin("SgAsmDwarfCompilationUnit");
24448  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
24449  s & BOOST_SERIALIZATION_NVP(p_producer);
24450  s & BOOST_SERIALIZATION_NVP(p_language);
24451  s & BOOST_SERIALIZATION_NVP(p_low_pc);
24452  s & BOOST_SERIALIZATION_NVP(p_hi_pc);
24453  s & BOOST_SERIALIZATION_NVP(p_version_stamp);
24454  s & BOOST_SERIALIZATION_NVP(p_abbrev_offset);
24455  s & BOOST_SERIALIZATION_NVP(p_address_size);
24456  s & BOOST_SERIALIZATION_NVP(p_offset_length);
24457  s & BOOST_SERIALIZATION_NVP(p_line_info);
24458  s & BOOST_SERIALIZATION_NVP(p_language_constructs);
24459  s & BOOST_SERIALIZATION_NVP(p_macro_info);
24460  debugSerializationEnd("SgAsmDwarfCompilationUnit");
24461  }
24462 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
24463 
24464 public:
24465  std::string const& get_producer() const;
24466  void set_producer(std::string const&);
24467 
24468 public:
24469  std::string const& get_language() const;
24470  void set_language(std::string const&);
24471 
24472 public:
24473  uint64_t const& get_low_pc() const;
24474  void set_low_pc(uint64_t const&);
24475 
24476 public:
24477  uint64_t const& get_hi_pc() const;
24478  void set_hi_pc(uint64_t const&);
24479 
24480 public:
24481  int const& get_version_stamp() const;
24482  void set_version_stamp(int const&);
24483 
24484 public:
24485  uint64_t const& get_abbrev_offset() const;
24486  void set_abbrev_offset(uint64_t const&);
24487 
24488 public:
24489  uint64_t const& get_address_size() const;
24490  void set_address_size(uint64_t const&);
24491 
24492 public:
24493  uint64_t const& get_offset_length() const;
24494  void set_offset_length(uint64_t const&);
24495 
24496 public:
24497  SgAsmDwarfLineList* const& get_line_info() const;
24498  void set_line_info(SgAsmDwarfLineList* const&);
24499 
24500 public:
24501  SgAsmDwarfConstructList* const& get_language_constructs() const;
24502  void set_language_constructs(SgAsmDwarfConstructList* const&);
24503 
24504 public:
24505  SgAsmDwarfMacroList* const& get_macro_info() const;
24506  void set_macro_info(SgAsmDwarfMacroList* const&);
24507 public:
24508  SgAsmDwarfConstructList* get_children() override;
24509 public:
24511  virtual ~SgAsmDwarfCompilationUnit();
24512 
24513 public:
24516 
24517 public:
24519  SgAsmDwarfCompilationUnit(int const& nesting_level,
24520  uint64_t const& offset,
24521  uint64_t const& overall_offset);
24522 
24523 protected:
24530  void initializeProperties();
24531 #endif // SgAsmDwarfCompilationUnit_OTHERS
24532 #ifdef DOCUMENTATION
24533 };
24534 #endif // DOCUMENTATION
24535 
24536 
24538 // SgAsmDwarfCommonInclusion -- MACHINE GENERATED; DO NOT MODIFY --
24540 
24541 DECLARE_LEAF_CLASS(AsmDwarfCommonInclusion);
24542 IS_SERIALIZABLE(AsmDwarfCommonInclusion);
24543 
24544 #ifdef DOCUMENTATION
24546 #endif // DOCUMENTATION
24547 
24548  DECLARE_OTHERS(AsmDwarfCommonInclusion);
24549 #if defined(SgAsmDwarfCommonInclusion_OTHERS) || defined(DOCUMENTATION)
24550 
24551  //----------------------- Boost serialization for SgAsmDwarfCommonInclusion -----------------------
24552 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
24553 private:
24554  friend class boost::serialization::access;
24555 
24556  template<class S>
24557  void serialize(S &s, const unsigned /*version*/) {
24558  debugSerializationBegin("SgAsmDwarfCommonInclusion");
24559  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
24560  debugSerializationEnd("SgAsmDwarfCommonInclusion");
24561  }
24562 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
24563 
24564 public:
24566  virtual ~SgAsmDwarfCommonInclusion();
24567 
24568 public:
24571 
24572 public:
24574  SgAsmDwarfCommonInclusion(int const& nesting_level,
24575  uint64_t const& offset,
24576  uint64_t const& overall_offset);
24577 
24578 protected:
24585  void initializeProperties();
24586 #endif // SgAsmDwarfCommonInclusion_OTHERS
24587 #ifdef DOCUMENTATION
24588 };
24589 #endif // DOCUMENTATION
24590 
24591 
24593 // SgAsmDwarfCommonBlock -- MACHINE GENERATED; DO NOT MODIFY --
24595 
24596 DECLARE_LEAF_CLASS(AsmDwarfCommonBlock);
24597 IS_SERIALIZABLE(AsmDwarfCommonBlock);
24598 
24599 #ifdef DOCUMENTATION
24601 #endif // DOCUMENTATION
24602 
24603 #ifndef DOCUMENTATION
24604  AsmDwarfCommonBlock.setDataPrototype(
24605  "SgAsmDwarfConstructList*", "body", "= NULL",
24606  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
24607 #endif // !DOCUMENTATION
24608 
24609  DECLARE_OTHERS(AsmDwarfCommonBlock);
24610 #if defined(SgAsmDwarfCommonBlock_OTHERS) || defined(DOCUMENTATION)
24611 
24612  //----------------------- Boost serialization for SgAsmDwarfCommonBlock -----------------------
24613 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
24614 private:
24615  friend class boost::serialization::access;
24616 
24617  template<class S>
24618  void serialize(S &s, const unsigned /*version*/) {
24619  debugSerializationBegin("SgAsmDwarfCommonBlock");
24620  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
24621  s & BOOST_SERIALIZATION_NVP(p_body);
24622  debugSerializationEnd("SgAsmDwarfCommonBlock");
24623  }
24624 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
24625 
24626 public:
24627  SgAsmDwarfConstructList* const& get_body() const;
24628  void set_body(SgAsmDwarfConstructList* const&);
24629 public:
24630  SgAsmDwarfConstructList* get_children() override;
24631 public:
24633  virtual ~SgAsmDwarfCommonBlock();
24634 
24635 public:
24638 
24639 public:
24641  SgAsmDwarfCommonBlock(int const& nesting_level,
24642  uint64_t const& offset,
24643  uint64_t const& overall_offset);
24644 
24645 protected:
24652  void initializeProperties();
24653 #endif // SgAsmDwarfCommonBlock_OTHERS
24654 #ifdef DOCUMENTATION
24655 };
24656 #endif // DOCUMENTATION
24657 
24658 
24660 // SgAsmDwarfClassType -- MACHINE GENERATED; DO NOT MODIFY --
24662 
24663 DECLARE_LEAF_CLASS(AsmDwarfClassType);
24664 IS_SERIALIZABLE(AsmDwarfClassType);
24665 
24666 #ifdef DOCUMENTATION
24668 #endif // DOCUMENTATION
24669 
24670 #ifndef DOCUMENTATION
24671  AsmDwarfClassType.setDataPrototype(
24672  "SgAsmDwarfConstructList*", "body", "= nullptr",
24673  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
24674 #endif // !DOCUMENTATION
24675 
24676  DECLARE_OTHERS(AsmDwarfClassType);
24677 #if defined(SgAsmDwarfClassType_OTHERS) || defined(DOCUMENTATION)
24678 
24679  //----------------------- Boost serialization for SgAsmDwarfClassType -----------------------
24680 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
24681 private:
24682  friend class boost::serialization::access;
24683 
24684  template<class S>
24685  void serialize(S &s, const unsigned /*version*/) {
24686  debugSerializationBegin("SgAsmDwarfClassType");
24687  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
24688  s & BOOST_SERIALIZATION_NVP(p_body);
24689  debugSerializationEnd("SgAsmDwarfClassType");
24690  }
24691 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
24692 
24693 public:
24694  SgAsmDwarfConstructList* const& get_body() const;
24695  void set_body(SgAsmDwarfConstructList* const&);
24696 public:
24697  SgAsmDwarfConstructList* get_children() override;
24698 public:
24700  virtual ~SgAsmDwarfClassType();
24701 
24702 public:
24705 
24706 public:
24708  SgAsmDwarfClassType(int const& nesting_level,
24709  uint64_t const& offset,
24710  uint64_t const& overall_offset);
24711 
24712 protected:
24719  void initializeProperties();
24720 #endif // SgAsmDwarfClassType_OTHERS
24721 #ifdef DOCUMENTATION
24722 };
24723 #endif // DOCUMENTATION
24724 
24725 
24727 // SgAsmDwarfClassTemplate -- MACHINE GENERATED; DO NOT MODIFY --
24729 
24730 DECLARE_LEAF_CLASS(AsmDwarfClassTemplate);
24731 IS_SERIALIZABLE(AsmDwarfClassTemplate);
24732 
24733 #ifdef DOCUMENTATION
24735 #endif // DOCUMENTATION
24736 
24737  DECLARE_OTHERS(AsmDwarfClassTemplate);
24738 #if defined(SgAsmDwarfClassTemplate_OTHERS) || defined(DOCUMENTATION)
24739 
24740  //----------------------- Boost serialization for SgAsmDwarfClassTemplate -----------------------
24741 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
24742 private:
24743  friend class boost::serialization::access;
24744 
24745  template<class S>
24746  void serialize(S &s, const unsigned /*version*/) {
24747  debugSerializationBegin("SgAsmDwarfClassTemplate");
24748  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
24749  debugSerializationEnd("SgAsmDwarfClassTemplate");
24750  }
24751 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
24752 
24753 public:
24755  virtual ~SgAsmDwarfClassTemplate();
24756 
24757 public:
24760 
24761 public:
24763  SgAsmDwarfClassTemplate(int const& nesting_level,
24764  uint64_t const& offset,
24765  uint64_t const& overall_offset);
24766 
24767 protected:
24774  void initializeProperties();
24775 #endif // SgAsmDwarfClassTemplate_OTHERS
24776 #ifdef DOCUMENTATION
24777 };
24778 #endif // DOCUMENTATION
24779 
24780 
24782 // SgAsmDwarfCatchBlock -- MACHINE GENERATED; DO NOT MODIFY --
24784 
24785 DECLARE_LEAF_CLASS(AsmDwarfCatchBlock);
24786 IS_SERIALIZABLE(AsmDwarfCatchBlock);
24787 
24788 #ifdef DOCUMENTATION
24790 #endif // DOCUMENTATION
24791 
24792  DECLARE_OTHERS(AsmDwarfCatchBlock);
24793 #if defined(SgAsmDwarfCatchBlock_OTHERS) || defined(DOCUMENTATION)
24794 
24795  //----------------------- Boost serialization for SgAsmDwarfCatchBlock -----------------------
24796 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
24797 private:
24798  friend class boost::serialization::access;
24799 
24800  template<class S>
24801  void serialize(S &s, const unsigned /*version*/) {
24802  debugSerializationBegin("SgAsmDwarfCatchBlock");
24803  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
24804  debugSerializationEnd("SgAsmDwarfCatchBlock");
24805  }
24806 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
24807 
24808 public:
24810  virtual ~SgAsmDwarfCatchBlock();
24811 
24812 public:
24815 
24816 public:
24818  SgAsmDwarfCatchBlock(int const& nesting_level,
24819  uint64_t const& offset,
24820  uint64_t const& overall_offset);
24821 
24822 protected:
24829  void initializeProperties();
24830 #endif // SgAsmDwarfCatchBlock_OTHERS
24831 #ifdef DOCUMENTATION
24832 };
24833 #endif // DOCUMENTATION
24834 
24835 
24837 // SgAsmDwarfBaseType -- MACHINE GENERATED; DO NOT MODIFY --
24839 
24840 DECLARE_LEAF_CLASS(AsmDwarfBaseType);
24841 IS_SERIALIZABLE(AsmDwarfBaseType);
24842 
24843 #ifdef DOCUMENTATION
24845 #endif // DOCUMENTATION
24846 
24847  DECLARE_OTHERS(AsmDwarfBaseType);
24848 #if defined(SgAsmDwarfBaseType_OTHERS) || defined(DOCUMENTATION)
24849 
24850  //----------------------- Boost serialization for SgAsmDwarfBaseType -----------------------
24851 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
24852 private:
24853  friend class boost::serialization::access;
24854 
24855  template<class S>
24856  void serialize(S &s, const unsigned /*version*/) {
24857  debugSerializationBegin("SgAsmDwarfBaseType");
24858  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
24859  debugSerializationEnd("SgAsmDwarfBaseType");
24860  }
24861 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
24862 
24863 public:
24865  virtual ~SgAsmDwarfBaseType();
24866 
24867 public:
24870 
24871 public:
24873  SgAsmDwarfBaseType(int const& nesting_level,
24874  uint64_t const& offset,
24875  uint64_t const& overall_offset);
24876 
24877 protected:
24884  void initializeProperties();
24885 #endif // SgAsmDwarfBaseType_OTHERS
24886 #ifdef DOCUMENTATION
24887 };
24888 #endif // DOCUMENTATION
24889 
24890 
24892 // SgAsmDwarfArrayType -- MACHINE GENERATED; DO NOT MODIFY --
24894 
24895 DECLARE_LEAF_CLASS(AsmDwarfArrayType);
24896 IS_SERIALIZABLE(AsmDwarfArrayType);
24897 
24898 #ifdef DOCUMENTATION
24900 #endif // DOCUMENTATION
24901 
24902 #ifndef DOCUMENTATION
24903  AsmDwarfArrayType.setDataPrototype(
24904  "SgAsmDwarfConstructList*", "body", "= nullptr",
24905  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
24906 #endif // !DOCUMENTATION
24907 
24908  DECLARE_OTHERS(AsmDwarfArrayType);
24909 #if defined(SgAsmDwarfArrayType_OTHERS) || defined(DOCUMENTATION)
24910 
24911  //----------------------- Boost serialization for SgAsmDwarfArrayType -----------------------
24912 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
24913 private:
24914  friend class boost::serialization::access;
24915 
24916  template<class S>
24917  void serialize(S &s, const unsigned /*version*/) {
24918  debugSerializationBegin("SgAsmDwarfArrayType");
24919  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
24920  s & BOOST_SERIALIZATION_NVP(p_body);
24921  debugSerializationEnd("SgAsmDwarfArrayType");
24922  }
24923 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
24924 
24925 public:
24926  SgAsmDwarfConstructList* const& get_body() const;
24927  void set_body(SgAsmDwarfConstructList* const&);
24928 public:
24929  SgAsmDwarfConstructList* get_children() override;
24930 public:
24932  virtual ~SgAsmDwarfArrayType();
24933 
24934 public:
24937 
24938 public:
24940  SgAsmDwarfArrayType(int const& nesting_level,
24941  uint64_t const& offset,
24942  uint64_t const& overall_offset);
24943 
24944 protected:
24951  void initializeProperties();
24952 #endif // SgAsmDwarfArrayType_OTHERS
24953 #ifdef DOCUMENTATION
24954 };
24955 #endif // DOCUMENTATION
24956 
24957 
24959 // SgAsmDwarfAccessDeclaration -- MACHINE GENERATED; DO NOT MODIFY --
24961 
24962 DECLARE_LEAF_CLASS(AsmDwarfAccessDeclaration);
24963 IS_SERIALIZABLE(AsmDwarfAccessDeclaration);
24964 
24965 #ifdef DOCUMENTATION
24967 #endif // DOCUMENTATION
24968 
24969  DECLARE_OTHERS(AsmDwarfAccessDeclaration);
24970 #if defined(SgAsmDwarfAccessDeclaration_OTHERS) || defined(DOCUMENTATION)
24971 
24972  //----------------------- Boost serialization for SgAsmDwarfAccessDeclaration -----------------------
24973 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
24974 private:
24975  friend class boost::serialization::access;
24976 
24977  template<class S>
24978  void serialize(S &s, const unsigned /*version*/) {
24979  debugSerializationBegin("SgAsmDwarfAccessDeclaration");
24980  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfConstruct);
24981  debugSerializationEnd("SgAsmDwarfAccessDeclaration");
24982  }
24983 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
24984 
24985 public:
24987  virtual ~SgAsmDwarfAccessDeclaration();
24988 
24989 public:
24992 
24993 public:
24995  SgAsmDwarfAccessDeclaration(int const& nesting_level,
24996  uint64_t const& offset,
24997  uint64_t const& overall_offset);
24998 
24999 protected:
25006  void initializeProperties();
25007 #endif // SgAsmDwarfAccessDeclaration_OTHERS
25008 #ifdef DOCUMENTATION
25009 };
25010 #endif // DOCUMENTATION
25011 
25012 
25014 // SgAsmDwarfConstruct -- MACHINE GENERATED; DO NOT MODIFY --
25016 
25017 #ifndef DOCUMENTATION
25018 AstNodeClass& AsmDwarfConstruct = nonTerminalConstructor(
25019  "AsmDwarfConstruct",
25020  *this,
25021  "AsmDwarfConstruct",
25022  "AsmDwarfConstructTag",
25023  SubclassListBuilder()
25024  | AsmDwarfAccessDeclaration
25025  | AsmDwarfArrayType
25026  | AsmDwarfBaseType
25027  | AsmDwarfCatchBlock
25028  | AsmDwarfClassTemplate
25029  | AsmDwarfClassType
25030  | AsmDwarfCommonBlock
25031  | AsmDwarfCommonInclusion
25032  | AsmDwarfCompilationUnit
25033  | AsmDwarfCondition
25034  | AsmDwarfConstant
25035  | AsmDwarfConstType
25036  | AsmDwarfDwarfProcedure
25037  | AsmDwarfEntryPoint
25038  | AsmDwarfEnumerationType
25039  | AsmDwarfEnumerator
25040  | AsmDwarfFileType
25041  | AsmDwarfFormalParameter
25042  | AsmDwarfFormatLabel
25043  | AsmDwarfFriend
25044  | AsmDwarfFunctionTemplate
25045  | AsmDwarfImportedDeclaration
25046  | AsmDwarfImportedModule
25047  | AsmDwarfImportedUnit
25048  | AsmDwarfInheritance
25049  | AsmDwarfInlinedSubroutine
25050  | AsmDwarfInterfaceType
25051  | AsmDwarfLabel
25052  | AsmDwarfLexicalBlock
25053  | AsmDwarfMember
25054  | AsmDwarfModule
25055  | AsmDwarfMutableType
25056  | AsmDwarfNamelist
25057  | AsmDwarfNamelistItem
25058  | AsmDwarfNamespace
25059  | AsmDwarfPackedType
25060  | AsmDwarfPartialUnit
25061  | AsmDwarfPointerType
25062  | AsmDwarfPtrToMemberType
25063  | AsmDwarfReferenceType
25064  | AsmDwarfRestrictType
25065  | AsmDwarfSetType
25066  | AsmDwarfSharedType
25067  | AsmDwarfStringType
25068  | AsmDwarfStructureType
25069  | AsmDwarfSubprogram
25070  | AsmDwarfSubrangeType
25071  | AsmDwarfSubroutineType
25072  | AsmDwarfTemplateTypeParameter
25073  | AsmDwarfTemplateValueParameter
25074  | AsmDwarfThrownType
25075  | AsmDwarfTryBlock
25076  | AsmDwarfTypedef
25077  | AsmDwarfUnionType
25078  | AsmDwarfUnknownConstruct
25079  | AsmDwarfUnspecifiedParameters
25080  | AsmDwarfUnspecifiedType
25081  | AsmDwarfUpcRelaxedType
25082  | AsmDwarfUpcSharedType
25083  | AsmDwarfUpcStrictType
25084  | AsmDwarfVariable
25085  | AsmDwarfVariant
25086  | AsmDwarfVariantPart
25087  | AsmDwarfWithStmt
25088  | AsmDwarfVolatileType
25089  , false);
25090 assert(AsmDwarfConstruct.associatedGrammar != nullptr);
25091 AsmDwarfConstruct.setCppCondition("!defined(DOCUMENTATION)");
25092 AsmDwarfConstruct.isBoostSerializable(true);
25093 AsmDwarfConstruct.setAutomaticGenerationOfConstructor(false);
25094 AsmDwarfConstruct.setAutomaticGenerationOfDestructor(false);
25095 #endif // !DOCUMENTATION
25096 
25097 #ifdef DOCUMENTATION
25099 #endif // DOCUMENTATION
25100 
25101 #ifndef DOCUMENTATION
25102  AsmDwarfConstruct.setDataPrototype(
25103  "int", "nesting_level", "= 0",
25104  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
25105 #endif // !DOCUMENTATION
25106 
25107 #ifndef DOCUMENTATION
25108  AsmDwarfConstruct.setDataPrototype(
25109  "uint64_t", "offset", "= 0",
25110  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
25111 #endif // !DOCUMENTATION
25112 
25113 #ifndef DOCUMENTATION
25114  AsmDwarfConstruct.setDataPrototype(
25115  "uint64_t", "overall_offset", "= 0",
25116  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
25117 #endif // !DOCUMENTATION
25118 
25119 #ifndef DOCUMENTATION
25120  AsmDwarfConstruct.setDataPrototype(
25121  "std::string", "name", "",
25122  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
25123 #endif // !DOCUMENTATION
25124 
25125 #ifndef DOCUMENTATION
25126  AsmDwarfConstruct.setDataPrototype(
25127  "SgAsmDwarfLine*", "source_position", "= nullptr",
25128  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
25129 #endif // !DOCUMENTATION
25130 
25131  DECLARE_OTHERS(AsmDwarfConstruct);
25132 #if defined(SgAsmDwarfConstruct_OTHERS) || defined(DOCUMENTATION)
25133 
25134  //----------------------- Boost serialization for SgAsmDwarfConstruct -----------------------
25135 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
25136 private:
25137  friend class boost::serialization::access;
25138 
25139  template<class S>
25140  void serialize(S &s, const unsigned /*version*/) {
25141  debugSerializationBegin("SgAsmDwarfConstruct");
25142  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmDwarfInformation);
25143  s & BOOST_SERIALIZATION_NVP(p_nesting_level);
25144  s & BOOST_SERIALIZATION_NVP(p_offset);
25145  s & BOOST_SERIALIZATION_NVP(p_overall_offset);
25146  s & BOOST_SERIALIZATION_NVP(p_name);
25147  s & BOOST_SERIALIZATION_NVP(p_source_position);
25148  debugSerializationEnd("SgAsmDwarfConstruct");
25149  }
25150 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
25151  // AsmDwarfConstruct.setFunctionPrototype("HEADER_ATTRIBUTE_SUPPORT", "../Grammar/Support.code");
25152  // AsmDwarfConstruct.setFunctionSource("SOURCE_ATTRIBUTE_SUPPORT", "../Grammar/Support.code");
25153 
25154  // For now we will store the nesting level (just to support debugging), then it will be removed.
25155 public:
25156  int const& get_nesting_level() const;
25157  void set_nesting_level(int const&);
25158 
25159 public:
25160  uint64_t const& get_offset() const;
25161  void set_offset(uint64_t const&);
25162 
25163 public:
25164  uint64_t const& get_overall_offset() const;
25165  void set_overall_offset(uint64_t const&);
25166  // A lot of constructs have a name so put the name into the base class
25167 public:
25168  std::string const& get_name() const;
25169  void set_name(std::string const&);
25170  // This is a data member that can be filled in via a separate analysis (we would have to read the line information before
25171  // hand).
25172 public:
25173  SgAsmDwarfLine* const& get_source_position() const;
25174  void set_source_position(SgAsmDwarfLine* const&);
25175  // [Robb Matzke 2023-03-22]: SgNode already has an attributeMechanism
25176  // [[using Rosebud: rosetta]]
25177  // AstAttributeMechanism* attributeMechanism = nullptr;
25178 
25179 public:
25181  static SgAsmDwarfConstruct* createDwarfConstruct( int tag, int nesting_level, uint64_t offset, uint64_t overall_offset );
25182 
25183  virtual SgAsmDwarfConstructList* get_children();
25184 public:
25186  virtual ~SgAsmDwarfConstruct();
25187 
25188 protected:
25191 
25192 protected:
25194  SgAsmDwarfConstruct(int const& nesting_level,
25195  uint64_t const& offset,
25196  uint64_t const& overall_offset);
25197 
25198 protected:
25205  void initializeProperties();
25206 #endif // SgAsmDwarfConstruct_OTHERS
25207 #ifdef DOCUMENTATION
25208 };
25209 #endif // DOCUMENTATION
25210 
25211 
25213 // SgAsmDwarfInformation -- MACHINE GENERATED; DO NOT MODIFY --
25215 
25216 #ifndef DOCUMENTATION
25217 AstNodeClass& AsmDwarfInformation = nonTerminalConstructor(
25218  "AsmDwarfInformation",
25219  *this,
25220  "AsmDwarfInformation",
25221  "AsmDwarfInformationTag",
25222  SubclassListBuilder()
25223  | AsmDwarfCompilationUnitList
25224  | AsmDwarfConstruct
25225  | AsmDwarfConstructList
25226  | AsmDwarfLine
25227  | AsmDwarfLineList
25228  | AsmDwarfMacro
25229  | AsmDwarfMacroList
25230  , false);
25231 assert(AsmDwarfInformation.associatedGrammar != nullptr);
25232 AsmDwarfInformation.setCppCondition("!defined(DOCUMENTATION)");
25233 AsmDwarfInformation.isBoostSerializable(true);
25234 AsmDwarfInformation.setAutomaticGenerationOfConstructor(false);
25235 AsmDwarfInformation.setAutomaticGenerationOfDestructor(false);
25236 #endif // !DOCUMENTATION
25237 
25238 #ifdef DOCUMENTATION
25240 #endif // DOCUMENTATION
25241 
25242  DECLARE_OTHERS(AsmDwarfInformation);
25243 #if defined(SgAsmDwarfInformation_OTHERS) || defined(DOCUMENTATION)
25244 
25245  //----------------------- Boost serialization for SgAsmDwarfInformation -----------------------
25246 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
25247 private:
25248  friend class boost::serialization::access;
25249 
25250  template<class S>
25251  void serialize(S &s, const unsigned /*version*/) {
25252  debugSerializationBegin("SgAsmDwarfInformation");
25253  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
25254  debugSerializationEnd("SgAsmDwarfInformation");
25255  }
25256 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
25257 
25258 public:
25260  virtual ~SgAsmDwarfInformation();
25261 
25262 protected:
25265 
25266 protected:
25273  void initializeProperties();
25274 #endif // SgAsmDwarfInformation_OTHERS
25275 #ifdef DOCUMENTATION
25276 };
25277 #endif // DOCUMENTATION
25278 
25279 
25281 // SgAsmDOSFileHeader -- MACHINE GENERATED; DO NOT MODIFY --
25283 
25284 DECLARE_LEAF_CLASS(AsmDOSFileHeader);
25285 IS_SERIALIZABLE(AsmDOSFileHeader);
25286 
25287 #ifdef DOCUMENTATION
25288 
25293 #endif // DOCUMENTATION
25294 
25295 #ifndef DOCUMENTATION
25296  AsmDOSFileHeader.setDataPrototype(
25297  "uint16_t", "e_last_page_size", "= 0",
25298  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
25299 #endif // !DOCUMENTATION
25300 
25301 #ifndef DOCUMENTATION
25302  AsmDOSFileHeader.setDataPrototype(
25303  "uint16_t", "e_total_pages", "= 0",
25304  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
25305 #endif // !DOCUMENTATION
25306 
25307 #ifndef DOCUMENTATION
25308  AsmDOSFileHeader.setDataPrototype(
25309  "uint16_t", "e_nrelocs", "= 0",
25310  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
25311 #endif // !DOCUMENTATION
25312 
25313 #ifndef DOCUMENTATION
25314  AsmDOSFileHeader.setDataPrototype(
25315  "uint16_t", "e_header_paragraphs", "= 0",
25316  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
25317 #endif // !DOCUMENTATION
25318 
25319 #ifndef DOCUMENTATION
25320  AsmDOSFileHeader.setDataPrototype(
25321  "uint16_t", "e_minalloc", "= 0",
25322  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
25323 #endif // !DOCUMENTATION
25324 
25325 #ifndef DOCUMENTATION
25326  AsmDOSFileHeader.setDataPrototype(
25327  "uint16_t", "e_maxalloc", "= 0",
25328  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
25329 #endif // !DOCUMENTATION
25330 
25331 #ifndef DOCUMENTATION
25332  AsmDOSFileHeader.setDataPrototype(
25333  "uint16_t", "e_ss", "= 0",
25334  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
25335 #endif // !DOCUMENTATION
25336 
25337 #ifndef DOCUMENTATION
25338  AsmDOSFileHeader.setDataPrototype(
25339  "uint16_t", "e_sp", "= 0",
25340  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
25341 #endif // !DOCUMENTATION
25342 
25343 #ifndef DOCUMENTATION
25344  AsmDOSFileHeader.setDataPrototype(
25345  "uint16_t", "e_cksum", "= 0",
25346  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
25347 #endif // !DOCUMENTATION
25348 
25349 #ifndef DOCUMENTATION
25350  AsmDOSFileHeader.setDataPrototype(
25351  "uint16_t", "e_ip", "= 0",
25352  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
25353 #endif // !DOCUMENTATION
25354 
25355 #ifndef DOCUMENTATION
25356  AsmDOSFileHeader.setDataPrototype(
25357  "uint16_t", "e_cs", "= 0",
25358  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
25359 #endif // !DOCUMENTATION
25360 
25361 #ifndef DOCUMENTATION
25362  AsmDOSFileHeader.setDataPrototype(
25363  "uint16_t", "e_overlay", "= 0",
25364  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
25365 #endif // !DOCUMENTATION
25366 
25367 #ifndef DOCUMENTATION
25368  AsmDOSFileHeader.setDataPrototype(
25369  "rose_addr_t", "e_relocs_offset", "= 0",
25370  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
25371 #endif // !DOCUMENTATION
25372 
25373 #ifndef DOCUMENTATION
25374  AsmDOSFileHeader.setDataPrototype(
25375  "unsigned", "e_res1", "= 0",
25376  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
25377 #endif // !DOCUMENTATION
25378 
25379 #ifndef DOCUMENTATION
25380  AsmDOSFileHeader.setDataPrototype(
25381  "SgAsmGenericSection*", "relocs", "= nullptr",
25382  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
25383 #endif // !DOCUMENTATION
25384 
25385 #ifndef DOCUMENTATION
25386  AsmDOSFileHeader.setDataPrototype(
25387  "SgAsmGenericSection*", "rm_section", "= nullptr",
25388  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
25389 #endif // !DOCUMENTATION
25390 
25391  DECLARE_OTHERS(AsmDOSFileHeader);
25392 #if defined(SgAsmDOSFileHeader_OTHERS) || defined(DOCUMENTATION)
25393 
25394  //----------------------- Boost serialization for SgAsmDOSFileHeader -----------------------
25395 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
25396 private:
25397  friend class boost::serialization::access;
25398 
25399  template<class S>
25400  void serialize(S &s, const unsigned /*version*/) {
25401  debugSerializationBegin("SgAsmDOSFileHeader");
25402  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmGenericHeader);
25403  s & BOOST_SERIALIZATION_NVP(p_e_last_page_size);
25404  s & BOOST_SERIALIZATION_NVP(p_e_total_pages);
25405  s & BOOST_SERIALIZATION_NVP(p_e_nrelocs);
25406  s & BOOST_SERIALIZATION_NVP(p_e_header_paragraphs);
25407  s & BOOST_SERIALIZATION_NVP(p_e_minalloc);
25408  s & BOOST_SERIALIZATION_NVP(p_e_maxalloc);
25409  s & BOOST_SERIALIZATION_NVP(p_e_ss);
25410  s & BOOST_SERIALIZATION_NVP(p_e_sp);
25411  s & BOOST_SERIALIZATION_NVP(p_e_cksum);
25412  s & BOOST_SERIALIZATION_NVP(p_e_ip);
25413  s & BOOST_SERIALIZATION_NVP(p_e_cs);
25414  s & BOOST_SERIALIZATION_NVP(p_e_overlay);
25415  s & BOOST_SERIALIZATION_NVP(p_e_relocs_offset);
25416  s & BOOST_SERIALIZATION_NVP(p_e_res1);
25417  s & BOOST_SERIALIZATION_NVP(p_relocs);
25418  s & BOOST_SERIALIZATION_NVP(p_rm_section);
25419  debugSerializationEnd("SgAsmDOSFileHeader");
25420  }
25421 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
25422  // Local types
25425 public:
25426 #ifdef _MSC_VER
25427 # pragma pack (1)
25428 #endif
25429 
25431  unsigned char e_magic[2];
25432  uint16_t e_last_page_size; //
25434  uint16_t e_total_pages;
25435  uint16_t e_nrelocs;
25437  uint16_t e_minalloc;
25438  uint16_t e_maxalloc;
25439  uint16_t e_ss;
25440  uint16_t e_sp;
25441  uint16_t e_cksum;
25443  uint16_t e_ip;
25444  uint16_t e_cs;
25445  uint16_t e_relocs_offset;
25446  uint16_t e_overlay;
25447  uint32_t e_res1;
25448  } /* 0x20 */
25449 #if !defined(SWIG) && !defined(_MSC_VER)
25450  __attribute__((packed))
25451 #endif
25452  ;
25453 
25455  uint16_t offset; /* 0x00 */
25456  uint16_t segment; /* 0x02 */
25457  } /* 0x04 */
25458 #if !defined(SWIG) && !defined(_MSC_VER)
25459  __attribute__((packed))
25460 #endif
25461  ;
25462 
25463 #ifdef _MSC_VER
25464 # pragma pack ()
25465 #endif
25466 
25468  // Properties
25470 public:
25476  uint16_t const& get_e_last_page_size() const;
25477  void set_e_last_page_size(uint16_t const&);
25480 public:
25486  uint16_t const& get_e_total_pages() const;
25487  void set_e_total_pages(uint16_t const&);
25490 public:
25496  uint16_t const& get_e_nrelocs() const;
25497  void set_e_nrelocs(uint16_t const&);
25500 public:
25506  uint16_t const& get_e_header_paragraphs() const;
25507  void set_e_header_paragraphs(uint16_t const&);
25510 public:
25516  uint16_t const& get_e_minalloc() const;
25517  void set_e_minalloc(uint16_t const&);
25520 public:
25526  uint16_t const& get_e_maxalloc() const;
25527  void set_e_maxalloc(uint16_t const&);
25530 public:
25536  uint16_t const& get_e_ss() const;
25537  void set_e_ss(uint16_t const&);
25540 public:
25546  uint16_t const& get_e_sp() const;
25547  void set_e_sp(uint16_t const&);
25550 public:
25556  uint16_t const& get_e_cksum() const;
25557  void set_e_cksum(uint16_t const&);
25560 public:
25566  uint16_t const& get_e_ip() const;
25567  void set_e_ip(uint16_t const&);
25570 public:
25576  uint16_t const& get_e_cs() const;
25577  void set_e_cs(uint16_t const&);
25580 public:
25586  uint16_t const& get_e_overlay() const;
25587  void set_e_overlay(uint16_t const&);
25590 public:
25596  rose_addr_t const& get_e_relocs_offset() const;
25597  void set_e_relocs_offset(rose_addr_t const&);
25600 public:
25606  unsigned const& get_e_res1() const;
25607  void set_e_res1(unsigned const&);
25610 public:
25614  SgAsmGenericSection* const& get_relocs() const;
25615  void set_relocs(SgAsmGenericSection* const&);
25618 public:
25622  SgAsmGenericSection* const& get_rm_section() const;
25623  void set_rm_section(SgAsmGenericSection* const&);
25625  // Functions
25628 public:
25630  virtual SgAsmDOSFileHeader *parse() override {return parse(true);}
25631  SgAsmDOSFileHeader *parse(bool define_rm_section);
25632  virtual bool reallocate() override;
25633  virtual void unparse(std::ostream&) const override;
25634  virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
25635  virtual const char *format_name() const override {return "DOS";}
25636 
25642  SgAsmGenericSection *parse_rm_section(rose_addr_t max_offset=0);
25643 
25649  void update_from_rm_section();
25650 
25652  static bool is_DOS(SgAsmGenericFile*);
25653 
25654 private:
25655  void *encode(SgAsmDOSFileHeader::DOSFileHeader_disk*) const;
25656 public:
25658  virtual ~SgAsmDOSFileHeader();
25659 
25660 public:
25663 
25664 protected:
25671  void initializeProperties();
25672 #endif // SgAsmDOSFileHeader_OTHERS
25673 #ifdef DOCUMENTATION
25674 };
25675 #endif // DOCUMENTATION
25676 
25677 
25679 // SgAsmGenericHeader -- MACHINE GENERATED; DO NOT MODIFY --
25681 
25682 #ifndef DOCUMENTATION
25683 AstNodeClass& AsmGenericHeader = nonTerminalConstructor(
25684  "AsmGenericHeader",
25685  *this,
25686  "AsmGenericHeader",
25687  "AsmGenericHeaderTag",
25688  SubclassListBuilder()
25689  | AsmDOSFileHeader
25690  | AsmElfFileHeader
25691  | AsmJvmFileHeader
25692  | AsmLEFileHeader
25693  | AsmNEFileHeader
25694  | AsmPEFileHeader
25695  , true);
25696 assert(AsmGenericHeader.associatedGrammar != nullptr);
25697 AsmGenericHeader.setCppCondition("!defined(DOCUMENTATION)");
25698 AsmGenericHeader.isBoostSerializable(true);
25699 AsmGenericHeader.setAutomaticGenerationOfConstructor(false);
25700 AsmGenericHeader.setAutomaticGenerationOfDestructor(false);
25701 #endif // !DOCUMENTATION
25702 
25703 DECLARE_HEADERS(AsmGenericHeader);
25704 #if defined(SgAsmGenericHeader_HEADERS) || defined(DOCUMENTATION)
25705 #include <Rose/BinaryAnalysis/ByteOrder.h>
25706 #endif // SgAsmGenericHeader_HEADERS
25707 
25708 #ifdef DOCUMENTATION
25709 
25711 #endif // DOCUMENTATION
25712 
25713 #ifndef DOCUMENTATION
25714  AsmGenericHeader.setDataPrototype(
25715  "SgAsmGenericFormat*", "exec_format", "= createAndParent<SgAsmGenericFormat>(this)",
25716  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
25717 #endif // !DOCUMENTATION
25718 
25719 #ifndef DOCUMENTATION
25720  AsmGenericHeader.setDataPrototype(
25721  "SgCharList", "magic", "",
25722  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
25723 #endif // !DOCUMENTATION
25724 
25725 #ifndef DOCUMENTATION
25726  AsmGenericHeader.setDataPrototype(
25727  "SgAsmGenericFormat::InsSetArchitecture", "isa", "= SgAsmGenericFormat::ISA_UNSPECIFIED",
25728  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
25729 #endif // !DOCUMENTATION
25730 
25731 #ifndef DOCUMENTATION
25732  AsmGenericHeader.setDataPrototype(
25733  "rose_addr_t", "base_va", "= 0",
25734  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
25735 #endif // !DOCUMENTATION
25736 
25737 #ifndef DOCUMENTATION
25738  AsmGenericHeader.setDataPrototype(
25739  "SgRVAList", "entry_rvas", "",
25740  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
25741 #endif // !DOCUMENTATION
25742 
25743 #ifndef DOCUMENTATION
25744  AsmGenericHeader.setDataPrototype(
25745  "SgAsmGenericDLLList*", "dlls", "= createAndParent<SgAsmGenericDLLList>(this)",
25746  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
25747 #endif // !DOCUMENTATION
25748 
25749 #ifndef DOCUMENTATION
25750  AsmGenericHeader.setDataPrototype(
25751  "SgAsmGenericSectionList*", "sections", "= createAndParent<SgAsmGenericSectionList>(this)",
25752  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
25753 #endif // !DOCUMENTATION
25754 
25755  DECLARE_OTHERS(AsmGenericHeader);
25756 #if defined(SgAsmGenericHeader_OTHERS) || defined(DOCUMENTATION)
25757 
25758  //----------------------- Boost serialization for SgAsmGenericHeader -----------------------
25759 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
25760 private:
25761  friend class boost::serialization::access;
25762 
25763  template<class S>
25764  void serialize(S &s, const unsigned /*version*/) {
25765  debugSerializationBegin("SgAsmGenericHeader");
25766  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmGenericSection);
25767  s & BOOST_SERIALIZATION_NVP(p_exec_format);
25768  s & BOOST_SERIALIZATION_NVP(p_magic);
25769  s & BOOST_SERIALIZATION_NVP(p_isa);
25770  s & BOOST_SERIALIZATION_NVP(p_base_va);
25771  s & BOOST_SERIALIZATION_NVP(p_entry_rvas);
25772  s & BOOST_SERIALIZATION_NVP(p_dlls);
25773  s & BOOST_SERIALIZATION_NVP(p_sections);
25774  debugSerializationEnd("SgAsmGenericHeader");
25775  }
25776 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
25777 
25778 public:
25782  SgAsmGenericFormat* const& get_exec_format() const;
25783  void set_exec_format(SgAsmGenericFormat* const&);
25786 public:
25790  SgCharList const& get_magic() const;
25791  SgCharList& get_magic();
25792  void set_magic(SgCharList const&);
25795 public:
25803 public:
25807  rose_addr_t const& get_base_va() const;
25808  void set_base_va(rose_addr_t const&);
25811 public:
25815  SgRVAList const& get_entry_rvas() const;
25816  SgRVAList& get_entry_rvas();
25817  void set_entry_rvas(SgRVAList const&);
25820 public:
25824  SgAsmGenericDLLList* const& get_dlls() const;
25825  void set_dlls(SgAsmGenericDLLList* const&);
25828 public:
25832  SgAsmGenericSectionList* const& get_sections() const;
25833  void set_sections(SgAsmGenericSectionList* const&);
25835 public:
25844 
25846  virtual bool reallocate() override;
25847 
25849  virtual void unparse(std::ostream&) const override;
25850 
25852  virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
25853 
25855  virtual const char *format_name() const;
25856 
25858  void add_dll(SgAsmGenericDLL *dll);
25859 
25861  std::vector<SgAsmGenericDLL*>& get_dlls() {
25862  ROSE_ASSERT(p_dlls != NULL);
25863  return p_dlls->get_dlls();
25864  }
25865 
25870  rose_addr_t get_entry_rva() const;
25871 
25873  void add_entry_rva(const rose_rva_t &rva) {
25874  p_entry_rvas.push_back(rva);
25875  }
25876 
25877  /* Convenience functions */
25878  Rose::BinaryAnalysis::ByteOrder::Endianness get_sex() const;
25879  size_t get_word_size() const;
25880 
25885 
25888 
25890  SgAsmGenericSectionPtrList get_mapped_sections() const;
25891 
25893  SgAsmGenericSectionPtrList get_sections_by_id(int id) const;
25894 
25898  SgAsmGenericSectionPtrList get_sections_by_name(std::string, char sep=0) const;
25899 
25901  SgAsmGenericSectionPtrList get_sections_by_offset(rose_addr_t offset, rose_addr_t size) const;
25902 
25904  SgAsmGenericSectionPtrList get_sections_by_rva(rose_addr_t rva) const;
25905 
25912  SgAsmGenericSectionPtrList get_sections_by_va(rose_addr_t va, bool use_preferred) const;
25913 
25915  SgAsmGenericSection *get_section_by_id(int id, size_t *nfound=0) const;
25916 
25918  SgAsmGenericSection *get_section_by_name(const std::string&, char sep=0, size_t *nfound=0) const;
25919 
25921  SgAsmGenericSection *get_section_by_offset(rose_addr_t offset, rose_addr_t size, size_t *nfound=0) const;
25922 
25926  SgAsmGenericSection *get_section_by_rva(rose_addr_t rva, size_t *nfound=0) const;
25927 
25934  SgAsmGenericSection *get_section_by_va(rose_addr_t va, bool use_preferred, size_t *nfound=0) const;
25935 
25937  SgAsmGenericSection *get_best_section_by_va(rose_addr_t va, bool use_preferred, size_t *nfound=0) const;
25938 
25939 protected:
25940  virtual void destructorHelper() override;
25941 public:
25943  virtual ~SgAsmGenericHeader();
25944 
25945 public:
25948 
25949 protected:
25956  void initializeProperties();
25957 #endif // SgAsmGenericHeader_OTHERS
25958 #ifdef DOCUMENTATION
25959 };
25960 #endif // DOCUMENTATION
25961 
25962 
25964 // SgAsmDOSExtendedHeader -- MACHINE GENERATED; DO NOT MODIFY --
25966 
25967 DECLARE_LEAF_CLASS(AsmDOSExtendedHeader);
25968 IS_SERIALIZABLE(AsmDOSExtendedHeader);
25969 
25970 #ifdef DOCUMENTATION
25971 
25975 #endif // DOCUMENTATION
25976 
25977 #ifndef DOCUMENTATION
25978  AsmDOSExtendedHeader.setDataPrototype(
25979  "unsigned", "e_res1", "= 0",
25980  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
25981 #endif // !DOCUMENTATION
25982 
25983 #ifndef DOCUMENTATION
25984  AsmDOSExtendedHeader.setDataPrototype(
25985  "unsigned", "e_oemid", "= 0",
25986  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
25987 #endif // !DOCUMENTATION
25988 
25989 #ifndef DOCUMENTATION
25990  AsmDOSExtendedHeader.setDataPrototype(
25991  "unsigned", "e_oeminfo", "= 0",
25992  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
25993 #endif // !DOCUMENTATION
25994 
25995 #ifndef DOCUMENTATION
25996  AsmDOSExtendedHeader.setDataPrototype(
25997  "unsigned", "e_res2", "= 0",
25998  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
25999 #endif // !DOCUMENTATION
26000 
26001 #ifndef DOCUMENTATION
26002  AsmDOSExtendedHeader.setDataPrototype(
26003  "unsigned", "e_res3", "= 0",
26004  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
26005 #endif // !DOCUMENTATION
26006 
26007 #ifndef DOCUMENTATION
26008  AsmDOSExtendedHeader.setDataPrototype(
26009  "unsigned", "e_res4", "= 0",
26010  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
26011 #endif // !DOCUMENTATION
26012 
26013 #ifndef DOCUMENTATION
26014  AsmDOSExtendedHeader.setDataPrototype(
26015  "unsigned", "e_res5", "= 0",
26016  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
26017 #endif // !DOCUMENTATION
26018 
26019 #ifndef DOCUMENTATION
26020  AsmDOSExtendedHeader.setDataPrototype(
26021  "unsigned", "e_res6", "= 0",
26022  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
26023 #endif // !DOCUMENTATION
26024 
26025 #ifndef DOCUMENTATION
26026  AsmDOSExtendedHeader.setDataPrototype(
26027  "rose_addr_t", "e_lfanew", "= 0",
26028  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
26029 #endif // !DOCUMENTATION
26030 
26031  DECLARE_OTHERS(AsmDOSExtendedHeader);
26032 #if defined(SgAsmDOSExtendedHeader_OTHERS) || defined(DOCUMENTATION)
26033 
26034  //----------------------- Boost serialization for SgAsmDOSExtendedHeader -----------------------
26035 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
26036 private:
26037  friend class boost::serialization::access;
26038 
26039  template<class S>
26040  void serialize(S &s, const unsigned /*version*/) {
26041  debugSerializationBegin("SgAsmDOSExtendedHeader");
26042  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmGenericSection);
26043  s & BOOST_SERIALIZATION_NVP(p_e_res1);
26044  s & BOOST_SERIALIZATION_NVP(p_e_oemid);
26045  s & BOOST_SERIALIZATION_NVP(p_e_oeminfo);
26046  s & BOOST_SERIALIZATION_NVP(p_e_res2);
26047  s & BOOST_SERIALIZATION_NVP(p_e_res3);
26048  s & BOOST_SERIALIZATION_NVP(p_e_res4);
26049  s & BOOST_SERIALIZATION_NVP(p_e_res5);
26050  s & BOOST_SERIALIZATION_NVP(p_e_res6);
26051  s & BOOST_SERIALIZATION_NVP(p_e_lfanew);
26052  debugSerializationEnd("SgAsmDOSExtendedHeader");
26053  }
26054 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
26055  // Local types
26058 public:
26059 #ifdef _MSC_VER
26060 # pragma pack (1)
26061 #endif
26063  uint32_t e_res1; /* 0x00 reserved */
26064  uint16_t e_oemid; /* 0x04 OEM Identifier */
26065  uint16_t e_oeminfo; /* 0x06 other OEM information; oemid specific */
26066  uint32_t e_res2; /* 0x08 reserved */
26067  uint32_t e_res3; /* 0x0c reserved */
26068  uint32_t e_res4; /* 0x10 reserved */
26069  uint32_t e_res5; /* 0x14 reserved */
26070  uint32_t e_res6; /* 0x18 reserved */
26071  uint32_t e_lfanew; /* 0x1c file offset of new exe (PE) header */
26072  } /* 0x20 */
26073 #if !defined(SWIG) && !defined(_MSC_VER)
26074  __attribute__((packed))
26075 #endif
26076  ;
26077 #ifdef _MSC_VER
26078 # pragma pack ()
26079 #endif
26080 
26082  // Properties
26084 public:
26090  unsigned const& get_e_res1() const;
26091  void set_e_res1(unsigned const&);
26094 public:
26100  unsigned const& get_e_oemid() const;
26101  void set_e_oemid(unsigned const&);
26104 public:
26110  unsigned const& get_e_oeminfo() const;
26111  void set_e_oeminfo(unsigned const&);
26114 public:
26120  unsigned const& get_e_res2() const;
26121  void set_e_res2(unsigned const&);
26124 public:
26130  unsigned const& get_e_res3() const;
26131  void set_e_res3(unsigned const&);
26134 public:
26140  unsigned const& get_e_res4() const;
26141  void set_e_res4(unsigned const&);
26144 public:
26150  unsigned const& get_e_res5() const;
26151  void set_e_res5(unsigned const&);
26154 public:
26160  unsigned const& get_e_res6() const;
26161  void set_e_res6(unsigned const&);
26164 public:
26170  rose_addr_t const& get_e_lfanew() const;
26171  void set_e_lfanew(rose_addr_t const&);
26173  // Functions
26176 public:
26178  virtual SgAsmDOSExtendedHeader *parse() override;
26180  virtual void unparse(std::ostream&) const override;
26181  virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
26182 public:
26184  virtual ~SgAsmDOSExtendedHeader();
26185 
26186 public:
26189 
26190 protected:
26197  void initializeProperties();
26198 #endif // SgAsmDOSExtendedHeader_OTHERS
26199 #ifdef DOCUMENTATION
26200 };
26201 #endif // DOCUMENTATION
26202 
26203 
26205 // SgAsmDirectRegisterExpression -- MACHINE GENERATED; DO NOT MODIFY --
26207 
26208 DECLARE_LEAF_CLASS(AsmDirectRegisterExpression);
26209 IS_SERIALIZABLE(AsmDirectRegisterExpression);
26210 
26211 #ifdef DOCUMENTATION
26212 
26214 #endif // DOCUMENTATION
26215 
26216  DECLARE_OTHERS(AsmDirectRegisterExpression);
26217 #if defined(SgAsmDirectRegisterExpression_OTHERS) || defined(DOCUMENTATION)
26218 
26219  //----------------------- Boost serialization for SgAsmDirectRegisterExpression -----------------------
26220 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
26221 private:
26222  friend class boost::serialization::access;
26223 
26224  template<class S>
26225  void serialize(S &s, const unsigned /*version*/) {
26226  debugSerializationBegin("SgAsmDirectRegisterExpression");
26227  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmRegisterReferenceExpression);
26228  debugSerializationEnd("SgAsmDirectRegisterExpression");
26229  }
26230 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
26231 
26232 public:
26235 
26236 public:
26239 
26240 public:
26243 
26244 protected:
26251  void initializeProperties();
26252 #endif // SgAsmDirectRegisterExpression_OTHERS
26253 #ifdef DOCUMENTATION
26254 };
26255 #endif // DOCUMENTATION
26256 
26257 
26259 // SgAsmRegisterReferenceExpression -- MACHINE GENERATED; DO NOT MODIFY --
26261 
26262 #ifndef DOCUMENTATION
26263 AstNodeClass& AsmRegisterReferenceExpression = nonTerminalConstructor(
26264  "AsmRegisterReferenceExpression",
26265  *this,
26266  "AsmRegisterReferenceExpression",
26267  "AsmRegisterReferenceExpressionTag",
26268  SubclassListBuilder()
26269  | AsmDirectRegisterExpression
26270  | AsmIndirectRegisterExpression
26271  , false);
26272 assert(AsmRegisterReferenceExpression.associatedGrammar != nullptr);
26273 AsmRegisterReferenceExpression.setCppCondition("!defined(DOCUMENTATION)");
26274 AsmRegisterReferenceExpression.isBoostSerializable(true);
26275 AsmRegisterReferenceExpression.setAutomaticGenerationOfConstructor(false);
26276 AsmRegisterReferenceExpression.setAutomaticGenerationOfDestructor(false);
26277 #endif // !DOCUMENTATION
26278 
26279 #ifdef DOCUMENTATION
26280 
26282 #endif // DOCUMENTATION
26283 
26284 #ifndef DOCUMENTATION
26285  AsmRegisterReferenceExpression.setDataPrototype(
26286  "Rose::BinaryAnalysis::RegisterDescriptor", "descriptor", "",
26287  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
26288 #endif // !DOCUMENTATION
26289 
26290 #ifndef DOCUMENTATION
26291  AsmRegisterReferenceExpression.setDataPrototype(
26292  "int", "adjustment", "= 0",
26293  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
26294 #endif // !DOCUMENTATION
26295 
26296  DECLARE_OTHERS(AsmRegisterReferenceExpression);
26297 #if defined(SgAsmRegisterReferenceExpression_OTHERS) || defined(DOCUMENTATION)
26298 
26299  //----------------------- Boost serialization for SgAsmRegisterReferenceExpression -----------------------
26300 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
26301 private:
26302  friend class boost::serialization::access;
26303 
26304  template<class S>
26305  void serialize(S &s, const unsigned /*version*/) {
26306  debugSerializationBegin("SgAsmRegisterReferenceExpression");
26307  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExpression);
26308  s & BOOST_SERIALIZATION_NVP(p_descriptor);
26309  s & BOOST_SERIALIZATION_NVP(p_adjustment);
26310  debugSerializationEnd("SgAsmRegisterReferenceExpression");
26311  }
26312 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
26313 
26314 public:
26322 public:
26328  int const& get_adjustment() const;
26329  void set_adjustment(int const&);
26332 public:
26335 
26336 protected:
26339 
26340 protected:
26343 
26344 protected:
26351  void initializeProperties();
26352 #endif // SgAsmRegisterReferenceExpression_OTHERS
26353 #ifdef DOCUMENTATION
26354 };
26355 #endif // DOCUMENTATION
26356 
26357 
26359 // SgAsmControlFlagsExpression -- MACHINE GENERATED; DO NOT MODIFY --
26361 
26362 DECLARE_LEAF_CLASS(AsmControlFlagsExpression);
26363 IS_SERIALIZABLE(AsmControlFlagsExpression);
26364 
26365 DECLARE_HEADERS(AsmControlFlagsExpression);
26366 #if defined(SgAsmControlFlagsExpression_HEADERS) || defined(DOCUMENTATION)
26367 // FIXME[Robb P Matzke 2016-10-31]: no idea what this is
26368 #endif // SgAsmControlFlagsExpression_HEADERS
26369 
26370 #ifdef DOCUMENTATION
26372 #endif // DOCUMENTATION
26373 
26374 #ifndef DOCUMENTATION
26375  AsmControlFlagsExpression.setDataPrototype(
26376  "unsigned long", "bit_flags", "= 0",
26377  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
26378 #endif // !DOCUMENTATION
26379 
26380  DECLARE_OTHERS(AsmControlFlagsExpression);
26381 #if defined(SgAsmControlFlagsExpression_OTHERS) || defined(DOCUMENTATION)
26382 
26383  //----------------------- Boost serialization for SgAsmControlFlagsExpression -----------------------
26384 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
26385 private:
26386  friend class boost::serialization::access;
26387 
26388  template<class S>
26389  void serialize(S &s, const unsigned /*version*/) {
26390  debugSerializationBegin("SgAsmControlFlagsExpression");
26391  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExpression);
26392  s & BOOST_SERIALIZATION_NVP(p_bit_flags);
26393  debugSerializationEnd("SgAsmControlFlagsExpression");
26394  }
26395 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
26396 
26397 public:
26398  unsigned long const& get_bit_flags() const;
26399  void set_bit_flags(unsigned long const&);
26400 
26401 public:
26403  virtual ~SgAsmControlFlagsExpression();
26404 
26405 public:
26408 
26409 protected:
26416  void initializeProperties();
26417 #endif // SgAsmControlFlagsExpression_OTHERS
26418 #ifdef DOCUMENTATION
26419 };
26420 #endif // DOCUMENTATION
26421 
26422 
26424 // SgAsmConstantExpression -- MACHINE GENERATED; DO NOT MODIFY --
26426 
26427 #ifndef DOCUMENTATION
26428 AstNodeClass& AsmConstantExpression = nonTerminalConstructor(
26429  "AsmConstantExpression",
26430  *this,
26431  "AsmConstantExpression",
26432  "AsmConstantExpressionTag",
26433  SubclassListBuilder()
26434  | AsmFloatValueExpression
26435  | AsmIntegerValueExpression
26436  , false);
26437 assert(AsmConstantExpression.associatedGrammar != nullptr);
26438 AsmConstantExpression.setCppCondition("!defined(DOCUMENTATION)");
26439 AsmConstantExpression.isBoostSerializable(true);
26440 AsmConstantExpression.setAutomaticGenerationOfConstructor(false);
26441 AsmConstantExpression.setAutomaticGenerationOfDestructor(false);
26442 #endif // !DOCUMENTATION
26443 
26444 DECLARE_HEADERS(AsmConstantExpression);
26445 #if defined(SgAsmConstantExpression_HEADERS) || defined(DOCUMENTATION)
26446 #include <Sawyer/BitVector.h>
26447 #endif // SgAsmConstantExpression_HEADERS
26448 
26449 #ifdef DOCUMENTATION
26450 
26455 #endif // DOCUMENTATION
26456 
26457 #ifndef DOCUMENTATION
26458  AsmConstantExpression.setDataPrototype(
26459  "Sawyer::Container::BitVector", "bitVector", "",
26460  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
26461 #endif // !DOCUMENTATION
26462 
26463  DECLARE_OTHERS(AsmConstantExpression);
26464 #if defined(SgAsmConstantExpression_OTHERS) || defined(DOCUMENTATION)
26465 
26466  //----------------------- Boost serialization for SgAsmConstantExpression -----------------------
26467 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
26468 private:
26469  friend class boost::serialization::access;
26470 
26471  template<class S>
26472  void serialize(S &s, const unsigned /*version*/) {
26473  debugSerializationBegin("SgAsmConstantExpression");
26474  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmValueExpression);
26475  s & BOOST_SERIALIZATION_NVP(p_bitVector);
26476  debugSerializationEnd("SgAsmConstantExpression");
26477  }
26478 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
26479 
26480 public:
26491 public:
26493  virtual ~SgAsmConstantExpression();
26494 
26495 protected:
26498 
26499 protected:
26506  void initializeProperties();
26507 #endif // SgAsmConstantExpression_OTHERS
26508 #ifdef DOCUMENTATION
26509 };
26510 #endif // DOCUMENTATION
26511 
26512 
26514 // SgAsmValueExpression -- MACHINE GENERATED; DO NOT MODIFY --
26516 
26517 #ifndef DOCUMENTATION
26518 AstNodeClass& AsmValueExpression = nonTerminalConstructor(
26519  "AsmValueExpression",
26520  *this,
26521  "AsmValueExpression",
26522  "AsmValueExpressionTag",
26523  SubclassListBuilder()
26524  | AsmConstantExpression
26525  , false);
26526 assert(AsmValueExpression.associatedGrammar != nullptr);
26527 AsmValueExpression.setCppCondition("!defined(DOCUMENTATION)");
26528 AsmValueExpression.isBoostSerializable(true);
26529 AsmValueExpression.setAutomaticGenerationOfConstructor(false);
26530 AsmValueExpression.setAutomaticGenerationOfDestructor(false);
26531 #endif // !DOCUMENTATION
26532 
26533 #ifdef DOCUMENTATION
26534 
26542 #endif // DOCUMENTATION
26543 
26544 #ifndef DOCUMENTATION
26545  AsmValueExpression.setDataPrototype(
26546  "SgAsmValueExpression*", "unfolded_expression_tree", "= nullptr",
26547  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
26548 #endif // !DOCUMENTATION
26549 
26550 #ifndef DOCUMENTATION
26551  AsmValueExpression.setDataPrototype(
26552  "unsigned short", "bit_offset", "= 0",
26553  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
26554 #endif // !DOCUMENTATION
26555 
26556 #ifndef DOCUMENTATION
26557  AsmValueExpression.setDataPrototype(
26558  "unsigned short", "bit_size", "= 0",
26559  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
26560 #endif // !DOCUMENTATION
26561 
26562 #ifndef DOCUMENTATION
26563  AsmValueExpression.setDataPrototype(
26564  "SgSymbol*", "symbol", "= nullptr",
26565  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
26566 #endif // !DOCUMENTATION
26567 
26568  DECLARE_OTHERS(AsmValueExpression);
26569 #if defined(SgAsmValueExpression_OTHERS) || defined(DOCUMENTATION)
26570 
26571  //----------------------- Boost serialization for SgAsmValueExpression -----------------------
26572 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
26573 private:
26574  friend class boost::serialization::access;
26575 
26576  template<class S>
26577  void serialize(S &s, const unsigned /*version*/) {
26578  debugSerializationBegin("SgAsmValueExpression");
26579  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExpression);
26580  s & BOOST_SERIALIZATION_NVP(p_unfolded_expression_tree);
26581  s & BOOST_SERIALIZATION_NVP(p_bit_offset);
26582  s & BOOST_SERIALIZATION_NVP(p_bit_size);
26583  debugSerializationEnd("SgAsmValueExpression");
26584  }
26585 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
26586 
26587 public:
26599 public:
26608  unsigned short const& get_bit_offset() const;
26609  void set_bit_offset(unsigned short const&);
26612 public:
26619  unsigned short const& get_bit_size() const;
26620  void set_bit_size(unsigned short const&);
26623 public:
26630  SgSymbol* const& get_symbol() const;
26631  void set_symbol(SgSymbol* const&);
26634 public:
26636  virtual ~SgAsmValueExpression();
26637 
26638 protected:
26641 
26642 protected:
26649  void initializeProperties();
26650 #endif // SgAsmValueExpression_OTHERS
26651 #ifdef DOCUMENTATION
26652 };
26653 #endif // DOCUMENTATION
26654 
26655 
26657 // SgAsmCommonSubExpression -- MACHINE GENERATED; DO NOT MODIFY --
26659 
26660 DECLARE_LEAF_CLASS(AsmCommonSubExpression);
26661 IS_SERIALIZABLE(AsmCommonSubExpression);
26662 
26663 DECLARE_HEADERS(AsmCommonSubExpression);
26664 #if defined(SgAsmCommonSubExpression_HEADERS) || defined(DOCUMENTATION)
26665 // FIXME[Robb P Matzke 2016-10-31]: no idea what this is
26666 #endif // SgAsmCommonSubExpression_HEADERS
26667 
26668 #ifdef DOCUMENTATION
26670 #endif // DOCUMENTATION
26671 
26672 #ifndef DOCUMENTATION
26673  AsmCommonSubExpression.setDataPrototype(
26674  "SgAsmExpression*", "subexpression", "= nullptr",
26675  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
26676 #endif // !DOCUMENTATION
26677 
26678  DECLARE_OTHERS(AsmCommonSubExpression);
26679 #if defined(SgAsmCommonSubExpression_OTHERS) || defined(DOCUMENTATION)
26680 
26681  //----------------------- Boost serialization for SgAsmCommonSubExpression -----------------------
26682 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
26683 private:
26684  friend class boost::serialization::access;
26685 
26686  template<class S>
26687  void serialize(S &s, const unsigned /*version*/) {
26688  debugSerializationBegin("SgAsmCommonSubExpression");
26689  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExpression);
26690  s & BOOST_SERIALIZATION_NVP(p_subexpression);
26691  debugSerializationEnd("SgAsmCommonSubExpression");
26692  }
26693 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
26694 
26695 public:
26696  SgAsmExpression* const& get_subexpression() const;
26697  void set_subexpression(SgAsmExpression* const&);
26698 
26699 public:
26701  virtual ~SgAsmCommonSubExpression();
26702 
26703 public:
26706 
26707 protected:
26714  void initializeProperties();
26715 #endif // SgAsmCommonSubExpression_OTHERS
26716 #ifdef DOCUMENTATION
26717 };
26718 #endif // DOCUMENTATION
26719 
26720 
26722 // SgAsmCoffSymbolTable -- MACHINE GENERATED; DO NOT MODIFY --
26724 
26725 DECLARE_LEAF_CLASS(AsmCoffSymbolTable);
26726 IS_SERIALIZABLE(AsmCoffSymbolTable);
26727 
26728 #ifdef DOCUMENTATION
26729 
26733 #endif // DOCUMENTATION
26734 
26735 #ifndef DOCUMENTATION
26736  AsmCoffSymbolTable.setDataPrototype(
26737  "SgAsmGenericSection*", "strtab", "= nullptr",
26738  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
26739 #endif // !DOCUMENTATION
26740 
26741 #ifndef DOCUMENTATION
26742  AsmCoffSymbolTable.setDataPrototype(
26743  "SgAsmCoffSymbolList*", "symbols", "= createAndParent<SgAsmCoffSymbolList>(this)",
26744  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
26745 #endif // !DOCUMENTATION
26746 
26747  DECLARE_OTHERS(AsmCoffSymbolTable);
26748 #if defined(SgAsmCoffSymbolTable_OTHERS) || defined(DOCUMENTATION)
26749 
26750  //----------------------- Boost serialization for SgAsmCoffSymbolTable -----------------------
26751 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
26752 private:
26753  friend class boost::serialization::access;
26754 
26755  template<class S>
26756  void serialize(S &s, const unsigned /*version*/) {
26757  debugSerializationBegin("SgAsmCoffSymbolTable");
26758  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmGenericSection);
26759  s & BOOST_SERIALIZATION_NVP(p_strtab);
26760  s & BOOST_SERIALIZATION_NVP(p_symbols);
26761  debugSerializationEnd("SgAsmCoffSymbolTable");
26762  }
26763 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
26764 
26765 public:
26771  SgAsmGenericSection* const& get_strtab() const;
26772  void set_strtab(SgAsmGenericSection* const&);
26775 public:
26779  SgAsmCoffSymbolList* const& get_symbols() const;
26780  void set_symbols(SgAsmCoffSymbolList* const&);
26782 public:
26784  size_t get_nslots() const;
26785  virtual SgAsmCoffSymbolTable *parse() override;
26786  virtual void unparse(std::ostream&) const override;
26787  virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
26788 public:
26790  virtual ~SgAsmCoffSymbolTable();
26791 
26792 public:
26795 
26796 protected:
26803  void initializeProperties();
26804 #endif // SgAsmCoffSymbolTable_OTHERS
26805 #ifdef DOCUMENTATION
26806 };
26807 #endif // DOCUMENTATION
26808 
26809 
26811 // SgAsmCoffSymbolList -- MACHINE GENERATED; DO NOT MODIFY --
26813 
26814 DECLARE_LEAF_CLASS(AsmCoffSymbolList);
26815 IS_SERIALIZABLE(AsmCoffSymbolList);
26816 
26817 #ifdef DOCUMENTATION
26818 
26820 #endif // DOCUMENTATION
26821 
26822 #ifndef DOCUMENTATION
26823  AsmCoffSymbolList.setDataPrototype(
26824  "SgAsmCoffSymbolPtrList", "symbols", "",
26825  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
26826 #endif // !DOCUMENTATION
26827 
26828  DECLARE_OTHERS(AsmCoffSymbolList);
26829 #if defined(SgAsmCoffSymbolList_OTHERS) || defined(DOCUMENTATION)
26830 
26831  //----------------------- Boost serialization for SgAsmCoffSymbolList -----------------------
26832 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
26833 private:
26834  friend class boost::serialization::access;
26835 
26836  template<class S>
26837  void serialize(S &s, const unsigned /*version*/) {
26838  debugSerializationBegin("SgAsmCoffSymbolList");
26839  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
26840  s & BOOST_SERIALIZATION_NVP(p_symbols);
26841  debugSerializationEnd("SgAsmCoffSymbolList");
26842  }
26843 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
26844 
26845 public:
26849  SgAsmCoffSymbolPtrList const& get_symbols() const;
26850  SgAsmCoffSymbolPtrList& get_symbols();
26851  void set_symbols(SgAsmCoffSymbolPtrList const&);
26854 public:
26856  virtual ~SgAsmCoffSymbolList();
26857 
26858 public:
26861 
26862 protected:
26869  void initializeProperties();
26870 #endif // SgAsmCoffSymbolList_OTHERS
26871 #ifdef DOCUMENTATION
26872 };
26873 #endif // DOCUMENTATION
26874 
26875 
26877 // SgAsmCoffSymbol -- MACHINE GENERATED; DO NOT MODIFY --
26879 
26880 DECLARE_LEAF_CLASS(AsmCoffSymbol);
26881 IS_SERIALIZABLE(AsmCoffSymbol);
26882 
26883 #ifdef DOCUMENTATION
26884 
26886 #endif // DOCUMENTATION
26887 
26888 #ifndef DOCUMENTATION
26889  AsmCoffSymbol.setDataPrototype(
26890  "std::string", "st_name", "",
26891  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
26892 #endif // !DOCUMENTATION
26893 
26894 #ifndef DOCUMENTATION
26895  AsmCoffSymbol.setDataPrototype(
26896  "rose_addr_t", "st_name_offset", "= 0",
26897  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
26898 #endif // !DOCUMENTATION
26899 
26900 #ifndef DOCUMENTATION
26901  AsmCoffSymbol.setDataPrototype(
26902  "int", "st_section_num", "= 0",
26903  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
26904 #endif // !DOCUMENTATION
26905 
26906 #ifndef DOCUMENTATION
26907  AsmCoffSymbol.setDataPrototype(
26908  "unsigned", "st_type", "= 0",
26909  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
26910 #endif // !DOCUMENTATION
26911 
26912 #ifndef DOCUMENTATION
26913  AsmCoffSymbol.setDataPrototype(
26914  "unsigned", "st_storage_class", "= 0",
26915  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
26916 #endif // !DOCUMENTATION
26917 
26918 #ifndef DOCUMENTATION
26919  AsmCoffSymbol.setDataPrototype(
26920  "unsigned", "st_num_aux_entries", "= 0",
26921  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
26922 #endif // !DOCUMENTATION
26923 
26924 #ifndef DOCUMENTATION
26925  AsmCoffSymbol.setDataPrototype(
26926  "SgUnsignedCharList", "aux_data", "",
26927  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
26928 #endif // !DOCUMENTATION
26929 
26930  DECLARE_OTHERS(AsmCoffSymbol);
26931 #if defined(SgAsmCoffSymbol_OTHERS) || defined(DOCUMENTATION)
26932 
26933  //----------------------- Boost serialization for SgAsmCoffSymbol -----------------------
26934 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
26935 private:
26936  friend class boost::serialization::access;
26937 
26938  template<class S>
26939  void serialize(S &s, const unsigned /*version*/) {
26940  debugSerializationBegin("SgAsmCoffSymbol");
26941  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmGenericSymbol);
26942  s & BOOST_SERIALIZATION_NVP(p_st_name);
26943  s & BOOST_SERIALIZATION_NVP(p_st_name_offset);
26944  s & BOOST_SERIALIZATION_NVP(p_st_section_num);
26945  s & BOOST_SERIALIZATION_NVP(p_st_type);
26946  s & BOOST_SERIALIZATION_NVP(p_st_storage_class);
26947  s & BOOST_SERIALIZATION_NVP(p_st_num_aux_entries);
26948  s & BOOST_SERIALIZATION_NVP(p_aux_data);
26949  debugSerializationEnd("SgAsmCoffSymbol");
26950  }
26951 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
26952  // Local types
26955 public:
26956 #ifdef _MSC_VER
26957 # pragma pack (1)
26958 #endif
26960  union {
26961  char st_name[8];
26962  struct {
26963  uint32_t st_zero;
26964  uint32_t st_offset;
26965  };
26966  };
26967  uint32_t st_value;
26968  int16_t st_section_num;
26969  uint16_t st_type;
26970  unsigned char st_storage_class;
26971  unsigned char st_num_aux_entries;
26972  }
26973 // DQ (3/7/2013): Adding support to restrict visability to SWIG.
26974 #if !defined(SWIG) && !defined(_MSC_VER)
26975  __attribute__((packed))
26976 #endif
26977  ;
26978 #ifdef _MSC_VER
26979 # pragma pack ()
26980 #endif
26981 
26983  // Properties and data members
26985 public:
26989  std::string const& get_st_name() const;
26990  void set_st_name(std::string const&);
26993 public:
26997  rose_addr_t const& get_st_name_offset() const;
26998  void set_st_name_offset(rose_addr_t const&);
27001 public:
27005  int const& get_st_section_num() const;
27006  void set_st_section_num(int const&);
27009 public:
27013  unsigned const& get_st_type() const;
27014  void set_st_type(unsigned const&);
27017 public:
27021  unsigned const& get_st_storage_class() const;
27022  void set_st_storage_class(unsigned const&);
27025 public:
27029  unsigned const& get_st_num_aux_entries() const;
27030  void set_st_num_aux_entries(unsigned const&);
27033 public:
27037  SgUnsignedCharList const& get_aux_data() const;
27038  SgUnsignedCharList& get_aux_data();
27039  void set_aux_data(SgUnsignedCharList const&);
27041 public:
27042  static const unsigned int COFFSymbol_disk_size = 18;
27043 
27045  // Functions
27047 public:
27048  SgAsmCoffSymbol(SgAsmPEFileHeader *fhdr, SgAsmGenericSection *symtab, SgAsmGenericSection *strtab, size_t idx);
27049  void *encode(SgAsmCoffSymbol::COFFSymbol_disk*) const;
27050  virtual void dump(FILE *f, const char *prefix, ssize_t idx) const override;
27051 public:
27053  virtual ~SgAsmCoffSymbol();
27054 
27055 public:
27057  SgAsmCoffSymbol();
27058 
27059 protected:
27066  void initializeProperties();
27067 #endif // SgAsmCoffSymbol_OTHERS
27068 #ifdef DOCUMENTATION
27069 };
27070 #endif // DOCUMENTATION
27071 
27072 
27074 // SgAsmGenericSymbol -- MACHINE GENERATED; DO NOT MODIFY --
27076 
27077 #ifndef DOCUMENTATION
27078 AstNodeClass& AsmGenericSymbol = nonTerminalConstructor(
27079  "AsmGenericSymbol",
27080  *this,
27081  "AsmGenericSymbol",
27082  "AsmGenericSymbolTag",
27083  SubclassListBuilder()
27084  | AsmCoffSymbol
27085  | AsmElfSymbol
27086  , false);
27087 assert(AsmGenericSymbol.associatedGrammar != nullptr);
27088 AsmGenericSymbol.setCppCondition("!defined(DOCUMENTATION)");
27089 AsmGenericSymbol.isBoostSerializable(true);
27090 AsmGenericSymbol.setAutomaticGenerationOfConstructor(false);
27091 AsmGenericSymbol.setAutomaticGenerationOfDestructor(false);
27092 #endif // !DOCUMENTATION
27093 
27094 DECLARE_HEADERS(AsmGenericSymbol);
27095 #if defined(SgAsmGenericSymbol_HEADERS) || defined(DOCUMENTATION)
27096 /* Base class for symbol tables. */
27097 #endif // SgAsmGenericSymbol_HEADERS
27098 
27099 #ifdef DOCUMENTATION
27101 #endif // DOCUMENTATION
27102 
27103 #ifndef DOCUMENTATION
27104  AsmGenericSymbol.setDataPrototype(
27105  "SgAsmGenericSymbol::SymbolDefState", "def_state", "= SgAsmGenericSymbol::SYM_UNDEFINED",
27106  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
27107 #endif // !DOCUMENTATION
27108 
27109 #ifndef DOCUMENTATION
27110  AsmGenericSymbol.setDataPrototype(
27111  "SgAsmGenericSymbol::SymbolBinding", "binding", "= SgAsmGenericSymbol::SYM_NO_BINDING",
27112  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
27113 #endif // !DOCUMENTATION
27114 
27115 #ifndef DOCUMENTATION
27116  AsmGenericSymbol.setDataPrototype(
27117  "SgAsmGenericSymbol::SymbolType", "type", "= SgAsmGenericSymbol::SYM_NO_TYPE",
27118  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
27119 #endif // !DOCUMENTATION
27120 
27121 #ifndef DOCUMENTATION
27122  AsmGenericSymbol.setDataPrototype(
27123  "rose_addr_t", "value", "= 0",
27124  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
27125 #endif // !DOCUMENTATION
27126 
27127 #ifndef DOCUMENTATION
27128  AsmGenericSymbol.setDataPrototype(
27129  "rose_addr_t", "size", "= 0",
27130  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
27131 #endif // !DOCUMENTATION
27132 
27133 #ifndef DOCUMENTATION
27134  AsmGenericSymbol.setDataPrototype(
27135  "SgAsmGenericSection*", "bound", "= nullptr",
27136  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
27137 #endif // !DOCUMENTATION
27138 
27139 #ifndef DOCUMENTATION
27140  AsmGenericSymbol.setDataPrototype(
27141  "SgAsmGenericString*", "name", "= nullptr",
27142  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
27143 #endif // !DOCUMENTATION
27144 
27145  DECLARE_OTHERS(AsmGenericSymbol);
27146 #if defined(SgAsmGenericSymbol_OTHERS) || defined(DOCUMENTATION)
27147 
27148  //----------------------- Boost serialization for SgAsmGenericSymbol -----------------------
27149 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
27150 private:
27151  friend class boost::serialization::access;
27152 
27153  template<class S>
27154  void serialize(S &s, const unsigned /*version*/) {
27155  debugSerializationBegin("SgAsmGenericSymbol");
27156  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
27157  s & BOOST_SERIALIZATION_NVP(p_def_state);
27158  s & BOOST_SERIALIZATION_NVP(p_binding);
27159  s & BOOST_SERIALIZATION_NVP(p_type);
27160  s & BOOST_SERIALIZATION_NVP(p_value);
27161  s & BOOST_SERIALIZATION_NVP(p_size);
27162  s & BOOST_SERIALIZATION_NVP(p_bound);
27163  s & BOOST_SERIALIZATION_NVP(p_name);
27164  debugSerializationEnd("SgAsmGenericSymbol");
27165  }
27166 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
27167  // Local types
27170 public:
27176  };
27177 
27179  enum SymbolType {
27190  };
27191 
27198  };
27199 
27201  // Properties
27203 public:
27211 public:
27219 public:
27227 public:
27231  rose_addr_t const& get_value() const;
27232  void set_value(rose_addr_t const&);
27235 public:
27239  rose_addr_t const& get_size() const;
27240  void set_size(rose_addr_t const&);
27243 public:
27247  SgAsmGenericSection* const& get_bound() const;
27248  void set_bound(SgAsmGenericSection* const&);
27251 public:
27255  SgAsmGenericString* get_name() const;
27259  // Functions
27262 public:
27264  virtual void dump(FILE*, const char *prefix, ssize_t idx) const;
27265 public:
27267  virtual ~SgAsmGenericSymbol();
27268 
27269 protected:
27272 
27273 protected:
27280  void initializeProperties();
27281 #endif // SgAsmGenericSymbol_OTHERS
27282 #ifdef DOCUMENTATION
27283 };
27284 #endif // DOCUMENTATION
27285 
27286 
27288 // SgAsmCoffStrtab -- MACHINE GENERATED; DO NOT MODIFY --
27290 
27291 DECLARE_LEAF_CLASS(AsmCoffStrtab);
27292 IS_SERIALIZABLE(AsmCoffStrtab);
27293 
27294 #ifdef DOCUMENTATION
27295 
27297 #endif // DOCUMENTATION
27298 
27299  DECLARE_OTHERS(AsmCoffStrtab);
27300 #if defined(SgAsmCoffStrtab_OTHERS) || defined(DOCUMENTATION)
27301 
27302  //----------------------- Boost serialization for SgAsmCoffStrtab -----------------------
27303 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
27304 private:
27305  friend class boost::serialization::access;
27306 
27307  template<class S>
27308  void serialize(S &s, const unsigned /*version*/) {
27309  debugSerializationBegin("SgAsmCoffStrtab");
27310  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmGenericStrtab);
27311  debugSerializationEnd("SgAsmCoffStrtab");
27312  }
27313 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
27314 public:
27315  explicit SgAsmCoffStrtab(class SgAsmPESection *containing_section);
27316  void destructorHelper() override;
27317  virtual void unparse(std::ostream&) const;
27318  virtual SgAsmStringStorage *create_storage(rose_addr_t offset, bool shared) override;
27319  virtual rose_addr_t get_storage_size(const SgAsmStringStorage*) override;
27320 public:
27322  virtual ~SgAsmCoffStrtab();
27323 
27324 public:
27326  SgAsmCoffStrtab();
27327 
27328 protected:
27335  void initializeProperties();
27336 #endif // SgAsmCoffStrtab_OTHERS
27337 #ifdef DOCUMENTATION
27338 };
27339 #endif // DOCUMENTATION
27340 
27341 
27343 // SgAsmGenericStrtab -- MACHINE GENERATED; DO NOT MODIFY --
27345 
27346 #ifndef DOCUMENTATION
27347 AstNodeClass& AsmGenericStrtab = nonTerminalConstructor(
27348  "AsmGenericStrtab",
27349  *this,
27350  "AsmGenericStrtab",
27351  "AsmGenericStrtabTag",
27352  SubclassListBuilder()
27353  | AsmCoffStrtab
27354  | AsmElfStrtab
27355  , false);
27356 assert(AsmGenericStrtab.associatedGrammar != nullptr);
27357 AsmGenericStrtab.setCppCondition("!defined(DOCUMENTATION)");
27358 AsmGenericStrtab.isBoostSerializable(true);
27359 AsmGenericStrtab.setAutomaticGenerationOfConstructor(false);
27360 AsmGenericStrtab.setAutomaticGenerationOfDestructor(false);
27361 #endif // !DOCUMENTATION
27362 
27363 #ifdef DOCUMENTATION
27364 
27366 #endif // DOCUMENTATION
27367 
27368 #ifndef DOCUMENTATION
27369  AsmGenericStrtab.setDataPrototype(
27370  "SgAsmGenericSection*", "container", "= nullptr",
27371  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
27372 #endif // !DOCUMENTATION
27373 
27374 #ifndef DOCUMENTATION
27375  AsmGenericStrtab.setDataPrototype(
27376  "SgAsmGenericStrtab::referenced_t", "storage_list", "",
27377  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
27378 #endif // !DOCUMENTATION
27379 
27380 #ifndef DOCUMENTATION
27381  AsmGenericStrtab.setDataPrototype(
27382  "AddressIntervalSet", "freelist", "",
27383  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
27384 #endif // !DOCUMENTATION
27385 
27386 #ifndef DOCUMENTATION
27387  AsmGenericStrtab.setDataPrototype(
27388  "SgAsmStringStorage*", "dont_free", "= nullptr",
27389  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
27390 #endif // !DOCUMENTATION
27391 
27392 #ifndef DOCUMENTATION
27393  AsmGenericStrtab.setDataPrototype(
27394  "size_t", "num_freed", "= 0",
27395  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
27396 #endif // !DOCUMENTATION
27397 
27398  DECLARE_OTHERS(AsmGenericStrtab);
27399 #if defined(SgAsmGenericStrtab_OTHERS) || defined(DOCUMENTATION)
27400 
27401  //----------------------- Boost serialization for SgAsmGenericStrtab -----------------------
27402 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
27403 private:
27404  friend class boost::serialization::access;
27405 
27406  template<class S>
27407  void serialize(S &s, const unsigned /*version*/) {
27408  debugSerializationBegin("SgAsmGenericStrtab");
27409  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
27410  s & BOOST_SERIALIZATION_NVP(p_container);
27411  s & BOOST_SERIALIZATION_NVP(p_storage_list);
27412  s & BOOST_SERIALIZATION_NVP(p_freelist);
27413  s & BOOST_SERIALIZATION_NVP(p_dont_free);
27414  s & BOOST_SERIALIZATION_NVP(p_num_freed);
27415  debugSerializationEnd("SgAsmGenericStrtab");
27416  }
27417 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
27418  // Local types
27421 public:
27422  typedef std::vector<class SgAsmStringStorage*> referenced_t;
27423 
27425  // Properties
27427 public:
27431  SgAsmGenericSection* const& get_container() const;
27432  void set_container(SgAsmGenericSection* const&);
27435 public:
27439  SgAsmGenericStrtab::referenced_t const& get_storage_list() const;
27440  void set_storage_list(SgAsmGenericStrtab::referenced_t const&);
27443 public:
27449  const AddressIntervalSet& get_freelist() const;
27452 public:
27456  SgAsmStringStorage* const& get_dont_free() const;
27457  void set_dont_free(SgAsmStringStorage* const&);
27460 public:
27464  size_t const& get_num_freed() const;
27465  void set_num_freed(size_t const&);
27467  // Functions
27470 public:
27472  explicit SgAsmGenericStrtab(SgAsmGenericSection *container);
27473 
27475  virtual SgAsmGenericStrtab* parse() {return this;}
27476 
27478  virtual void dump(FILE*, const char *prefix, ssize_t idx) const;
27479 
27481  SgAsmStoredString *create_string(rose_addr_t offset, bool shared);
27482 
27486  void free(SgAsmStringStorage*);
27487 
27492  void free(rose_addr_t offset, rose_addr_t size); /*mark part of table as free*/
27493 
27498  void free_all_strings(bool blow_away_holes=false);
27499 
27500  virtual void allocate_overlap(SgAsmStringStorage*) {};
27501 
27507  bool reallocate(bool shrink);
27508 
27509  //These should be pure virtual but ROSETTA apparently doesn't support that (RPM 2008-10-03)
27510  virtual SgAsmStringStorage *create_storage(rose_addr_t /*offset*/, bool /*shared*/) {abort(); return NULL;}
27511  virtual rose_addr_t get_storage_size(const SgAsmStringStorage*) {abort(); return 0;}
27512  virtual void rebind(SgAsmStringStorage*, rose_addr_t) {abort();}
27513 public:
27515  virtual ~SgAsmGenericStrtab();
27516 
27517 protected:
27520 
27521 protected:
27528  void initializeProperties();
27529 #endif // SgAsmGenericStrtab_OTHERS
27530 #ifdef DOCUMENTATION
27531 };
27532 #endif // DOCUMENTATION
27533 
27534 
27536 // SgAsmCliHeader -- MACHINE GENERATED; DO NOT MODIFY --
27538 
27539 DECLARE_LEAF_CLASS(AsmCliHeader);
27540 IS_SERIALIZABLE(AsmCliHeader);
27541 
27542 #ifdef DOCUMENTATION
27543 
27547 #endif // DOCUMENTATION
27548 
27549 #ifndef DOCUMENTATION
27550  AsmCliHeader.setDataPrototype(
27551  "uint32_t", "cb", "= 0",
27552  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
27553 #endif // !DOCUMENTATION
27554 
27555 #ifndef DOCUMENTATION
27556  AsmCliHeader.setDataPrototype(
27557  "uint16_t", "majorRuntimeVersion", "= 0",
27558  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
27559 #endif // !DOCUMENTATION
27560 
27561 #ifndef DOCUMENTATION
27562  AsmCliHeader.setDataPrototype(
27563  "uint16_t", "minorRuntimeVersion", "= 0",
27564  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
27565 #endif // !DOCUMENTATION
27566 
27567 #ifndef DOCUMENTATION
27568  AsmCliHeader.setDataPrototype(
27569  "uint64_t", "metaData", "= 0",
27570  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
27571 #endif // !DOCUMENTATION
27572 
27573 #ifndef DOCUMENTATION
27574  AsmCliHeader.setDataPrototype(
27575  "uint32_t", "flags", "= 0",
27576  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
27577 #endif // !DOCUMENTATION
27578 
27579 #ifndef DOCUMENTATION
27580  AsmCliHeader.setDataPrototype(
27581  "uint32_t", "entryPointToken", "= 0",
27582  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
27583 #endif // !DOCUMENTATION
27584 
27585 #ifndef DOCUMENTATION
27586  AsmCliHeader.setDataPrototype(
27587  "uint64_t", "resources", "= 0",
27588  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
27589 #endif // !DOCUMENTATION
27590 
27591 #ifndef DOCUMENTATION
27592  AsmCliHeader.setDataPrototype(
27593  "uint64_t", "strongNameSignature", "= 0",
27594  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
27595 #endif // !DOCUMENTATION
27596 
27597 #ifndef DOCUMENTATION
27598  AsmCliHeader.setDataPrototype(
27599  "uint64_t", "codeManagerTable", "= 0",
27600  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
27601 #endif // !DOCUMENTATION
27602 
27603 #ifndef DOCUMENTATION
27604  AsmCliHeader.setDataPrototype(
27605  "uint64_t", "vTableFixups", "= 0",
27606  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
27607 #endif // !DOCUMENTATION
27608 
27609 #ifndef DOCUMENTATION
27610  AsmCliHeader.setDataPrototype(
27611  "uint64_t", "exportAddressTableJumps", "= 0",
27612  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
27613 #endif // !DOCUMENTATION
27614 
27615 #ifndef DOCUMENTATION
27616  AsmCliHeader.setDataPrototype(
27617  "uint64_t", "managedNativeHeader", "= 0",
27618  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
27619 #endif // !DOCUMENTATION
27620 
27621 #ifndef DOCUMENTATION
27622  AsmCliHeader.setDataPrototype(
27623  "SgAsmCilMetadataRoot*", "metadataRoot", "= nullptr",
27624  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
27625 #endif // !DOCUMENTATION
27626 
27627  DECLARE_OTHERS(AsmCliHeader);
27628 #if defined(SgAsmCliHeader_OTHERS) || defined(DOCUMENTATION)
27629 
27630  //----------------------- Boost serialization for SgAsmCliHeader -----------------------
27631 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
27632 private:
27633  friend class boost::serialization::access;
27634 
27635  template<class S>
27636  void serialize(S &s, const unsigned /*version*/) {
27637  debugSerializationBegin("SgAsmCliHeader");
27638  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmGenericSection);
27639  s & BOOST_SERIALIZATION_NVP(p_cb);
27640  s & BOOST_SERIALIZATION_NVP(p_majorRuntimeVersion);
27641  s & BOOST_SERIALIZATION_NVP(p_minorRuntimeVersion);
27642  s & BOOST_SERIALIZATION_NVP(p_metaData);
27643  s & BOOST_SERIALIZATION_NVP(p_flags);
27644  s & BOOST_SERIALIZATION_NVP(p_entryPointToken);
27645  s & BOOST_SERIALIZATION_NVP(p_resources);
27646  s & BOOST_SERIALIZATION_NVP(p_strongNameSignature);
27647  s & BOOST_SERIALIZATION_NVP(p_codeManagerTable);
27648  s & BOOST_SERIALIZATION_NVP(p_vTableFixups);
27649  s & BOOST_SERIALIZATION_NVP(p_exportAddressTableJumps);
27650  s & BOOST_SERIALIZATION_NVP(p_managedNativeHeader);
27651  debugSerializationEnd("SgAsmCliHeader");
27652  }
27653 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
27654 
27655 public:
27661  uint32_t const& get_cb() const;
27662  void set_cb(uint32_t const&);
27665 public:
27671  uint16_t const& get_majorRuntimeVersion() const;
27672  void set_majorRuntimeVersion(uint16_t const&);
27675 public:
27681  uint16_t const& get_minorRuntimeVersion() const;
27682  void set_minorRuntimeVersion(uint16_t const&);
27685 public:
27691  uint64_t const& get_metaData() const;
27692  void set_metaData(uint64_t const&);
27695 public:
27701  uint32_t const& get_flags() const;
27702  void set_flags(uint32_t const&);
27705 public:
27711  uint32_t const& get_entryPointToken() const;
27712  void set_entryPointToken(uint32_t const&);
27715 public:
27721  uint64_t const& get_resources() const;
27722  void set_resources(uint64_t const&);
27725 public:
27731  uint64_t const& get_strongNameSignature() const;
27732  void set_strongNameSignature(uint64_t const&);
27735 public:
27741  uint64_t const& get_codeManagerTable() const;
27742  void set_codeManagerTable(uint64_t const&);
27745 public:
27751  uint64_t const& get_vTableFixups() const;
27752  void set_vTableFixups(uint64_t const&);
27755 public:
27761  uint64_t const& get_exportAddressTableJumps() const;
27762  void set_exportAddressTableJumps(uint64_t const&);
27765 public:
27771  uint64_t const& get_managedNativeHeader() const;
27772  void set_managedNativeHeader(uint64_t const&);
27774  // FIXME[Robb Matzke 2023-03-20]: is no_serialize a bug?
27775 public:
27779  SgAsmCilMetadataRoot* const& get_metadataRoot() const;
27780  void set_metadataRoot(SgAsmCilMetadataRoot* const&);
27782  public:
27786  explicit SgAsmCliHeader(SgAsmPEFileHeader*);
27787 
27789  virtual SgAsmCliHeader* parse() override;
27790 
27792  virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
27793 public:
27795  virtual ~SgAsmCliHeader();
27796 
27797 public:
27799  SgAsmCliHeader();
27800 
27801 protected:
27808  void initializeProperties();
27809 #endif // SgAsmCliHeader_OTHERS
27810 #ifdef DOCUMENTATION
27811 };
27812 #endif // DOCUMENTATION
27813 
27814 
27816 // SgAsmGenericSection -- MACHINE GENERATED; DO NOT MODIFY --
27818 
27819 #ifndef DOCUMENTATION
27820 AstNodeClass& AsmGenericSection = nonTerminalConstructor(
27821  "AsmGenericSection",
27822  *this,
27823  "AsmGenericSection",
27824  "AsmGenericSectionTag",
27825  SubclassListBuilder()
27826  | AsmCliHeader
27827  | AsmCoffSymbolTable
27828  | AsmDOSExtendedHeader
27829  | AsmElfSection
27830  | AsmElfSectionTable
27831  | AsmElfSegmentTable
27832  | AsmGenericHeader
27833  | AsmJvmAttributeTable
27834  | AsmJvmConstantPool
27835  | AsmJvmFieldTable
27836  | AsmJvmMethodTable
27837  | AsmLEEntryTable
27838  | AsmLENameTable
27839  | AsmLEPageTable
27840  | AsmLERelocTable
27841  | AsmLESection
27842  | AsmLESectionTable
27843  | AsmNEEntryTable
27844  | AsmNEModuleTable
27845  | AsmNENameTable
27846  | AsmNERelocTable
27847  | AsmNESection
27848  | AsmNESectionTable
27849  | AsmNEStringTable
27850  | AsmPESection
27851  | AsmPESectionTable
27852  , true);
27853 assert(AsmGenericSection.associatedGrammar != nullptr);
27854 AsmGenericSection.setCppCondition("!defined(DOCUMENTATION)");
27855 AsmGenericSection.isBoostSerializable(true);
27856 AsmGenericSection.setAutomaticGenerationOfConstructor(false);
27857 AsmGenericSection.setAutomaticGenerationOfDestructor(false);
27858 #endif // !DOCUMENTATION
27859 
27860 #ifdef DOCUMENTATION
27861 
27866 #endif // DOCUMENTATION
27867 
27868 #ifndef DOCUMENTATION
27869  AsmGenericSection.setDataPrototype(
27870  "SgAsmGenericFile*", "file", "= nullptr",
27871  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
27872 #endif // !DOCUMENTATION
27873 
27874 #ifndef DOCUMENTATION
27875  AsmGenericSection.setDataPrototype(
27876  "SgAsmGenericHeader*", "header", "= nullptr",
27877  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
27878 #endif // !DOCUMENTATION
27879 
27880 #ifndef DOCUMENTATION
27881  AsmGenericSection.setDataPrototype(
27882  "rose_addr_t", "size", "= 0",
27883  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
27884 #endif // !DOCUMENTATION
27885 
27886 #ifndef DOCUMENTATION
27887  AsmGenericSection.setDataPrototype(
27888  "rose_addr_t", "offset", "= 0",
27889  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
27890 #endif // !DOCUMENTATION
27891 
27892 #ifndef DOCUMENTATION
27893  AsmGenericSection.setDataPrototype(
27894  "rose_addr_t", "file_alignment", "= 0",
27895  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
27896 #endif // !DOCUMENTATION
27897 
27898 #ifndef DOCUMENTATION
27899  AsmGenericSection.setDataPrototype(
27900  "SgFileContentList", "data", "",
27901  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
27902 #endif // !DOCUMENTATION
27903 
27904 #ifndef DOCUMENTATION
27905  AsmGenericSection.setDataPrototype(
27906  "SgAsmGenericSection::SectionPurpose", "purpose", "= SgAsmGenericSection::SP_UNSPECIFIED",
27907  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
27908 #endif // !DOCUMENTATION
27909 
27910 #ifndef DOCUMENTATION
27911  AsmGenericSection.setDataPrototype(
27912  "bool", "synthesized", "= false",
27913  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
27914 #endif // !DOCUMENTATION
27915 
27916 #ifndef DOCUMENTATION
27917  AsmGenericSection.setDataPrototype(
27918  "int", "id", "= -1",
27919  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
27920 #endif // !DOCUMENTATION
27921 
27922 #ifndef DOCUMENTATION
27923  AsmGenericSection.setDataPrototype(
27924  "SgAsmGenericString*", "name", "= createAndParent<SgAsmBasicString>(this)",
27925  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
27926 #endif // !DOCUMENTATION
27927 
27928 #ifndef DOCUMENTATION
27929  AsmGenericSection.setDataPrototype(
27930  "std::string", "short_name", "",
27931  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
27932 #endif // !DOCUMENTATION
27933 
27934 #ifndef DOCUMENTATION
27935  AsmGenericSection.setDataPrototype(
27936  "rose_addr_t", "mapped_preferred_rva", "= 0",
27937  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
27938 #endif // !DOCUMENTATION
27939 
27940 #ifndef DOCUMENTATION
27941  AsmGenericSection.setDataPrototype(
27942  "rose_addr_t", "mapped_size", "= 0",
27943  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
27944 #endif // !DOCUMENTATION
27945 
27946 #ifndef DOCUMENTATION
27947  AsmGenericSection.setDataPrototype(
27948  "rose_addr_t", "mapped_alignment", "= 0",
27949  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
27950 #endif // !DOCUMENTATION
27951 
27952 #ifndef DOCUMENTATION
27953  AsmGenericSection.setDataPrototype(
27954  "bool", "mapped_rperm", "= false",
27955  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
27956 #endif // !DOCUMENTATION
27957 
27958 #ifndef DOCUMENTATION
27959  AsmGenericSection.setDataPrototype(
27960  "bool", "mapped_wperm", "= false",
27961  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
27962 #endif // !DOCUMENTATION
27963 
27964 #ifndef DOCUMENTATION
27965  AsmGenericSection.setDataPrototype(
27966  "bool", "mapped_xperm", "= false",
27967  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
27968 #endif // !DOCUMENTATION
27969 
27970 #ifndef DOCUMENTATION
27971  AsmGenericSection.setDataPrototype(
27972  "bool", "contains_code", "= false",
27973  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
27974 #endif // !DOCUMENTATION
27975 
27976 #ifndef DOCUMENTATION
27977  AsmGenericSection.setDataPrototype(
27978  "rose_addr_t", "mapped_actual_va", "= 0",
27979  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
27980 #endif // !DOCUMENTATION
27981 
27982  DECLARE_OTHERS(AsmGenericSection);
27983 #if defined(SgAsmGenericSection_OTHERS) || defined(DOCUMENTATION)
27984 
27985  //----------------------- Boost serialization for SgAsmGenericSection -----------------------
27986 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
27987 private:
27988  friend class boost::serialization::access;
27989 
27990  template<class S>
27991  void serialize(S &s, const unsigned /*version*/) {
27992  debugSerializationBegin("SgAsmGenericSection");
27993  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
27994  s & BOOST_SERIALIZATION_NVP(p_file);
27995  s & BOOST_SERIALIZATION_NVP(p_header);
27996  s & BOOST_SERIALIZATION_NVP(p_size);
27997  s & BOOST_SERIALIZATION_NVP(p_offset);
27998  s & BOOST_SERIALIZATION_NVP(p_file_alignment);
27999  s & BOOST_SERIALIZATION_NVP(p_data);
28000  s & BOOST_SERIALIZATION_NVP(p_purpose);
28001  s & BOOST_SERIALIZATION_NVP(p_synthesized);
28002  s & BOOST_SERIALIZATION_NVP(p_id);
28003  s & BOOST_SERIALIZATION_NVP(p_name);
28004  s & BOOST_SERIALIZATION_NVP(p_short_name);
28005  s & BOOST_SERIALIZATION_NVP(p_mapped_preferred_rva);
28006  s & BOOST_SERIALIZATION_NVP(p_mapped_size);
28007  s & BOOST_SERIALIZATION_NVP(p_mapped_alignment);
28008  s & BOOST_SERIALIZATION_NVP(p_mapped_rperm);
28009  s & BOOST_SERIALIZATION_NVP(p_mapped_wperm);
28010  s & BOOST_SERIALIZATION_NVP(p_mapped_xperm);
28011  s & BOOST_SERIALIZATION_NVP(p_contains_code);
28012  s & BOOST_SERIALIZATION_NVP(p_mapped_actual_va);
28013  debugSerializationEnd("SgAsmGenericSection");
28014  }
28015 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
28016  // Local types
28019 public:
28030  };
28031 
28033  // Properties
28035 public:
28039  SgAsmGenericFile* const& get_file() const;
28040  void set_file(SgAsmGenericFile* const&);
28043 public:
28047  SgAsmGenericHeader* const& get_header() const;
28048  void set_header(SgAsmGenericHeader* const&);
28051 public:
28062  rose_addr_t get_size() const;
28063  virtual void set_size(rose_addr_t);
28065 public:
28073  // Starting file offset of the section
28074 
28075  rose_addr_t get_offset() const;
28076  virtual void set_offset(rose_addr_t);
28078 public:
28084  rose_addr_t const& get_file_alignment() const;
28085  void set_file_alignment(rose_addr_t const&);
28088 public:
28094  SgFileContentList const& get_data() const;
28095  void set_data(SgFileContentList const&);
28098 public:
28106 public:
28112  bool const& get_synthesized() const;
28113  void set_synthesized(bool const&);
28116 public:
28122  int const& get_id() const;
28123  void set_id(int const&);
28126 public:
28134  SgAsmGenericString *get_name() const;
28135  void set_name(SgAsmGenericString *s);
28137 public:
28145  std::string get_short_name() const;
28146  void set_short_name(const std::string&);
28148 public:
28158  rose_addr_t get_mapped_preferred_rva() const;
28159  virtual void set_mapped_preferred_rva(rose_addr_t);
28161 public:
28167  rose_addr_t get_mapped_size() const;
28168  virtual void set_mapped_size(rose_addr_t);
28170 public:
28174  rose_addr_t const& get_mapped_alignment() const;
28175  void set_mapped_alignment(rose_addr_t const&);
28178 public:
28182  bool const& get_mapped_rperm() const;
28183  void set_mapped_rperm(bool const&);
28186 public:
28190  bool const& get_mapped_wperm() const;
28191  void set_mapped_wperm(bool const&);
28194 public:
28198  bool const& get_mapped_xperm() const;
28199  void set_mapped_xperm(bool const&);
28202 public:
28212  bool const& get_contains_code() const;
28213  void set_contains_code(bool const&);
28216 public:
28230  rose_addr_t const& get_mapped_actual_va() const;
28231  void set_mapped_actual_va(rose_addr_t const&);
28233  // Non-property data members
28236 private:
28237  /* This is an optional local, writable pool for the p_data member. Normally a section will point into the pool
28238  * for its SgAsmGenericFile which is memory-mapped (read-only) from the actual file being parsed. The default
28239  * unparsing action is to write the original data back to the file. By allowing a section to allocate its own
28240  * pool for p_data we create a very easy way to get data into the unparsed file (the alternative is to derive
28241  * a new class and override the unparse() method). */
28242  unsigned char *local_data_pool;
28243 
28245  // Functions
28247 public:
28255 
28257  static void dump_containing_sections(FILE*, const std::string &prefix, rose_rva_t, const SgAsmGenericSectionPtrList&);
28258 
28263  void grab_content();
28264 
28265  virtual SgAsmGenericSection* parse();
28266 
28268  virtual void dump(FILE*, const char *prefix, ssize_t idx) const;
28269 
28270  // Implemented in subclasses
28271  virtual bool reallocate() { return false; }
28272 
28276  virtual void unparse(std::ostream&) const;
28277 
28279  void unparse(std::ostream&, const ExtentMap&) const;
28280 
28282  void unparse_holes(std::ostream&) const;
28283 
28289 
28291  rose_addr_t get_end_offset() const;
28292 
28299  void extend(rose_addr_t nbytes);
28300 
28316  rose_addr_t write(std::ostream &f, rose_addr_t offset, size_t bufsize, const void *buf) const;
28317  rose_addr_t write(std::ostream &f, rose_addr_t offset, const std::string &str) const;
28318  rose_addr_t write(std::ostream &f, rose_addr_t offset, char c) const;
28319  rose_addr_t write(std::ostream &f, rose_addr_t offset, const SgFileContentList &buf) const;
28320  rose_addr_t write(std::ostream &f, rose_addr_t offset, const SgUnsignedCharList &buf) const;
28326  rose_addr_t write_uleb128(unsigned char*, rose_addr_t offset, uint64_t) const;
28327 
28331  rose_addr_t write_sleb128(unsigned char*, rose_addr_t offset, int64_t) const;
28332 
28340  size_t read_content(rose_addr_t abs_offset, void *dst_buf, rose_addr_t size, bool strict=true);
28341 
28353  size_t read_content(const Rose::BinaryAnalysis::MemoryMap::Ptr&, rose_addr_t start, void *dst_buf,
28354  rose_addr_t size, bool strict=true);
28355  size_t read_content(const Rose::BinaryAnalysis::MemoryMap::Ptr&, const rose_rva_t &start, void *dst_buf,
28356  rose_addr_t size, bool strict=true);
28365  size_t read_content_local(rose_addr_t rel_offset, void *dst_buf, rose_addr_t size, bool strict=true);
28366 
28373  std::string read_content_str(const Rose::BinaryAnalysis::MemoryMap::Ptr&, rose_addr_t va, bool strict=true);
28374 
28382  std::string read_content_str(rose_addr_t abs_offset, bool strict=true);
28383  std::string read_content_str(const Rose::BinaryAnalysis::MemoryMap::Ptr &map, rose_rva_t rva, bool strict=true) {
28384  return read_content_str(map, rva.get_va(), strict);
28385  }
28393  std::string read_content_local_str(rose_addr_t rel_offset, bool strict=true);
28394 
28399  SgUnsignedCharList read_content_local_ucl(rose_addr_t rel_offset, rose_addr_t size);
28400 
28406  int64_t read_content_local_sleb128(rose_addr_t *rel_offset, bool strict=true);
28407 
28413  uint64_t read_content_local_uleb128(rose_addr_t *rel_offset, bool strict=true);
28414 
28423  unsigned char *writable_content(size_t nbytes);
28424 
28431 
28438 
28442  bool is_mapped() const;
28443 
28447  void clear_mapped();
28448 
28453  rose_addr_t get_base_va() const;
28454 
28459  rose_addr_t get_mapped_preferred_va() const;
28460 
28465  rose_addr_t get_va_offset(rose_addr_t va) const;
28466 
28471  rose_addr_t get_rva_offset(rose_addr_t rva) const;
28472 
28476  Extent get_file_extent() const;
28477 
28483 
28497  bool align();
28498 
28499 protected:
28500  virtual void destructorHelper() override;
28501 public:
28503  virtual ~SgAsmGenericSection();
28504 
28505 public:
28508 
28509 protected:
28516  void initializeProperties();
28517 #endif // SgAsmGenericSection_OTHERS
28518 #ifdef DOCUMENTATION
28519 };
28520 #endif // DOCUMENTATION
28521 
28522 
28524 // SgAsmCilUint8Heap -- MACHINE GENERATED; DO NOT MODIFY --
28526 
28527 DECLARE_LEAF_CLASS(AsmCilUint8Heap);
28528 IS_SERIALIZABLE(AsmCilUint8Heap);
28529 
28530 #ifdef DOCUMENTATION
28531 
28533 #endif // DOCUMENTATION
28534 
28535 #ifndef DOCUMENTATION
28536  AsmCilUint8Heap.setDataPrototype(
28537  "std::vector<uint8_t>", "Stream", "",
28538  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
28539 #endif // !DOCUMENTATION
28540 
28541  DECLARE_OTHERS(AsmCilUint8Heap);
28542 #if defined(SgAsmCilUint8Heap_OTHERS) || defined(DOCUMENTATION)
28543 
28544  //----------------------- Boost serialization for SgAsmCilUint8Heap -----------------------
28545 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
28546 private:
28547  friend class boost::serialization::access;
28548 
28549  template<class S>
28550  void serialize(S &s, const unsigned /*version*/) {
28551  debugSerializationBegin("SgAsmCilUint8Heap");
28552  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilDataStream);
28553  s & BOOST_SERIALIZATION_NVP(p_Stream);
28554  debugSerializationEnd("SgAsmCilUint8Heap");
28555  }
28556 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
28557 
28558 public:
28559  std::vector<uint8_t> const& get_Stream() const;
28560  std::vector<uint8_t>& get_Stream();
28561 public:
28562  void parse(std::vector<uint8_t>& buf, size_t startOfMetaData) override;
28563 public:
28565  virtual ~SgAsmCilUint8Heap();
28566 
28567 public:
28570 
28571 public:
28573  SgAsmCilUint8Heap(uint32_t const& Offset,
28574  uint32_t const& Size,
28575  std::string const& Name,
28576  uint32_t const& NamePadding);
28577 
28578 protected:
28585  void initializeProperties();
28586 #endif // SgAsmCilUint8Heap_OTHERS
28587 #ifdef DOCUMENTATION
28588 };
28589 #endif // DOCUMENTATION
28590 
28591 
28593 // SgAsmCilUint32Heap -- MACHINE GENERATED; DO NOT MODIFY --
28595 
28596 DECLARE_LEAF_CLASS(AsmCilUint32Heap);
28597 IS_SERIALIZABLE(AsmCilUint32Heap);
28598 
28599 #ifdef DOCUMENTATION
28600 
28602 #endif // DOCUMENTATION
28603 
28604 #ifndef DOCUMENTATION
28605  AsmCilUint32Heap.setDataPrototype(
28606  "std::vector<uint32_t>", "Stream", "",
28607  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
28608 #endif // !DOCUMENTATION
28609 
28610  DECLARE_OTHERS(AsmCilUint32Heap);
28611 #if defined(SgAsmCilUint32Heap_OTHERS) || defined(DOCUMENTATION)
28612 
28613  //----------------------- Boost serialization for SgAsmCilUint32Heap -----------------------
28614 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
28615 private:
28616  friend class boost::serialization::access;
28617 
28618  template<class S>
28619  void serialize(S &s, const unsigned /*version*/) {
28620  debugSerializationBegin("SgAsmCilUint32Heap");
28621  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilDataStream);
28622  s & BOOST_SERIALIZATION_NVP(p_Stream);
28623  debugSerializationEnd("SgAsmCilUint32Heap");
28624  }
28625 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
28626 
28627 public:
28628  std::vector<uint32_t> const& get_Stream() const;
28629  std::vector<uint32_t>& get_Stream();
28630 public:
28631  void parse(std::vector<uint8_t>& buf, size_t startOfMetaData) override;
28632 public:
28634  virtual ~SgAsmCilUint32Heap();
28635 
28636 public:
28639 
28640 public:
28642  SgAsmCilUint32Heap(uint32_t const& Offset,
28643  uint32_t const& Size,
28644  std::string const& Name,
28645  uint32_t const& NamePadding);
28646 
28647 protected:
28654  void initializeProperties();
28655 #endif // SgAsmCilUint32Heap_OTHERS
28656 #ifdef DOCUMENTATION
28657 };
28658 #endif // DOCUMENTATION
28659 
28660 
28662 // SgAsmCilTypeSpecTable -- MACHINE GENERATED; DO NOT MODIFY --
28664 
28665 DECLARE_LEAF_CLASS(AsmCilTypeSpecTable);
28666 IS_SERIALIZABLE(AsmCilTypeSpecTable);
28667 
28668 #ifdef DOCUMENTATION
28669 
28671 #endif // DOCUMENTATION
28672 
28673 #ifndef DOCUMENTATION
28674  AsmCilTypeSpecTable.setDataPrototype(
28675  "std::vector<SgAsmCilTypeSpec*>", "elements", "",
28676  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
28677 #endif // !DOCUMENTATION
28678 
28679  DECLARE_OTHERS(AsmCilTypeSpecTable);
28680 #if defined(SgAsmCilTypeSpecTable_OTHERS) || defined(DOCUMENTATION)
28681 
28682  //----------------------- Boost serialization for SgAsmCilTypeSpecTable -----------------------
28683 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
28684 private:
28685  friend class boost::serialization::access;
28686 
28687  template<class S>
28688  void serialize(S &s, const unsigned /*version*/) {
28689  debugSerializationBegin("SgAsmCilTypeSpecTable");
28690  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
28691  s & BOOST_SERIALIZATION_NVP(p_elements);
28692  debugSerializationEnd("SgAsmCilTypeSpecTable");
28693  }
28694 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
28695 
28696 public:
28697  std::vector<SgAsmCilTypeSpec*> const& get_elements() const;
28698  std::vector<SgAsmCilTypeSpec*>& get_elements();
28699 public:
28701 public:
28703  virtual ~SgAsmCilTypeSpecTable();
28704 
28705 public:
28708 
28709 protected:
28716  void initializeProperties();
28717 #endif // SgAsmCilTypeSpecTable_OTHERS
28718 #ifdef DOCUMENTATION
28719 };
28720 #endif // DOCUMENTATION
28721 
28722 
28724 // SgAsmCilTypeSpec -- MACHINE GENERATED; DO NOT MODIFY --
28726 
28727 DECLARE_LEAF_CLASS(AsmCilTypeSpec);
28728 IS_SERIALIZABLE(AsmCilTypeSpec);
28729 
28730 #ifdef DOCUMENTATION
28731 
28733 #endif // DOCUMENTATION
28734 
28735 #ifndef DOCUMENTATION
28736  AsmCilTypeSpec.setDataPrototype(
28737  "uint32_t", "Signature", "= 0",
28738  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
28739 #endif // !DOCUMENTATION
28740 
28741  DECLARE_OTHERS(AsmCilTypeSpec);
28742 #if defined(SgAsmCilTypeSpec_OTHERS) || defined(DOCUMENTATION)
28743 
28744  //----------------------- Boost serialization for SgAsmCilTypeSpec -----------------------
28745 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
28746 private:
28747  friend class boost::serialization::access;
28748 
28749  template<class S>
28750  void serialize(S &s, const unsigned /*version*/) {
28751  debugSerializationBegin("SgAsmCilTypeSpec");
28752  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
28753  s & BOOST_SERIALIZATION_NVP(p_Signature);
28754  debugSerializationEnd("SgAsmCilTypeSpec");
28755  }
28756 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
28757 
28758 public:
28764  uint32_t const& get_Signature() const;
28765  void set_Signature(uint32_t const&);
28767 public:
28768  void parse(std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing);
28769 
28770  const std::uint8_t* get_Signature_blob() const;
28771 public:
28773  virtual ~SgAsmCilTypeSpec();
28774 
28775 public:
28777  SgAsmCilTypeSpec();
28778 
28779 protected:
28786  void initializeProperties();
28787 #endif // SgAsmCilTypeSpec_OTHERS
28788 #ifdef DOCUMENTATION
28789 };
28790 #endif // DOCUMENTATION
28791 
28792 
28794 // SgAsmCilTypeRefTable -- MACHINE GENERATED; DO NOT MODIFY --
28796 
28797 DECLARE_LEAF_CLASS(AsmCilTypeRefTable);
28798 IS_SERIALIZABLE(AsmCilTypeRefTable);
28799 
28800 #ifdef DOCUMENTATION
28801 
28803 #endif // DOCUMENTATION
28804 
28805 #ifndef DOCUMENTATION
28806  AsmCilTypeRefTable.setDataPrototype(
28807  "std::vector<SgAsmCilTypeRef*>", "elements", "",
28808  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
28809 #endif // !DOCUMENTATION
28810 
28811  DECLARE_OTHERS(AsmCilTypeRefTable);
28812 #if defined(SgAsmCilTypeRefTable_OTHERS) || defined(DOCUMENTATION)
28813 
28814  //----------------------- Boost serialization for SgAsmCilTypeRefTable -----------------------
28815 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
28816 private:
28817  friend class boost::serialization::access;
28818 
28819  template<class S>
28820  void serialize(S &s, const unsigned /*version*/) {
28821  debugSerializationBegin("SgAsmCilTypeRefTable");
28822  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
28823  s & BOOST_SERIALIZATION_NVP(p_elements);
28824  debugSerializationEnd("SgAsmCilTypeRefTable");
28825  }
28826 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
28827 
28828 public:
28829  std::vector<SgAsmCilTypeRef*> const& get_elements() const;
28830  std::vector<SgAsmCilTypeRef*>& get_elements();
28831 public:
28833 public:
28835  virtual ~SgAsmCilTypeRefTable();
28836 
28837 public:
28840 
28841 protected:
28848  void initializeProperties();
28849 #endif // SgAsmCilTypeRefTable_OTHERS
28850 #ifdef DOCUMENTATION
28851 };
28852 #endif // DOCUMENTATION
28853 
28854 
28856 // SgAsmCilTypeRef -- MACHINE GENERATED; DO NOT MODIFY --
28858 
28859 DECLARE_LEAF_CLASS(AsmCilTypeRef);
28860 IS_SERIALIZABLE(AsmCilTypeRef);
28861 
28862 #ifdef DOCUMENTATION
28863 
28865 #endif // DOCUMENTATION
28866 
28867 #ifndef DOCUMENTATION
28868  AsmCilTypeRef.setDataPrototype(
28869  "uint16_t", "ResolutionScope", "= 0",
28870  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
28871 #endif // !DOCUMENTATION
28872 
28873 #ifndef DOCUMENTATION
28874  AsmCilTypeRef.setDataPrototype(
28875  "uint32_t", "TypeName", "= 0",
28876  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
28877 #endif // !DOCUMENTATION
28878 
28879 #ifndef DOCUMENTATION
28880  AsmCilTypeRef.setDataPrototype(
28881  "uint32_t", "TypeNamespace", "= 0",
28882  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
28883 #endif // !DOCUMENTATION
28884 
28885  DECLARE_OTHERS(AsmCilTypeRef);
28886 #if defined(SgAsmCilTypeRef_OTHERS) || defined(DOCUMENTATION)
28887 
28888  //----------------------- Boost serialization for SgAsmCilTypeRef -----------------------
28889 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
28890 private:
28891  friend class boost::serialization::access;
28892 
28893  template<class S>
28894  void serialize(S &s, const unsigned /*version*/) {
28895  debugSerializationBegin("SgAsmCilTypeRef");
28896  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
28897  s & BOOST_SERIALIZATION_NVP(p_ResolutionScope);
28898  s & BOOST_SERIALIZATION_NVP(p_TypeName);
28899  s & BOOST_SERIALIZATION_NVP(p_TypeNamespace);
28900  debugSerializationEnd("SgAsmCilTypeRef");
28901  }
28902 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
28903 
28904 public:
28910  uint16_t const& get_ResolutionScope() const;
28911  void set_ResolutionScope(uint16_t const&);
28914 public:
28920  uint32_t const& get_TypeName() const;
28921  void set_TypeName(uint32_t const&);
28924 public:
28930  uint32_t const& get_TypeNamespace() const;
28931  void set_TypeNamespace(uint32_t const&);
28933 public:
28934  void parse(std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing);
28935 
28936  const SgAsmCilMetadata* get_ResolutionScope_object() const;
28937  const std::uint8_t* get_TypeName_string() const;
28938  const std::uint8_t* get_TypeNamespace_string() const;
28939 public:
28941  virtual ~SgAsmCilTypeRef();
28942 
28943 public:
28945  SgAsmCilTypeRef();
28946 
28947 protected:
28954  void initializeProperties();
28955 #endif // SgAsmCilTypeRef_OTHERS
28956 #ifdef DOCUMENTATION
28957 };
28958 #endif // DOCUMENTATION
28959 
28960 
28962 // SgAsmCilTypeDefTable -- MACHINE GENERATED; DO NOT MODIFY --
28964 
28965 DECLARE_LEAF_CLASS(AsmCilTypeDefTable);
28966 IS_SERIALIZABLE(AsmCilTypeDefTable);
28967 
28968 #ifdef DOCUMENTATION
28969 
28971 #endif // DOCUMENTATION
28972 
28973 #ifndef DOCUMENTATION
28974  AsmCilTypeDefTable.setDataPrototype(
28975  "std::vector<SgAsmCilTypeDef*>", "elements", "",
28976  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
28977 #endif // !DOCUMENTATION
28978 
28979  DECLARE_OTHERS(AsmCilTypeDefTable);
28980 #if defined(SgAsmCilTypeDefTable_OTHERS) || defined(DOCUMENTATION)
28981 
28982  //----------------------- Boost serialization for SgAsmCilTypeDefTable -----------------------
28983 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
28984 private:
28985  friend class boost::serialization::access;
28986 
28987  template<class S>
28988  void serialize(S &s, const unsigned /*version*/) {
28989  debugSerializationBegin("SgAsmCilTypeDefTable");
28990  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
28991  s & BOOST_SERIALIZATION_NVP(p_elements);
28992  debugSerializationEnd("SgAsmCilTypeDefTable");
28993  }
28994 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
28995 
28996 public:
28997  std::vector<SgAsmCilTypeDef*> const& get_elements() const;
28998  std::vector<SgAsmCilTypeDef*>& get_elements();
28999 public:
29001 public:
29003  virtual ~SgAsmCilTypeDefTable();
29004 
29005 public:
29008 
29009 protected:
29016  void initializeProperties();
29017 #endif // SgAsmCilTypeDefTable_OTHERS
29018 #ifdef DOCUMENTATION
29019 };
29020 #endif // DOCUMENTATION
29021 
29022 
29024 // SgAsmCilTypeDef -- MACHINE GENERATED; DO NOT MODIFY --
29026 
29027 DECLARE_LEAF_CLASS(AsmCilTypeDef);
29028 IS_SERIALIZABLE(AsmCilTypeDef);
29029 
29030 #ifdef DOCUMENTATION
29031 
29033 #endif // DOCUMENTATION
29034 
29035 #ifndef DOCUMENTATION
29036  AsmCilTypeDef.setDataPrototype(
29037  "uint32_t", "Flags", "= 0",
29038  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
29039 #endif // !DOCUMENTATION
29040 
29041 #ifndef DOCUMENTATION
29042  AsmCilTypeDef.setDataPrototype(
29043  "uint32_t", "TypeName", "= 0",
29044  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
29045 #endif // !DOCUMENTATION
29046 
29047 #ifndef DOCUMENTATION
29048  AsmCilTypeDef.setDataPrototype(
29049  "uint32_t", "TypeNamespace", "= 0",
29050  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
29051 #endif // !DOCUMENTATION
29052 
29053 #ifndef DOCUMENTATION
29054  AsmCilTypeDef.setDataPrototype(
29055  "uint32_t", "Extends", "= 0",
29056  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
29057 #endif // !DOCUMENTATION
29058 
29059 #ifndef DOCUMENTATION
29060  AsmCilTypeDef.setDataPrototype(
29061  "uint32_t", "FieldList", "= 0",
29062  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
29063 #endif // !DOCUMENTATION
29064 
29065 #ifndef DOCUMENTATION
29066  AsmCilTypeDef.setDataPrototype(
29067  "uint32_t", "MethodList", "= 0",
29068  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
29069 #endif // !DOCUMENTATION
29070 
29071  DECLARE_OTHERS(AsmCilTypeDef);
29072 #if defined(SgAsmCilTypeDef_OTHERS) || defined(DOCUMENTATION)
29073 
29074  //----------------------- Boost serialization for SgAsmCilTypeDef -----------------------
29075 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
29076 private:
29077  friend class boost::serialization::access;
29078 
29079  template<class S>
29080  void serialize(S &s, const unsigned /*version*/) {
29081  debugSerializationBegin("SgAsmCilTypeDef");
29082  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
29083  s & BOOST_SERIALIZATION_NVP(p_Flags);
29084  s & BOOST_SERIALIZATION_NVP(p_TypeName);
29085  s & BOOST_SERIALIZATION_NVP(p_TypeNamespace);
29086  s & BOOST_SERIALIZATION_NVP(p_Extends);
29087  s & BOOST_SERIALIZATION_NVP(p_FieldList);
29088  s & BOOST_SERIALIZATION_NVP(p_MethodList);
29089  debugSerializationEnd("SgAsmCilTypeDef");
29090  }
29091 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
29092 
29093 public:
29099  uint32_t const& get_Flags() const;
29100  void set_Flags(uint32_t const&);
29103 public:
29109  uint32_t const& get_TypeName() const;
29110  void set_TypeName(uint32_t const&);
29113 public:
29119  uint32_t const& get_TypeNamespace() const;
29120  void set_TypeNamespace(uint32_t const&);
29123 public:
29129  uint32_t const& get_Extends() const;
29130  void set_Extends(uint32_t const&);
29133 public:
29139  uint32_t const& get_FieldList() const;
29140  void set_FieldList(uint32_t const&);
29143 public:
29149  uint32_t const& get_MethodList() const;
29150  void set_MethodList(uint32_t const&);
29152 public:
29153  void parse(std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing);
29154 
29155  const std::uint8_t* get_TypeName_string() const;
29156  const std::uint8_t* get_TypeNamespace_string() const;
29157  const SgAsmCilMetadata* get_Extends_object() const;
29158  const SgAsmCilMetadata* get_FieldList_object() const;
29159  const SgAsmCilMetadata* get_MethodList_object() const;
29160 public:
29162  virtual ~SgAsmCilTypeDef();
29163 
29164 public:
29166  SgAsmCilTypeDef();
29167 
29168 protected:
29175  void initializeProperties();
29176 #endif // SgAsmCilTypeDef_OTHERS
29177 #ifdef DOCUMENTATION
29178 };
29179 #endif // DOCUMENTATION
29180 
29181 
29183 // SgAsmCilStandAloneSigTable -- MACHINE GENERATED; DO NOT MODIFY --
29185 
29186 DECLARE_LEAF_CLASS(AsmCilStandAloneSigTable);
29187 IS_SERIALIZABLE(AsmCilStandAloneSigTable);
29188 
29189 #ifdef DOCUMENTATION
29190 
29192 #endif // DOCUMENTATION
29193 
29194 #ifndef DOCUMENTATION
29195  AsmCilStandAloneSigTable.setDataPrototype(
29196  "std::vector<SgAsmCilStandAloneSig*>", "elements", "",
29197  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
29198 #endif // !DOCUMENTATION
29199 
29200  DECLARE_OTHERS(AsmCilStandAloneSigTable);
29201 #if defined(SgAsmCilStandAloneSigTable_OTHERS) || defined(DOCUMENTATION)
29202 
29203  //----------------------- Boost serialization for SgAsmCilStandAloneSigTable -----------------------
29204 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
29205 private:
29206  friend class boost::serialization::access;
29207 
29208  template<class S>
29209  void serialize(S &s, const unsigned /*version*/) {
29210  debugSerializationBegin("SgAsmCilStandAloneSigTable");
29211  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
29212  s & BOOST_SERIALIZATION_NVP(p_elements);
29213  debugSerializationEnd("SgAsmCilStandAloneSigTable");
29214  }
29215 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
29216 
29217 public:
29218  std::vector<SgAsmCilStandAloneSig*> const& get_elements() const;
29219  std::vector<SgAsmCilStandAloneSig*>& get_elements();
29220 public:
29222 public:
29224  virtual ~SgAsmCilStandAloneSigTable();
29225 
29226 public:
29229 
29230 protected:
29237  void initializeProperties();
29238 #endif // SgAsmCilStandAloneSigTable_OTHERS
29239 #ifdef DOCUMENTATION
29240 };
29241 #endif // DOCUMENTATION
29242 
29243 
29245 // SgAsmCilStandAloneSig -- MACHINE GENERATED; DO NOT MODIFY --
29247 
29248 DECLARE_LEAF_CLASS(AsmCilStandAloneSig);
29249 IS_SERIALIZABLE(AsmCilStandAloneSig);
29250 
29251 #ifdef DOCUMENTATION
29252 
29254 #endif // DOCUMENTATION
29255 
29256 #ifndef DOCUMENTATION
29257  AsmCilStandAloneSig.setDataPrototype(
29258  "uint32_t", "Signature", "= 0",
29259  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
29260 #endif // !DOCUMENTATION
29261 
29262  DECLARE_OTHERS(AsmCilStandAloneSig);
29263 #if defined(SgAsmCilStandAloneSig_OTHERS) || defined(DOCUMENTATION)
29264 
29265  //----------------------- Boost serialization for SgAsmCilStandAloneSig -----------------------
29266 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
29267 private:
29268  friend class boost::serialization::access;
29269 
29270  template<class S>
29271  void serialize(S &s, const unsigned /*version*/) {
29272  debugSerializationBegin("SgAsmCilStandAloneSig");
29273  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
29274  s & BOOST_SERIALIZATION_NVP(p_Signature);
29275  debugSerializationEnd("SgAsmCilStandAloneSig");
29276  }
29277 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
29278 
29279 public:
29285  uint32_t const& get_Signature() const;
29286  void set_Signature(uint32_t const&);
29288 public:
29289  void parse(std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing);
29290 
29291  const std::uint8_t* get_Signature_blob() const;
29292 public:
29294  virtual ~SgAsmCilStandAloneSig();
29295 
29296 public:
29299 
29300 protected:
29307  void initializeProperties();
29308 #endif // SgAsmCilStandAloneSig_OTHERS
29309 #ifdef DOCUMENTATION
29310 };
29311 #endif // DOCUMENTATION
29312 
29313 
29315 // SgAsmCilPropertyTable -- MACHINE GENERATED; DO NOT MODIFY --
29317 
29318 DECLARE_LEAF_CLASS(AsmCilPropertyTable);
29319 IS_SERIALIZABLE(AsmCilPropertyTable);
29320 
29321 #ifdef DOCUMENTATION
29322 
29324 #endif // DOCUMENTATION
29325 
29326 #ifndef DOCUMENTATION
29327  AsmCilPropertyTable.setDataPrototype(
29328  "std::vector<SgAsmCilProperty*>", "elements", "",
29329  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
29330 #endif // !DOCUMENTATION
29331 
29332  DECLARE_OTHERS(AsmCilPropertyTable);
29333 #if defined(SgAsmCilPropertyTable_OTHERS) || defined(DOCUMENTATION)
29334 
29335  //----------------------- Boost serialization for SgAsmCilPropertyTable -----------------------
29336 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
29337 private:
29338  friend class boost::serialization::access;
29339 
29340  template<class S>
29341  void serialize(S &s, const unsigned /*version*/) {
29342  debugSerializationBegin("SgAsmCilPropertyTable");
29343  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
29344  s & BOOST_SERIALIZATION_NVP(p_elements);
29345  debugSerializationEnd("SgAsmCilPropertyTable");
29346  }
29347 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
29348 
29349 public:
29350  std::vector<SgAsmCilProperty*> const& get_elements() const;
29351  std::vector<SgAsmCilProperty*>& get_elements();
29352 public:
29354 public:
29356  virtual ~SgAsmCilPropertyTable();
29357 
29358 public:
29361 
29362 protected:
29369  void initializeProperties();
29370 #endif // SgAsmCilPropertyTable_OTHERS
29371 #ifdef DOCUMENTATION
29372 };
29373 #endif // DOCUMENTATION
29374 
29375 
29377 // SgAsmCilPropertyMapTable -- MACHINE GENERATED; DO NOT MODIFY --
29379 
29380 DECLARE_LEAF_CLASS(AsmCilPropertyMapTable);
29381 IS_SERIALIZABLE(AsmCilPropertyMapTable);
29382 
29383 #ifdef DOCUMENTATION
29384 
29386 #endif // DOCUMENTATION
29387 
29388 #ifndef DOCUMENTATION
29389  AsmCilPropertyMapTable.setDataPrototype(
29390  "std::vector<SgAsmCilPropertyMap*>", "elements", "",
29391  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
29392 #endif // !DOCUMENTATION
29393 
29394  DECLARE_OTHERS(AsmCilPropertyMapTable);
29395 #if defined(SgAsmCilPropertyMapTable_OTHERS) || defined(DOCUMENTATION)
29396 
29397  //----------------------- Boost serialization for SgAsmCilPropertyMapTable -----------------------
29398 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
29399 private:
29400  friend class boost::serialization::access;
29401 
29402  template<class S>
29403  void serialize(S &s, const unsigned /*version*/) {
29404  debugSerializationBegin("SgAsmCilPropertyMapTable");
29405  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
29406  s & BOOST_SERIALIZATION_NVP(p_elements);
29407  debugSerializationEnd("SgAsmCilPropertyMapTable");
29408  }
29409 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
29410 
29411 public:
29412  std::vector<SgAsmCilPropertyMap*> const& get_elements() const;
29413  std::vector<SgAsmCilPropertyMap*>& get_elements();
29414 public:
29416 public:
29418  virtual ~SgAsmCilPropertyMapTable();
29419 
29420 public:
29423 
29424 protected:
29431  void initializeProperties();
29432 #endif // SgAsmCilPropertyMapTable_OTHERS
29433 #ifdef DOCUMENTATION
29434 };
29435 #endif // DOCUMENTATION
29436 
29437 
29439 // SgAsmCilPropertyMap -- MACHINE GENERATED; DO NOT MODIFY --
29441 
29442 DECLARE_LEAF_CLASS(AsmCilPropertyMap);
29443 IS_SERIALIZABLE(AsmCilPropertyMap);
29444 
29445 #ifdef DOCUMENTATION
29446 
29448 #endif // DOCUMENTATION
29449 
29450 #ifndef DOCUMENTATION
29451  AsmCilPropertyMap.setDataPrototype(
29452  "uint32_t", "Parent", "= 0",
29453  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
29454 #endif // !DOCUMENTATION
29455 
29456 #ifndef DOCUMENTATION
29457  AsmCilPropertyMap.setDataPrototype(
29458  "uint32_t", "PropertyList", "= 0",
29459  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
29460 #endif // !DOCUMENTATION
29461 
29462  DECLARE_OTHERS(AsmCilPropertyMap);
29463 #if defined(SgAsmCilPropertyMap_OTHERS) || defined(DOCUMENTATION)
29464 
29465  //----------------------- Boost serialization for SgAsmCilPropertyMap -----------------------
29466 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
29467 private:
29468  friend class boost::serialization::access;
29469 
29470  template<class S>
29471  void serialize(S &s, const unsigned /*version*/) {
29472  debugSerializationBegin("SgAsmCilPropertyMap");
29473  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
29474  s & BOOST_SERIALIZATION_NVP(p_Parent);
29475  s & BOOST_SERIALIZATION_NVP(p_PropertyList);
29476  debugSerializationEnd("SgAsmCilPropertyMap");
29477  }
29478 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
29479 
29480 public:
29486  uint32_t const& get_Parent() const;
29487  void set_Parent(uint32_t const&);
29490 public:
29496  uint32_t const& get_PropertyList() const;
29497  void set_PropertyList(uint32_t const&);
29499 public:
29500  void parse(std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing);
29501 
29502  const SgAsmCilMetadata* get_Parent_object() const;
29503  const SgAsmCilMetadata* get_PropertyList_object() const;
29504 public:
29506  virtual ~SgAsmCilPropertyMap();
29507 
29508 public:
29511 
29512 protected:
29519  void initializeProperties();
29520 #endif // SgAsmCilPropertyMap_OTHERS
29521 #ifdef DOCUMENTATION
29522 };
29523 #endif // DOCUMENTATION
29524 
29525 
29527 // SgAsmCilProperty -- MACHINE GENERATED; DO NOT MODIFY --
29529 
29530 DECLARE_LEAF_CLASS(AsmCilProperty);
29531 IS_SERIALIZABLE(AsmCilProperty);
29532 
29533 #ifdef DOCUMENTATION
29534 
29536 #endif // DOCUMENTATION
29537 
29538 #ifndef DOCUMENTATION
29539  AsmCilProperty.setDataPrototype(
29540  "uint16_t", "Flags", "= 0",
29541  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
29542 #endif // !DOCUMENTATION
29543 
29544 #ifndef DOCUMENTATION
29545  AsmCilProperty.setDataPrototype(
29546  "uint32_t", "Name", "= 0",
29547  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
29548 #endif // !DOCUMENTATION
29549 
29550 #ifndef DOCUMENTATION
29551  AsmCilProperty.setDataPrototype(
29552  "uint32_t", "Type", "= 0",
29553  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
29554 #endif // !DOCUMENTATION
29555 
29556  DECLARE_OTHERS(AsmCilProperty);
29557 #if defined(SgAsmCilProperty_OTHERS) || defined(DOCUMENTATION)
29558 
29559  //----------------------- Boost serialization for SgAsmCilProperty -----------------------
29560 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
29561 private:
29562  friend class boost::serialization::access;
29563 
29564  template<class S>
29565  void serialize(S &s, const unsigned /*version*/) {
29566  debugSerializationBegin("SgAsmCilProperty");
29567  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
29568  s & BOOST_SERIALIZATION_NVP(p_Flags);
29569  s & BOOST_SERIALIZATION_NVP(p_Name);
29570  s & BOOST_SERIALIZATION_NVP(p_Type);
29571  debugSerializationEnd("SgAsmCilProperty");
29572  }
29573 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
29574 
29575 public:
29581  uint16_t const& get_Flags() const;
29582  void set_Flags(uint16_t const&);
29585 public:
29591  uint32_t const& get_Name() const;
29592  void set_Name(uint32_t const&);
29595 public:
29601  uint32_t const& get_Type() const;
29602  void set_Type(uint32_t const&);
29604 public:
29605  void parse(std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing);
29606 
29607  const std::uint8_t* get_Name_string() const;
29608  const std::uint8_t* get_Type_blob() const;
29609 public:
29611  virtual ~SgAsmCilProperty();
29612 
29613 public:
29615  SgAsmCilProperty();
29616 
29617 protected:
29624  void initializeProperties();
29625 #endif // SgAsmCilProperty_OTHERS
29626 #ifdef DOCUMENTATION
29627 };
29628 #endif // DOCUMENTATION
29629 
29630 
29632 // SgAsmCilParamTable -- MACHINE GENERATED; DO NOT MODIFY --
29634 
29635 DECLARE_LEAF_CLASS(AsmCilParamTable);
29636 IS_SERIALIZABLE(AsmCilParamTable);
29637 
29638 #ifdef DOCUMENTATION
29639 
29641 #endif // DOCUMENTATION
29642 
29643 #ifndef DOCUMENTATION
29644  AsmCilParamTable.setDataPrototype(
29645  "std::vector<SgAsmCilParam*>", "elements", "",
29646  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
29647 #endif // !DOCUMENTATION
29648 
29649  DECLARE_OTHERS(AsmCilParamTable);
29650 #if defined(SgAsmCilParamTable_OTHERS) || defined(DOCUMENTATION)
29651 
29652  //----------------------- Boost serialization for SgAsmCilParamTable -----------------------
29653 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
29654 private:
29655  friend class boost::serialization::access;
29656 
29657  template<class S>
29658  void serialize(S &s, const unsigned /*version*/) {
29659  debugSerializationBegin("SgAsmCilParamTable");
29660  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
29661  s & BOOST_SERIALIZATION_NVP(p_elements);
29662  debugSerializationEnd("SgAsmCilParamTable");
29663  }
29664 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
29665 
29666 public:
29667  std::vector<SgAsmCilParam*> const& get_elements() const;
29668  std::vector<SgAsmCilParam*>& get_elements();
29669 public:
29671 public:
29673  virtual ~SgAsmCilParamTable();
29674 
29675 public:
29678 
29679 protected:
29686  void initializeProperties();
29687 #endif // SgAsmCilParamTable_OTHERS
29688 #ifdef DOCUMENTATION
29689 };
29690 #endif // DOCUMENTATION
29691 
29692 
29694 // SgAsmCilParam -- MACHINE GENERATED; DO NOT MODIFY --
29696 
29697 DECLARE_LEAF_CLASS(AsmCilParam);
29698 IS_SERIALIZABLE(AsmCilParam);
29699 
29700 #ifdef DOCUMENTATION
29701 
29703 #endif // DOCUMENTATION
29704 
29705 #ifndef DOCUMENTATION
29706  AsmCilParam.setDataPrototype(
29707  "uint16_t", "Flags", "= 0",
29708  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
29709 #endif // !DOCUMENTATION
29710 
29711 #ifndef DOCUMENTATION
29712  AsmCilParam.setDataPrototype(
29713  "uint16_t", "Sequence", "= 0",
29714  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
29715 #endif // !DOCUMENTATION
29716 
29717 #ifndef DOCUMENTATION
29718  AsmCilParam.setDataPrototype(
29719  "uint32_t", "Name", "= 0",
29720  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
29721 #endif // !DOCUMENTATION
29722 
29723  DECLARE_OTHERS(AsmCilParam);
29724 #if defined(SgAsmCilParam_OTHERS) || defined(DOCUMENTATION)
29725 
29726  //----------------------- Boost serialization for SgAsmCilParam -----------------------
29727 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
29728 private:
29729  friend class boost::serialization::access;
29730 
29731  template<class S>
29732  void serialize(S &s, const unsigned /*version*/) {
29733  debugSerializationBegin("SgAsmCilParam");
29734  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
29735  s & BOOST_SERIALIZATION_NVP(p_Flags);
29736  s & BOOST_SERIALIZATION_NVP(p_Sequence);
29737  s & BOOST_SERIALIZATION_NVP(p_Name);
29738  debugSerializationEnd("SgAsmCilParam");
29739  }
29740 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
29741 
29742 public:
29748  uint16_t const& get_Flags() const;
29749  void set_Flags(uint16_t const&);
29752 public:
29758  uint16_t const& get_Sequence() const;
29759  void set_Sequence(uint16_t const&);
29762 public:
29768  uint32_t const& get_Name() const;
29769  void set_Name(uint32_t const&);
29771 public:
29772  void parse(std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing);
29773 
29774  const std::uint8_t* get_Name_blob() const;
29775 public:
29777  virtual ~SgAsmCilParam();
29778 
29779 public:
29781  SgAsmCilParam();
29782 
29783 protected:
29790  void initializeProperties();
29791 #endif // SgAsmCilParam_OTHERS
29792 #ifdef DOCUMENTATION
29793 };
29794 #endif // DOCUMENTATION
29795 
29796 
29798 // SgAsmCilNestedClassTable -- MACHINE GENERATED; DO NOT MODIFY --
29800 
29801 DECLARE_LEAF_CLASS(AsmCilNestedClassTable);
29802 IS_SERIALIZABLE(AsmCilNestedClassTable);
29803 
29804 #ifdef DOCUMENTATION
29805 
29807 #endif // DOCUMENTATION
29808 
29809 #ifndef DOCUMENTATION
29810  AsmCilNestedClassTable.setDataPrototype(
29811  "std::vector<SgAsmCilNestedClass*>", "elements", "",
29812  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
29813 #endif // !DOCUMENTATION
29814 
29815  DECLARE_OTHERS(AsmCilNestedClassTable);
29816 #if defined(SgAsmCilNestedClassTable_OTHERS) || defined(DOCUMENTATION)
29817 
29818  //----------------------- Boost serialization for SgAsmCilNestedClassTable -----------------------
29819 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
29820 private:
29821  friend class boost::serialization::access;
29822 
29823  template<class S>
29824  void serialize(S &s, const unsigned /*version*/) {
29825  debugSerializationBegin("SgAsmCilNestedClassTable");
29826  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
29827  s & BOOST_SERIALIZATION_NVP(p_elements);
29828  debugSerializationEnd("SgAsmCilNestedClassTable");
29829  }
29830 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
29831 
29832 public:
29833  std::vector<SgAsmCilNestedClass*> const& get_elements() const;
29834  std::vector<SgAsmCilNestedClass*>& get_elements();
29835 public:
29837 public:
29839  virtual ~SgAsmCilNestedClassTable();
29840 
29841 public:
29844 
29845 protected:
29852  void initializeProperties();
29853 #endif // SgAsmCilNestedClassTable_OTHERS
29854 #ifdef DOCUMENTATION
29855 };
29856 #endif // DOCUMENTATION
29857 
29858 
29860 // SgAsmCilNestedClass -- MACHINE GENERATED; DO NOT MODIFY --
29862 
29863 DECLARE_LEAF_CLASS(AsmCilNestedClass);
29864 IS_SERIALIZABLE(AsmCilNestedClass);
29865 
29866 #ifdef DOCUMENTATION
29867 
29869 #endif // DOCUMENTATION
29870 
29871 #ifndef DOCUMENTATION
29872  AsmCilNestedClass.setDataPrototype(
29873  "uint32_t", "NestedClass", "= 0",
29874  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
29875 #endif // !DOCUMENTATION
29876 
29877 #ifndef DOCUMENTATION
29878  AsmCilNestedClass.setDataPrototype(
29879  "uint32_t", "EnclosingClass", "= 0",
29880  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
29881 #endif // !DOCUMENTATION
29882 
29883  DECLARE_OTHERS(AsmCilNestedClass);
29884 #if defined(SgAsmCilNestedClass_OTHERS) || defined(DOCUMENTATION)
29885 
29886  //----------------------- Boost serialization for SgAsmCilNestedClass -----------------------
29887 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
29888 private:
29889  friend class boost::serialization::access;
29890 
29891  template<class S>
29892  void serialize(S &s, const unsigned /*version*/) {
29893  debugSerializationBegin("SgAsmCilNestedClass");
29894  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
29895  s & BOOST_SERIALIZATION_NVP(p_NestedClass);
29896  s & BOOST_SERIALIZATION_NVP(p_EnclosingClass);
29897  debugSerializationEnd("SgAsmCilNestedClass");
29898  }
29899 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
29900 
29901 public:
29907  uint32_t const& get_NestedClass() const;
29908  void set_NestedClass(uint32_t const&);
29911 public:
29917  uint32_t const& get_EnclosingClass() const;
29918  void set_EnclosingClass(uint32_t const&);
29920 public:
29921  void parse(std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing);
29922 
29923  const SgAsmCilMetadata* get_NestedClass_object() const;
29924  const SgAsmCilMetadata* get_EnclosingClass_object() const;
29925 public:
29927  virtual ~SgAsmCilNestedClass();
29928 
29929 public:
29932 
29933 protected:
29940  void initializeProperties();
29941 #endif // SgAsmCilNestedClass_OTHERS
29942 #ifdef DOCUMENTATION
29943 };
29944 #endif // DOCUMENTATION
29945 
29946 
29948 // SgAsmCilModuleTable -- MACHINE GENERATED; DO NOT MODIFY --
29950 
29951 DECLARE_LEAF_CLASS(AsmCilModuleTable);
29952 IS_SERIALIZABLE(AsmCilModuleTable);
29953 
29954 #ifdef DOCUMENTATION
29955 
29957 #endif // DOCUMENTATION
29958 
29959 #ifndef DOCUMENTATION
29960  AsmCilModuleTable.setDataPrototype(
29961  "std::vector<SgAsmCilModule*>", "elements", "",
29962  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
29963 #endif // !DOCUMENTATION
29964 
29965  DECLARE_OTHERS(AsmCilModuleTable);
29966 #if defined(SgAsmCilModuleTable_OTHERS) || defined(DOCUMENTATION)
29967 
29968  //----------------------- Boost serialization for SgAsmCilModuleTable -----------------------
29969 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
29970 private:
29971  friend class boost::serialization::access;
29972 
29973  template<class S>
29974  void serialize(S &s, const unsigned /*version*/) {
29975  debugSerializationBegin("SgAsmCilModuleTable");
29976  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
29977  s & BOOST_SERIALIZATION_NVP(p_elements);
29978  debugSerializationEnd("SgAsmCilModuleTable");
29979  }
29980 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
29981 
29982 public:
29983  std::vector<SgAsmCilModule*> const& get_elements() const;
29984  std::vector<SgAsmCilModule*>& get_elements();
29985 public:
29987 public:
29989  virtual ~SgAsmCilModuleTable();
29990 
29991 public:
29994 
29995 protected:
30002  void initializeProperties();
30003 #endif // SgAsmCilModuleTable_OTHERS
30004 #ifdef DOCUMENTATION
30005 };
30006 #endif // DOCUMENTATION
30007 
30008 
30010 // SgAsmCilModuleRefTable -- MACHINE GENERATED; DO NOT MODIFY --
30012 
30013 DECLARE_LEAF_CLASS(AsmCilModuleRefTable);
30014 IS_SERIALIZABLE(AsmCilModuleRefTable);
30015 
30016 #ifdef DOCUMENTATION
30017 
30019 #endif // DOCUMENTATION
30020 
30021 #ifndef DOCUMENTATION
30022  AsmCilModuleRefTable.setDataPrototype(
30023  "std::vector<SgAsmCilModuleRef*>", "elements", "",
30024  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
30025 #endif // !DOCUMENTATION
30026 
30027  DECLARE_OTHERS(AsmCilModuleRefTable);
30028 #if defined(SgAsmCilModuleRefTable_OTHERS) || defined(DOCUMENTATION)
30029 
30030  //----------------------- Boost serialization for SgAsmCilModuleRefTable -----------------------
30031 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
30032 private:
30033  friend class boost::serialization::access;
30034 
30035  template<class S>
30036  void serialize(S &s, const unsigned /*version*/) {
30037  debugSerializationBegin("SgAsmCilModuleRefTable");
30038  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
30039  s & BOOST_SERIALIZATION_NVP(p_elements);
30040  debugSerializationEnd("SgAsmCilModuleRefTable");
30041  }
30042 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
30043 
30044 public:
30045  std::vector<SgAsmCilModuleRef*> const& get_elements() const;
30046  std::vector<SgAsmCilModuleRef*>& get_elements();
30047 public:
30049 public:
30051  virtual ~SgAsmCilModuleRefTable();
30052 
30053 public:
30056 
30057 protected:
30064  void initializeProperties();
30065 #endif // SgAsmCilModuleRefTable_OTHERS
30066 #ifdef DOCUMENTATION
30067 };
30068 #endif // DOCUMENTATION
30069 
30070 
30072 // SgAsmCilModuleRef -- MACHINE GENERATED; DO NOT MODIFY --
30074 
30075 DECLARE_LEAF_CLASS(AsmCilModuleRef);
30076 IS_SERIALIZABLE(AsmCilModuleRef);
30077 
30078 #ifdef DOCUMENTATION
30079 
30081 #endif // DOCUMENTATION
30082 
30083 #ifndef DOCUMENTATION
30084  AsmCilModuleRef.setDataPrototype(
30085  "uint32_t", "Name", "= 0",
30086  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
30087 #endif // !DOCUMENTATION
30088 
30089  DECLARE_OTHERS(AsmCilModuleRef);
30090 #if defined(SgAsmCilModuleRef_OTHERS) || defined(DOCUMENTATION)
30091 
30092  //----------------------- Boost serialization for SgAsmCilModuleRef -----------------------
30093 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
30094 private:
30095  friend class boost::serialization::access;
30096 
30097  template<class S>
30098  void serialize(S &s, const unsigned /*version*/) {
30099  debugSerializationBegin("SgAsmCilModuleRef");
30100  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
30101  s & BOOST_SERIALIZATION_NVP(p_Name);
30102  debugSerializationEnd("SgAsmCilModuleRef");
30103  }
30104 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
30105 
30106 public:
30112  uint32_t const& get_Name() const;
30113  void set_Name(uint32_t const&);
30115 public:
30116  void parse(std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing);
30117 
30118  const std::uint8_t* get_Name_string() const;
30119 public:
30121  virtual ~SgAsmCilModuleRef();
30122 
30123 public:
30126 
30127 protected:
30134  void initializeProperties();
30135 #endif // SgAsmCilModuleRef_OTHERS
30136 #ifdef DOCUMENTATION
30137 };
30138 #endif // DOCUMENTATION
30139 
30140 
30142 // SgAsmCilModule -- MACHINE GENERATED; DO NOT MODIFY --
30144 
30145 DECLARE_LEAF_CLASS(AsmCilModule);
30146 IS_SERIALIZABLE(AsmCilModule);
30147 
30148 #ifdef DOCUMENTATION
30149 
30151 #endif // DOCUMENTATION
30152 
30153 #ifndef DOCUMENTATION
30154  AsmCilModule.setDataPrototype(
30155  "uint16_t", "Generation", "= 0",
30156  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
30157 #endif // !DOCUMENTATION
30158 
30159 #ifndef DOCUMENTATION
30160  AsmCilModule.setDataPrototype(
30161  "uint32_t", "Name", "= 0",
30162  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
30163 #endif // !DOCUMENTATION
30164 
30165 #ifndef DOCUMENTATION
30166  AsmCilModule.setDataPrototype(
30167  "uint32_t", "Mvid", "= 0",
30168  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
30169 #endif // !DOCUMENTATION
30170 
30171 #ifndef DOCUMENTATION
30172  AsmCilModule.setDataPrototype(
30173  "uint32_t", "Encld", "= 0",
30174  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
30175 #endif // !DOCUMENTATION
30176 
30177 #ifndef DOCUMENTATION
30178  AsmCilModule.setDataPrototype(
30179  "uint32_t", "EncBaseId", "= 0",
30180  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
30181 #endif // !DOCUMENTATION
30182 
30183  DECLARE_OTHERS(AsmCilModule);
30184 #if defined(SgAsmCilModule_OTHERS) || defined(DOCUMENTATION)
30185 
30186  //----------------------- Boost serialization for SgAsmCilModule -----------------------
30187 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
30188 private:
30189  friend class boost::serialization::access;
30190 
30191  template<class S>
30192  void serialize(S &s, const unsigned /*version*/) {
30193  debugSerializationBegin("SgAsmCilModule");
30194  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
30195  s & BOOST_SERIALIZATION_NVP(p_Generation);
30196  s & BOOST_SERIALIZATION_NVP(p_Name);
30197  s & BOOST_SERIALIZATION_NVP(p_Mvid);
30198  s & BOOST_SERIALIZATION_NVP(p_Encld);
30199  s & BOOST_SERIALIZATION_NVP(p_EncBaseId);
30200  debugSerializationEnd("SgAsmCilModule");
30201  }
30202 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
30203 
30204 public:
30210  uint16_t const& get_Generation() const;
30211  void set_Generation(uint16_t const&);
30214 public:
30220  uint32_t const& get_Name() const;
30221  void set_Name(uint32_t const&);
30224 public:
30230  uint32_t const& get_Mvid() const;
30231  void set_Mvid(uint32_t const&);
30234 public:
30240  uint32_t const& get_Encld() const;
30241  void set_Encld(uint32_t const&);
30244 public:
30250  uint32_t const& get_EncBaseId() const;
30251  void set_EncBaseId(uint32_t const&);
30253 public:
30254  void parse(std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing);
30255 
30256  const std::uint8_t* get_Name_string() const;
30257  const std::uint32_t* get_Mvid_guid() const;
30258  const std::uint32_t* get_Encld_guid() const;
30259  const std::uint32_t* get_EncBaseId_guid() const;
30260 public:
30262  virtual ~SgAsmCilModule();
30263 
30264 public:
30266  SgAsmCilModule();
30267 
30268 protected:
30275  void initializeProperties();
30276 #endif // SgAsmCilModule_OTHERS
30277 #ifdef DOCUMENTATION
30278 };
30279 #endif // DOCUMENTATION
30280 
30281 
30283 // SgAsmCilMethodSpecTable -- MACHINE GENERATED; DO NOT MODIFY --
30285 
30286 DECLARE_LEAF_CLASS(AsmCilMethodSpecTable);
30287 IS_SERIALIZABLE(AsmCilMethodSpecTable);
30288 
30289 #ifdef DOCUMENTATION
30290 
30292 #endif // DOCUMENTATION
30293 
30294 #ifndef DOCUMENTATION
30295  AsmCilMethodSpecTable.setDataPrototype(
30296  "std::vector<SgAsmCilMethodSpec*>", "elements", "",
30297  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
30298 #endif // !DOCUMENTATION
30299 
30300  DECLARE_OTHERS(AsmCilMethodSpecTable);
30301 #if defined(SgAsmCilMethodSpecTable_OTHERS) || defined(DOCUMENTATION)
30302 
30303  //----------------------- Boost serialization for SgAsmCilMethodSpecTable -----------------------
30304 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
30305 private:
30306  friend class boost::serialization::access;
30307 
30308  template<class S>
30309  void serialize(S &s, const unsigned /*version*/) {
30310  debugSerializationBegin("SgAsmCilMethodSpecTable");
30311  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
30312  s & BOOST_SERIALIZATION_NVP(p_elements);
30313  debugSerializationEnd("SgAsmCilMethodSpecTable");
30314  }
30315 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
30316 
30317 public:
30318  std::vector<SgAsmCilMethodSpec*> const& get_elements() const;
30319  std::vector<SgAsmCilMethodSpec*>& get_elements();
30320 public:
30322 public:
30324  virtual ~SgAsmCilMethodSpecTable();
30325 
30326 public:
30329 
30330 protected:
30337  void initializeProperties();
30338 #endif // SgAsmCilMethodSpecTable_OTHERS
30339 #ifdef DOCUMENTATION
30340 };
30341 #endif // DOCUMENTATION
30342 
30343 
30345 // SgAsmCilMethodSpec -- MACHINE GENERATED; DO NOT MODIFY --
30347 
30348 DECLARE_LEAF_CLASS(AsmCilMethodSpec);
30349 IS_SERIALIZABLE(AsmCilMethodSpec);
30350 
30351 #ifdef DOCUMENTATION
30352 
30354 #endif // DOCUMENTATION
30355 
30356 #ifndef DOCUMENTATION
30357  AsmCilMethodSpec.setDataPrototype(
30358  "uint32_t", "Method", "= 0",
30359  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
30360 #endif // !DOCUMENTATION
30361 
30362 #ifndef DOCUMENTATION
30363  AsmCilMethodSpec.setDataPrototype(
30364  "uint32_t", "Instantiation", "= 0",
30365  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
30366 #endif // !DOCUMENTATION
30367 
30368  DECLARE_OTHERS(AsmCilMethodSpec);
30369 #if defined(SgAsmCilMethodSpec_OTHERS) || defined(DOCUMENTATION)
30370 
30371  //----------------------- Boost serialization for SgAsmCilMethodSpec -----------------------
30372 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
30373 private:
30374  friend class boost::serialization::access;
30375 
30376  template<class S>
30377  void serialize(S &s, const unsigned /*version*/) {
30378  debugSerializationBegin("SgAsmCilMethodSpec");
30379  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
30380  s & BOOST_SERIALIZATION_NVP(p_Method);
30381  s & BOOST_SERIALIZATION_NVP(p_Instantiation);
30382  debugSerializationEnd("SgAsmCilMethodSpec");
30383  }
30384 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
30385 
30386 public:
30392  uint32_t const& get_Method() const;
30393  void set_Method(uint32_t const&);
30396 public:
30402  uint32_t const& get_Instantiation() const;
30403  void set_Instantiation(uint32_t const&);
30405 public:
30406  void parse(std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing);
30407 
30408  const SgAsmCilMetadata* get_Method_object() const;
30409  const std::uint8_t* get_Instantiation_blob() const;
30410 public:
30412  virtual ~SgAsmCilMethodSpec();
30413 
30414 public:
30417 
30418 protected:
30425  void initializeProperties();
30426 #endif // SgAsmCilMethodSpec_OTHERS
30427 #ifdef DOCUMENTATION
30428 };
30429 #endif // DOCUMENTATION
30430 
30431 
30433 // SgAsmCilMethodSemanticsTable -- MACHINE GENERATED; DO NOT MODIFY --
30435 
30436 DECLARE_LEAF_CLASS(AsmCilMethodSemanticsTable);
30437 IS_SERIALIZABLE(AsmCilMethodSemanticsTable);
30438 
30439 #ifdef DOCUMENTATION
30440 
30442 #endif // DOCUMENTATION
30443 
30444 #ifndef DOCUMENTATION
30445  AsmCilMethodSemanticsTable.setDataPrototype(
30446  "std::vector<SgAsmCilMethodSemantics*>", "elements", "",
30447  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
30448 #endif // !DOCUMENTATION
30449 
30450  DECLARE_OTHERS(AsmCilMethodSemanticsTable);
30451 #if defined(SgAsmCilMethodSemanticsTable_OTHERS) || defined(DOCUMENTATION)
30452 
30453  //----------------------- Boost serialization for SgAsmCilMethodSemanticsTable -----------------------
30454 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
30455 private:
30456  friend class boost::serialization::access;
30457 
30458  template<class S>
30459  void serialize(S &s, const unsigned /*version*/) {
30460  debugSerializationBegin("SgAsmCilMethodSemanticsTable");
30461  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
30462  s & BOOST_SERIALIZATION_NVP(p_elements);
30463  debugSerializationEnd("SgAsmCilMethodSemanticsTable");
30464  }
30465 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
30466 
30467 public:
30468  std::vector<SgAsmCilMethodSemantics*> const& get_elements() const;
30469  std::vector<SgAsmCilMethodSemantics*>& get_elements();
30470 public:
30472 public:
30475 
30476 public:
30479 
30480 protected:
30487  void initializeProperties();
30488 #endif // SgAsmCilMethodSemanticsTable_OTHERS
30489 #ifdef DOCUMENTATION
30490 };
30491 #endif // DOCUMENTATION
30492 
30493 
30495 // SgAsmCilMethodSemantics -- MACHINE GENERATED; DO NOT MODIFY --
30497 
30498 DECLARE_LEAF_CLASS(AsmCilMethodSemantics);
30499 IS_SERIALIZABLE(AsmCilMethodSemantics);
30500 
30501 #ifdef DOCUMENTATION
30502 
30504 #endif // DOCUMENTATION
30505 
30506 #ifndef DOCUMENTATION
30507  AsmCilMethodSemantics.setDataPrototype(
30508  "uint16_t", "Semantics", "= 0",
30509  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
30510 #endif // !DOCUMENTATION
30511 
30512 #ifndef DOCUMENTATION
30513  AsmCilMethodSemantics.setDataPrototype(
30514  "uint32_t", "Method", "= 0",
30515  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
30516 #endif // !DOCUMENTATION
30517 
30518 #ifndef DOCUMENTATION
30519  AsmCilMethodSemantics.setDataPrototype(
30520  "uint32_t", "Association", "= 0",
30521  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
30522 #endif // !DOCUMENTATION
30523 
30524  DECLARE_OTHERS(AsmCilMethodSemantics);
30525 #if defined(SgAsmCilMethodSemantics_OTHERS) || defined(DOCUMENTATION)
30526 
30527  //----------------------- Boost serialization for SgAsmCilMethodSemantics -----------------------
30528 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
30529 private:
30530  friend class boost::serialization::access;
30531 
30532  template<class S>
30533  void serialize(S &s, const unsigned /*version*/) {
30534  debugSerializationBegin("SgAsmCilMethodSemantics");
30535  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
30536  s & BOOST_SERIALIZATION_NVP(p_Semantics);
30537  s & BOOST_SERIALIZATION_NVP(p_Method);
30538  s & BOOST_SERIALIZATION_NVP(p_Association);
30539  debugSerializationEnd("SgAsmCilMethodSemantics");
30540  }
30541 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
30542 
30543 public:
30549  uint16_t const& get_Semantics() const;
30550  void set_Semantics(uint16_t const&);
30553 public:
30559  uint32_t const& get_Method() const;
30560  void set_Method(uint32_t const&);
30563 public:
30569  uint32_t const& get_Association() const;
30570  void set_Association(uint32_t const&);
30572 public:
30573  void parse(std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing);
30574 
30575  const SgAsmCilMetadata* get_Method_object() const;
30576  const SgAsmCilMetadata* get_Association_object() const;
30577 public:
30579  virtual ~SgAsmCilMethodSemantics();
30580 
30581 public:
30584 
30585 protected:
30592  void initializeProperties();
30593 #endif // SgAsmCilMethodSemantics_OTHERS
30594 #ifdef DOCUMENTATION
30595 };
30596 #endif // DOCUMENTATION
30597 
30598 
30600 // SgAsmCilMethodImplTable -- MACHINE GENERATED; DO NOT MODIFY --
30602 
30603 DECLARE_LEAF_CLASS(AsmCilMethodImplTable);
30604 IS_SERIALIZABLE(AsmCilMethodImplTable);
30605 
30606 #ifdef DOCUMENTATION
30607 
30609 #endif // DOCUMENTATION
30610 
30611 #ifndef DOCUMENTATION
30612  AsmCilMethodImplTable.setDataPrototype(
30613  "std::vector<SgAsmCilMethodImpl*>", "elements", "",
30614  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
30615 #endif // !DOCUMENTATION
30616 
30617  DECLARE_OTHERS(AsmCilMethodImplTable);
30618 #if defined(SgAsmCilMethodImplTable_OTHERS) || defined(DOCUMENTATION)
30619 
30620  //----------------------- Boost serialization for SgAsmCilMethodImplTable -----------------------
30621 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
30622 private:
30623  friend class boost::serialization::access;
30624 
30625  template<class S>
30626  void serialize(S &s, const unsigned /*version*/) {
30627  debugSerializationBegin("SgAsmCilMethodImplTable");
30628  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
30629  s & BOOST_SERIALIZATION_NVP(p_elements);
30630  debugSerializationEnd("SgAsmCilMethodImplTable");
30631  }
30632 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
30633 
30634 public:
30635  std::vector<SgAsmCilMethodImpl*> const& get_elements() const;
30636  std::vector<SgAsmCilMethodImpl*>& get_elements();
30637 public:
30639 public:
30641  virtual ~SgAsmCilMethodImplTable();
30642 
30643 public:
30646 
30647 protected:
30654  void initializeProperties();
30655 #endif // SgAsmCilMethodImplTable_OTHERS
30656 #ifdef DOCUMENTATION
30657 };
30658 #endif // DOCUMENTATION
30659 
30660 
30662 // SgAsmCilMethodImpl -- MACHINE GENERATED; DO NOT MODIFY --
30664 
30665 DECLARE_LEAF_CLASS(AsmCilMethodImpl);
30666 IS_SERIALIZABLE(AsmCilMethodImpl);
30667 
30668 #ifdef DOCUMENTATION
30669 
30671 #endif // DOCUMENTATION
30672 
30673 #ifndef DOCUMENTATION
30674  AsmCilMethodImpl.setDataPrototype(
30675  "uint32_t", "Class", "= 0",
30676  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
30677 #endif // !DOCUMENTATION
30678 
30679 #ifndef DOCUMENTATION
30680  AsmCilMethodImpl.setDataPrototype(
30681  "uint32_t", "MethodBody", "= 0",
30682  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
30683 #endif // !DOCUMENTATION
30684 
30685 #ifndef DOCUMENTATION
30686  AsmCilMethodImpl.setDataPrototype(
30687  "uint32_t", "MethodDeclaration", "= 0",
30688  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
30689 #endif // !DOCUMENTATION
30690 
30691  DECLARE_OTHERS(AsmCilMethodImpl);
30692 #if defined(SgAsmCilMethodImpl_OTHERS) || defined(DOCUMENTATION)
30693 
30694  //----------------------- Boost serialization for SgAsmCilMethodImpl -----------------------
30695 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
30696 private:
30697  friend class boost::serialization::access;
30698 
30699  template<class S>
30700  void serialize(S &s, const unsigned /*version*/) {
30701  debugSerializationBegin("SgAsmCilMethodImpl");
30702  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
30703  s & BOOST_SERIALIZATION_NVP(p_Class);
30704  s & BOOST_SERIALIZATION_NVP(p_MethodBody);
30705  s & BOOST_SERIALIZATION_NVP(p_MethodDeclaration);
30706  debugSerializationEnd("SgAsmCilMethodImpl");
30707  }
30708 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
30709 
30710 public:
30716  uint32_t const& get_Class() const;
30717  void set_Class(uint32_t const&);
30720 public:
30726  uint32_t const& get_MethodBody() const;
30727  void set_MethodBody(uint32_t const&);
30730 public:
30736  uint32_t const& get_MethodDeclaration() const;
30737  void set_MethodDeclaration(uint32_t const&);
30739 public:
30740  void parse(std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing);
30741 
30742  const SgAsmCilMetadata* get_Class_object() const;
30743  const SgAsmCilMetadata* get_MethodBody_object() const;
30744  const SgAsmCilMetadata* get_MethodDeclaration_object() const;
30745 public:
30747  virtual ~SgAsmCilMethodImpl();
30748 
30749 public:
30752 
30753 protected:
30760  void initializeProperties();
30761 #endif // SgAsmCilMethodImpl_OTHERS
30762 #ifdef DOCUMENTATION
30763 };
30764 #endif // DOCUMENTATION
30765 
30766 
30768 // SgAsmCilMethodDefTable -- MACHINE GENERATED; DO NOT MODIFY --
30770 
30771 DECLARE_LEAF_CLASS(AsmCilMethodDefTable);
30772 IS_SERIALIZABLE(AsmCilMethodDefTable);
30773 
30774 #ifdef DOCUMENTATION
30775 
30777 #endif // DOCUMENTATION
30778 
30779 #ifndef DOCUMENTATION
30780  AsmCilMethodDefTable.setDataPrototype(
30781  "std::vector<SgAsmCilMethodDef*>", "elements", "",
30782  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
30783 #endif // !DOCUMENTATION
30784 
30785  DECLARE_OTHERS(AsmCilMethodDefTable);
30786 #if defined(SgAsmCilMethodDefTable_OTHERS) || defined(DOCUMENTATION)
30787 
30788  //----------------------- Boost serialization for SgAsmCilMethodDefTable -----------------------
30789 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
30790 private:
30791  friend class boost::serialization::access;
30792 
30793  template<class S>
30794  void serialize(S &s, const unsigned /*version*/) {
30795  debugSerializationBegin("SgAsmCilMethodDefTable");
30796  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
30797  s & BOOST_SERIALIZATION_NVP(p_elements);
30798  debugSerializationEnd("SgAsmCilMethodDefTable");
30799  }
30800 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
30801 
30802 public:
30803  std::vector<SgAsmCilMethodDef*> const& get_elements() const;
30804  std::vector<SgAsmCilMethodDef*>& get_elements();
30805 public:
30807 public:
30809  virtual ~SgAsmCilMethodDefTable();
30810 
30811 public:
30814 
30815 protected:
30822  void initializeProperties();
30823 #endif // SgAsmCilMethodDefTable_OTHERS
30824 #ifdef DOCUMENTATION
30825 };
30826 #endif // DOCUMENTATION
30827 
30828 
30830 // SgAsmCilMethodDef -- MACHINE GENERATED; DO NOT MODIFY --
30832 
30833 DECLARE_LEAF_CLASS(AsmCilMethodDef);
30834 IS_SERIALIZABLE(AsmCilMethodDef);
30835 
30836 #ifdef DOCUMENTATION
30837 
30839 #endif // DOCUMENTATION
30840 
30841 #ifndef DOCUMENTATION
30842  AsmCilMethodDef.setDataPrototype(
30843  "uint32_t", "RVA", "= 0",
30844  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
30845 #endif // !DOCUMENTATION
30846 
30847 #ifndef DOCUMENTATION
30848  AsmCilMethodDef.setDataPrototype(
30849  "uint32_t", "ImplFlags", "= 0",
30850  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
30851 #endif // !DOCUMENTATION
30852 
30853 #ifndef DOCUMENTATION
30854  AsmCilMethodDef.setDataPrototype(
30855  "uint16_t", "Flags", "= 0",
30856  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
30857 #endif // !DOCUMENTATION
30858 
30859 #ifndef DOCUMENTATION
30860  AsmCilMethodDef.setDataPrototype(
30861  "uint32_t", "Name", "= 0",
30862  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
30863 #endif // !DOCUMENTATION
30864 
30865 #ifndef DOCUMENTATION
30866  AsmCilMethodDef.setDataPrototype(
30867  "uint32_t", "Signature", "= 0",
30868  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
30869 #endif // !DOCUMENTATION
30870 
30871 #ifndef DOCUMENTATION
30872  AsmCilMethodDef.setDataPrototype(
30873  "uint32_t", "ParamList", "= 0",
30874  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
30875 #endif // !DOCUMENTATION
30876 
30877 #ifndef DOCUMENTATION
30878  AsmCilMethodDef.setDataPrototype(
30879  "SgAsmBlock*", "body", "= 0",
30880  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
30881 #endif // !DOCUMENTATION
30882 
30883 #ifndef DOCUMENTATION
30884  AsmCilMethodDef.setDataPrototype(
30885  "bool", "initLocals", "= 0",
30886  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
30887 #endif // !DOCUMENTATION
30888 
30889 #ifndef DOCUMENTATION
30890  AsmCilMethodDef.setDataPrototype(
30891  "uint32_t", "stackSize", "= 0",
30892  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
30893 #endif // !DOCUMENTATION
30894 
30895 #ifndef DOCUMENTATION
30896  AsmCilMethodDef.setDataPrototype(
30897  "bool", "hasMoreSections", "= 0",
30898  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
30899 #endif // !DOCUMENTATION
30900 
30901  DECLARE_OTHERS(AsmCilMethodDef);
30902 #if defined(SgAsmCilMethodDef_OTHERS) || defined(DOCUMENTATION)
30903 
30904  //----------------------- Boost serialization for SgAsmCilMethodDef -----------------------
30905 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
30906 private:
30907  friend class boost::serialization::access;
30908 
30909  template<class S>
30910  void serialize(S &s, const unsigned /*version*/) {
30911  debugSerializationBegin("SgAsmCilMethodDef");
30912  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
30913  s & BOOST_SERIALIZATION_NVP(p_RVA);
30914  s & BOOST_SERIALIZATION_NVP(p_ImplFlags);
30915  s & BOOST_SERIALIZATION_NVP(p_Flags);
30916  s & BOOST_SERIALIZATION_NVP(p_Name);
30917  s & BOOST_SERIALIZATION_NVP(p_Signature);
30918  s & BOOST_SERIALIZATION_NVP(p_ParamList);
30919  s & BOOST_SERIALIZATION_NVP(p_body);
30920  s & BOOST_SERIALIZATION_NVP(p_initLocals);
30921  s & BOOST_SERIALIZATION_NVP(p_stackSize);
30922  s & BOOST_SERIALIZATION_NVP(p_hasMoreSections);
30923  debugSerializationEnd("SgAsmCilMethodDef");
30924  }
30925 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
30926 
30927 public:
30933  uint32_t const& get_RVA() const;
30934  void set_RVA(uint32_t const&);
30937 public:
30943  uint32_t const& get_ImplFlags() const;
30944  void set_ImplFlags(uint32_t const&);
30947 public:
30953  uint16_t const& get_Flags() const;
30954  void set_Flags(uint16_t const&);
30957 public:
30963  uint32_t const& get_Name() const;
30964  void set_Name(uint32_t const&);
30967 public:
30973  uint32_t const& get_Signature() const;
30974  void set_Signature(uint32_t const&);
30977 public:
30983  uint32_t const& get_ParamList() const;
30984  void set_ParamList(uint32_t const&);
30987 public:
30993  SgAsmBlock* const& get_body() const;
30994  void set_body(SgAsmBlock* const&);
30997 public:
31003  bool const& get_initLocals() const;
31004  void set_initLocals(bool const&);
31007 public:
31013  uint32_t const& get_stackSize() const;
31014  void set_stackSize(uint32_t const&);
31017 public:
31023  bool const& get_hasMoreSections() const;
31024  void set_hasMoreSections(bool const&);
31026 public:
31027  void parse(std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing);
31028 
31029  const std::uint8_t* get_Name_string() const;
31030  const std::uint8_t* get_Signature_blob() const;
31031  const SgAsmCilMetadata* get_ParamList_object() const;
31032 public:
31034  virtual ~SgAsmCilMethodDef();
31035 
31036 public:
31039 
31040 protected:
31047  void initializeProperties();
31048 #endif // SgAsmCilMethodDef_OTHERS
31049 #ifdef DOCUMENTATION
31050 };
31051 #endif // DOCUMENTATION
31052 
31053 
31055 // SgAsmCilMetadataRoot -- MACHINE GENERATED; DO NOT MODIFY --
31057 
31058 DECLARE_LEAF_CLASS(AsmCilMetadataRoot);
31059 IS_SERIALIZABLE(AsmCilMetadataRoot);
31060 
31061 #ifdef DOCUMENTATION
31062 
31064 #endif // DOCUMENTATION
31065 
31066 #ifndef DOCUMENTATION
31067  AsmCilMetadataRoot.setDataPrototype(
31068  "uint32_t", "Signature", "= 0",
31069  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
31070 #endif // !DOCUMENTATION
31071 
31072 #ifndef DOCUMENTATION
31073  AsmCilMetadataRoot.setDataPrototype(
31074  "uint16_t", "MajorVersion", "= 0",
31075  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
31076 #endif // !DOCUMENTATION
31077 
31078 #ifndef DOCUMENTATION
31079  AsmCilMetadataRoot.setDataPrototype(
31080  "uint16_t", "MinorVersion", "= 0",
31081  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
31082 #endif // !DOCUMENTATION
31083 
31084 #ifndef DOCUMENTATION
31085  AsmCilMetadataRoot.setDataPrototype(
31086  "uint32_t", "Reserved0", "= 0",
31087  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
31088 #endif // !DOCUMENTATION
31089 
31090 #ifndef DOCUMENTATION
31091  AsmCilMetadataRoot.setDataPrototype(
31092  "uint32_t", "Length", "= 0",
31093  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
31094 #endif // !DOCUMENTATION
31095 
31096 #ifndef DOCUMENTATION
31097  AsmCilMetadataRoot.setDataPrototype(
31098  "std::string", "Version", "",
31099  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
31100 #endif // !DOCUMENTATION
31101 
31102 #ifndef DOCUMENTATION
31103  AsmCilMetadataRoot.setDataPrototype(
31104  "uint32_t", "VersionPadding", "= 0",
31105  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
31106 #endif // !DOCUMENTATION
31107 
31108 #ifndef DOCUMENTATION
31109  AsmCilMetadataRoot.setDataPrototype(
31110  "uint16_t", "Flags", "= 0",
31111  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
31112 #endif // !DOCUMENTATION
31113 
31114 #ifndef DOCUMENTATION
31115  AsmCilMetadataRoot.setDataPrototype(
31116  "uint16_t", "NumberOfStreams", "= 0",
31117  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
31118 #endif // !DOCUMENTATION
31119 
31120 #ifndef DOCUMENTATION
31121  AsmCilMetadataRoot.setDataPrototype(
31122  "std::vector<SgAsmCilDataStream*>", "Streams", "",
31123  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
31124 #endif // !DOCUMENTATION
31125 
31126  DECLARE_OTHERS(AsmCilMetadataRoot);
31127 #if defined(SgAsmCilMetadataRoot_OTHERS) || defined(DOCUMENTATION)
31128 
31129  //----------------------- Boost serialization for SgAsmCilMetadataRoot -----------------------
31130 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
31131 private:
31132  friend class boost::serialization::access;
31133 
31134  template<class S>
31135  void serialize(S &s, const unsigned /*version*/) {
31136  debugSerializationBegin("SgAsmCilMetadataRoot");
31137  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilNode);
31138  s & BOOST_SERIALIZATION_NVP(p_Signature);
31139  s & BOOST_SERIALIZATION_NVP(p_MajorVersion);
31140  s & BOOST_SERIALIZATION_NVP(p_MinorVersion);
31141  s & BOOST_SERIALIZATION_NVP(p_Reserved0);
31142  s & BOOST_SERIALIZATION_NVP(p_Length);
31143  s & BOOST_SERIALIZATION_NVP(p_Version);
31144  s & BOOST_SERIALIZATION_NVP(p_VersionPadding);
31145  s & BOOST_SERIALIZATION_NVP(p_Flags);
31146  s & BOOST_SERIALIZATION_NVP(p_NumberOfStreams);
31147  s & BOOST_SERIALIZATION_NVP(p_Streams);
31148  debugSerializationEnd("SgAsmCilMetadataRoot");
31149  }
31150 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
31151 
31152 public:
31156  uint32_t const& get_Signature() const;
31157  void set_Signature(uint32_t const&);
31160 public:
31164  uint16_t const& get_MajorVersion() const;
31165  void set_MajorVersion(uint16_t const&);
31168 public:
31172  uint16_t const& get_MinorVersion() const;
31173  void set_MinorVersion(uint16_t const&);
31176 public:
31180  uint32_t const& get_Reserved0() const;
31181  void set_Reserved0(uint32_t const&);
31184 public:
31188  uint32_t const& get_Length() const;
31189  void set_Length(uint32_t const&);
31192 public:
31196  std::string const& get_Version() const;
31197  void set_Version(std::string const&);
31200 public:
31204  uint32_t const& get_VersionPadding() const;
31205  void set_VersionPadding(uint32_t const&);
31208 public:
31212  uint16_t const& get_Flags() const;
31213  void set_Flags(uint16_t const&);
31216 public:
31220  uint16_t const& get_NumberOfStreams() const;
31221  void set_NumberOfStreams(uint16_t const&);
31223  // FIXME[Robb Matzke 2023-03-22]: these were implemented elsewhere, but could be auto generated
31224 public:
31228  std::vector<SgAsmCilDataStream*> const& get_Streams() const;
31229  std::vector<SgAsmCilDataStream*>& get_Streams();
31231  //const std::vector<SgAsmCilDataStream*>& get_Streams() const;
31232  //std::vector<SgAsmCilDataStream*>& get_Streams();
31233 private:
31236  mutable int8_t idxStringHeap = -1;
31237  mutable int8_t idxBlobHeap = -1;
31238  mutable int8_t idxUsHeap = -1;
31239  mutable int8_t idxGuidHeap = -1;
31240  mutable int8_t idxMetadataHeap = -1;
31243 public:
31246  static constexpr uint32_t MAGIC_SIGNATURE = 0x424A5342;
31247 
31251  void parse();
31252 
31258  void parse(std::vector<uint8_t>& buf, size_t index);
31259 
31264  SgAsmCilUint8Heap* get_UsHeap() const;
31268 public:
31270  virtual ~SgAsmCilMetadataRoot();
31271 
31272 public:
31275 
31276 protected:
31283  void initializeProperties();
31284 #endif // SgAsmCilMetadataRoot_OTHERS
31285 #ifdef DOCUMENTATION
31286 };
31287 #endif // DOCUMENTATION
31288 
31289 
31291 // SgAsmCilMetadataHeap -- MACHINE GENERATED; DO NOT MODIFY --
31293 
31294 DECLARE_LEAF_CLASS(AsmCilMetadataHeap);
31295 IS_SERIALIZABLE(AsmCilMetadataHeap);
31296 
31297 #ifdef DOCUMENTATION
31298 
31300 #endif // DOCUMENTATION
31301 
31302 #ifndef DOCUMENTATION
31303  AsmCilMetadataHeap.setDataPrototype(
31304  "uint32_t", "ReservedAlwaysZero", "= 0",
31305  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
31306 #endif // !DOCUMENTATION
31307 
31308 #ifndef DOCUMENTATION
31309  AsmCilMetadataHeap.setDataPrototype(
31310  "uint8_t", "MajorVersion", "= 0",
31311  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
31312 #endif // !DOCUMENTATION
31313 
31314 #ifndef DOCUMENTATION
31315  AsmCilMetadataHeap.setDataPrototype(
31316  "uint8_t", "MinorVersion", "= 0",
31317  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
31318 #endif // !DOCUMENTATION
31319 
31320 #ifndef DOCUMENTATION
31321  AsmCilMetadataHeap.setDataPrototype(
31322  "uint8_t", "HeapSizes", "= 0",
31323  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
31324 #endif // !DOCUMENTATION
31325 
31326 #ifndef DOCUMENTATION
31327  AsmCilMetadataHeap.setDataPrototype(
31328  "uint8_t", "ReservedAlwaysOne", "= 0",
31329  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
31330 #endif // !DOCUMENTATION
31331 
31332 #ifndef DOCUMENTATION
31333  AsmCilMetadataHeap.setDataPrototype(
31334  "uint64_t", "Valid", "= 0",
31335  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
31336 #endif // !DOCUMENTATION
31337 
31338 #ifndef DOCUMENTATION
31339  AsmCilMetadataHeap.setDataPrototype(
31340  "uint64_t", "Sorted", "= 0",
31341  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
31342 #endif // !DOCUMENTATION
31343 
31344 #ifndef DOCUMENTATION
31345  AsmCilMetadataHeap.setDataPrototype(
31346  "std::vector<uint32_t>", "NumberOfRows", "",
31347  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
31348 #endif // !DOCUMENTATION
31349 
31350 #ifndef DOCUMENTATION
31351  AsmCilMetadataHeap.setDataPrototype(
31352  "uint64_t", "DataSizeFlags", "= 0",
31353  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
31354 #endif // !DOCUMENTATION
31355 
31356 #ifndef DOCUMENTATION
31357  AsmCilMetadataHeap.setDataPrototype(
31358  "SgAsmCilAssemblyTable*", "AssemblyTable", "",
31359  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
31360 #endif // !DOCUMENTATION
31361 
31362 #ifndef DOCUMENTATION
31363  AsmCilMetadataHeap.setDataPrototype(
31364  "SgAsmCilAssemblyOSTable*", "AssemblyOSTable", "",
31365  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
31366 #endif // !DOCUMENTATION
31367 
31368 #ifndef DOCUMENTATION
31369  AsmCilMetadataHeap.setDataPrototype(
31370  "SgAsmCilAssemblyProcessorTable*", "AssemblyProcessorTable", "",
31371  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
31372 #endif // !DOCUMENTATION
31373 
31374 #ifndef DOCUMENTATION
31375  AsmCilMetadataHeap.setDataPrototype(
31376  "SgAsmCilAssemblyRefTable*", "AssemblyRefTable", "",
31377  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
31378 #endif // !DOCUMENTATION
31379 
31380 #ifndef DOCUMENTATION
31381  AsmCilMetadataHeap.setDataPrototype(
31382  "SgAsmCilAssemblyRefOSTable*", "AssemblyRefOSTable", "",
31383  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
31384 #endif // !DOCUMENTATION
31385 
31386 #ifndef DOCUMENTATION
31387  AsmCilMetadataHeap.setDataPrototype(
31388  "SgAsmCilAssemblyRefProcessorTable*", "AssemblyRefProcessorTable", "",
31389  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
31390 #endif // !DOCUMENTATION
31391 
31392 #ifndef DOCUMENTATION
31393  AsmCilMetadataHeap.setDataPrototype(
31394  "SgAsmCilClassLayoutTable*", "ClassLayoutTable", "",
31395  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
31396 #endif // !DOCUMENTATION
31397 
31398 #ifndef DOCUMENTATION
31399  AsmCilMetadataHeap.setDataPrototype(
31400  "SgAsmCilConstantTable*", "ConstantTable", "",
31401  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
31402 #endif // !DOCUMENTATION
31403 
31404 #ifndef DOCUMENTATION
31405  AsmCilMetadataHeap.setDataPrototype(
31406  "SgAsmCilCustomAttributeTable*", "CustomAttributeTable", "",
31407  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
31408 #endif // !DOCUMENTATION
31409 
31410 #ifndef DOCUMENTATION
31411  AsmCilMetadataHeap.setDataPrototype(
31412  "SgAsmCilDeclSecurityTable*", "DeclSecurityTable", "",
31413  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
31414 #endif // !DOCUMENTATION
31415 
31416 #ifndef DOCUMENTATION
31417  AsmCilMetadataHeap.setDataPrototype(
31418  "SgAsmCilEventTable*", "EventTable", "",
31419  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
31420 #endif // !DOCUMENTATION
31421 
31422 #ifndef DOCUMENTATION
31423  AsmCilMetadataHeap.setDataPrototype(
31424  "SgAsmCilEventMapTable*", "EventMapTable", "",
31425  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
31426 #endif // !DOCUMENTATION
31427 
31428 #ifndef DOCUMENTATION
31429  AsmCilMetadataHeap.setDataPrototype(
31430  "SgAsmCilExportedTypeTable*", "ExportedTypeTable", "",
31431  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
31432 #endif // !DOCUMENTATION
31433 
31434 #ifndef DOCUMENTATION
31435  AsmCilMetadataHeap.setDataPrototype(
31436  "SgAsmCilFieldTable*", "FieldTable", "",
31437  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
31438 #endif // !DOCUMENTATION
31439 
31440 #ifndef DOCUMENTATION
31441  AsmCilMetadataHeap.setDataPrototype(
31442  "SgAsmCilFieldLayoutTable*", "FieldLayoutTable", "",
31443  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
31444 #endif // !DOCUMENTATION
31445 
31446 #ifndef DOCUMENTATION
31447  AsmCilMetadataHeap.setDataPrototype(
31448  "SgAsmCilFieldMarshalTable*", "FieldMarshalTable", "",
31449  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
31450 #endif // !DOCUMENTATION
31451 
31452 #ifndef DOCUMENTATION
31453  AsmCilMetadataHeap.setDataPrototype(
31454  "SgAsmCilFieldRVATable*", "FieldRVATable", "",
31455  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
31456 #endif // !DOCUMENTATION
31457 
31458 #ifndef DOCUMENTATION
31459  AsmCilMetadataHeap.setDataPrototype(
31460  "SgAsmCilFileTable*", "FileTable", "",
31461  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
31462 #endif // !DOCUMENTATION
31463 
31464 #ifndef DOCUMENTATION
31465  AsmCilMetadataHeap.setDataPrototype(
31466  "SgAsmCilGenericParamTable*", "GenericParamTable", "",
31467  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
31468 #endif // !DOCUMENTATION
31469 
31470 #ifndef DOCUMENTATION
31471  AsmCilMetadataHeap.setDataPrototype(
31472  "SgAsmCilGenericParamConstraintTable*", "GenericParamConstraintTable", "",
31473  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
31474 #endif // !DOCUMENTATION
31475 
31476 #ifndef DOCUMENTATION
31477  AsmCilMetadataHeap.setDataPrototype(
31478  "SgAsmCilImplMapTable*", "ImplMapTable", "",
31479  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
31480 #endif // !DOCUMENTATION
31481 
31482 #ifndef DOCUMENTATION
31483  AsmCilMetadataHeap.setDataPrototype(
31484  "SgAsmCilInterfaceImplTable*", "InterfaceImplTable", "",
31485  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
31486 #endif // !DOCUMENTATION
31487 
31488 #ifndef DOCUMENTATION
31489  AsmCilMetadataHeap.setDataPrototype(
31490  "SgAsmCilManifestResourceTable*", "ManifestResourceTable", "",
31491  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
31492 #endif // !DOCUMENTATION
31493 
31494 #ifndef DOCUMENTATION
31495  AsmCilMetadataHeap.setDataPrototype(
31496  "SgAsmCilMemberRefTable*", "MemberRefTable", "",
31497  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
31498 #endif // !DOCUMENTATION
31499 
31500 #ifndef DOCUMENTATION
31501  AsmCilMetadataHeap.setDataPrototype(
31502  "SgAsmCilMethodDefTable*", "MethodDefTable", "",
31503  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
31504 #endif // !DOCUMENTATION
31505 
31506 #ifndef DOCUMENTATION
31507  AsmCilMetadataHeap.setDataPrototype(
31508  "SgAsmCilMethodImplTable*", "MethodImplTable", "",
31509  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
31510 #endif // !DOCUMENTATION
31511 
31512 #ifndef DOCUMENTATION
31513  AsmCilMetadataHeap.setDataPrototype(
31514  "SgAsmCilMethodSemanticsTable*", "MethodSemanticsTable", "",
31515  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
31516 #endif // !DOCUMENTATION
31517 
31518 #ifndef DOCUMENTATION
31519  AsmCilMetadataHeap.setDataPrototype(
31520  "SgAsmCilMethodSpecTable*", "MethodSpecTable", "",
31521  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
31522 #endif // !DOCUMENTATION
31523 
31524 #ifndef DOCUMENTATION
31525  AsmCilMetadataHeap.setDataPrototype(
31526  "SgAsmCilModuleTable*", "ModuleTable", "",
31527  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
31528 #endif // !DOCUMENTATION
31529 
31530 #ifndef DOCUMENTATION
31531  AsmCilMetadataHeap.setDataPrototype(
31532  "SgAsmCilModuleRefTable*", "ModuleRefTable", "",
31533  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
31534 #endif // !DOCUMENTATION
31535 
31536 #ifndef DOCUMENTATION
31537  AsmCilMetadataHeap.setDataPrototype(
31538  "SgAsmCilNestedClassTable*", "NestedClassTable", "",
31539  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
31540 #endif // !DOCUMENTATION
31541 
31542 #ifndef DOCUMENTATION
31543  AsmCilMetadataHeap.setDataPrototype(
31544  "SgAsmCilParamTable*", "ParamTable", "",
31545  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
31546 #endif // !DOCUMENTATION
31547 
31548 #ifndef DOCUMENTATION
31549  AsmCilMetadataHeap.setDataPrototype(
31550  "SgAsmCilPropertyTable*", "PropertyTable", "",
31551  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
31552 #endif // !DOCUMENTATION
31553 
31554 #ifndef DOCUMENTATION
31555  AsmCilMetadataHeap.setDataPrototype(
31556  "SgAsmCilPropertyMapTable*", "PropertyMapTable", "",
31557  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
31558 #endif // !DOCUMENTATION
31559 
31560 #ifndef DOCUMENTATION
31561  AsmCilMetadataHeap.setDataPrototype(
31562  "SgAsmCilStandAloneSigTable*", "StandAloneSigTable", "",
31563  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
31564 #endif // !DOCUMENTATION
31565 
31566 #ifndef DOCUMENTATION
31567  AsmCilMetadataHeap.setDataPrototype(
31568  "SgAsmCilTypeDefTable*", "TypeDefTable", "",
31569  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
31570 #endif // !DOCUMENTATION
31571 
31572 #ifndef DOCUMENTATION
31573  AsmCilMetadataHeap.setDataPrototype(
31574  "SgAsmCilTypeRefTable*", "TypeRefTable", "",
31575  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
31576 #endif // !DOCUMENTATION
31577 
31578 #ifndef DOCUMENTATION
31579  AsmCilMetadataHeap.setDataPrototype(
31580  "SgAsmCilTypeSpecTable*", "TypeSpecTable", "",
31581  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
31582 #endif // !DOCUMENTATION
31583 
31584  DECLARE_OTHERS(AsmCilMetadataHeap);
31585 #if defined(SgAsmCilMetadataHeap_OTHERS) || defined(DOCUMENTATION)
31586 
31587  //----------------------- Boost serialization for SgAsmCilMetadataHeap -----------------------
31588 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
31589 private:
31590  friend class boost::serialization::access;
31591 
31592  template<class S>
31593  void serialize(S &s, const unsigned /*version*/) {
31594  debugSerializationBegin("SgAsmCilMetadataHeap");
31595  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilDataStream);
31596  s & BOOST_SERIALIZATION_NVP(p_ReservedAlwaysZero);
31597  s & BOOST_SERIALIZATION_NVP(p_MajorVersion);
31598  s & BOOST_SERIALIZATION_NVP(p_MinorVersion);
31599  s & BOOST_SERIALIZATION_NVP(p_HeapSizes);
31600  s & BOOST_SERIALIZATION_NVP(p_ReservedAlwaysOne);
31601  s & BOOST_SERIALIZATION_NVP(p_Valid);
31602  s & BOOST_SERIALIZATION_NVP(p_Sorted);
31603  s & BOOST_SERIALIZATION_NVP(p_NumberOfRows);
31604  s & BOOST_SERIALIZATION_NVP(p_DataSizeFlags);
31605  s & BOOST_SERIALIZATION_NVP(p_AssemblyTable);
31606  s & BOOST_SERIALIZATION_NVP(p_AssemblyOSTable);
31607  s & BOOST_SERIALIZATION_NVP(p_AssemblyProcessorTable);
31608  s & BOOST_SERIALIZATION_NVP(p_AssemblyRefTable);
31609  s & BOOST_SERIALIZATION_NVP(p_AssemblyRefOSTable);
31610  s & BOOST_SERIALIZATION_NVP(p_AssemblyRefProcessorTable);
31611  s & BOOST_SERIALIZATION_NVP(p_ClassLayoutTable);
31612  s & BOOST_SERIALIZATION_NVP(p_ConstantTable);
31613  s & BOOST_SERIALIZATION_NVP(p_CustomAttributeTable);
31614  s & BOOST_SERIALIZATION_NVP(p_DeclSecurityTable);
31615  s & BOOST_SERIALIZATION_NVP(p_EventTable);
31616  s & BOOST_SERIALIZATION_NVP(p_EventMapTable);
31617  s & BOOST_SERIALIZATION_NVP(p_ExportedTypeTable);
31618  s & BOOST_SERIALIZATION_NVP(p_FieldTable);
31619  s & BOOST_SERIALIZATION_NVP(p_FieldLayoutTable);
31620  s & BOOST_SERIALIZATION_NVP(p_FieldMarshalTable);
31621  s & BOOST_SERIALIZATION_NVP(p_FieldRVATable);
31622  s & BOOST_SERIALIZATION_NVP(p_FileTable);
31623  s & BOOST_SERIALIZATION_NVP(p_GenericParamTable);
31624  s & BOOST_SERIALIZATION_NVP(p_GenericParamConstraintTable);
31625  s & BOOST_SERIALIZATION_NVP(p_ImplMapTable);
31626  s & BOOST_SERIALIZATION_NVP(p_InterfaceImplTable);
31627  s & BOOST_SERIALIZATION_NVP(p_ManifestResourceTable);
31628  s & BOOST_SERIALIZATION_NVP(p_MemberRefTable);
31629  s & BOOST_SERIALIZATION_NVP(p_MethodDefTable);
31630  s & BOOST_SERIALIZATION_NVP(p_MethodImplTable);
31631  s & BOOST_SERIALIZATION_NVP(p_MethodSemanticsTable);
31632  s & BOOST_SERIALIZATION_NVP(p_MethodSpecTable);
31633  s & BOOST_SERIALIZATION_NVP(p_ModuleTable);
31634  s & BOOST_SERIALIZATION_NVP(p_ModuleRefTable);
31635  s & BOOST_SERIALIZATION_NVP(p_NestedClassTable);
31636  s & BOOST_SERIALIZATION_NVP(p_ParamTable);
31637  s & BOOST_SERIALIZATION_NVP(p_PropertyTable);
31638  s & BOOST_SERIALIZATION_NVP(p_PropertyMapTable);
31639  s & BOOST_SERIALIZATION_NVP(p_StandAloneSigTable);
31640  s & BOOST_SERIALIZATION_NVP(p_TypeDefTable);
31641  s & BOOST_SERIALIZATION_NVP(p_TypeRefTable);
31642  s & BOOST_SERIALIZATION_NVP(p_TypeSpecTable);
31643  debugSerializationEnd("SgAsmCilMetadataHeap");
31644  }
31645 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
31646 
31647 public:
31651  uint32_t const& get_ReservedAlwaysZero() const;
31652  void set_ReservedAlwaysZero(uint32_t const&);
31655 public:
31659  uint8_t const& get_MajorVersion() const;
31660  void set_MajorVersion(uint8_t const&);
31663 public:
31667  uint8_t const& get_MinorVersion() const;
31668  void set_MinorVersion(uint8_t const&);
31671 public:
31675  uint8_t const& get_HeapSizes() const;
31676  void set_HeapSizes(uint8_t const&);
31679 public:
31683  uint8_t const& get_ReservedAlwaysOne() const;
31684  void set_ReservedAlwaysOne(uint8_t const&);
31687 public:
31691  uint64_t const& get_Valid() const;
31692  void set_Valid(uint64_t const&);
31695 public:
31699  uint64_t const& get_Sorted() const;
31700  void set_Sorted(uint64_t const&);
31703 public:
31707  std::vector<uint32_t> const& get_NumberOfRows() const;
31708  void set_NumberOfRows(std::vector<uint32_t> const&);
31711 public:
31715  uint64_t const& get_DataSizeFlags() const;
31716  void set_DataSizeFlags(uint64_t const&);
31719 public:
31723  SgAsmCilAssemblyTable* const& get_AssemblyTable() const;
31727 public:
31735 public:
31743 public:
31751 public:
31759 public:
31767 public:
31775 public:
31779  SgAsmCilConstantTable* const& get_ConstantTable() const;
31783 public:
31791 public:
31799 public:
31803  SgAsmCilEventTable* const& get_EventTable() const;
31804  void set_EventTable(SgAsmCilEventTable* const&);
31807 public:
31811  SgAsmCilEventMapTable* const& get_EventMapTable() const;
31815 public:
31823 public:
31827  SgAsmCilFieldTable* const& get_FieldTable() const;
31828  void set_FieldTable(SgAsmCilFieldTable* const&);
31831 public:
31839 public:
31847 public:
31851  SgAsmCilFieldRVATable* const& get_FieldRVATable() const;
31855 public:
31859  SgAsmCilFileTable* const& get_FileTable() const;
31860  void set_FileTable(SgAsmCilFileTable* const&);
31863 public:
31871 public:
31879 public:
31883  SgAsmCilImplMapTable* const& get_ImplMapTable() const;
31884  void set_ImplMapTable(SgAsmCilImplMapTable* const&);
31887 public:
31895 public:
31903 public:
31911 public:
31919 public:
31927 public:
31935 public:
31943 public:
31947  SgAsmCilModuleTable* const& get_ModuleTable() const;
31948  void set_ModuleTable(SgAsmCilModuleTable* const&);
31951 public:
31959 public:
31967 public:
31971  SgAsmCilParamTable* const& get_ParamTable() const;
31972  void set_ParamTable(SgAsmCilParamTable* const&);
31975 public:
31979  SgAsmCilPropertyTable* const& get_PropertyTable() const;
31983 public:
31991 public:
31999 public:
32003  SgAsmCilTypeDefTable* const& get_TypeDefTable() const;
32004  void set_TypeDefTable(SgAsmCilTypeDefTable* const&);
32007 public:
32011  SgAsmCilTypeRefTable* const& get_TypeRefTable() const;
32012  void set_TypeRefTable(SgAsmCilTypeRefTable* const&);
32015 public:
32019  SgAsmCilTypeSpecTable* const& get_TypeSpecTable() const;
32022 public:
32025  {
32026  // heaps
32027  e_ref_string_heap = 1 << 0,
32028  e_ref_guid_heap = 1 << 1,
32029  e_ref_blob_heap = 1 << 2,
32030  // single-table references
32031  e_ref_assembly_ref = 1 << 3,
32032  e_ref_type_def = 1 << 4,
32033  e_ref_event = 1 << 5,
32034  e_ref_field = 1 << 6,
32035  e_ref_generic_param = 1 << 7,
32036  e_ref_module_ref = 1 << 8,
32037  e_ref_method_def = 1 << 9,
32038  e_ref_param = 1 << 10,
32039  e_ref_property = 1 << 11,
32040  // multi-table references
32041  e_ref_has_constant = 1 << 12,
32042  e_ref_has_custom_attribute = 1 << 13,
32043  e_ref_has_decl_security = 1 << 14,
32044  e_ref_has_field_marshall = 1 << 15,
32045  e_ref_has_semantics = 1 << 16,
32046  e_ref_method_def_or_ref = 1 << 17,
32047  e_ref_type_def_or_ref = 1 << 18,
32048  e_ref_implementation = 1 << 19,
32049  e_ref_member_forwarded = 1 << 20,
32050  e_ref_member_ref_parent = 1 << 21,
32051  e_ref_type_or_method_def = 1 << 22,
32052  e_ref_custom_attribute_type = 1 << 23,
32053  e_ref_resolution_scope = 1 << 24,
32054  e_ref_last = 1 << 25,
32055  };
32056 
32057  enum TableKind : std::uint8_t
32058  {
32059 
32060  e_Assembly = 0x20,
32061  e_AssemblyOS = 0x22,
32062  e_AssemblyProcessor = 0x21,
32063  e_AssemblyRef = 0x23,
32064  e_AssemblyRefOS = 0x25,
32065  e_AssemblyRefProcessor = 0x24,
32066  e_ClassLayout = 0x0F,
32067  e_Constant = 0x0B,
32068  e_CustomAttribute = 0x0C,
32069  e_DeclSecurity = 0x0E,
32070  e_Event = 0x14,
32071  e_EventMap = 0x12,
32072  e_ExportedType = 0x27,
32073  e_Field = 0x04,
32074  e_FieldLayout = 0x10,
32075  e_FieldMarshal = 0x0D,
32076  e_FieldRVA = 0x1D,
32077  e_File = 0x26,
32078  e_GenericParam = 0x2A,
32079  e_GenericParamConstraint = 0x2C,
32080  e_ImplMap = 0x1C,
32081  e_InterfaceImpl = 0x09,
32082  e_ManifestResource = 0x28,
32083  e_MemberRef = 0x0A,
32084  e_MethodDef = 0x06,
32085  e_MethodImpl = 0x19,
32086  e_MethodSemantics = 0x18,
32087  e_MethodSpec = 0x2B,
32088  e_Module = 0x00,
32089  e_ModuleRef = 0x1A,
32090  e_NestedClass = 0x29,
32091  e_Param = 0x08,
32092  e_Property = 0x17,
32093  e_PropertyMap = 0x15,
32094  e_StandAloneSig = 0x11,
32095  e_TypeDef = 0x02,
32096  e_TypeRef = 0x01,
32097  e_TypeSpec = 0x1B,
32098  e_Unknown_table_kind = 0xFF
32099  };
32100 
32102  void parse(std::vector<uint8_t>& buf, size_t startOfMetaData) override;
32103 
32107  SgAsmCilMetadata* get_MetadataNode(std::uint32_t idx, TableKind tblcode) const;
32108 
32112  SgAsmCilMetadata* get_CodedMetadataNode(std::uint32_t refcode, ReferenceKind knd) const;
32113 
32117  SgAsmCilMetadata* get_MetadataNode(std::uint32_t refcode, ReferenceKind knd) const;
32118 public:
32120  virtual ~SgAsmCilMetadataHeap();
32121 
32122 public:
32125 
32126 public:
32128  SgAsmCilMetadataHeap(uint32_t const& Offset,
32129  uint32_t const& Size,
32130  std::string const& Name,
32131  uint32_t const& NamePadding);
32132 
32133 protected:
32140  void initializeProperties();
32141 #endif // SgAsmCilMetadataHeap_OTHERS
32142 #ifdef DOCUMENTATION
32143 };
32144 #endif // DOCUMENTATION
32145 
32146 
32148 // SgAsmCilMemberRefTable -- MACHINE GENERATED; DO NOT MODIFY --
32150 
32151 DECLARE_LEAF_CLASS(AsmCilMemberRefTable);
32152 IS_SERIALIZABLE(AsmCilMemberRefTable);
32153 
32154 #ifdef DOCUMENTATION
32155 
32157 #endif // DOCUMENTATION
32158 
32159 #ifndef DOCUMENTATION
32160  AsmCilMemberRefTable.setDataPrototype(
32161  "std::vector<SgAsmCilMemberRef*>", "elements", "",
32162  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
32163 #endif // !DOCUMENTATION
32164 
32165  DECLARE_OTHERS(AsmCilMemberRefTable);
32166 #if defined(SgAsmCilMemberRefTable_OTHERS) || defined(DOCUMENTATION)
32167 
32168  //----------------------- Boost serialization for SgAsmCilMemberRefTable -----------------------
32169 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
32170 private:
32171  friend class boost::serialization::access;
32172 
32173  template<class S>
32174  void serialize(S &s, const unsigned /*version*/) {
32175  debugSerializationBegin("SgAsmCilMemberRefTable");
32176  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
32177  s & BOOST_SERIALIZATION_NVP(p_elements);
32178  debugSerializationEnd("SgAsmCilMemberRefTable");
32179  }
32180 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
32181 
32182 public:
32183  std::vector<SgAsmCilMemberRef*> const& get_elements() const;
32184  std::vector<SgAsmCilMemberRef*>& get_elements();
32185 public:
32187 public:
32189  virtual ~SgAsmCilMemberRefTable();
32190 
32191 public:
32194 
32195 protected:
32202  void initializeProperties();
32203 #endif // SgAsmCilMemberRefTable_OTHERS
32204 #ifdef DOCUMENTATION
32205 };
32206 #endif // DOCUMENTATION
32207 
32208 
32210 // SgAsmCilMemberRef -- MACHINE GENERATED; DO NOT MODIFY --
32212 
32213 DECLARE_LEAF_CLASS(AsmCilMemberRef);
32214 IS_SERIALIZABLE(AsmCilMemberRef);
32215 
32216 #ifdef DOCUMENTATION
32217 
32219 #endif // DOCUMENTATION
32220 
32221 #ifndef DOCUMENTATION
32222  AsmCilMemberRef.setDataPrototype(
32223  "uint32_t", "Class", "= 0",
32224  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
32225 #endif // !DOCUMENTATION
32226 
32227 #ifndef DOCUMENTATION
32228  AsmCilMemberRef.setDataPrototype(
32229  "uint32_t", "Name", "= 0",
32230  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
32231 #endif // !DOCUMENTATION
32232 
32233 #ifndef DOCUMENTATION
32234  AsmCilMemberRef.setDataPrototype(
32235  "uint32_t", "Signature", "= 0",
32236  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
32237 #endif // !DOCUMENTATION
32238 
32239  DECLARE_OTHERS(AsmCilMemberRef);
32240 #if defined(SgAsmCilMemberRef_OTHERS) || defined(DOCUMENTATION)
32241 
32242  //----------------------- Boost serialization for SgAsmCilMemberRef -----------------------
32243 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
32244 private:
32245  friend class boost::serialization::access;
32246 
32247  template<class S>
32248  void serialize(S &s, const unsigned /*version*/) {
32249  debugSerializationBegin("SgAsmCilMemberRef");
32250  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
32251  s & BOOST_SERIALIZATION_NVP(p_Class);
32252  s & BOOST_SERIALIZATION_NVP(p_Name);
32253  s & BOOST_SERIALIZATION_NVP(p_Signature);
32254  debugSerializationEnd("SgAsmCilMemberRef");
32255  }
32256 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
32257 
32258 public:
32264  uint32_t const& get_Class() const;
32265  void set_Class(uint32_t const&);
32268 public:
32274  uint32_t const& get_Name() const;
32275  void set_Name(uint32_t const&);
32278 public:
32284  uint32_t const& get_Signature() const;
32285  void set_Signature(uint32_t const&);
32287 public:
32288  void parse(std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing);
32289 
32290  const SgAsmCilMetadata* get_Class_object() const;
32291  const std::uint8_t* get_Name_string() const;
32292  const std::uint8_t* get_Signature_blob() const;
32293 public:
32295  virtual ~SgAsmCilMemberRef();
32296 
32297 public:
32300 
32301 protected:
32308  void initializeProperties();
32309 #endif // SgAsmCilMemberRef_OTHERS
32310 #ifdef DOCUMENTATION
32311 };
32312 #endif // DOCUMENTATION
32313 
32314 
32316 // SgAsmCilManifestResourceTable -- MACHINE GENERATED; DO NOT MODIFY --
32318 
32319 DECLARE_LEAF_CLASS(AsmCilManifestResourceTable);
32320 IS_SERIALIZABLE(AsmCilManifestResourceTable);
32321 
32322 #ifdef DOCUMENTATION
32323 
32325 #endif // DOCUMENTATION
32326 
32327 #ifndef DOCUMENTATION
32328  AsmCilManifestResourceTable.setDataPrototype(
32329  "std::vector<SgAsmCilManifestResource*>", "elements", "",
32330  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
32331 #endif // !DOCUMENTATION
32332 
32333  DECLARE_OTHERS(AsmCilManifestResourceTable);
32334 #if defined(SgAsmCilManifestResourceTable_OTHERS) || defined(DOCUMENTATION)
32335 
32336  //----------------------- Boost serialization for SgAsmCilManifestResourceTable -----------------------
32337 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
32338 private:
32339  friend class boost::serialization::access;
32340 
32341  template<class S>
32342  void serialize(S &s, const unsigned /*version*/) {
32343  debugSerializationBegin("SgAsmCilManifestResourceTable");
32344  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
32345  s & BOOST_SERIALIZATION_NVP(p_elements);
32346  debugSerializationEnd("SgAsmCilManifestResourceTable");
32347  }
32348 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
32349 
32350 public:
32351  std::vector<SgAsmCilManifestResource*> const& get_elements() const;
32352  std::vector<SgAsmCilManifestResource*>& get_elements();
32353 public:
32355 public:
32358 
32359 public:
32362 
32363 protected:
32370  void initializeProperties();
32371 #endif // SgAsmCilManifestResourceTable_OTHERS
32372 #ifdef DOCUMENTATION
32373 };
32374 #endif // DOCUMENTATION
32375 
32376 
32378 // SgAsmCilManifestResource -- MACHINE GENERATED; DO NOT MODIFY --
32380 
32381 DECLARE_LEAF_CLASS(AsmCilManifestResource);
32382 IS_SERIALIZABLE(AsmCilManifestResource);
32383 
32384 #ifdef DOCUMENTATION
32385 
32387 #endif // DOCUMENTATION
32388 
32389 #ifndef DOCUMENTATION
32390  AsmCilManifestResource.setDataPrototype(
32391  "uint32_t", "Offset", "= 0",
32392  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
32393 #endif // !DOCUMENTATION
32394 
32395 #ifndef DOCUMENTATION
32396  AsmCilManifestResource.setDataPrototype(
32397  "uint32_t", "Flags", "= 0",
32398  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
32399 #endif // !DOCUMENTATION
32400 
32401 #ifndef DOCUMENTATION
32402  AsmCilManifestResource.setDataPrototype(
32403  "uint32_t", "Name", "= 0",
32404  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
32405 #endif // !DOCUMENTATION
32406 
32407 #ifndef DOCUMENTATION
32408  AsmCilManifestResource.setDataPrototype(
32409  "uint32_t", "Implementation", "= 0",
32410  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
32411 #endif // !DOCUMENTATION
32412 
32413  DECLARE_OTHERS(AsmCilManifestResource);
32414 #if defined(SgAsmCilManifestResource_OTHERS) || defined(DOCUMENTATION)
32415 
32416  //----------------------- Boost serialization for SgAsmCilManifestResource -----------------------
32417 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
32418 private:
32419  friend class boost::serialization::access;
32420 
32421  template<class S>
32422  void serialize(S &s, const unsigned /*version*/) {
32423  debugSerializationBegin("SgAsmCilManifestResource");
32424  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
32425  s & BOOST_SERIALIZATION_NVP(p_Offset);
32426  s & BOOST_SERIALIZATION_NVP(p_Flags);
32427  s & BOOST_SERIALIZATION_NVP(p_Name);
32428  s & BOOST_SERIALIZATION_NVP(p_Implementation);
32429  debugSerializationEnd("SgAsmCilManifestResource");
32430  }
32431 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
32432 
32433 public:
32439  uint32_t const& get_Offset() const;
32440  void set_Offset(uint32_t const&);
32443 public:
32449  uint32_t const& get_Flags() const;
32450  void set_Flags(uint32_t const&);
32453 public:
32459  uint32_t const& get_Name() const;
32460  void set_Name(uint32_t const&);
32463 public:
32469  uint32_t const& get_Implementation() const;
32470  void set_Implementation(uint32_t const&);
32472 public:
32473  void parse(std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing);
32474 
32475  const std::uint8_t* get_Name_string() const;
32476  const SgAsmCilMetadata* get_Implementation_object() const;
32477 public:
32479  virtual ~SgAsmCilManifestResource();
32480 
32481 public:
32484 
32485 protected:
32492  void initializeProperties();
32493 #endif // SgAsmCilManifestResource_OTHERS
32494 #ifdef DOCUMENTATION
32495 };
32496 #endif // DOCUMENTATION
32497 
32498 
32500 // SgAsmCilInterfaceImplTable -- MACHINE GENERATED; DO NOT MODIFY --
32502 
32503 DECLARE_LEAF_CLASS(AsmCilInterfaceImplTable);
32504 IS_SERIALIZABLE(AsmCilInterfaceImplTable);
32505 
32506 #ifdef DOCUMENTATION
32507 
32509 #endif // DOCUMENTATION
32510 
32511 #ifndef DOCUMENTATION
32512  AsmCilInterfaceImplTable.setDataPrototype(
32513  "std::vector<SgAsmCilInterfaceImpl*>", "elements", "",
32514  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
32515 #endif // !DOCUMENTATION
32516 
32517  DECLARE_OTHERS(AsmCilInterfaceImplTable);
32518 #if defined(SgAsmCilInterfaceImplTable_OTHERS) || defined(DOCUMENTATION)
32519 
32520  //----------------------- Boost serialization for SgAsmCilInterfaceImplTable -----------------------
32521 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
32522 private:
32523  friend class boost::serialization::access;
32524 
32525  template<class S>
32526  void serialize(S &s, const unsigned /*version*/) {
32527  debugSerializationBegin("SgAsmCilInterfaceImplTable");
32528  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
32529  s & BOOST_SERIALIZATION_NVP(p_elements);
32530  debugSerializationEnd("SgAsmCilInterfaceImplTable");
32531  }
32532 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
32533 
32534 public:
32535  std::vector<SgAsmCilInterfaceImpl*> const& get_elements() const;
32536  std::vector<SgAsmCilInterfaceImpl*>& get_elements();
32537 public:
32539 public:
32541  virtual ~SgAsmCilInterfaceImplTable();
32542 
32543 public:
32546 
32547 protected:
32554  void initializeProperties();
32555 #endif // SgAsmCilInterfaceImplTable_OTHERS
32556 #ifdef DOCUMENTATION
32557 };
32558 #endif // DOCUMENTATION
32559 
32560 
32562 // SgAsmCilInterfaceImpl -- MACHINE GENERATED; DO NOT MODIFY --
32564 
32565 DECLARE_LEAF_CLASS(AsmCilInterfaceImpl);
32566 IS_SERIALIZABLE(AsmCilInterfaceImpl);
32567 
32568 #ifdef DOCUMENTATION
32569 
32571 #endif // DOCUMENTATION
32572 
32573 #ifndef DOCUMENTATION
32574  AsmCilInterfaceImpl.setDataPrototype(
32575  "uint32_t", "Class", "= 0",
32576  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
32577 #endif // !DOCUMENTATION
32578 
32579 #ifndef DOCUMENTATION
32580  AsmCilInterfaceImpl.setDataPrototype(
32581  "uint32_t", "Interface", "= 0",
32582  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
32583 #endif // !DOCUMENTATION
32584 
32585  DECLARE_OTHERS(AsmCilInterfaceImpl);
32586 #if defined(SgAsmCilInterfaceImpl_OTHERS) || defined(DOCUMENTATION)
32587 
32588  //----------------------- Boost serialization for SgAsmCilInterfaceImpl -----------------------
32589 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
32590 private:
32591  friend class boost::serialization::access;
32592 
32593  template<class S>
32594  void serialize(S &s, const unsigned /*version*/) {
32595  debugSerializationBegin("SgAsmCilInterfaceImpl");
32596  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
32597  s & BOOST_SERIALIZATION_NVP(p_Class);
32598  s & BOOST_SERIALIZATION_NVP(p_Interface);
32599  debugSerializationEnd("SgAsmCilInterfaceImpl");
32600  }
32601 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
32602 
32603 public:
32609  uint32_t const& get_Class() const;
32610  void set_Class(uint32_t const&);
32613 public:
32619  uint32_t const& get_Interface() const;
32620  void set_Interface(uint32_t const&);
32622 public:
32623  void parse(std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing);
32624 
32625  const SgAsmCilMetadata* get_Class_object() const;
32626  const SgAsmCilMetadata* get_Interface_object() const;
32627 public:
32629  virtual ~SgAsmCilInterfaceImpl();
32630 
32631 public:
32634 
32635 protected:
32642  void initializeProperties();
32643 #endif // SgAsmCilInterfaceImpl_OTHERS
32644 #ifdef DOCUMENTATION
32645 };
32646 #endif // DOCUMENTATION
32647 
32648 
32650 // SgAsmCilInstruction -- MACHINE GENERATED; DO NOT MODIFY --
32652 
32653 DECLARE_LEAF_CLASS(AsmCilInstruction);
32654 IS_SERIALIZABLE(AsmCilInstruction);
32655 
32656 DECLARE_HEADERS(AsmCilInstruction);
32657 #if defined(SgAsmCilInstruction_HEADERS) || defined(DOCUMENTATION)
32658 #include <Rose/BinaryAnalysis/InstructionEnumsCil.h>
32659 #endif // SgAsmCilInstruction_HEADERS
32660 
32661 #ifdef DOCUMENTATION
32663 #endif // DOCUMENTATION
32664 
32665 #ifndef DOCUMENTATION
32666  AsmCilInstruction.setDataPrototype(
32667  "Rose::BinaryAnalysis::CilInstructionKind", "kind", "= Rose::BinaryAnalysis::Cil_unknown_instruction",
32668  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
32669 #endif // !DOCUMENTATION
32670 
32671  DECLARE_OTHERS(AsmCilInstruction);
32672 #if defined(SgAsmCilInstruction_OTHERS) || defined(DOCUMENTATION)
32673 
32674  //----------------------- Boost serialization for SgAsmCilInstruction -----------------------
32675 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
32676 private:
32677  friend class boost::serialization::access;
32678 
32679  template<class S>
32680  void serialize(S &s, const unsigned /*version*/) {
32681  debugSerializationBegin("SgAsmCilInstruction");
32682  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmInstruction);
32683  s & BOOST_SERIALIZATION_NVP(p_kind);
32684  debugSerializationEnd("SgAsmCilInstruction");
32685  }
32686 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
32687 
32688 public:
32698 public:
32699  // Overrides are documented in the base class
32700  virtual std::string description() const override;
32701  virtual bool terminatesBasicBlock() override;
32702  virtual bool isFunctionCallFast(const std::vector<SgAsmInstruction*> &insns,
32703  rose_addr_t *target/*out*/, rose_addr_t *ret/*out*/) override;
32704  virtual bool isFunctionCallSlow(const std::vector<SgAsmInstruction*>&,
32705  rose_addr_t *target, rose_addr_t *ret) override;
32706  virtual bool isFunctionReturnFast(const std::vector<SgAsmInstruction*> &insns) override;
32707  virtual bool isFunctionReturnSlow(const std::vector<SgAsmInstruction*> &insns) override;
32708  virtual Sawyer::Optional<rose_addr_t> branchTarget() override;
32709  virtual Rose::BinaryAnalysis::AddressSet getSuccessors(bool &complete) override;
32710  virtual Rose::BinaryAnalysis::AddressSet getSuccessors(const std::vector<SgAsmInstruction*>&,
32711  bool &complete,
32712  const Rose::BinaryAnalysis::MemoryMap::Ptr &initial_memory =
32714  virtual bool isUnknown() const override;
32715  virtual unsigned get_anyKind() const override;
32716 public:
32718  virtual ~SgAsmCilInstruction();
32719 
32720 public:
32723 
32724 public:
32726  SgAsmCilInstruction(rose_addr_t const& address,
32727  std::string const& mnemonic,
32729 
32730 protected:
32737  void initializeProperties();
32738 #endif // SgAsmCilInstruction_OTHERS
32739 #ifdef DOCUMENTATION
32740 };
32741 #endif // DOCUMENTATION
32742 
32743 
32745 // SgAsmCilImplMapTable -- MACHINE GENERATED; DO NOT MODIFY --
32747 
32748 DECLARE_LEAF_CLASS(AsmCilImplMapTable);
32749 IS_SERIALIZABLE(AsmCilImplMapTable);
32750 
32751 #ifdef DOCUMENTATION
32752 
32754 #endif // DOCUMENTATION
32755 
32756 #ifndef DOCUMENTATION
32757  AsmCilImplMapTable.setDataPrototype(
32758  "std::vector<SgAsmCilImplMap*>", "elements", "",
32759  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
32760 #endif // !DOCUMENTATION
32761 
32762  DECLARE_OTHERS(AsmCilImplMapTable);
32763 #if defined(SgAsmCilImplMapTable_OTHERS) || defined(DOCUMENTATION)
32764 
32765  //----------------------- Boost serialization for SgAsmCilImplMapTable -----------------------
32766 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
32767 private:
32768  friend class boost::serialization::access;
32769 
32770  template<class S>
32771  void serialize(S &s, const unsigned /*version*/) {
32772  debugSerializationBegin("SgAsmCilImplMapTable");
32773  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
32774  s & BOOST_SERIALIZATION_NVP(p_elements);
32775  debugSerializationEnd("SgAsmCilImplMapTable");
32776  }
32777 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
32778 
32779 public:
32780  std::vector<SgAsmCilImplMap*> const& get_elements() const;
32781  std::vector<SgAsmCilImplMap*>& get_elements();
32782 public:
32784 public:
32786  virtual ~SgAsmCilImplMapTable();
32787 
32788 public:
32791 
32792 protected:
32799  void initializeProperties();
32800 #endif // SgAsmCilImplMapTable_OTHERS
32801 #ifdef DOCUMENTATION
32802 };
32803 #endif // DOCUMENTATION
32804 
32805 
32807 // SgAsmCilImplMap -- MACHINE GENERATED; DO NOT MODIFY --
32809 
32810 DECLARE_LEAF_CLASS(AsmCilImplMap);
32811 IS_SERIALIZABLE(AsmCilImplMap);
32812 
32813 #ifdef DOCUMENTATION
32814 
32816 #endif // DOCUMENTATION
32817 
32818 #ifndef DOCUMENTATION
32819  AsmCilImplMap.setDataPrototype(
32820  "uint16_t", "MappingFlags", "= 0",
32821  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
32822 #endif // !DOCUMENTATION
32823 
32824 #ifndef DOCUMENTATION
32825  AsmCilImplMap.setDataPrototype(
32826  "uint32_t", "MemberForwarded", "= 0",
32827  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
32828 #endif // !DOCUMENTATION
32829 
32830 #ifndef DOCUMENTATION
32831  AsmCilImplMap.setDataPrototype(
32832  "uint32_t", "ImportName", "= 0",
32833  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
32834 #endif // !DOCUMENTATION
32835 
32836 #ifndef DOCUMENTATION
32837  AsmCilImplMap.setDataPrototype(
32838  "uint32_t", "ImportScope", "= 0",
32839  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
32840 #endif // !DOCUMENTATION
32841 
32842  DECLARE_OTHERS(AsmCilImplMap);
32843 #if defined(SgAsmCilImplMap_OTHERS) || defined(DOCUMENTATION)
32844 
32845  //----------------------- Boost serialization for SgAsmCilImplMap -----------------------
32846 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
32847 private:
32848  friend class boost::serialization::access;
32849 
32850  template<class S>
32851  void serialize(S &s, const unsigned /*version*/) {
32852  debugSerializationBegin("SgAsmCilImplMap");
32853  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
32854  s & BOOST_SERIALIZATION_NVP(p_MappingFlags);
32855  s & BOOST_SERIALIZATION_NVP(p_MemberForwarded);
32856  s & BOOST_SERIALIZATION_NVP(p_ImportName);
32857  s & BOOST_SERIALIZATION_NVP(p_ImportScope);
32858  debugSerializationEnd("SgAsmCilImplMap");
32859  }
32860 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
32861 
32862 public:
32868  uint16_t const& get_MappingFlags() const;
32869  void set_MappingFlags(uint16_t const&);
32872 public:
32878  uint32_t const& get_MemberForwarded() const;
32879  void set_MemberForwarded(uint32_t const&);
32882 public:
32888  uint32_t const& get_ImportName() const;
32889  void set_ImportName(uint32_t const&);
32892 public:
32898  uint32_t const& get_ImportScope() const;
32899  void set_ImportScope(uint32_t const&);
32901 public:
32902  void parse(std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing);
32903 
32904  const SgAsmCilMetadata* get_MemberForwarded_object() const;
32905  const std::uint8_t* get_ImportName_string() const;
32906  const SgAsmCilMetadata* get_ImportScope_object() const;
32907 public:
32909  virtual ~SgAsmCilImplMap();
32910 
32911 public:
32913  SgAsmCilImplMap();
32914 
32915 protected:
32922  void initializeProperties();
32923 #endif // SgAsmCilImplMap_OTHERS
32924 #ifdef DOCUMENTATION
32925 };
32926 #endif // DOCUMENTATION
32927 
32928 
32930 // SgAsmCilGenericParamTable -- MACHINE GENERATED; DO NOT MODIFY --
32932 
32933 DECLARE_LEAF_CLASS(AsmCilGenericParamTable);
32934 IS_SERIALIZABLE(AsmCilGenericParamTable);
32935 
32936 #ifdef DOCUMENTATION
32937 
32939 #endif // DOCUMENTATION
32940 
32941 #ifndef DOCUMENTATION
32942  AsmCilGenericParamTable.setDataPrototype(
32943  "std::vector<SgAsmCilGenericParam*>", "elements", "",
32944  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
32945 #endif // !DOCUMENTATION
32946 
32947  DECLARE_OTHERS(AsmCilGenericParamTable);
32948 #if defined(SgAsmCilGenericParamTable_OTHERS) || defined(DOCUMENTATION)
32949 
32950  //----------------------- Boost serialization for SgAsmCilGenericParamTable -----------------------
32951 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
32952 private:
32953  friend class boost::serialization::access;
32954 
32955  template<class S>
32956  void serialize(S &s, const unsigned /*version*/) {
32957  debugSerializationBegin("SgAsmCilGenericParamTable");
32958  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
32959  s & BOOST_SERIALIZATION_NVP(p_elements);
32960  debugSerializationEnd("SgAsmCilGenericParamTable");
32961  }
32962 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
32963 
32964 public:
32965  std::vector<SgAsmCilGenericParam*> const& get_elements() const;
32966  std::vector<SgAsmCilGenericParam*>& get_elements();
32967 public:
32969 public:
32971  virtual ~SgAsmCilGenericParamTable();
32972 
32973 public:
32976 
32977 protected:
32984  void initializeProperties();
32985 #endif // SgAsmCilGenericParamTable_OTHERS
32986 #ifdef DOCUMENTATION
32987 };
32988 #endif // DOCUMENTATION
32989 
32990 
32992 // SgAsmCilGenericParam -- MACHINE GENERATED; DO NOT MODIFY --
32994 
32995 DECLARE_LEAF_CLASS(AsmCilGenericParam);
32996 IS_SERIALIZABLE(AsmCilGenericParam);
32997 
32998 #ifdef DOCUMENTATION
32999 
33001 #endif // DOCUMENTATION
33002 
33003 #ifndef DOCUMENTATION
33004  AsmCilGenericParam.setDataPrototype(
33005  "uint16_t", "Number", "= 0",
33006  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
33007 #endif // !DOCUMENTATION
33008 
33009 #ifndef DOCUMENTATION
33010  AsmCilGenericParam.setDataPrototype(
33011  "uint16_t", "Flags", "= 0",
33012  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
33013 #endif // !DOCUMENTATION
33014 
33015 #ifndef DOCUMENTATION
33016  AsmCilGenericParam.setDataPrototype(
33017  "uint32_t", "Owner", "= 0",
33018  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
33019 #endif // !DOCUMENTATION
33020 
33021 #ifndef DOCUMENTATION
33022  AsmCilGenericParam.setDataPrototype(
33023  "uint32_t", "Name", "= 0",
33024  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
33025 #endif // !DOCUMENTATION
33026 
33027  DECLARE_OTHERS(AsmCilGenericParam);
33028 #if defined(SgAsmCilGenericParam_OTHERS) || defined(DOCUMENTATION)
33029 
33030  //----------------------- Boost serialization for SgAsmCilGenericParam -----------------------
33031 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
33032 private:
33033  friend class boost::serialization::access;
33034 
33035  template<class S>
33036  void serialize(S &s, const unsigned /*version*/) {
33037  debugSerializationBegin("SgAsmCilGenericParam");
33038  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
33039  s & BOOST_SERIALIZATION_NVP(p_Number);
33040  s & BOOST_SERIALIZATION_NVP(p_Flags);
33041  s & BOOST_SERIALIZATION_NVP(p_Owner);
33042  s & BOOST_SERIALIZATION_NVP(p_Name);
33043  debugSerializationEnd("SgAsmCilGenericParam");
33044  }
33045 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
33046 
33047 public:
33053  uint16_t const& get_Number() const;
33054  void set_Number(uint16_t const&);
33057 public:
33063  uint16_t const& get_Flags() const;
33064  void set_Flags(uint16_t const&);
33067 public:
33073  uint32_t const& get_Owner() const;
33074  void set_Owner(uint32_t const&);
33077 public:
33083  uint32_t const& get_Name() const;
33084  void set_Name(uint32_t const&);
33086 public:
33087  void parse(std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing);
33088 
33089  const SgAsmCilMetadata* get_Owner_object() const;
33090  const std::uint8_t* get_Name_string() const;
33091 public:
33093  virtual ~SgAsmCilGenericParam();
33094 
33095 public:
33098 
33099 protected:
33106  void initializeProperties();
33107 #endif // SgAsmCilGenericParam_OTHERS
33108 #ifdef DOCUMENTATION
33109 };
33110 #endif // DOCUMENTATION
33111 
33112 
33114 // SgAsmCilGenericParamConstraintTable -- MACHINE GENERATED; DO NOT MODIFY --
33116 
33117 DECLARE_LEAF_CLASS(AsmCilGenericParamConstraintTable);
33118 IS_SERIALIZABLE(AsmCilGenericParamConstraintTable);
33119 
33120 #ifdef DOCUMENTATION
33121 
33123 #endif // DOCUMENTATION
33124 
33125 #ifndef DOCUMENTATION
33126  AsmCilGenericParamConstraintTable.setDataPrototype(
33127  "std::vector<SgAsmCilGenericParamConstraint*>", "elements", "",
33128  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
33129 #endif // !DOCUMENTATION
33130 
33131  DECLARE_OTHERS(AsmCilGenericParamConstraintTable);
33132 #if defined(SgAsmCilGenericParamConstraintTable_OTHERS) || defined(DOCUMENTATION)
33133 
33134  //----------------------- Boost serialization for SgAsmCilGenericParamConstraintTable -----------------------
33135 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
33136 private:
33137  friend class boost::serialization::access;
33138 
33139  template<class S>
33140  void serialize(S &s, const unsigned /*version*/) {
33141  debugSerializationBegin("SgAsmCilGenericParamConstraintTable");
33142  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
33143  s & BOOST_SERIALIZATION_NVP(p_elements);
33144  debugSerializationEnd("SgAsmCilGenericParamConstraintTable");
33145  }
33146 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
33147 
33148 public:
33149  std::vector<SgAsmCilGenericParamConstraint*> const& get_elements() const;
33150  std::vector<SgAsmCilGenericParamConstraint*>& get_elements();
33151 public:
33153 public:
33156 
33157 public:
33160 
33161 protected:
33168  void initializeProperties();
33169 #endif // SgAsmCilGenericParamConstraintTable_OTHERS
33170 #ifdef DOCUMENTATION
33171 };
33172 #endif // DOCUMENTATION
33173 
33174 
33176 // SgAsmCilGenericParamConstraint -- MACHINE GENERATED; DO NOT MODIFY --
33178 
33179 DECLARE_LEAF_CLASS(AsmCilGenericParamConstraint);
33180 IS_SERIALIZABLE(AsmCilGenericParamConstraint);
33181 
33182 #ifdef DOCUMENTATION
33183 
33185 #endif // DOCUMENTATION
33186 
33187 #ifndef DOCUMENTATION
33188  AsmCilGenericParamConstraint.setDataPrototype(
33189  "uint32_t", "Owner", "= 0",
33190  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
33191 #endif // !DOCUMENTATION
33192 
33193 #ifndef DOCUMENTATION
33194  AsmCilGenericParamConstraint.setDataPrototype(
33195  "uint32_t", "Constraint", "= 0",
33196  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
33197 #endif // !DOCUMENTATION
33198 
33199  DECLARE_OTHERS(AsmCilGenericParamConstraint);
33200 #if defined(SgAsmCilGenericParamConstraint_OTHERS) || defined(DOCUMENTATION)
33201 
33202  //----------------------- Boost serialization for SgAsmCilGenericParamConstraint -----------------------
33203 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
33204 private:
33205  friend class boost::serialization::access;
33206 
33207  template<class S>
33208  void serialize(S &s, const unsigned /*version*/) {
33209  debugSerializationBegin("SgAsmCilGenericParamConstraint");
33210  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
33211  s & BOOST_SERIALIZATION_NVP(p_Owner);
33212  s & BOOST_SERIALIZATION_NVP(p_Constraint);
33213  debugSerializationEnd("SgAsmCilGenericParamConstraint");
33214  }
33215 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
33216 
33217 public:
33223  uint32_t const& get_Owner() const;
33224  void set_Owner(uint32_t const&);
33227 public:
33233  uint32_t const& get_Constraint() const;
33234  void set_Constraint(uint32_t const&);
33236 public:
33237  void parse(std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing);
33238 
33239  const SgAsmCilMetadata* get_Owner_object() const;
33240  const SgAsmCilMetadata* get_Constraint_object() const;
33241 public:
33244 
33245 public:
33248 
33249 protected:
33256  void initializeProperties();
33257 #endif // SgAsmCilGenericParamConstraint_OTHERS
33258 #ifdef DOCUMENTATION
33259 };
33260 #endif // DOCUMENTATION
33261 
33262 
33264 // SgAsmCilFileTable -- MACHINE GENERATED; DO NOT MODIFY --
33266 
33267 DECLARE_LEAF_CLASS(AsmCilFileTable);
33268 IS_SERIALIZABLE(AsmCilFileTable);
33269 
33270 #ifdef DOCUMENTATION
33271 
33273 #endif // DOCUMENTATION
33274 
33275 #ifndef DOCUMENTATION
33276  AsmCilFileTable.setDataPrototype(
33277  "std::vector<SgAsmCilFile*>", "elements", "",
33278  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
33279 #endif // !DOCUMENTATION
33280 
33281  DECLARE_OTHERS(AsmCilFileTable);
33282 #if defined(SgAsmCilFileTable_OTHERS) || defined(DOCUMENTATION)
33283 
33284  //----------------------- Boost serialization for SgAsmCilFileTable -----------------------
33285 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
33286 private:
33287  friend class boost::serialization::access;
33288 
33289  template<class S>
33290  void serialize(S &s, const unsigned /*version*/) {
33291  debugSerializationBegin("SgAsmCilFileTable");
33292  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
33293  s & BOOST_SERIALIZATION_NVP(p_elements);
33294  debugSerializationEnd("SgAsmCilFileTable");
33295  }
33296 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
33297 
33298 public:
33299  std::vector<SgAsmCilFile*> const& get_elements() const;
33300  std::vector<SgAsmCilFile*>& get_elements();
33301 public:
33302  using CilMetadataType = SgAsmCilFile;
33303 public:
33305  virtual ~SgAsmCilFileTable();
33306 
33307 public:
33310 
33311 protected:
33318  void initializeProperties();
33319 #endif // SgAsmCilFileTable_OTHERS
33320 #ifdef DOCUMENTATION
33321 };
33322 #endif // DOCUMENTATION
33323 
33324 
33326 // SgAsmCilFile -- MACHINE GENERATED; DO NOT MODIFY --
33328 
33329 DECLARE_LEAF_CLASS(AsmCilFile);
33330 IS_SERIALIZABLE(AsmCilFile);
33331 
33332 #ifdef DOCUMENTATION
33333 
33335 #endif // DOCUMENTATION
33336 
33337 #ifndef DOCUMENTATION
33338  AsmCilFile.setDataPrototype(
33339  "uint32_t", "Flags", "= 0",
33340  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
33341 #endif // !DOCUMENTATION
33342 
33343 #ifndef DOCUMENTATION
33344  AsmCilFile.setDataPrototype(
33345  "uint32_t", "Name", "= 0",
33346  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
33347 #endif // !DOCUMENTATION
33348 
33349 #ifndef DOCUMENTATION
33350  AsmCilFile.setDataPrototype(
33351  "uint32_t", "HashValue", "= 0",
33352  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
33353 #endif // !DOCUMENTATION
33354 
33355  DECLARE_OTHERS(AsmCilFile);
33356 #if defined(SgAsmCilFile_OTHERS) || defined(DOCUMENTATION)
33357 
33358  //----------------------- Boost serialization for SgAsmCilFile -----------------------
33359 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
33360 private:
33361  friend class boost::serialization::access;
33362 
33363  template<class S>
33364  void serialize(S &s, const unsigned /*version*/) {
33365  debugSerializationBegin("SgAsmCilFile");
33366  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
33367  s & BOOST_SERIALIZATION_NVP(p_Flags);
33368  s & BOOST_SERIALIZATION_NVP(p_Name);
33369  s & BOOST_SERIALIZATION_NVP(p_HashValue);
33370  debugSerializationEnd("SgAsmCilFile");
33371  }
33372 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
33373 
33374 public:
33380  uint32_t const& get_Flags() const;
33381  void set_Flags(uint32_t const&);
33384 public:
33390  uint32_t const& get_Name() const;
33391  void set_Name(uint32_t const&);
33394 public:
33400  uint32_t const& get_HashValue() const;
33401  void set_HashValue(uint32_t const&);
33403 public:
33404  void parse(std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing);
33405 
33406  const std::uint8_t* get_Name_string() const;
33407  const std::uint8_t* get_HashValue_blob() const;
33408 public:
33410  virtual ~SgAsmCilFile();
33411 
33412 public:
33414  SgAsmCilFile();
33415 
33416 protected:
33423  void initializeProperties();
33424 #endif // SgAsmCilFile_OTHERS
33425 #ifdef DOCUMENTATION
33426 };
33427 #endif // DOCUMENTATION
33428 
33429 
33431 // SgAsmCilFieldTable -- MACHINE GENERATED; DO NOT MODIFY --
33433 
33434 DECLARE_LEAF_CLASS(AsmCilFieldTable);
33435 IS_SERIALIZABLE(AsmCilFieldTable);
33436 
33437 #ifdef DOCUMENTATION
33438 
33440 #endif // DOCUMENTATION
33441 
33442 #ifndef DOCUMENTATION
33443  AsmCilFieldTable.setDataPrototype(
33444  "std::vector<SgAsmCilField*>", "elements", "",
33445  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
33446 #endif // !DOCUMENTATION
33447 
33448  DECLARE_OTHERS(AsmCilFieldTable);
33449 #if defined(SgAsmCilFieldTable_OTHERS) || defined(DOCUMENTATION)
33450 
33451  //----------------------- Boost serialization for SgAsmCilFieldTable -----------------------
33452 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
33453 private:
33454  friend class boost::serialization::access;
33455 
33456  template<class S>
33457  void serialize(S &s, const unsigned /*version*/) {
33458  debugSerializationBegin("SgAsmCilFieldTable");
33459  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
33460  s & BOOST_SERIALIZATION_NVP(p_elements);
33461  debugSerializationEnd("SgAsmCilFieldTable");
33462  }
33463 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
33464 
33465 public:
33466  std::vector<SgAsmCilField*> const& get_elements() const;
33467  std::vector<SgAsmCilField*>& get_elements();
33468 public:
33470 public:
33472  virtual ~SgAsmCilFieldTable();
33473 
33474 public:
33477 
33478 protected:
33485  void initializeProperties();
33486 #endif // SgAsmCilFieldTable_OTHERS
33487 #ifdef DOCUMENTATION
33488 };
33489 #endif // DOCUMENTATION
33490 
33491 
33493 // SgAsmCilFieldRVATable -- MACHINE GENERATED; DO NOT MODIFY --
33495 
33496 DECLARE_LEAF_CLASS(AsmCilFieldRVATable);
33497 IS_SERIALIZABLE(AsmCilFieldRVATable);
33498 
33499 #ifdef DOCUMENTATION
33500 
33502 #endif // DOCUMENTATION
33503 
33504 #ifndef DOCUMENTATION
33505  AsmCilFieldRVATable.setDataPrototype(
33506  "std::vector<SgAsmCilFieldRVA*>", "elements", "",
33507  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
33508 #endif // !DOCUMENTATION
33509 
33510  DECLARE_OTHERS(AsmCilFieldRVATable);
33511 #if defined(SgAsmCilFieldRVATable_OTHERS) || defined(DOCUMENTATION)
33512 
33513  //----------------------- Boost serialization for SgAsmCilFieldRVATable -----------------------
33514 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
33515 private:
33516  friend class boost::serialization::access;
33517 
33518  template<class S>
33519  void serialize(S &s, const unsigned /*version*/) {
33520  debugSerializationBegin("SgAsmCilFieldRVATable");
33521  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
33522  s & BOOST_SERIALIZATION_NVP(p_elements);
33523  debugSerializationEnd("SgAsmCilFieldRVATable");
33524  }
33525 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
33526 
33527 public:
33528  std::vector<SgAsmCilFieldRVA*> const& get_elements() const;
33529  std::vector<SgAsmCilFieldRVA*>& get_elements();
33530 public:
33532 public:
33534  virtual ~SgAsmCilFieldRVATable();
33535 
33536 public:
33539 
33540 protected:
33547  void initializeProperties();
33548 #endif // SgAsmCilFieldRVATable_OTHERS
33549 #ifdef DOCUMENTATION
33550 };
33551 #endif // DOCUMENTATION
33552 
33553 
33555 // SgAsmCilFieldRVA -- MACHINE GENERATED; DO NOT MODIFY --
33557 
33558 DECLARE_LEAF_CLASS(AsmCilFieldRVA);
33559 IS_SERIALIZABLE(AsmCilFieldRVA);
33560 
33561 #ifdef DOCUMENTATION
33562 
33564 #endif // DOCUMENTATION
33565 
33566 #ifndef DOCUMENTATION
33567  AsmCilFieldRVA.setDataPrototype(
33568  "uint32_t", "RVA", "= 0",
33569  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
33570 #endif // !DOCUMENTATION
33571 
33572 #ifndef DOCUMENTATION
33573  AsmCilFieldRVA.setDataPrototype(
33574  "uint32_t", "Field", "= 0",
33575  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
33576 #endif // !DOCUMENTATION
33577 
33578  DECLARE_OTHERS(AsmCilFieldRVA);
33579 #if defined(SgAsmCilFieldRVA_OTHERS) || defined(DOCUMENTATION)
33580 
33581  //----------------------- Boost serialization for SgAsmCilFieldRVA -----------------------
33582 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
33583 private:
33584  friend class boost::serialization::access;
33585 
33586  template<class S>
33587  void serialize(S &s, const unsigned /*version*/) {
33588  debugSerializationBegin("SgAsmCilFieldRVA");
33589  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
33590  s & BOOST_SERIALIZATION_NVP(p_RVA);
33591  s & BOOST_SERIALIZATION_NVP(p_Field);
33592  debugSerializationEnd("SgAsmCilFieldRVA");
33593  }
33594 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
33595 
33596 public:
33602  uint32_t const& get_RVA() const;
33603  void set_RVA(uint32_t const&);
33606 public:
33612  uint32_t const& get_Field() const;
33613  void set_Field(uint32_t const&);
33615 public:
33616  void parse(std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing);
33617 
33618  const SgAsmCilMetadata* get_Field_object() const;
33619 public:
33621  virtual ~SgAsmCilFieldRVA();
33622 
33623 public:
33625  SgAsmCilFieldRVA();
33626 
33627 protected:
33634  void initializeProperties();
33635 #endif // SgAsmCilFieldRVA_OTHERS
33636 #ifdef DOCUMENTATION
33637 };
33638 #endif // DOCUMENTATION
33639 
33640 
33642 // SgAsmCilFieldMarshalTable -- MACHINE GENERATED; DO NOT MODIFY --
33644 
33645 DECLARE_LEAF_CLASS(AsmCilFieldMarshalTable);
33646 IS_SERIALIZABLE(AsmCilFieldMarshalTable);
33647 
33648 #ifdef DOCUMENTATION
33649 
33651 #endif // DOCUMENTATION
33652 
33653 #ifndef DOCUMENTATION
33654  AsmCilFieldMarshalTable.setDataPrototype(
33655  "std::vector<SgAsmCilFieldMarshal*>", "elements", "",
33656  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
33657 #endif // !DOCUMENTATION
33658 
33659  DECLARE_OTHERS(AsmCilFieldMarshalTable);
33660 #if defined(SgAsmCilFieldMarshalTable_OTHERS) || defined(DOCUMENTATION)
33661 
33662  //----------------------- Boost serialization for SgAsmCilFieldMarshalTable -----------------------
33663 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
33664 private:
33665  friend class boost::serialization::access;
33666 
33667  template<class S>
33668  void serialize(S &s, const unsigned /*version*/) {
33669  debugSerializationBegin("SgAsmCilFieldMarshalTable");
33670  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
33671  s & BOOST_SERIALIZATION_NVP(p_elements);
33672  debugSerializationEnd("SgAsmCilFieldMarshalTable");
33673  }
33674 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
33675 
33676 public:
33677  std::vector<SgAsmCilFieldMarshal*> const& get_elements() const;
33678  std::vector<SgAsmCilFieldMarshal*>& get_elements();
33679 public:
33681 public:
33683  virtual ~SgAsmCilFieldMarshalTable();
33684 
33685 public:
33688 
33689 protected:
33696  void initializeProperties();
33697 #endif // SgAsmCilFieldMarshalTable_OTHERS
33698 #ifdef DOCUMENTATION
33699 };
33700 #endif // DOCUMENTATION
33701 
33702 
33704 // SgAsmCilFieldMarshal -- MACHINE GENERATED; DO NOT MODIFY --
33706 
33707 DECLARE_LEAF_CLASS(AsmCilFieldMarshal);
33708 IS_SERIALIZABLE(AsmCilFieldMarshal);
33709 
33710 #ifdef DOCUMENTATION
33711 
33713 #endif // DOCUMENTATION
33714 
33715 #ifndef DOCUMENTATION
33716  AsmCilFieldMarshal.setDataPrototype(
33717  "uint32_t", "Parent", "= 0",
33718  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
33719 #endif // !DOCUMENTATION
33720 
33721 #ifndef DOCUMENTATION
33722  AsmCilFieldMarshal.setDataPrototype(
33723  "uint32_t", "NativeType", "= 0",
33724  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
33725 #endif // !DOCUMENTATION
33726 
33727  DECLARE_OTHERS(AsmCilFieldMarshal);
33728 #if defined(SgAsmCilFieldMarshal_OTHERS) || defined(DOCUMENTATION)
33729 
33730  //----------------------- Boost serialization for SgAsmCilFieldMarshal -----------------------
33731 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
33732 private:
33733  friend class boost::serialization::access;
33734 
33735  template<class S>
33736  void serialize(S &s, const unsigned /*version*/) {
33737  debugSerializationBegin("SgAsmCilFieldMarshal");
33738  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
33739  s & BOOST_SERIALIZATION_NVP(p_Parent);
33740  s & BOOST_SERIALIZATION_NVP(p_NativeType);
33741  debugSerializationEnd("SgAsmCilFieldMarshal");
33742  }
33743 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
33744 
33745 public:
33751  uint32_t const& get_Parent() const;
33752  void set_Parent(uint32_t const&);
33755 public:
33761  uint32_t const& get_NativeType() const;
33762  void set_NativeType(uint32_t const&);
33764 public:
33765  void parse(std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing);
33766 
33767  const SgAsmCilMetadata* get_Parent_object() const;
33768  const std::uint8_t* get_NativeType_blob() const;
33769 public:
33771  virtual ~SgAsmCilFieldMarshal();
33772 
33773 public:
33776 
33777 protected:
33784  void initializeProperties();
33785 #endif // SgAsmCilFieldMarshal_OTHERS
33786 #ifdef DOCUMENTATION
33787 };
33788 #endif // DOCUMENTATION
33789 
33790 
33792 // SgAsmCilFieldLayoutTable -- MACHINE GENERATED; DO NOT MODIFY --
33794 
33795 DECLARE_LEAF_CLASS(AsmCilFieldLayoutTable);
33796 IS_SERIALIZABLE(AsmCilFieldLayoutTable);
33797 
33798 #ifdef DOCUMENTATION
33799 
33801 #endif // DOCUMENTATION
33802 
33803 #ifndef DOCUMENTATION
33804  AsmCilFieldLayoutTable.setDataPrototype(
33805  "std::vector<SgAsmCilFieldLayout*>", "elements", "",
33806  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
33807 #endif // !DOCUMENTATION
33808 
33809  DECLARE_OTHERS(AsmCilFieldLayoutTable);
33810 #if defined(SgAsmCilFieldLayoutTable_OTHERS) || defined(DOCUMENTATION)
33811 
33812  //----------------------- Boost serialization for SgAsmCilFieldLayoutTable -----------------------
33813 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
33814 private:
33815  friend class boost::serialization::access;
33816 
33817  template<class S>
33818  void serialize(S &s, const unsigned /*version*/) {
33819  debugSerializationBegin("SgAsmCilFieldLayoutTable");
33820  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
33821  s & BOOST_SERIALIZATION_NVP(p_elements);
33822  debugSerializationEnd("SgAsmCilFieldLayoutTable");
33823  }
33824 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
33825 
33826 public:
33827  std::vector<SgAsmCilFieldLayout*> const& get_elements() const;
33828  std::vector<SgAsmCilFieldLayout*>& get_elements();
33829 public:
33831 public:
33833  virtual ~SgAsmCilFieldLayoutTable();
33834 
33835 public:
33838 
33839 protected:
33846  void initializeProperties();
33847 #endif // SgAsmCilFieldLayoutTable_OTHERS
33848 #ifdef DOCUMENTATION
33849 };
33850 #endif // DOCUMENTATION
33851 
33852 
33854 // SgAsmCilFieldLayout -- MACHINE GENERATED; DO NOT MODIFY --
33856 
33857 DECLARE_LEAF_CLASS(AsmCilFieldLayout);
33858 IS_SERIALIZABLE(AsmCilFieldLayout);
33859 
33860 #ifdef DOCUMENTATION
33861 
33863 #endif // DOCUMENTATION
33864 
33865 #ifndef DOCUMENTATION
33866  AsmCilFieldLayout.setDataPrototype(
33867  "uint32_t", "Offset", "= 0",
33868  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
33869 #endif // !DOCUMENTATION
33870 
33871 #ifndef DOCUMENTATION
33872  AsmCilFieldLayout.setDataPrototype(
33873  "uint32_t", "Field", "= 0",
33874  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
33875 #endif // !DOCUMENTATION
33876 
33877  DECLARE_OTHERS(AsmCilFieldLayout);
33878 #if defined(SgAsmCilFieldLayout_OTHERS) || defined(DOCUMENTATION)
33879 
33880  //----------------------- Boost serialization for SgAsmCilFieldLayout -----------------------
33881 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
33882 private:
33883  friend class boost::serialization::access;
33884 
33885  template<class S>
33886  void serialize(S &s, const unsigned /*version*/) {
33887  debugSerializationBegin("SgAsmCilFieldLayout");
33888  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
33889  s & BOOST_SERIALIZATION_NVP(p_Offset);
33890  s & BOOST_SERIALIZATION_NVP(p_Field);
33891  debugSerializationEnd("SgAsmCilFieldLayout");
33892  }
33893 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
33894 
33895 public:
33901  uint32_t const& get_Offset() const;
33902  void set_Offset(uint32_t const&);
33905 public:
33911  uint32_t const& get_Field() const;
33912  void set_Field(uint32_t const&);
33914 public:
33915  void parse(std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing);
33916 
33917  const SgAsmCilMetadata* get_Field_object() const;
33918 public:
33920  virtual ~SgAsmCilFieldLayout();
33921 
33922 public:
33925 
33926 protected:
33933  void initializeProperties();
33934 #endif // SgAsmCilFieldLayout_OTHERS
33935 #ifdef DOCUMENTATION
33936 };
33937 #endif // DOCUMENTATION
33938 
33939 
33941 // SgAsmCilField -- MACHINE GENERATED; DO NOT MODIFY --
33943 
33944 DECLARE_LEAF_CLASS(AsmCilField);
33945 IS_SERIALIZABLE(AsmCilField);
33946 
33947 #ifdef DOCUMENTATION
33948 
33950 #endif // DOCUMENTATION
33951 
33952 #ifndef DOCUMENTATION
33953  AsmCilField.setDataPrototype(
33954  "uint16_t", "Flags", "= 0",
33955  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
33956 #endif // !DOCUMENTATION
33957 
33958 #ifndef DOCUMENTATION
33959  AsmCilField.setDataPrototype(
33960  "uint32_t", "Name", "= 0",
33961  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
33962 #endif // !DOCUMENTATION
33963 
33964 #ifndef DOCUMENTATION
33965  AsmCilField.setDataPrototype(
33966  "uint32_t", "Signature", "= 0",
33967  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
33968 #endif // !DOCUMENTATION
33969 
33970  DECLARE_OTHERS(AsmCilField);
33971 #if defined(SgAsmCilField_OTHERS) || defined(DOCUMENTATION)
33972 
33973  //----------------------- Boost serialization for SgAsmCilField -----------------------
33974 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
33975 private:
33976  friend class boost::serialization::access;
33977 
33978  template<class S>
33979  void serialize(S &s, const unsigned /*version*/) {
33980  debugSerializationBegin("SgAsmCilField");
33981  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
33982  s & BOOST_SERIALIZATION_NVP(p_Flags);
33983  s & BOOST_SERIALIZATION_NVP(p_Name);
33984  s & BOOST_SERIALIZATION_NVP(p_Signature);
33985  debugSerializationEnd("SgAsmCilField");
33986  }
33987 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
33988 
33989 public:
33995  uint16_t const& get_Flags() const;
33996  void set_Flags(uint16_t const&);
33999 public:
34005  uint32_t const& get_Name() const;
34006  void set_Name(uint32_t const&);
34009 public:
34015  uint32_t const& get_Signature() const;
34016  void set_Signature(uint32_t const&);
34018 public:
34019  void parse(std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing);
34020 
34021  const std::uint8_t* get_Name_string() const;
34022  const std::uint8_t* get_Signature_blob() const;
34023 public:
34025  virtual ~SgAsmCilField();
34026 
34027 public:
34029  SgAsmCilField();
34030 
34031 protected:
34038  void initializeProperties();
34039 #endif // SgAsmCilField_OTHERS
34040 #ifdef DOCUMENTATION
34041 };
34042 #endif // DOCUMENTATION
34043 
34044 
34046 // SgAsmCilExportedTypeTable -- MACHINE GENERATED; DO NOT MODIFY --
34048 
34049 DECLARE_LEAF_CLASS(AsmCilExportedTypeTable);
34050 IS_SERIALIZABLE(AsmCilExportedTypeTable);
34051 
34052 #ifdef DOCUMENTATION
34053 
34055 #endif // DOCUMENTATION
34056 
34057 #ifndef DOCUMENTATION
34058  AsmCilExportedTypeTable.setDataPrototype(
34059  "std::vector<SgAsmCilExportedType*>", "elements", "",
34060  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
34061 #endif // !DOCUMENTATION
34062 
34063  DECLARE_OTHERS(AsmCilExportedTypeTable);
34064 #if defined(SgAsmCilExportedTypeTable_OTHERS) || defined(DOCUMENTATION)
34065 
34066  //----------------------- Boost serialization for SgAsmCilExportedTypeTable -----------------------
34067 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
34068 private:
34069  friend class boost::serialization::access;
34070 
34071  template<class S>
34072  void serialize(S &s, const unsigned /*version*/) {
34073  debugSerializationBegin("SgAsmCilExportedTypeTable");
34074  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
34075  s & BOOST_SERIALIZATION_NVP(p_elements);
34076  debugSerializationEnd("SgAsmCilExportedTypeTable");
34077  }
34078 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
34079 
34080 public:
34081  std::vector<SgAsmCilExportedType*> const& get_elements() const;
34082  std::vector<SgAsmCilExportedType*>& get_elements();
34083 public:
34085 public:
34087  virtual ~SgAsmCilExportedTypeTable();
34088 
34089 public:
34092 
34093 protected:
34100  void initializeProperties();
34101 #endif // SgAsmCilExportedTypeTable_OTHERS
34102 #ifdef DOCUMENTATION
34103 };
34104 #endif // DOCUMENTATION
34105 
34106 
34108 // SgAsmCilExportedType -- MACHINE GENERATED; DO NOT MODIFY --
34110 
34111 DECLARE_LEAF_CLASS(AsmCilExportedType);
34112 IS_SERIALIZABLE(AsmCilExportedType);
34113 
34114 #ifdef DOCUMENTATION
34115 
34117 #endif // DOCUMENTATION
34118 
34119 #ifndef DOCUMENTATION
34120  AsmCilExportedType.setDataPrototype(
34121  "uint32_t", "EventFlags", "= 0",
34122  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
34123 #endif // !DOCUMENTATION
34124 
34125 #ifndef DOCUMENTATION
34126  AsmCilExportedType.setDataPrototype(
34127  "uint32_t", "TypeDefIdName", "= 0",
34128  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
34129 #endif // !DOCUMENTATION
34130 
34131 #ifndef DOCUMENTATION
34132  AsmCilExportedType.setDataPrototype(
34133  "uint32_t", "TypeName", "= 0",
34134  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
34135 #endif // !DOCUMENTATION
34136 
34137 #ifndef DOCUMENTATION
34138  AsmCilExportedType.setDataPrototype(
34139  "uint32_t", "TypeNamespace", "= 0",
34140  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
34141 #endif // !DOCUMENTATION
34142 
34143 #ifndef DOCUMENTATION
34144  AsmCilExportedType.setDataPrototype(
34145  "uint32_t", "Implementation", "= 0",
34146  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
34147 #endif // !DOCUMENTATION
34148 
34149  DECLARE_OTHERS(AsmCilExportedType);
34150 #if defined(SgAsmCilExportedType_OTHERS) || defined(DOCUMENTATION)
34151 
34152  //----------------------- Boost serialization for SgAsmCilExportedType -----------------------
34153 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
34154 private:
34155  friend class boost::serialization::access;
34156 
34157  template<class S>
34158  void serialize(S &s, const unsigned /*version*/) {
34159  debugSerializationBegin("SgAsmCilExportedType");
34160  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
34161  s & BOOST_SERIALIZATION_NVP(p_EventFlags);
34162  s & BOOST_SERIALIZATION_NVP(p_TypeDefIdName);
34163  s & BOOST_SERIALIZATION_NVP(p_TypeName);
34164  s & BOOST_SERIALIZATION_NVP(p_TypeNamespace);
34165  s & BOOST_SERIALIZATION_NVP(p_Implementation);
34166  debugSerializationEnd("SgAsmCilExportedType");
34167  }
34168 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
34169 
34170 public:
34176  uint32_t const& get_EventFlags() const;
34177  void set_EventFlags(uint32_t const&);
34180 public:
34186  uint32_t const& get_TypeDefIdName() const;
34187  void set_TypeDefIdName(uint32_t const&);
34190 public:
34196  uint32_t const& get_TypeName() const;
34197  void set_TypeName(uint32_t const&);
34200 public:
34206  uint32_t const& get_TypeNamespace() const;
34207  void set_TypeNamespace(uint32_t const&);
34210 public:
34216  uint32_t const& get_Implementation() const;
34217  void set_Implementation(uint32_t const&);
34219 public:
34220  void parse(std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing);
34221 
34222  const std::uint8_t* get_TypeName_string() const;
34223  const std::uint8_t* get_TypeNamespace_string() const;
34224  const SgAsmCilMetadata* get_Implementation_object() const;
34225 public:
34227  virtual ~SgAsmCilExportedType();
34228 
34229 public:
34232 
34233 protected:
34240  void initializeProperties();
34241 #endif // SgAsmCilExportedType_OTHERS
34242 #ifdef DOCUMENTATION
34243 };
34244 #endif // DOCUMENTATION
34245 
34246 
34248 // SgAsmCilEventTable -- MACHINE GENERATED; DO NOT MODIFY --
34250 
34251 DECLARE_LEAF_CLASS(AsmCilEventTable);
34252 IS_SERIALIZABLE(AsmCilEventTable);
34253 
34254 #ifdef DOCUMENTATION
34255 
34257 #endif // DOCUMENTATION
34258 
34259 #ifndef DOCUMENTATION
34260  AsmCilEventTable.setDataPrototype(
34261  "std::vector<SgAsmCilEvent*>", "elements", "",
34262  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
34263 #endif // !DOCUMENTATION
34264 
34265  DECLARE_OTHERS(AsmCilEventTable);
34266 #if defined(SgAsmCilEventTable_OTHERS) || defined(DOCUMENTATION)
34267 
34268  //----------------------- Boost serialization for SgAsmCilEventTable -----------------------
34269 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
34270 private:
34271  friend class boost::serialization::access;
34272 
34273  template<class S>
34274  void serialize(S &s, const unsigned /*version*/) {
34275  debugSerializationBegin("SgAsmCilEventTable");
34276  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
34277  s & BOOST_SERIALIZATION_NVP(p_elements);
34278  debugSerializationEnd("SgAsmCilEventTable");
34279  }
34280 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
34281 
34282 public:
34283  std::vector<SgAsmCilEvent*> const& get_elements() const;
34284  std::vector<SgAsmCilEvent*>& get_elements();
34285 public:
34287 public:
34289  virtual ~SgAsmCilEventTable();
34290 
34291 public:
34294 
34295 protected:
34302  void initializeProperties();
34303 #endif // SgAsmCilEventTable_OTHERS
34304 #ifdef DOCUMENTATION
34305 };
34306 #endif // DOCUMENTATION
34307 
34308 
34310 // SgAsmCilEventMapTable -- MACHINE GENERATED; DO NOT MODIFY --
34312 
34313 DECLARE_LEAF_CLASS(AsmCilEventMapTable);
34314 IS_SERIALIZABLE(AsmCilEventMapTable);
34315 
34316 #ifdef DOCUMENTATION
34317 
34319 #endif // DOCUMENTATION
34320 
34321 #ifndef DOCUMENTATION
34322  AsmCilEventMapTable.setDataPrototype(
34323  "std::vector<SgAsmCilEventMap*>", "elements", "",
34324  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
34325 #endif // !DOCUMENTATION
34326 
34327  DECLARE_OTHERS(AsmCilEventMapTable);
34328 #if defined(SgAsmCilEventMapTable_OTHERS) || defined(DOCUMENTATION)
34329 
34330  //----------------------- Boost serialization for SgAsmCilEventMapTable -----------------------
34331 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
34332 private:
34333  friend class boost::serialization::access;
34334 
34335  template<class S>
34336  void serialize(S &s, const unsigned /*version*/) {
34337  debugSerializationBegin("SgAsmCilEventMapTable");
34338  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
34339  s & BOOST_SERIALIZATION_NVP(p_elements);
34340  debugSerializationEnd("SgAsmCilEventMapTable");
34341  }
34342 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
34343 
34344 public:
34345  std::vector<SgAsmCilEventMap*> const& get_elements() const;
34346  std::vector<SgAsmCilEventMap*>& get_elements();
34347 public:
34349 public:
34351  virtual ~SgAsmCilEventMapTable();
34352 
34353 public:
34356 
34357 protected:
34364  void initializeProperties();
34365 #endif // SgAsmCilEventMapTable_OTHERS
34366 #ifdef DOCUMENTATION
34367 };
34368 #endif // DOCUMENTATION
34369 
34370 
34372 // SgAsmCilEventMap -- MACHINE GENERATED; DO NOT MODIFY --
34374 
34375 DECLARE_LEAF_CLASS(AsmCilEventMap);
34376 IS_SERIALIZABLE(AsmCilEventMap);
34377 
34378 #ifdef DOCUMENTATION
34379 
34381 #endif // DOCUMENTATION
34382 
34383 #ifndef DOCUMENTATION
34384  AsmCilEventMap.setDataPrototype(
34385  "uint32_t", "Parent", "= 0",
34386  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
34387 #endif // !DOCUMENTATION
34388 
34389 #ifndef DOCUMENTATION
34390  AsmCilEventMap.setDataPrototype(
34391  "uint32_t", "EventList", "= 0",
34392  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
34393 #endif // !DOCUMENTATION
34394 
34395  DECLARE_OTHERS(AsmCilEventMap);
34396 #if defined(SgAsmCilEventMap_OTHERS) || defined(DOCUMENTATION)
34397 
34398  //----------------------- Boost serialization for SgAsmCilEventMap -----------------------
34399 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
34400 private:
34401  friend class boost::serialization::access;
34402 
34403  template<class S>
34404  void serialize(S &s, const unsigned /*version*/) {
34405  debugSerializationBegin("SgAsmCilEventMap");
34406  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
34407  s & BOOST_SERIALIZATION_NVP(p_Parent);
34408  s & BOOST_SERIALIZATION_NVP(p_EventList);
34409  debugSerializationEnd("SgAsmCilEventMap");
34410  }
34411 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
34412 
34413 public:
34419  uint32_t const& get_Parent() const;
34420  void set_Parent(uint32_t const&);
34423 public:
34429  uint32_t const& get_EventList() const;
34430  void set_EventList(uint32_t const&);
34432 public:
34433  void parse(std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing);
34434 
34435  const SgAsmCilMetadata* get_Parent_object() const;
34436  const SgAsmCilMetadata* get_EventList_object() const;
34437 public:
34439  virtual ~SgAsmCilEventMap();
34440 
34441 public:
34443  SgAsmCilEventMap();
34444 
34445 protected:
34452  void initializeProperties();
34453 #endif // SgAsmCilEventMap_OTHERS
34454 #ifdef DOCUMENTATION
34455 };
34456 #endif // DOCUMENTATION
34457 
34458 
34460 // SgAsmCilEvent -- MACHINE GENERATED; DO NOT MODIFY --
34462 
34463 DECLARE_LEAF_CLASS(AsmCilEvent);
34464 IS_SERIALIZABLE(AsmCilEvent);
34465 
34466 #ifdef DOCUMENTATION
34467 
34469 #endif // DOCUMENTATION
34470 
34471 #ifndef DOCUMENTATION
34472  AsmCilEvent.setDataPrototype(
34473  "uint16_t", "EventFlags", "= 0",
34474  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
34475 #endif // !DOCUMENTATION
34476 
34477 #ifndef DOCUMENTATION
34478  AsmCilEvent.setDataPrototype(
34479  "uint32_t", "Name", "= 0",
34480  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
34481 #endif // !DOCUMENTATION
34482 
34483 #ifndef DOCUMENTATION
34484  AsmCilEvent.setDataPrototype(
34485  "uint32_t", "EventType", "= 0",
34486  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
34487 #endif // !DOCUMENTATION
34488 
34489  DECLARE_OTHERS(AsmCilEvent);
34490 #if defined(SgAsmCilEvent_OTHERS) || defined(DOCUMENTATION)
34491 
34492  //----------------------- Boost serialization for SgAsmCilEvent -----------------------
34493 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
34494 private:
34495  friend class boost::serialization::access;
34496 
34497  template<class S>
34498  void serialize(S &s, const unsigned /*version*/) {
34499  debugSerializationBegin("SgAsmCilEvent");
34500  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
34501  s & BOOST_SERIALIZATION_NVP(p_EventFlags);
34502  s & BOOST_SERIALIZATION_NVP(p_Name);
34503  s & BOOST_SERIALIZATION_NVP(p_EventType);
34504  debugSerializationEnd("SgAsmCilEvent");
34505  }
34506 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
34507 
34508 public:
34514  uint16_t const& get_EventFlags() const;
34515  void set_EventFlags(uint16_t const&);
34518 public:
34524  uint32_t const& get_Name() const;
34525  void set_Name(uint32_t const&);
34528 public:
34534  uint32_t const& get_EventType() const;
34535  void set_EventType(uint32_t const&);
34537 public:
34538  void parse(std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing);
34539 
34540  const std::uint8_t* get_Name_string() const;
34541  const SgAsmCilMetadata* get_EventType_object() const;
34542 public:
34544  virtual ~SgAsmCilEvent();
34545 
34546 public:
34548  SgAsmCilEvent();
34549 
34550 protected:
34557  void initializeProperties();
34558 #endif // SgAsmCilEvent_OTHERS
34559 #ifdef DOCUMENTATION
34560 };
34561 #endif // DOCUMENTATION
34562 
34563 
34565 // SgAsmCilDeclSecurityTable -- MACHINE GENERATED; DO NOT MODIFY --
34567 
34568 DECLARE_LEAF_CLASS(AsmCilDeclSecurityTable);
34569 IS_SERIALIZABLE(AsmCilDeclSecurityTable);
34570 
34571 #ifdef DOCUMENTATION
34572 
34574 #endif // DOCUMENTATION
34575 
34576 #ifndef DOCUMENTATION
34577  AsmCilDeclSecurityTable.setDataPrototype(
34578  "std::vector<SgAsmCilDeclSecurity*>", "elements", "",
34579  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
34580 #endif // !DOCUMENTATION
34581 
34582  DECLARE_OTHERS(AsmCilDeclSecurityTable);
34583 #if defined(SgAsmCilDeclSecurityTable_OTHERS) || defined(DOCUMENTATION)
34584 
34585  //----------------------- Boost serialization for SgAsmCilDeclSecurityTable -----------------------
34586 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
34587 private:
34588  friend class boost::serialization::access;
34589 
34590  template<class S>
34591  void serialize(S &s, const unsigned /*version*/) {
34592  debugSerializationBegin("SgAsmCilDeclSecurityTable");
34593  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
34594  s & BOOST_SERIALIZATION_NVP(p_elements);
34595  debugSerializationEnd("SgAsmCilDeclSecurityTable");
34596  }
34597 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
34598 
34599 public:
34600  std::vector<SgAsmCilDeclSecurity*> const& get_elements() const;
34601  std::vector<SgAsmCilDeclSecurity*>& get_elements();
34602 public:
34604 public:
34606  virtual ~SgAsmCilDeclSecurityTable();
34607 
34608 public:
34611 
34612 protected:
34619  void initializeProperties();
34620 #endif // SgAsmCilDeclSecurityTable_OTHERS
34621 #ifdef DOCUMENTATION
34622 };
34623 #endif // DOCUMENTATION
34624 
34625 
34627 // SgAsmCilDeclSecurity -- MACHINE GENERATED; DO NOT MODIFY --
34629 
34630 DECLARE_LEAF_CLASS(AsmCilDeclSecurity);
34631 IS_SERIALIZABLE(AsmCilDeclSecurity);
34632 
34633 #ifdef DOCUMENTATION
34634 
34636 #endif // DOCUMENTATION
34637 
34638 #ifndef DOCUMENTATION
34639  AsmCilDeclSecurity.setDataPrototype(
34640  "uint16_t", "Action", "= 0",
34641  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
34642 #endif // !DOCUMENTATION
34643 
34644 #ifndef DOCUMENTATION
34645  AsmCilDeclSecurity.setDataPrototype(
34646  "uint32_t", "Parent", "= 0",
34647  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
34648 #endif // !DOCUMENTATION
34649 
34650 #ifndef DOCUMENTATION
34651  AsmCilDeclSecurity.setDataPrototype(
34652  "uint32_t", "PermissionSet", "= 0",
34653  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
34654 #endif // !DOCUMENTATION
34655 
34656  DECLARE_OTHERS(AsmCilDeclSecurity);
34657 #if defined(SgAsmCilDeclSecurity_OTHERS) || defined(DOCUMENTATION)
34658 
34659  //----------------------- Boost serialization for SgAsmCilDeclSecurity -----------------------
34660 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
34661 private:
34662  friend class boost::serialization::access;
34663 
34664  template<class S>
34665  void serialize(S &s, const unsigned /*version*/) {
34666  debugSerializationBegin("SgAsmCilDeclSecurity");
34667  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
34668  s & BOOST_SERIALIZATION_NVP(p_Action);
34669  s & BOOST_SERIALIZATION_NVP(p_Parent);
34670  s & BOOST_SERIALIZATION_NVP(p_PermissionSet);
34671  debugSerializationEnd("SgAsmCilDeclSecurity");
34672  }
34673 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
34674 
34675 public:
34681  uint16_t const& get_Action() const;
34682  void set_Action(uint16_t const&);
34685 public:
34691  uint32_t const& get_Parent() const;
34692  void set_Parent(uint32_t const&);
34695 public:
34701  uint32_t const& get_PermissionSet() const;
34702  void set_PermissionSet(uint32_t const&);
34704 public:
34705  void parse(std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing);
34706 
34707  const SgAsmCilMetadata* get_Parent_object() const;
34708  const std::uint8_t* get_PermissionSet_blob() const;
34709 public:
34711  virtual ~SgAsmCilDeclSecurity();
34712 
34713 public:
34716 
34717 protected:
34724  void initializeProperties();
34725 #endif // SgAsmCilDeclSecurity_OTHERS
34726 #ifdef DOCUMENTATION
34727 };
34728 #endif // DOCUMENTATION
34729 
34730 
34732 // SgAsmCilDataStream -- MACHINE GENERATED; DO NOT MODIFY --
34734 
34735 #ifndef DOCUMENTATION
34736 AstNodeClass& AsmCilDataStream = nonTerminalConstructor(
34737  "AsmCilDataStream",
34738  *this,
34739  "AsmCilDataStream",
34740  "AsmCilDataStreamTag",
34741  SubclassListBuilder()
34742  | AsmCilMetadataHeap
34743  | AsmCilUint32Heap
34744  | AsmCilUint8Heap
34745  , false);
34746 assert(AsmCilDataStream.associatedGrammar != nullptr);
34747 AsmCilDataStream.setCppCondition("!defined(DOCUMENTATION)");
34748 AsmCilDataStream.isBoostSerializable(true);
34749 AsmCilDataStream.setAutomaticGenerationOfConstructor(false);
34750 AsmCilDataStream.setAutomaticGenerationOfDestructor(false);
34751 #endif // !DOCUMENTATION
34752 
34753 #ifdef DOCUMENTATION
34754 
34756 #endif // DOCUMENTATION
34757 
34758 #ifndef DOCUMENTATION
34759  AsmCilDataStream.setDataPrototype(
34760  "uint32_t", "Offset", "",
34761  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
34762 #endif // !DOCUMENTATION
34763 
34764 #ifndef DOCUMENTATION
34765  AsmCilDataStream.setDataPrototype(
34766  "uint32_t", "Size", "",
34767  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
34768 #endif // !DOCUMENTATION
34769 
34770 #ifndef DOCUMENTATION
34771  AsmCilDataStream.setDataPrototype(
34772  "std::string", "Name", "",
34773  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
34774 #endif // !DOCUMENTATION
34775 
34776 #ifndef DOCUMENTATION
34777  AsmCilDataStream.setDataPrototype(
34778  "uint32_t", "NamePadding", "",
34779  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
34780 #endif // !DOCUMENTATION
34781 
34782  DECLARE_OTHERS(AsmCilDataStream);
34783 #if defined(SgAsmCilDataStream_OTHERS) || defined(DOCUMENTATION)
34784 
34785  //----------------------- Boost serialization for SgAsmCilDataStream -----------------------
34786 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
34787 private:
34788  friend class boost::serialization::access;
34789 
34790  template<class S>
34791  void serialize(S &s, const unsigned /*version*/) {
34792  debugSerializationBegin("SgAsmCilDataStream");
34793  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilNode);
34794  s & BOOST_SERIALIZATION_NVP(p_Offset);
34795  s & BOOST_SERIALIZATION_NVP(p_Size);
34796  s & BOOST_SERIALIZATION_NVP(p_Name);
34797  s & BOOST_SERIALIZATION_NVP(p_NamePadding);
34798  debugSerializationEnd("SgAsmCilDataStream");
34799  }
34800 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
34801 
34802 public:
34806  uint32_t const& get_Offset() const;
34807  void set_Offset(uint32_t const&);
34810 public:
34814  uint32_t const& get_Size() const;
34815  void set_Size(uint32_t const&);
34818 public:
34822  std::string const& get_Name() const;
34823  void set_Name(std::string const&);
34826 public:
34830  uint32_t const& get_NamePadding() const;
34831  void set_NamePadding(uint32_t const&);
34833 public:
34837  static const std::string ID_STRING_HEAP;
34838  static const std::string ID_BLOB_HEAP;
34839  static const std::string ID_US_HEAP;
34840  static const std::string ID_GUID_HEAP;
34841  static const std::string ID_METADATA_HEAP;
34854  virtual void parse(std::vector<uint8_t>& buf, size_t startOfMetaData) { /* FIXME: should be abstract */ }
34855 public:
34857  virtual ~SgAsmCilDataStream();
34858 
34859 protected:
34862 
34863 protected:
34865  SgAsmCilDataStream(uint32_t const& Offset,
34866  uint32_t const& Size,
34867  std::string const& Name,
34868  uint32_t const& NamePadding);
34869 
34870 protected:
34877  void initializeProperties();
34878 #endif // SgAsmCilDataStream_OTHERS
34879 #ifdef DOCUMENTATION
34880 };
34881 #endif // DOCUMENTATION
34882 
34883 
34885 // SgAsmCilCustomAttributeTable -- MACHINE GENERATED; DO NOT MODIFY --
34887 
34888 DECLARE_LEAF_CLASS(AsmCilCustomAttributeTable);
34889 IS_SERIALIZABLE(AsmCilCustomAttributeTable);
34890 
34891 #ifdef DOCUMENTATION
34892 
34894 #endif // DOCUMENTATION
34895 
34896 #ifndef DOCUMENTATION
34897  AsmCilCustomAttributeTable.setDataPrototype(
34898  "std::vector<SgAsmCilCustomAttribute*>", "elements", "",
34899  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
34900 #endif // !DOCUMENTATION
34901 
34902  DECLARE_OTHERS(AsmCilCustomAttributeTable);
34903 #if defined(SgAsmCilCustomAttributeTable_OTHERS) || defined(DOCUMENTATION)
34904 
34905  //----------------------- Boost serialization for SgAsmCilCustomAttributeTable -----------------------
34906 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
34907 private:
34908  friend class boost::serialization::access;
34909 
34910  template<class S>
34911  void serialize(S &s, const unsigned /*version*/) {
34912  debugSerializationBegin("SgAsmCilCustomAttributeTable");
34913  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
34914  s & BOOST_SERIALIZATION_NVP(p_elements);
34915  debugSerializationEnd("SgAsmCilCustomAttributeTable");
34916  }
34917 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
34918 
34919 public:
34920  std::vector<SgAsmCilCustomAttribute*> const& get_elements() const;
34921  std::vector<SgAsmCilCustomAttribute*>& get_elements();
34922 public:
34924 public:
34927 
34928 public:
34931 
34932 protected:
34939  void initializeProperties();
34940 #endif // SgAsmCilCustomAttributeTable_OTHERS
34941 #ifdef DOCUMENTATION
34942 };
34943 #endif // DOCUMENTATION
34944 
34945 
34947 // SgAsmCilCustomAttribute -- MACHINE GENERATED; DO NOT MODIFY --
34949 
34950 DECLARE_LEAF_CLASS(AsmCilCustomAttribute);
34951 IS_SERIALIZABLE(AsmCilCustomAttribute);
34952 
34953 #ifdef DOCUMENTATION
34954 
34956 #endif // DOCUMENTATION
34957 
34958 #ifndef DOCUMENTATION
34959  AsmCilCustomAttribute.setDataPrototype(
34960  "uint32_t", "Parent", "= 0",
34961  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
34962 #endif // !DOCUMENTATION
34963 
34964 #ifndef DOCUMENTATION
34965  AsmCilCustomAttribute.setDataPrototype(
34966  "uint32_t", "Type", "= 0",
34967  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
34968 #endif // !DOCUMENTATION
34969 
34970 #ifndef DOCUMENTATION
34971  AsmCilCustomAttribute.setDataPrototype(
34972  "uint32_t", "Value", "= 0",
34973  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
34974 #endif // !DOCUMENTATION
34975 
34976  DECLARE_OTHERS(AsmCilCustomAttribute);
34977 #if defined(SgAsmCilCustomAttribute_OTHERS) || defined(DOCUMENTATION)
34978 
34979  //----------------------- Boost serialization for SgAsmCilCustomAttribute -----------------------
34980 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
34981 private:
34982  friend class boost::serialization::access;
34983 
34984  template<class S>
34985  void serialize(S &s, const unsigned /*version*/) {
34986  debugSerializationBegin("SgAsmCilCustomAttribute");
34987  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
34988  s & BOOST_SERIALIZATION_NVP(p_Parent);
34989  s & BOOST_SERIALIZATION_NVP(p_Type);
34990  s & BOOST_SERIALIZATION_NVP(p_Value);
34991  debugSerializationEnd("SgAsmCilCustomAttribute");
34992  }
34993 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
34994 
34995 public:
35001  uint32_t const& get_Parent() const;
35002  void set_Parent(uint32_t const&);
35005 public:
35011  uint32_t const& get_Type() const;
35012  void set_Type(uint32_t const&);
35015 public:
35021  uint32_t const& get_Value() const;
35022  void set_Value(uint32_t const&);
35024 public:
35025  void parse(std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing);
35026 
35027  const SgAsmCilMetadata* get_Parent_object() const;
35028  const SgAsmCilMetadata* get_Type_object() const;
35029  const std::uint8_t* get_Value_blob() const;
35030 public:
35032  virtual ~SgAsmCilCustomAttribute();
35033 
35034 public:
35037 
35038 protected:
35045  void initializeProperties();
35046 #endif // SgAsmCilCustomAttribute_OTHERS
35047 #ifdef DOCUMENTATION
35048 };
35049 #endif // DOCUMENTATION
35050 
35051 
35053 // SgAsmCilConstantTable -- MACHINE GENERATED; DO NOT MODIFY --
35055 
35056 DECLARE_LEAF_CLASS(AsmCilConstantTable);
35057 IS_SERIALIZABLE(AsmCilConstantTable);
35058 
35059 #ifdef DOCUMENTATION
35060 
35062 #endif // DOCUMENTATION
35063 
35064 #ifndef DOCUMENTATION
35065  AsmCilConstantTable.setDataPrototype(
35066  "std::vector<SgAsmCilConstant*>", "elements", "",
35067  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
35068 #endif // !DOCUMENTATION
35069 
35070  DECLARE_OTHERS(AsmCilConstantTable);
35071 #if defined(SgAsmCilConstantTable_OTHERS) || defined(DOCUMENTATION)
35072 
35073  //----------------------- Boost serialization for SgAsmCilConstantTable -----------------------
35074 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
35075 private:
35076  friend class boost::serialization::access;
35077 
35078  template<class S>
35079  void serialize(S &s, const unsigned /*version*/) {
35080  debugSerializationBegin("SgAsmCilConstantTable");
35081  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
35082  s & BOOST_SERIALIZATION_NVP(p_elements);
35083  debugSerializationEnd("SgAsmCilConstantTable");
35084  }
35085 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
35086 
35087 public:
35088  std::vector<SgAsmCilConstant*> const& get_elements() const;
35089  std::vector<SgAsmCilConstant*>& get_elements();
35090 public:
35092 public:
35094  virtual ~SgAsmCilConstantTable();
35095 
35096 public:
35099 
35100 protected:
35107  void initializeProperties();
35108 #endif // SgAsmCilConstantTable_OTHERS
35109 #ifdef DOCUMENTATION
35110 };
35111 #endif // DOCUMENTATION
35112 
35113 
35115 // SgAsmCilConstant -- MACHINE GENERATED; DO NOT MODIFY --
35117 
35118 DECLARE_LEAF_CLASS(AsmCilConstant);
35119 IS_SERIALIZABLE(AsmCilConstant);
35120 
35121 #ifdef DOCUMENTATION
35122 
35124 #endif // DOCUMENTATION
35125 
35126 #ifndef DOCUMENTATION
35127  AsmCilConstant.setDataPrototype(
35128  "uint8_t", "Type", "= 0",
35129  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
35130 #endif // !DOCUMENTATION
35131 
35132 #ifndef DOCUMENTATION
35133  AsmCilConstant.setDataPrototype(
35134  "uint8_t", "Padding", "= 0",
35135  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
35136 #endif // !DOCUMENTATION
35137 
35138 #ifndef DOCUMENTATION
35139  AsmCilConstant.setDataPrototype(
35140  "uint32_t", "Parent", "= 0",
35141  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
35142 #endif // !DOCUMENTATION
35143 
35144 #ifndef DOCUMENTATION
35145  AsmCilConstant.setDataPrototype(
35146  "uint32_t", "Value", "= 0",
35147  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
35148 #endif // !DOCUMENTATION
35149 
35150  DECLARE_OTHERS(AsmCilConstant);
35151 #if defined(SgAsmCilConstant_OTHERS) || defined(DOCUMENTATION)
35152 
35153  //----------------------- Boost serialization for SgAsmCilConstant -----------------------
35154 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
35155 private:
35156  friend class boost::serialization::access;
35157 
35158  template<class S>
35159  void serialize(S &s, const unsigned /*version*/) {
35160  debugSerializationBegin("SgAsmCilConstant");
35161  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
35162  s & BOOST_SERIALIZATION_NVP(p_Type);
35163  s & BOOST_SERIALIZATION_NVP(p_Padding);
35164  s & BOOST_SERIALIZATION_NVP(p_Parent);
35165  s & BOOST_SERIALIZATION_NVP(p_Value);
35166  debugSerializationEnd("SgAsmCilConstant");
35167  }
35168 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
35169 
35170 public:
35176  uint8_t const& get_Type() const;
35177  void set_Type(uint8_t const&);
35180 public:
35186  uint8_t const& get_Padding() const;
35187  void set_Padding(uint8_t const&);
35190 public:
35196  uint32_t const& get_Parent() const;
35197  void set_Parent(uint32_t const&);
35200 public:
35206  uint32_t const& get_Value() const;
35207  void set_Value(uint32_t const&);
35209 public:
35210  void parse(std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing);
35211 
35212  const SgAsmCilMetadata* get_Parent_object() const;
35213  const std::uint8_t* get_Value_blob() const;
35214 public:
35216  virtual ~SgAsmCilConstant();
35217 
35218 public:
35220  SgAsmCilConstant();
35221 
35222 protected:
35229  void initializeProperties();
35230 #endif // SgAsmCilConstant_OTHERS
35231 #ifdef DOCUMENTATION
35232 };
35233 #endif // DOCUMENTATION
35234 
35235 
35237 // SgAsmCilClassLayoutTable -- MACHINE GENERATED; DO NOT MODIFY --
35239 
35240 DECLARE_LEAF_CLASS(AsmCilClassLayoutTable);
35241 IS_SERIALIZABLE(AsmCilClassLayoutTable);
35242 
35243 #ifdef DOCUMENTATION
35244 
35246 #endif // DOCUMENTATION
35247 
35248 #ifndef DOCUMENTATION
35249  AsmCilClassLayoutTable.setDataPrototype(
35250  "std::vector<SgAsmCilClassLayout*>", "elements", "",
35251  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
35252 #endif // !DOCUMENTATION
35253 
35254  DECLARE_OTHERS(AsmCilClassLayoutTable);
35255 #if defined(SgAsmCilClassLayoutTable_OTHERS) || defined(DOCUMENTATION)
35256 
35257  //----------------------- Boost serialization for SgAsmCilClassLayoutTable -----------------------
35258 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
35259 private:
35260  friend class boost::serialization::access;
35261 
35262  template<class S>
35263  void serialize(S &s, const unsigned /*version*/) {
35264  debugSerializationBegin("SgAsmCilClassLayoutTable");
35265  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
35266  s & BOOST_SERIALIZATION_NVP(p_elements);
35267  debugSerializationEnd("SgAsmCilClassLayoutTable");
35268  }
35269 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
35270 
35271 public:
35272  std::vector<SgAsmCilClassLayout*> const& get_elements() const;
35273  std::vector<SgAsmCilClassLayout*>& get_elements();
35274 public:
35276 public:
35278  virtual ~SgAsmCilClassLayoutTable();
35279 
35280 public:
35283 
35284 protected:
35291  void initializeProperties();
35292 #endif // SgAsmCilClassLayoutTable_OTHERS
35293 #ifdef DOCUMENTATION
35294 };
35295 #endif // DOCUMENTATION
35296 
35297 
35299 // SgAsmCilClassLayout -- MACHINE GENERATED; DO NOT MODIFY --
35301 
35302 DECLARE_LEAF_CLASS(AsmCilClassLayout);
35303 IS_SERIALIZABLE(AsmCilClassLayout);
35304 
35305 #ifdef DOCUMENTATION
35306 
35308 #endif // DOCUMENTATION
35309 
35310 #ifndef DOCUMENTATION
35311  AsmCilClassLayout.setDataPrototype(
35312  "uint16_t", "PackingSize", "= 0",
35313  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
35314 #endif // !DOCUMENTATION
35315 
35316 #ifndef DOCUMENTATION
35317  AsmCilClassLayout.setDataPrototype(
35318  "uint32_t", "ClassSize", "= 0",
35319  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
35320 #endif // !DOCUMENTATION
35321 
35322 #ifndef DOCUMENTATION
35323  AsmCilClassLayout.setDataPrototype(
35324  "uint32_t", "Parent", "= 0",
35325  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
35326 #endif // !DOCUMENTATION
35327 
35328  DECLARE_OTHERS(AsmCilClassLayout);
35329 #if defined(SgAsmCilClassLayout_OTHERS) || defined(DOCUMENTATION)
35330 
35331  //----------------------- Boost serialization for SgAsmCilClassLayout -----------------------
35332 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
35333 private:
35334  friend class boost::serialization::access;
35335 
35336  template<class S>
35337  void serialize(S &s, const unsigned /*version*/) {
35338  debugSerializationBegin("SgAsmCilClassLayout");
35339  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
35340  s & BOOST_SERIALIZATION_NVP(p_PackingSize);
35341  s & BOOST_SERIALIZATION_NVP(p_ClassSize);
35342  s & BOOST_SERIALIZATION_NVP(p_Parent);
35343  debugSerializationEnd("SgAsmCilClassLayout");
35344  }
35345 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
35346 
35347 public:
35353  uint16_t const& get_PackingSize() const;
35354  void set_PackingSize(uint16_t const&);
35357 public:
35363  uint32_t const& get_ClassSize() const;
35364  void set_ClassSize(uint32_t const&);
35367 public:
35373  uint32_t const& get_Parent() const;
35374  void set_Parent(uint32_t const&);
35376 public:
35377  void parse(std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing);
35378 
35379  const SgAsmCilMetadata* get_Parent_object() const;
35380 public:
35382  virtual ~SgAsmCilClassLayout();
35383 
35384 public:
35387 
35388 protected:
35395  void initializeProperties();
35396 #endif // SgAsmCilClassLayout_OTHERS
35397 #ifdef DOCUMENTATION
35398 };
35399 #endif // DOCUMENTATION
35400 
35401 
35403 // SgAsmCilAssemblyTable -- MACHINE GENERATED; DO NOT MODIFY --
35405 
35406 DECLARE_LEAF_CLASS(AsmCilAssemblyTable);
35407 IS_SERIALIZABLE(AsmCilAssemblyTable);
35408 
35409 #ifdef DOCUMENTATION
35410 
35412 #endif // DOCUMENTATION
35413 
35414 #ifndef DOCUMENTATION
35415  AsmCilAssemblyTable.setDataPrototype(
35416  "std::vector<SgAsmCilAssembly*>", "elements", "",
35417  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
35418 #endif // !DOCUMENTATION
35419 
35420  DECLARE_OTHERS(AsmCilAssemblyTable);
35421 #if defined(SgAsmCilAssemblyTable_OTHERS) || defined(DOCUMENTATION)
35422 
35423  //----------------------- Boost serialization for SgAsmCilAssemblyTable -----------------------
35424 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
35425 private:
35426  friend class boost::serialization::access;
35427 
35428  template<class S>
35429  void serialize(S &s, const unsigned /*version*/) {
35430  debugSerializationBegin("SgAsmCilAssemblyTable");
35431  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
35432  s & BOOST_SERIALIZATION_NVP(p_elements);
35433  debugSerializationEnd("SgAsmCilAssemblyTable");
35434  }
35435 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
35436 
35437 public:
35438  std::vector<SgAsmCilAssembly*> const& get_elements() const;
35439  std::vector<SgAsmCilAssembly*>& get_elements();
35440 public:
35442 public:
35444  virtual ~SgAsmCilAssemblyTable();
35445 
35446 public:
35449 
35450 protected:
35457  void initializeProperties();
35458 #endif // SgAsmCilAssemblyTable_OTHERS
35459 #ifdef DOCUMENTATION
35460 };
35461 #endif // DOCUMENTATION
35462 
35463 
35465 // SgAsmCilAssemblyRefTable -- MACHINE GENERATED; DO NOT MODIFY --
35467 
35468 DECLARE_LEAF_CLASS(AsmCilAssemblyRefTable);
35469 IS_SERIALIZABLE(AsmCilAssemblyRefTable);
35470 
35471 #ifdef DOCUMENTATION
35472 
35474 #endif // DOCUMENTATION
35475 
35476 #ifndef DOCUMENTATION
35477  AsmCilAssemblyRefTable.setDataPrototype(
35478  "std::vector<SgAsmCilAssemblyRef*>", "elements", "",
35479  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
35480 #endif // !DOCUMENTATION
35481 
35482  DECLARE_OTHERS(AsmCilAssemblyRefTable);
35483 #if defined(SgAsmCilAssemblyRefTable_OTHERS) || defined(DOCUMENTATION)
35484 
35485  //----------------------- Boost serialization for SgAsmCilAssemblyRefTable -----------------------
35486 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
35487 private:
35488  friend class boost::serialization::access;
35489 
35490  template<class S>
35491  void serialize(S &s, const unsigned /*version*/) {
35492  debugSerializationBegin("SgAsmCilAssemblyRefTable");
35493  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
35494  s & BOOST_SERIALIZATION_NVP(p_elements);
35495  debugSerializationEnd("SgAsmCilAssemblyRefTable");
35496  }
35497 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
35498 
35499 public:
35500  std::vector<SgAsmCilAssemblyRef*> const& get_elements() const;
35501  std::vector<SgAsmCilAssemblyRef*>& get_elements();
35502 public:
35504 public:
35506  virtual ~SgAsmCilAssemblyRefTable();
35507 
35508 public:
35511 
35512 protected:
35519  void initializeProperties();
35520 #endif // SgAsmCilAssemblyRefTable_OTHERS
35521 #ifdef DOCUMENTATION
35522 };
35523 #endif // DOCUMENTATION
35524 
35525 
35527 // SgAsmCilAssemblyRefProcessorTable -- MACHINE GENERATED; DO NOT MODIFY --
35529 
35530 DECLARE_LEAF_CLASS(AsmCilAssemblyRefProcessorTable);
35531 IS_SERIALIZABLE(AsmCilAssemblyRefProcessorTable);
35532 
35533 #ifdef DOCUMENTATION
35534 
35536 #endif // DOCUMENTATION
35537 
35538 #ifndef DOCUMENTATION
35539  AsmCilAssemblyRefProcessorTable.setDataPrototype(
35540  "std::vector<SgAsmCilAssemblyRefProcessor*>", "elements", "",
35541  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
35542 #endif // !DOCUMENTATION
35543 
35544  DECLARE_OTHERS(AsmCilAssemblyRefProcessorTable);
35545 #if defined(SgAsmCilAssemblyRefProcessorTable_OTHERS) || defined(DOCUMENTATION)
35546 
35547  //----------------------- Boost serialization for SgAsmCilAssemblyRefProcessorTable -----------------------
35548 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
35549 private:
35550  friend class boost::serialization::access;
35551 
35552  template<class S>
35553  void serialize(S &s, const unsigned /*version*/) {
35554  debugSerializationBegin("SgAsmCilAssemblyRefProcessorTable");
35555  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
35556  s & BOOST_SERIALIZATION_NVP(p_elements);
35557  debugSerializationEnd("SgAsmCilAssemblyRefProcessorTable");
35558  }
35559 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
35560 
35561 public:
35562  std::vector<SgAsmCilAssemblyRefProcessor*> const& get_elements() const;
35563  std::vector<SgAsmCilAssemblyRefProcessor*>& get_elements();
35564 public:
35566 public:
35569 
35570 public:
35573 
35574 protected:
35581  void initializeProperties();
35582 #endif // SgAsmCilAssemblyRefProcessorTable_OTHERS
35583 #ifdef DOCUMENTATION
35584 };
35585 #endif // DOCUMENTATION
35586 
35587 
35589 // SgAsmCilAssemblyRefProcessor -- MACHINE GENERATED; DO NOT MODIFY --
35591 
35592 DECLARE_LEAF_CLASS(AsmCilAssemblyRefProcessor);
35593 IS_SERIALIZABLE(AsmCilAssemblyRefProcessor);
35594 
35595 #ifdef DOCUMENTATION
35596 
35598 #endif // DOCUMENTATION
35599 
35600 #ifndef DOCUMENTATION
35601  AsmCilAssemblyRefProcessor.setDataPrototype(
35602  "uint32_t", "Processor", "= 0",
35603  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
35604 #endif // !DOCUMENTATION
35605 
35606 #ifndef DOCUMENTATION
35607  AsmCilAssemblyRefProcessor.setDataPrototype(
35608  "uint32_t", "AssemblyRef", "= 0",
35609  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
35610 #endif // !DOCUMENTATION
35611 
35612  DECLARE_OTHERS(AsmCilAssemblyRefProcessor);
35613 #if defined(SgAsmCilAssemblyRefProcessor_OTHERS) || defined(DOCUMENTATION)
35614 
35615  //----------------------- Boost serialization for SgAsmCilAssemblyRefProcessor -----------------------
35616 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
35617 private:
35618  friend class boost::serialization::access;
35619 
35620  template<class S>
35621  void serialize(S &s, const unsigned /*version*/) {
35622  debugSerializationBegin("SgAsmCilAssemblyRefProcessor");
35623  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
35624  s & BOOST_SERIALIZATION_NVP(p_Processor);
35625  s & BOOST_SERIALIZATION_NVP(p_AssemblyRef);
35626  debugSerializationEnd("SgAsmCilAssemblyRefProcessor");
35627  }
35628 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
35629 
35630 public:
35636  uint32_t const& get_Processor() const;
35637  void set_Processor(uint32_t const&);
35640 public:
35646  uint32_t const& get_AssemblyRef() const;
35647  void set_AssemblyRef(uint32_t const&);
35649 public:
35650  void parse(std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing);
35651 
35652  const SgAsmCilMetadata* get_AssemblyRef_object() const;
35653 public:
35656 
35657 public:
35660 
35661 protected:
35668  void initializeProperties();
35669 #endif // SgAsmCilAssemblyRefProcessor_OTHERS
35670 #ifdef DOCUMENTATION
35671 };
35672 #endif // DOCUMENTATION
35673 
35674 
35676 // SgAsmCilAssemblyRefOSTable -- MACHINE GENERATED; DO NOT MODIFY --
35678 
35679 DECLARE_LEAF_CLASS(AsmCilAssemblyRefOSTable);
35680 IS_SERIALIZABLE(AsmCilAssemblyRefOSTable);
35681 
35682 #ifdef DOCUMENTATION
35683 
35685 #endif // DOCUMENTATION
35686 
35687 #ifndef DOCUMENTATION
35688  AsmCilAssemblyRefOSTable.setDataPrototype(
35689  "std::vector<SgAsmCilAssemblyRefOS*>", "elements", "",
35690  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
35691 #endif // !DOCUMENTATION
35692 
35693  DECLARE_OTHERS(AsmCilAssemblyRefOSTable);
35694 #if defined(SgAsmCilAssemblyRefOSTable_OTHERS) || defined(DOCUMENTATION)
35695 
35696  //----------------------- Boost serialization for SgAsmCilAssemblyRefOSTable -----------------------
35697 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
35698 private:
35699  friend class boost::serialization::access;
35700 
35701  template<class S>
35702  void serialize(S &s, const unsigned /*version*/) {
35703  debugSerializationBegin("SgAsmCilAssemblyRefOSTable");
35704  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
35705  s & BOOST_SERIALIZATION_NVP(p_elements);
35706  debugSerializationEnd("SgAsmCilAssemblyRefOSTable");
35707  }
35708 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
35709 
35710 public:
35711  std::vector<SgAsmCilAssemblyRefOS*> const& get_elements() const;
35712  std::vector<SgAsmCilAssemblyRefOS*>& get_elements();
35713 public:
35715 public:
35717  virtual ~SgAsmCilAssemblyRefOSTable();
35718 
35719 public:
35722 
35723 protected:
35730  void initializeProperties();
35731 #endif // SgAsmCilAssemblyRefOSTable_OTHERS
35732 #ifdef DOCUMENTATION
35733 };
35734 #endif // DOCUMENTATION
35735 
35736 
35738 // SgAsmCilAssemblyRefOS -- MACHINE GENERATED; DO NOT MODIFY --
35740 
35741 DECLARE_LEAF_CLASS(AsmCilAssemblyRefOS);
35742 IS_SERIALIZABLE(AsmCilAssemblyRefOS);
35743 
35744 #ifdef DOCUMENTATION
35745 
35747 #endif // DOCUMENTATION
35748 
35749 #ifndef DOCUMENTATION
35750  AsmCilAssemblyRefOS.setDataPrototype(
35751  "uint32_t", "OSPlatformID", "= 0",
35752  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
35753 #endif // !DOCUMENTATION
35754 
35755 #ifndef DOCUMENTATION
35756  AsmCilAssemblyRefOS.setDataPrototype(
35757  "uint32_t", "OSMajorVersion", "= 0",
35758  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
35759 #endif // !DOCUMENTATION
35760 
35761 #ifndef DOCUMENTATION
35762  AsmCilAssemblyRefOS.setDataPrototype(
35763  "uint32_t", "OSMinorVersion", "= 0",
35764  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
35765 #endif // !DOCUMENTATION
35766 
35767 #ifndef DOCUMENTATION
35768  AsmCilAssemblyRefOS.setDataPrototype(
35769  "uint32_t", "AssemblyRefOS", "= 0",
35770  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
35771 #endif // !DOCUMENTATION
35772 
35773  DECLARE_OTHERS(AsmCilAssemblyRefOS);
35774 #if defined(SgAsmCilAssemblyRefOS_OTHERS) || defined(DOCUMENTATION)
35775 
35776  //----------------------- Boost serialization for SgAsmCilAssemblyRefOS -----------------------
35777 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
35778 private:
35779  friend class boost::serialization::access;
35780 
35781  template<class S>
35782  void serialize(S &s, const unsigned /*version*/) {
35783  debugSerializationBegin("SgAsmCilAssemblyRefOS");
35784  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
35785  s & BOOST_SERIALIZATION_NVP(p_OSPlatformID);
35786  s & BOOST_SERIALIZATION_NVP(p_OSMajorVersion);
35787  s & BOOST_SERIALIZATION_NVP(p_OSMinorVersion);
35788  s & BOOST_SERIALIZATION_NVP(p_AssemblyRefOS);
35789  debugSerializationEnd("SgAsmCilAssemblyRefOS");
35790  }
35791 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
35792 
35793 public:
35799  uint32_t const& get_OSPlatformID() const;
35800  void set_OSPlatformID(uint32_t const&);
35803 public:
35809  uint32_t const& get_OSMajorVersion() const;
35810  void set_OSMajorVersion(uint32_t const&);
35813 public:
35819  uint32_t const& get_OSMinorVersion() const;
35820  void set_OSMinorVersion(uint32_t const&);
35823 public:
35829  uint32_t const& get_AssemblyRefOS() const;
35830  void set_AssemblyRefOS(uint32_t const&);
35832 public:
35833  void parse(std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing);
35834 
35835  const SgAsmCilMetadata* get_AssemblyRefOS_object() const;
35836 public:
35838  virtual ~SgAsmCilAssemblyRefOS();
35839 
35840 public:
35843 
35844 protected:
35851  void initializeProperties();
35852 #endif // SgAsmCilAssemblyRefOS_OTHERS
35853 #ifdef DOCUMENTATION
35854 };
35855 #endif // DOCUMENTATION
35856 
35857 
35859 // SgAsmCilAssemblyRef -- MACHINE GENERATED; DO NOT MODIFY --
35861 
35862 DECLARE_LEAF_CLASS(AsmCilAssemblyRef);
35863 IS_SERIALIZABLE(AsmCilAssemblyRef);
35864 
35865 #ifdef DOCUMENTATION
35866 
35868 #endif // DOCUMENTATION
35869 
35870 #ifndef DOCUMENTATION
35871  AsmCilAssemblyRef.setDataPrototype(
35872  "uint16_t", "MajorVersion", "= 0",
35873  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
35874 #endif // !DOCUMENTATION
35875 
35876 #ifndef DOCUMENTATION
35877  AsmCilAssemblyRef.setDataPrototype(
35878  "uint16_t", "MinorVersion", "= 0",
35879  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
35880 #endif // !DOCUMENTATION
35881 
35882 #ifndef DOCUMENTATION
35883  AsmCilAssemblyRef.setDataPrototype(
35884  "uint16_t", "BuildNumber", "= 0",
35885  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
35886 #endif // !DOCUMENTATION
35887 
35888 #ifndef DOCUMENTATION
35889  AsmCilAssemblyRef.setDataPrototype(
35890  "uint16_t", "RevisionNumber", "= 0",
35891  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
35892 #endif // !DOCUMENTATION
35893 
35894 #ifndef DOCUMENTATION
35895  AsmCilAssemblyRef.setDataPrototype(
35896  "uint32_t", "Flags", "= 0",
35897  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
35898 #endif // !DOCUMENTATION
35899 
35900 #ifndef DOCUMENTATION
35901  AsmCilAssemblyRef.setDataPrototype(
35902  "uint32_t", "PublicKeyOrToken", "= 0",
35903  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
35904 #endif // !DOCUMENTATION
35905 
35906 #ifndef DOCUMENTATION
35907  AsmCilAssemblyRef.setDataPrototype(
35908  "uint32_t", "Name", "= 0",
35909  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
35910 #endif // !DOCUMENTATION
35911 
35912 #ifndef DOCUMENTATION
35913  AsmCilAssemblyRef.setDataPrototype(
35914  "uint32_t", "Culture", "= 0",
35915  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
35916 #endif // !DOCUMENTATION
35917 
35918 #ifndef DOCUMENTATION
35919  AsmCilAssemblyRef.setDataPrototype(
35920  "uint32_t", "HashValue", "= 0",
35921  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
35922 #endif // !DOCUMENTATION
35923 
35924  DECLARE_OTHERS(AsmCilAssemblyRef);
35925 #if defined(SgAsmCilAssemblyRef_OTHERS) || defined(DOCUMENTATION)
35926 
35927  //----------------------- Boost serialization for SgAsmCilAssemblyRef -----------------------
35928 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
35929 private:
35930  friend class boost::serialization::access;
35931 
35932  template<class S>
35933  void serialize(S &s, const unsigned /*version*/) {
35934  debugSerializationBegin("SgAsmCilAssemblyRef");
35935  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
35936  s & BOOST_SERIALIZATION_NVP(p_MajorVersion);
35937  s & BOOST_SERIALIZATION_NVP(p_MinorVersion);
35938  s & BOOST_SERIALIZATION_NVP(p_BuildNumber);
35939  s & BOOST_SERIALIZATION_NVP(p_RevisionNumber);
35940  s & BOOST_SERIALIZATION_NVP(p_Flags);
35941  s & BOOST_SERIALIZATION_NVP(p_PublicKeyOrToken);
35942  s & BOOST_SERIALIZATION_NVP(p_Name);
35943  s & BOOST_SERIALIZATION_NVP(p_Culture);
35944  s & BOOST_SERIALIZATION_NVP(p_HashValue);
35945  debugSerializationEnd("SgAsmCilAssemblyRef");
35946  }
35947 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
35948 
35949 public:
35955  uint16_t const& get_MajorVersion() const;
35956  void set_MajorVersion(uint16_t const&);
35959 public:
35965  uint16_t const& get_MinorVersion() const;
35966  void set_MinorVersion(uint16_t const&);
35969 public:
35975  uint16_t const& get_BuildNumber() const;
35976  void set_BuildNumber(uint16_t const&);
35979 public:
35985  uint16_t const& get_RevisionNumber() const;
35986  void set_RevisionNumber(uint16_t const&);
35989 public:
35995  uint32_t const& get_Flags() const;
35996  void set_Flags(uint32_t const&);
35999 public:
36005  uint32_t const& get_PublicKeyOrToken() const;
36006  void set_PublicKeyOrToken(uint32_t const&);
36009 public:
36015  uint32_t const& get_Name() const;
36016  void set_Name(uint32_t const&);
36019 public:
36025  uint32_t const& get_Culture() const;
36026  void set_Culture(uint32_t const&);
36029 public:
36035  uint32_t const& get_HashValue() const;
36036  void set_HashValue(uint32_t const&);
36038 public:
36039  void parse(std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing);
36040 
36041  const std::uint8_t* get_PublicKeyOrToken_blob() const;
36042  const std::uint8_t* get_Name_string() const;
36043  const std::uint8_t* get_Culture_string() const;
36044  const std::uint8_t* get_HashValue_blob() const;
36045 public:
36047  virtual ~SgAsmCilAssemblyRef();
36048 
36049 public:
36052 
36053 protected:
36060  void initializeProperties();
36061 #endif // SgAsmCilAssemblyRef_OTHERS
36062 #ifdef DOCUMENTATION
36063 };
36064 #endif // DOCUMENTATION
36065 
36066 
36068 // SgAsmCilAssemblyProcessorTable -- MACHINE GENERATED; DO NOT MODIFY --
36070 
36071 DECLARE_LEAF_CLASS(AsmCilAssemblyProcessorTable);
36072 IS_SERIALIZABLE(AsmCilAssemblyProcessorTable);
36073 
36074 #ifdef DOCUMENTATION
36075 
36077 #endif // DOCUMENTATION
36078 
36079 #ifndef DOCUMENTATION
36080  AsmCilAssemblyProcessorTable.setDataPrototype(
36081  "std::vector<SgAsmCilAssemblyProcessor*>", "elements", "",
36082  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
36083 #endif // !DOCUMENTATION
36084 
36085  DECLARE_OTHERS(AsmCilAssemblyProcessorTable);
36086 #if defined(SgAsmCilAssemblyProcessorTable_OTHERS) || defined(DOCUMENTATION)
36087 
36088  //----------------------- Boost serialization for SgAsmCilAssemblyProcessorTable -----------------------
36089 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
36090 private:
36091  friend class boost::serialization::access;
36092 
36093  template<class S>
36094  void serialize(S &s, const unsigned /*version*/) {
36095  debugSerializationBegin("SgAsmCilAssemblyProcessorTable");
36096  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
36097  s & BOOST_SERIALIZATION_NVP(p_elements);
36098  debugSerializationEnd("SgAsmCilAssemblyProcessorTable");
36099  }
36100 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
36101 
36102 public:
36103  std::vector<SgAsmCilAssemblyProcessor*> const& get_elements() const;
36104  std::vector<SgAsmCilAssemblyProcessor*>& get_elements();
36105 public:
36107 public:
36110 
36111 public:
36114 
36115 protected:
36122  void initializeProperties();
36123 #endif // SgAsmCilAssemblyProcessorTable_OTHERS
36124 #ifdef DOCUMENTATION
36125 };
36126 #endif // DOCUMENTATION
36127 
36128 
36130 // SgAsmCilAssemblyProcessor -- MACHINE GENERATED; DO NOT MODIFY --
36132 
36133 DECLARE_LEAF_CLASS(AsmCilAssemblyProcessor);
36134 IS_SERIALIZABLE(AsmCilAssemblyProcessor);
36135 
36136 #ifdef DOCUMENTATION
36137 
36139 #endif // DOCUMENTATION
36140 
36141 #ifndef DOCUMENTATION
36142  AsmCilAssemblyProcessor.setDataPrototype(
36143  "uint32_t", "Processor", "= 0",
36144  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
36145 #endif // !DOCUMENTATION
36146 
36147  DECLARE_OTHERS(AsmCilAssemblyProcessor);
36148 #if defined(SgAsmCilAssemblyProcessor_OTHERS) || defined(DOCUMENTATION)
36149 
36150  //----------------------- Boost serialization for SgAsmCilAssemblyProcessor -----------------------
36151 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
36152 private:
36153  friend class boost::serialization::access;
36154 
36155  template<class S>
36156  void serialize(S &s, const unsigned /*version*/) {
36157  debugSerializationBegin("SgAsmCilAssemblyProcessor");
36158  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
36159  s & BOOST_SERIALIZATION_NVP(p_Processor);
36160  debugSerializationEnd("SgAsmCilAssemblyProcessor");
36161  }
36162 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
36163 
36164 public:
36170  uint32_t const& get_Processor() const;
36171  void set_Processor(uint32_t const&);
36173 public:
36174  void parse(std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing);
36175 public:
36177  virtual ~SgAsmCilAssemblyProcessor();
36178 
36179 public:
36182 
36183 protected:
36190  void initializeProperties();
36191 #endif // SgAsmCilAssemblyProcessor_OTHERS
36192 #ifdef DOCUMENTATION
36193 };
36194 #endif // DOCUMENTATION
36195 
36196 
36198 // SgAsmCilAssemblyOSTable -- MACHINE GENERATED; DO NOT MODIFY --
36200 
36201 DECLARE_LEAF_CLASS(AsmCilAssemblyOSTable);
36202 IS_SERIALIZABLE(AsmCilAssemblyOSTable);
36203 
36204 #ifdef DOCUMENTATION
36205 
36207 #endif // DOCUMENTATION
36208 
36209 #ifndef DOCUMENTATION
36210  AsmCilAssemblyOSTable.setDataPrototype(
36211  "std::vector<SgAsmCilAssemblyOS*>", "elements", "",
36212  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
36213 #endif // !DOCUMENTATION
36214 
36215  DECLARE_OTHERS(AsmCilAssemblyOSTable);
36216 #if defined(SgAsmCilAssemblyOSTable_OTHERS) || defined(DOCUMENTATION)
36217 
36218  //----------------------- Boost serialization for SgAsmCilAssemblyOSTable -----------------------
36219 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
36220 private:
36221  friend class boost::serialization::access;
36222 
36223  template<class S>
36224  void serialize(S &s, const unsigned /*version*/) {
36225  debugSerializationBegin("SgAsmCilAssemblyOSTable");
36226  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
36227  s & BOOST_SERIALIZATION_NVP(p_elements);
36228  debugSerializationEnd("SgAsmCilAssemblyOSTable");
36229  }
36230 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
36231 
36232 public:
36233  std::vector<SgAsmCilAssemblyOS*> const& get_elements() const;
36234  std::vector<SgAsmCilAssemblyOS*>& get_elements();
36235 public:
36237 public:
36239  virtual ~SgAsmCilAssemblyOSTable();
36240 
36241 public:
36244 
36245 protected:
36252  void initializeProperties();
36253 #endif // SgAsmCilAssemblyOSTable_OTHERS
36254 #ifdef DOCUMENTATION
36255 };
36256 #endif // DOCUMENTATION
36257 
36258 
36260 // SgAsmCilAssemblyOS -- MACHINE GENERATED; DO NOT MODIFY --
36262 
36263 DECLARE_LEAF_CLASS(AsmCilAssemblyOS);
36264 IS_SERIALIZABLE(AsmCilAssemblyOS);
36265 
36266 #ifdef DOCUMENTATION
36267 
36269 #endif // DOCUMENTATION
36270 
36271 #ifndef DOCUMENTATION
36272  AsmCilAssemblyOS.setDataPrototype(
36273  "uint32_t", "OSPlatformID", "= 0",
36274  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
36275 #endif // !DOCUMENTATION
36276 
36277 #ifndef DOCUMENTATION
36278  AsmCilAssemblyOS.setDataPrototype(
36279  "uint32_t", "OSMajorVersion", "= 0",
36280  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
36281 #endif // !DOCUMENTATION
36282 
36283 #ifndef DOCUMENTATION
36284  AsmCilAssemblyOS.setDataPrototype(
36285  "uint32_t", "OSMinorVersion", "= 0",
36286  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
36287 #endif // !DOCUMENTATION
36288 
36289  DECLARE_OTHERS(AsmCilAssemblyOS);
36290 #if defined(SgAsmCilAssemblyOS_OTHERS) || defined(DOCUMENTATION)
36291 
36292  //----------------------- Boost serialization for SgAsmCilAssemblyOS -----------------------
36293 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
36294 private:
36295  friend class boost::serialization::access;
36296 
36297  template<class S>
36298  void serialize(S &s, const unsigned /*version*/) {
36299  debugSerializationBegin("SgAsmCilAssemblyOS");
36300  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
36301  s & BOOST_SERIALIZATION_NVP(p_OSPlatformID);
36302  s & BOOST_SERIALIZATION_NVP(p_OSMajorVersion);
36303  s & BOOST_SERIALIZATION_NVP(p_OSMinorVersion);
36304  debugSerializationEnd("SgAsmCilAssemblyOS");
36305  }
36306 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
36307 
36308 public:
36314  uint32_t const& get_OSPlatformID() const;
36315  void set_OSPlatformID(uint32_t const&);
36318 public:
36324  uint32_t const& get_OSMajorVersion() const;
36325  void set_OSMajorVersion(uint32_t const&);
36328 public:
36334  uint32_t const& get_OSMinorVersion() const;
36335  void set_OSMinorVersion(uint32_t const&);
36337 public:
36338  void parse(std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing);
36339 public:
36341  virtual ~SgAsmCilAssemblyOS();
36342 
36343 public:
36346 
36347 protected:
36354  void initializeProperties();
36355 #endif // SgAsmCilAssemblyOS_OTHERS
36356 #ifdef DOCUMENTATION
36357 };
36358 #endif // DOCUMENTATION
36359 
36360 
36362 // SgAsmCilAssembly -- MACHINE GENERATED; DO NOT MODIFY --
36364 
36365 DECLARE_LEAF_CLASS(AsmCilAssembly);
36366 IS_SERIALIZABLE(AsmCilAssembly);
36367 
36368 #ifdef DOCUMENTATION
36369 
36371 #endif // DOCUMENTATION
36372 
36373 #ifndef DOCUMENTATION
36374  AsmCilAssembly.setDataPrototype(
36375  "uint32_t", "HashAlgId", "= 0",
36376  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
36377 #endif // !DOCUMENTATION
36378 
36379 #ifndef DOCUMENTATION
36380  AsmCilAssembly.setDataPrototype(
36381  "uint16_t", "MajorVersion", "= 0",
36382  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
36383 #endif // !DOCUMENTATION
36384 
36385 #ifndef DOCUMENTATION
36386  AsmCilAssembly.setDataPrototype(
36387  "uint16_t", "MinorVersion", "= 0",
36388  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
36389 #endif // !DOCUMENTATION
36390 
36391 #ifndef DOCUMENTATION
36392  AsmCilAssembly.setDataPrototype(
36393  "uint16_t", "BuildNumber", "= 0",
36394  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
36395 #endif // !DOCUMENTATION
36396 
36397 #ifndef DOCUMENTATION
36398  AsmCilAssembly.setDataPrototype(
36399  "uint16_t", "RevisionNumber", "= 0",
36400  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
36401 #endif // !DOCUMENTATION
36402 
36403 #ifndef DOCUMENTATION
36404  AsmCilAssembly.setDataPrototype(
36405  "uint32_t", "Flags", "= 0",
36406  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
36407 #endif // !DOCUMENTATION
36408 
36409 #ifndef DOCUMENTATION
36410  AsmCilAssembly.setDataPrototype(
36411  "uint32_t", "PublicKey", "= 0",
36412  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
36413 #endif // !DOCUMENTATION
36414 
36415 #ifndef DOCUMENTATION
36416  AsmCilAssembly.setDataPrototype(
36417  "uint32_t", "Name", "= 0",
36418  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
36419 #endif // !DOCUMENTATION
36420 
36421 #ifndef DOCUMENTATION
36422  AsmCilAssembly.setDataPrototype(
36423  "uint32_t", "Culture", "= 0",
36424  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
36425 #endif // !DOCUMENTATION
36426 
36427  DECLARE_OTHERS(AsmCilAssembly);
36428 #if defined(SgAsmCilAssembly_OTHERS) || defined(DOCUMENTATION)
36429 
36430  //----------------------- Boost serialization for SgAsmCilAssembly -----------------------
36431 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
36432 private:
36433  friend class boost::serialization::access;
36434 
36435  template<class S>
36436  void serialize(S &s, const unsigned /*version*/) {
36437  debugSerializationBegin("SgAsmCilAssembly");
36438  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilMetadata);
36439  s & BOOST_SERIALIZATION_NVP(p_HashAlgId);
36440  s & BOOST_SERIALIZATION_NVP(p_MajorVersion);
36441  s & BOOST_SERIALIZATION_NVP(p_MinorVersion);
36442  s & BOOST_SERIALIZATION_NVP(p_BuildNumber);
36443  s & BOOST_SERIALIZATION_NVP(p_RevisionNumber);
36444  s & BOOST_SERIALIZATION_NVP(p_Flags);
36445  s & BOOST_SERIALIZATION_NVP(p_PublicKey);
36446  s & BOOST_SERIALIZATION_NVP(p_Name);
36447  s & BOOST_SERIALIZATION_NVP(p_Culture);
36448  debugSerializationEnd("SgAsmCilAssembly");
36449  }
36450 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
36451 
36452 public:
36458  uint32_t const& get_HashAlgId() const;
36459  void set_HashAlgId(uint32_t const&);
36462 public:
36468  uint16_t const& get_MajorVersion() const;
36469  void set_MajorVersion(uint16_t const&);
36472 public:
36478  uint16_t const& get_MinorVersion() const;
36479  void set_MinorVersion(uint16_t const&);
36482 public:
36488  uint16_t const& get_BuildNumber() const;
36489  void set_BuildNumber(uint16_t const&);
36492 public:
36498  uint16_t const& get_RevisionNumber() const;
36499  void set_RevisionNumber(uint16_t const&);
36502 public:
36508  uint32_t const& get_Flags() const;
36509  void set_Flags(uint32_t const&);
36512 public:
36518  uint32_t const& get_PublicKey() const;
36519  void set_PublicKey(uint32_t const&);
36522 public:
36528  uint32_t const& get_Name() const;
36529  void set_Name(uint32_t const&);
36532 public:
36538  uint32_t const& get_Culture() const;
36539  void set_Culture(uint32_t const&);
36541 public:
36542  void parse(std::vector<uint8_t>& buf, size_t& index, uint64_t uses4byteIndexing);
36543 
36544  const std::uint8_t* get_PublicKey_blob() const;
36545  const std::uint8_t* get_Name_string() const;
36546  const std::uint8_t* get_Culture_string() const;
36547 public:
36549  virtual ~SgAsmCilAssembly();
36550 
36551 public:
36553  SgAsmCilAssembly();
36554 
36555 protected:
36562  void initializeProperties();
36563 #endif // SgAsmCilAssembly_OTHERS
36564 #ifdef DOCUMENTATION
36565 };
36566 #endif // DOCUMENTATION
36567 
36568 
36570 // SgAsmCilMetadata -- MACHINE GENERATED; DO NOT MODIFY --
36572 
36573 #ifndef DOCUMENTATION
36574 AstNodeClass& AsmCilMetadata = nonTerminalConstructor(
36575  "AsmCilMetadata",
36576  *this,
36577  "AsmCilMetadata",
36578  "AsmCilMetadataTag",
36579  SubclassListBuilder()
36580  | AsmCilAssembly
36581  | AsmCilAssemblyOS
36582  | AsmCilAssemblyOSTable
36583  | AsmCilAssemblyProcessor
36584  | AsmCilAssemblyProcessorTable
36585  | AsmCilAssemblyRef
36586  | AsmCilAssemblyRefOS
36587  | AsmCilAssemblyRefOSTable
36588  | AsmCilAssemblyRefProcessor
36589  | AsmCilAssemblyRefProcessorTable
36590  | AsmCilAssemblyRefTable
36591  | AsmCilAssemblyTable
36592  | AsmCilClassLayout
36593  | AsmCilClassLayoutTable
36594  | AsmCilConstant
36595  | AsmCilConstantTable
36596  | AsmCilCustomAttribute
36597  | AsmCilCustomAttributeTable
36598  | AsmCilDeclSecurity
36599  | AsmCilDeclSecurityTable
36600  | AsmCilEvent
36601  | AsmCilEventMap
36602  | AsmCilEventMapTable
36603  | AsmCilEventTable
36604  | AsmCilExportedType
36605  | AsmCilExportedTypeTable
36606  | AsmCilField
36607  | AsmCilFieldLayout
36608  | AsmCilFieldLayoutTable
36609  | AsmCilFieldMarshal
36610  | AsmCilFieldMarshalTable
36611  | AsmCilFieldRVA
36612  | AsmCilFieldRVATable
36613  | AsmCilFieldTable
36614  | AsmCilFile
36615  | AsmCilFileTable
36616  | AsmCilGenericParamConstraint
36617  | AsmCilGenericParamConstraintTable
36618  | AsmCilGenericParam
36619  | AsmCilGenericParamTable
36620  | AsmCilImplMap
36621  | AsmCilImplMapTable
36622  | AsmCilInterfaceImpl
36623  | AsmCilInterfaceImplTable
36624  | AsmCilManifestResource
36625  | AsmCilManifestResourceTable
36626  | AsmCilMemberRef
36627  | AsmCilMemberRefTable
36628  | AsmCilMethodDef
36629  | AsmCilMethodDefTable
36630  | AsmCilMethodImpl
36631  | AsmCilMethodImplTable
36632  | AsmCilMethodSemantics
36633  | AsmCilMethodSemanticsTable
36634  | AsmCilMethodSpec
36635  | AsmCilMethodSpecTable
36636  | AsmCilModule
36637  | AsmCilModuleRef
36638  | AsmCilModuleRefTable
36639  | AsmCilModuleTable
36640  | AsmCilNestedClass
36641  | AsmCilNestedClassTable
36642  | AsmCilParam
36643  | AsmCilParamTable
36644  | AsmCilProperty
36645  | AsmCilPropertyMap
36646  | AsmCilPropertyMapTable
36647  | AsmCilPropertyTable
36648  | AsmCilStandAloneSig
36649  | AsmCilStandAloneSigTable
36650  | AsmCilTypeDef
36651  | AsmCilTypeDefTable
36652  | AsmCilTypeRef
36653  | AsmCilTypeRefTable
36654  | AsmCilTypeSpec
36655  | AsmCilTypeSpecTable
36656  , false);
36657 assert(AsmCilMetadata.associatedGrammar != nullptr);
36658 AsmCilMetadata.setCppCondition("!defined(DOCUMENTATION)");
36659 AsmCilMetadata.isBoostSerializable(true);
36660 AsmCilMetadata.setAutomaticGenerationOfConstructor(false);
36661 AsmCilMetadata.setAutomaticGenerationOfDestructor(false);
36662 #endif // !DOCUMENTATION
36663 
36664 #ifdef DOCUMENTATION
36665 
36667 #endif // DOCUMENTATION
36668 
36669  DECLARE_OTHERS(AsmCilMetadata);
36670 #if defined(SgAsmCilMetadata_OTHERS) || defined(DOCUMENTATION)
36671 
36672  //----------------------- Boost serialization for SgAsmCilMetadata -----------------------
36673 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
36674 private:
36675  friend class boost::serialization::access;
36676 
36677  template<class S>
36678  void serialize(S &s, const unsigned /*version*/) {
36679  debugSerializationBegin("SgAsmCilMetadata");
36680  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmCilNode);
36681  debugSerializationEnd("SgAsmCilMetadata");
36682  }
36683 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
36684 
36685 public:
36687  virtual ~SgAsmCilMetadata();
36688 
36689 protected:
36691  SgAsmCilMetadata();
36692 
36693 protected:
36700  void initializeProperties();
36701 #endif // SgAsmCilMetadata_OTHERS
36702 #ifdef DOCUMENTATION
36703 };
36704 #endif // DOCUMENTATION
36705 
36706 
36708 // SgAsmCilNode -- MACHINE GENERATED; DO NOT MODIFY --
36710 
36711 #ifndef DOCUMENTATION
36712 AstNodeClass& AsmCilNode = nonTerminalConstructor(
36713  "AsmCilNode",
36714  *this,
36715  "AsmCilNode",
36716  "AsmCilNodeTag",
36717  SubclassListBuilder()
36718  | AsmCilDataStream
36719  | AsmCilMetadata
36720  | AsmCilMetadataRoot
36721  , false);
36722 assert(AsmCilNode.associatedGrammar != nullptr);
36723 AsmCilNode.setCppCondition("!defined(DOCUMENTATION)");
36724 AsmCilNode.isBoostSerializable(true);
36725 AsmCilNode.setAutomaticGenerationOfConstructor(false);
36726 AsmCilNode.setAutomaticGenerationOfDestructor(false);
36727 #endif // !DOCUMENTATION
36728 
36729 #ifdef DOCUMENTATION
36730 
36731 class SgAsmCilNode: public SgAsmNode {
36732 #endif // DOCUMENTATION
36733 
36734  DECLARE_OTHERS(AsmCilNode);
36735 #if defined(SgAsmCilNode_OTHERS) || defined(DOCUMENTATION)
36736 
36737  //----------------------- Boost serialization for SgAsmCilNode -----------------------
36738 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
36739 private:
36740  friend class boost::serialization::access;
36741 
36742  template<class S>
36743  void serialize(S &s, const unsigned /*version*/) {
36744  debugSerializationBegin("SgAsmCilNode");
36745  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmNode);
36746  debugSerializationEnd("SgAsmCilNode");
36747  }
36748 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
36749 
36750 public:
36752  virtual ~SgAsmCilNode();
36753 
36754 protected:
36756  SgAsmCilNode();
36757 
36758 protected:
36765  void initializeProperties();
36766 #endif // SgAsmCilNode_OTHERS
36767 #ifdef DOCUMENTATION
36768 };
36769 #endif // DOCUMENTATION
36770 
36771 
36773 // SgAsmByteOrder -- MACHINE GENERATED; DO NOT MODIFY --
36775 
36776 DECLARE_LEAF_CLASS(AsmByteOrder);
36777 IS_SERIALIZABLE(AsmByteOrder);
36778 
36779 DECLARE_HEADERS(AsmByteOrder);
36780 #if defined(SgAsmByteOrder_HEADERS) || defined(DOCUMENTATION)
36781 #include <Rose/BinaryAnalysis/ByteOrder.h>
36782 #endif // SgAsmByteOrder_HEADERS
36783 
36784 #ifdef DOCUMENTATION
36785 
36787 #endif // DOCUMENTATION
36788 
36789  DECLARE_OTHERS(AsmByteOrder);
36790 #if defined(SgAsmByteOrder_OTHERS) || defined(DOCUMENTATION)
36791 
36792  //----------------------- Boost serialization for SgAsmByteOrder -----------------------
36793 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
36794 private:
36795  friend class boost::serialization::access;
36796 
36797  template<class S>
36798  void serialize(S &s, const unsigned /*version*/) {
36799  debugSerializationBegin("SgAsmByteOrder");
36800  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExpression);
36801  s & BOOST_SERIALIZATION_NVP(byteOrder_);
36802  debugSerializationEnd("SgAsmByteOrder");
36803  }
36804 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
36805 
36806 private:
36807  Rose::BinaryAnalysis::ByteOrder::Endianness byteOrder_;
36808 
36809 public:
36813  Rose::BinaryAnalysis::ByteOrder::Endianness const& byteOrder() const;
36814  void byteOrder(Rose::BinaryAnalysis::ByteOrder::Endianness const&);
36817 public:
36819  virtual ~SgAsmByteOrder();
36820 
36821 public:
36823  SgAsmByteOrder();
36824 
36825 public:
36827  explicit SgAsmByteOrder(Rose::BinaryAnalysis::ByteOrder::Endianness const& byteOrder);
36828 
36829 protected:
36836  void initializeProperties();
36837 #endif // SgAsmByteOrder_OTHERS
36838 #ifdef DOCUMENTATION
36839 };
36840 #endif // DOCUMENTATION
36841 
36842 
36844 // SgAsmBlock -- MACHINE GENERATED; DO NOT MODIFY --
36846 
36847 DECLARE_LEAF_CLASS(AsmBlock);
36848 IS_SERIALIZABLE(AsmBlock);
36849 
36850 #ifdef DOCUMENTATION
36851 
36872 #endif // DOCUMENTATION
36873 
36874 #ifndef DOCUMENTATION
36875  AsmBlock.setDataPrototype(
36876  "rose_addr_t", "id", "= 0",
36877  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
36878 #endif // !DOCUMENTATION
36879 
36880 #ifndef DOCUMENTATION
36881  AsmBlock.setDataPrototype(
36882  "unsigned", "reason", "= SgAsmBlock::BLK_NONE",
36883  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
36884 #endif // !DOCUMENTATION
36885 
36886 #ifndef DOCUMENTATION
36887  AsmBlock.setDataPrototype(
36888  "SgAsmStatementPtrList", "statementList", "",
36889  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
36890 #endif // !DOCUMENTATION
36891 
36892 #ifndef DOCUMENTATION
36893  AsmBlock.setDataPrototype(
36894  "SgAsmIntegerValuePtrList", "successors", "",
36895  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
36896 #endif // !DOCUMENTATION
36897 
36898 #ifndef DOCUMENTATION
36899  AsmBlock.setDataPrototype(
36900  "bool", "successors_complete", "= false",
36901  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
36902 #endif // !DOCUMENTATION
36903 
36904 #ifndef DOCUMENTATION
36905  AsmBlock.setDataPrototype(
36906  "SgAsmBlock*", "immediate_dominator", "= nullptr",
36907  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
36908 #endif // !DOCUMENTATION
36909 
36910 #ifndef DOCUMENTATION
36911  AsmBlock.setDataPrototype(
36912  "size_t", "cached_vertex", "= (size_t)(-1)",
36913  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
36914 #endif // !DOCUMENTATION
36915 
36916 #ifndef DOCUMENTATION
36917  AsmBlock.setDataPrototype(
36918  "double", "code_likelihood", "= 0.0",
36919  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
36920 #endif // !DOCUMENTATION
36921 
36922 #ifndef DOCUMENTATION
36923  AsmBlock.setDataPrototype(
36924  "int64_t", "stackDeltaOut", "= SgAsmInstruction::INVALID_STACK_DELTA",
36925  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
36926 #endif // !DOCUMENTATION
36927 
36928  DECLARE_OTHERS(AsmBlock);
36929 #if defined(SgAsmBlock_OTHERS) || defined(DOCUMENTATION)
36930 
36931  //----------------------- Boost serialization for SgAsmBlock -----------------------
36932 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
36933 private:
36934  friend class boost::serialization::access;
36935 
36936  template<class S>
36937  void serialize(S &s, const unsigned /*version*/) {
36938  debugSerializationBegin("SgAsmBlock");
36939  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmStatement);
36940  s & BOOST_SERIALIZATION_NVP(p_reason);
36941  s & BOOST_SERIALIZATION_NVP(p_statementList);
36942  s & BOOST_SERIALIZATION_NVP(p_successors);
36943  s & BOOST_SERIALIZATION_NVP(p_successors_complete);
36944  s & BOOST_SERIALIZATION_NVP(p_immediate_dominator);
36945  s & BOOST_SERIALIZATION_NVP(p_cached_vertex);
36946  s & BOOST_SERIALIZATION_NVP(p_code_likelihood);
36947  s & BOOST_SERIALIZATION_NVP(p_stackDeltaOut);
36948  debugSerializationEnd("SgAsmBlock");
36949  }
36950 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
36951  // Local types
36954 public:
36956  enum Reason {
36957  // Please update SgAsmBlock::reason_str() if you change this enum!
36958  BLK_NONE = 0x00000000,
36959  BLK_ENTRY_POINT = 0x00010000,
36960  BLK_PADDING = 0x00020000,
36961  BLK_FRAGMENT = 0x00080000,
36963  BLK_CFGHEAD = 0x00100000,
36964  BLK_USERDEF = 0x00200000,
36965  BLK_LEFTOVERS = 0x00400000,
36967  BLK_JUMPTABLE = 0x00800000,
36968  BLK_GRAPH1 = 0x01000000,
36969  BLK_GRAPH2 = 0x02000000,
36970  BLK_GRAPH3 = 0x04000000,
36972  BLK_DEFAULT = BLK_NONE, //NO_STRINGIFY
36973 
36974  // ========= Miscellaneous Reasons ===========================================================================
36975  // The first half of the range (1-127, inclusive) is used for algorithms defined by ROSE. The second half is
36976  // availalble for users to use as they see fit.
36977  BLK_MISCMASK = 0x000000ff,
36979  BLK_FINDDATA = 0x00000001,
36981  BLK_POSTFUNC = 0x00000002
36983  };
36984 
36986  // Properties
36988 
36989  // FIXME[Robb Matzke 2023-03-18]: is the no_serialize a bug?
36990 public:
36996  rose_addr_t const& get_id() const;
36997  void set_id(rose_addr_t const&);
37000 public:
37006  unsigned const& get_reason() const;
37007  void set_reason(unsigned const&);
37009  // statementList and successors should have been pointers to nodes that contain the list rather than being the lists
37010  // themselves because ROSETTA doesn't allow traversals on multiple list data members--we can traverse either one list or
37011  // the other, but not both. It's too late to change how this part of the AST is structured because so much user code
37012  // already depends on it, therefore we can only traverse statementList and not successors. [Robb Matzke 2016-02-25]
37013 public:
37020  SgAsmStatementPtrList const& get_statementList() const;
37021  SgAsmStatementPtrList& get_statementList();
37022  void set_statementList(SgAsmStatementPtrList const&);
37024  // statementList and successors should have been pointers to nodes that contain the list rather than being the lists
37025  // themselves because ROSETTA doesn't allow traversals on multiple list data members--we can traverse either one list or
37026  // the other, but not both. It's too late to change how this part of the AST is structured because so much user code
37027  // already depends on it, therefore we can only traverse statementList and not successors. [Robb Matzke 2016-02-25]
37028 public:
37036  SgAsmIntegerValuePtrList const& get_successors() const;
37037  SgAsmIntegerValuePtrList& get_successors();
37038  void set_successors(SgAsmIntegerValuePtrList const&);
37041 public:
37052  bool const& get_successors_complete() const;
37053  void set_successors_complete(bool const&);
37056 public:
37066  SgAsmBlock* const& get_immediate_dominator() const;
37067  void set_immediate_dominator(SgAsmBlock* const&);
37070 public:
37079  size_t const& get_cached_vertex() const;
37080  void set_cached_vertex(size_t const&);
37082  // see BinaryAnalysis::ControlFlow
37083 public:
37090  double const& get_code_likelihood() const;
37091  void set_code_likelihood(double const&);
37094 public:
37103  int64_t const& get_stackDeltaOut() const;
37104  void set_stackDeltaOut(int64_t const&);
37106  // Functions
37109 public:
37114 
37119 
37120  // FIXME[Robb P Matzke 2017-02-13]: wrong name -- erases only statements, not all children
37125  void remove_children();
37126 
37131  rose_addr_t get_fallthrough_va();
37132 
37137 
37143  bool has_instructions() const;
37144 
37150  bool is_basic_block() const { return has_instructions(); }
37151 
37161  bool is_function_call(rose_addr_t &target_va/*out*/, rose_addr_t &return_va/*out*/);
37162 
37166  static std::string reason_key(const std::string &prefix="");
37167 
37171  std::string reason_str(bool pad) const;
37172 
37178  static std::string reason_str(bool pad, unsigned reason);
37179 public:
37181  virtual ~SgAsmBlock();
37182 
37183 public:
37185  SgAsmBlock();
37186 
37187 public:
37189  explicit SgAsmBlock(rose_addr_t const& address);
37190 
37191 protected:
37198  void initializeProperties();
37199 #endif // SgAsmBlock_OTHERS
37200 #ifdef DOCUMENTATION
37201 };
37202 #endif // DOCUMENTATION
37203 
37204 
37206 // SgAsmBinarySubtract -- MACHINE GENERATED; DO NOT MODIFY --
37208 
37209 DECLARE_LEAF_CLASS(AsmBinarySubtract);
37210 IS_SERIALIZABLE(AsmBinarySubtract);
37211 
37212 #ifdef DOCUMENTATION
37213 
37215 #endif // DOCUMENTATION
37216 
37217  DECLARE_OTHERS(AsmBinarySubtract);
37218 #if defined(SgAsmBinarySubtract_OTHERS) || defined(DOCUMENTATION)
37219 
37220  //----------------------- Boost serialization for SgAsmBinarySubtract -----------------------
37221 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
37222 private:
37223  friend class boost::serialization::access;
37224 
37225  template<class S>
37226  void serialize(S &s, const unsigned /*version*/) {
37227  debugSerializationBegin("SgAsmBinarySubtract");
37228  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmBinaryExpression);
37229  debugSerializationEnd("SgAsmBinarySubtract");
37230  }
37231 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
37232 
37233 public:
37235  virtual ~SgAsmBinarySubtract();
37236 
37237 public:
37240 
37241 public:
37244  SgAsmExpression* const& rhs);
37245 
37246 protected:
37253  void initializeProperties();
37254 #endif // SgAsmBinarySubtract_OTHERS
37255 #ifdef DOCUMENTATION
37256 };
37257 #endif // DOCUMENTATION
37258 
37259 
37261 // SgAsmBinaryRor -- MACHINE GENERATED; DO NOT MODIFY --
37263 
37264 DECLARE_LEAF_CLASS(AsmBinaryRor);
37265 IS_SERIALIZABLE(AsmBinaryRor);
37266 
37267 #ifdef DOCUMENTATION
37268 
37270 #endif // DOCUMENTATION
37271 
37272  DECLARE_OTHERS(AsmBinaryRor);
37273 #if defined(SgAsmBinaryRor_OTHERS) || defined(DOCUMENTATION)
37274 
37275  //----------------------- Boost serialization for SgAsmBinaryRor -----------------------
37276 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
37277 private:
37278  friend class boost::serialization::access;
37279 
37280  template<class S>
37281  void serialize(S &s, const unsigned /*version*/) {
37282  debugSerializationBegin("SgAsmBinaryRor");
37283  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmBinaryExpression);
37284  debugSerializationEnd("SgAsmBinaryRor");
37285  }
37286 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
37287 
37288 public:
37290  virtual ~SgAsmBinaryRor();
37291 
37292 public:
37294  SgAsmBinaryRor();
37295 
37296 public:
37298  SgAsmBinaryRor(SgAsmExpression* const& lhs,
37299  SgAsmExpression* const& rhs);
37300 
37301 protected:
37308  void initializeProperties();
37309 #endif // SgAsmBinaryRor_OTHERS
37310 #ifdef DOCUMENTATION
37311 };
37312 #endif // DOCUMENTATION
37313 
37314 
37316 // SgAsmBinaryPreupdate -- MACHINE GENERATED; DO NOT MODIFY --
37318 
37319 DECLARE_LEAF_CLASS(AsmBinaryPreupdate);
37320 IS_SERIALIZABLE(AsmBinaryPreupdate);
37321 
37322 #ifdef DOCUMENTATION
37323 
37328 #endif // DOCUMENTATION
37329 
37330  DECLARE_OTHERS(AsmBinaryPreupdate);
37331 #if defined(SgAsmBinaryPreupdate_OTHERS) || defined(DOCUMENTATION)
37332 
37333  //----------------------- Boost serialization for SgAsmBinaryPreupdate -----------------------
37334 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
37335 private:
37336  friend class boost::serialization::access;
37337 
37338  template<class S>
37339  void serialize(S &s, const unsigned /*version*/) {
37340  debugSerializationBegin("SgAsmBinaryPreupdate");
37341  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmBinaryExpression);
37342  debugSerializationEnd("SgAsmBinaryPreupdate");
37343  }
37344 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
37345 
37346 public:
37348  virtual ~SgAsmBinaryPreupdate();
37349 
37350 public:
37353 
37354 public:
37357  SgAsmExpression* const& rhs);
37358 
37359 protected:
37366  void initializeProperties();
37367 #endif // SgAsmBinaryPreupdate_OTHERS
37368 #ifdef DOCUMENTATION
37369 };
37370 #endif // DOCUMENTATION
37371 
37372 
37374 // SgAsmBinaryPostupdate -- MACHINE GENERATED; DO NOT MODIFY --
37376 
37377 DECLARE_LEAF_CLASS(AsmBinaryPostupdate);
37378 IS_SERIALIZABLE(AsmBinaryPostupdate);
37379 
37380 #ifdef DOCUMENTATION
37381 
37386 #endif // DOCUMENTATION
37387 
37388  DECLARE_OTHERS(AsmBinaryPostupdate);
37389 #if defined(SgAsmBinaryPostupdate_OTHERS) || defined(DOCUMENTATION)
37390 
37391  //----------------------- Boost serialization for SgAsmBinaryPostupdate -----------------------
37392 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
37393 private:
37394  friend class boost::serialization::access;
37395 
37396  template<class S>
37397  void serialize(S &s, const unsigned /*version*/) {
37398  debugSerializationBegin("SgAsmBinaryPostupdate");
37399  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmBinaryExpression);
37400  debugSerializationEnd("SgAsmBinaryPostupdate");
37401  }
37402 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
37403 
37404 public:
37406  virtual ~SgAsmBinaryPostupdate();
37407 
37408 public:
37411 
37412 public:
37415  SgAsmExpression* const& rhs);
37416 
37417 protected:
37424  void initializeProperties();
37425 #endif // SgAsmBinaryPostupdate_OTHERS
37426 #ifdef DOCUMENTATION
37427 };
37428 #endif // DOCUMENTATION
37429 
37430 
37432 // SgAsmBinaryMultiply -- MACHINE GENERATED; DO NOT MODIFY --
37434 
37435 DECLARE_LEAF_CLASS(AsmBinaryMultiply);
37436 IS_SERIALIZABLE(AsmBinaryMultiply);
37437 
37438 #ifdef DOCUMENTATION
37439 
37441 #endif // DOCUMENTATION
37442 
37443  DECLARE_OTHERS(AsmBinaryMultiply);
37444 #if defined(SgAsmBinaryMultiply_OTHERS) || defined(DOCUMENTATION)
37445 
37446  //----------------------- Boost serialization for SgAsmBinaryMultiply -----------------------
37447 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
37448 private:
37449  friend class boost::serialization::access;
37450 
37451  template<class S>
37452  void serialize(S &s, const unsigned /*version*/) {
37453  debugSerializationBegin("SgAsmBinaryMultiply");
37454  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmBinaryExpression);
37455  debugSerializationEnd("SgAsmBinaryMultiply");
37456  }
37457 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
37458 
37459 public:
37461  virtual ~SgAsmBinaryMultiply();
37462 
37463 public:
37466 
37467 public:
37470  SgAsmExpression* const& rhs);
37471 
37472 protected:
37479  void initializeProperties();
37480 #endif // SgAsmBinaryMultiply_OTHERS
37481 #ifdef DOCUMENTATION
37482 };
37483 #endif // DOCUMENTATION
37484 
37485 
37487 // SgAsmBinaryMsl -- MACHINE GENERATED; DO NOT MODIFY --
37489 
37490 DECLARE_LEAF_CLASS(AsmBinaryMsl);
37491 IS_SERIALIZABLE(AsmBinaryMsl);
37492 
37493 #ifdef DOCUMENTATION
37494 
37498 #endif // DOCUMENTATION
37499 
37500  DECLARE_OTHERS(AsmBinaryMsl);
37501 #if defined(SgAsmBinaryMsl_OTHERS) || defined(DOCUMENTATION)
37502 
37503  //----------------------- Boost serialization for SgAsmBinaryMsl -----------------------
37504 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
37505 private:
37506  friend class boost::serialization::access;
37507 
37508  template<class S>
37509  void serialize(S &s, const unsigned /*version*/) {
37510  debugSerializationBegin("SgAsmBinaryMsl");
37511  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmBinaryExpression);
37512  debugSerializationEnd("SgAsmBinaryMsl");
37513  }
37514 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
37515 
37516 public:
37518  virtual ~SgAsmBinaryMsl();
37519 
37520 public:
37522  SgAsmBinaryMsl();
37523 
37524 public:
37526  SgAsmBinaryMsl(SgAsmExpression* const& lhs,
37527  SgAsmExpression* const& rhs);
37528 
37529 protected:
37536  void initializeProperties();
37537 #endif // SgAsmBinaryMsl_OTHERS
37538 #ifdef DOCUMENTATION
37539 };
37540 #endif // DOCUMENTATION
37541 
37542 
37544 // SgAsmBinaryMod -- MACHINE GENERATED; DO NOT MODIFY --
37546 
37547 DECLARE_LEAF_CLASS(AsmBinaryMod);
37548 IS_SERIALIZABLE(AsmBinaryMod);
37549 
37550 #ifdef DOCUMENTATION
37551 
37553 #endif // DOCUMENTATION
37554 
37555  DECLARE_OTHERS(AsmBinaryMod);
37556 #if defined(SgAsmBinaryMod_OTHERS) || defined(DOCUMENTATION)
37557 
37558  //----------------------- Boost serialization for SgAsmBinaryMod -----------------------
37559 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
37560 private:
37561  friend class boost::serialization::access;
37562 
37563  template<class S>
37564  void serialize(S &s, const unsigned /*version*/) {
37565  debugSerializationBegin("SgAsmBinaryMod");
37566  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmBinaryExpression);
37567  debugSerializationEnd("SgAsmBinaryMod");
37568  }
37569 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
37570 
37571 public:
37573  virtual ~SgAsmBinaryMod();
37574 
37575 public:
37577  SgAsmBinaryMod();
37578 
37579 public:
37581  SgAsmBinaryMod(SgAsmExpression* const& lhs,
37582  SgAsmExpression* const& rhs);
37583 
37584 protected:
37591  void initializeProperties();
37592 #endif // SgAsmBinaryMod_OTHERS
37593 #ifdef DOCUMENTATION
37594 };
37595 #endif // DOCUMENTATION
37596 
37597 
37599 // SgAsmBinaryLsr -- MACHINE GENERATED; DO NOT MODIFY --
37601 
37602 DECLARE_LEAF_CLASS(AsmBinaryLsr);
37603 IS_SERIALIZABLE(AsmBinaryLsr);
37604 
37605 #ifdef DOCUMENTATION
37606 
37608 #endif // DOCUMENTATION
37609 
37610  DECLARE_OTHERS(AsmBinaryLsr);
37611 #if defined(SgAsmBinaryLsr_OTHERS) || defined(DOCUMENTATION)
37612 
37613  //----------------------- Boost serialization for SgAsmBinaryLsr -----------------------
37614 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
37615 private:
37616  friend class boost::serialization::access;
37617 
37618  template<class S>
37619  void serialize(S &s, const unsigned /*version*/) {
37620  debugSerializationBegin("SgAsmBinaryLsr");
37621  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmBinaryExpression);
37622  debugSerializationEnd("SgAsmBinaryLsr");
37623  }
37624 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
37625 
37626 public:
37628  virtual ~SgAsmBinaryLsr();
37629 
37630 public:
37632  SgAsmBinaryLsr();
37633 
37634 public:
37636  SgAsmBinaryLsr(SgAsmExpression* const& lhs,
37637  SgAsmExpression* const& rhs);
37638 
37639 protected:
37646  void initializeProperties();
37647 #endif // SgAsmBinaryLsr_OTHERS
37648 #ifdef DOCUMENTATION
37649 };
37650 #endif // DOCUMENTATION
37651 
37652 
37654 // SgAsmBinaryLsl -- MACHINE GENERATED; DO NOT MODIFY --
37656 
37657 DECLARE_LEAF_CLASS(AsmBinaryLsl);
37658 IS_SERIALIZABLE(AsmBinaryLsl);
37659 
37660 #ifdef DOCUMENTATION
37661 
37663 #endif // DOCUMENTATION
37664 
37665  DECLARE_OTHERS(AsmBinaryLsl);
37666 #if defined(SgAsmBinaryLsl_OTHERS) || defined(DOCUMENTATION)
37667 
37668  //----------------------- Boost serialization for SgAsmBinaryLsl -----------------------
37669 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
37670 private:
37671  friend class boost::serialization::access;
37672 
37673  template<class S>
37674  void serialize(S &s, const unsigned /*version*/) {
37675  debugSerializationBegin("SgAsmBinaryLsl");
37676  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmBinaryExpression);
37677  debugSerializationEnd("SgAsmBinaryLsl");
37678  }
37679 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
37680 
37681 public:
37683  virtual ~SgAsmBinaryLsl();
37684 
37685 public:
37687  SgAsmBinaryLsl();
37688 
37689 public:
37691  SgAsmBinaryLsl(SgAsmExpression* const& lhs,
37692  SgAsmExpression* const& rhs);
37693 
37694 protected:
37701  void initializeProperties();
37702 #endif // SgAsmBinaryLsl_OTHERS
37703 #ifdef DOCUMENTATION
37704 };
37705 #endif // DOCUMENTATION
37706 
37707 
37709 // SgAsmBinaryDivide -- MACHINE GENERATED; DO NOT MODIFY --
37711 
37712 DECLARE_LEAF_CLASS(AsmBinaryDivide);
37713 IS_SERIALIZABLE(AsmBinaryDivide);
37714 
37715 #ifdef DOCUMENTATION
37716 
37718 #endif // DOCUMENTATION
37719 
37720  DECLARE_OTHERS(AsmBinaryDivide);
37721 #if defined(SgAsmBinaryDivide_OTHERS) || defined(DOCUMENTATION)
37722 
37723  //----------------------- Boost serialization for SgAsmBinaryDivide -----------------------
37724 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
37725 private:
37726  friend class boost::serialization::access;
37727 
37728  template<class S>
37729  void serialize(S &s, const unsigned /*version*/) {
37730  debugSerializationBegin("SgAsmBinaryDivide");
37731  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmBinaryExpression);
37732  debugSerializationEnd("SgAsmBinaryDivide");
37733  }
37734 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
37735 
37736 public:
37738  virtual ~SgAsmBinaryDivide();
37739 
37740 public:
37743 
37744 public:
37746  SgAsmBinaryDivide(SgAsmExpression* const& lhs,
37747  SgAsmExpression* const& rhs);
37748 
37749 protected:
37756  void initializeProperties();
37757 #endif // SgAsmBinaryDivide_OTHERS
37758 #ifdef DOCUMENTATION
37759 };
37760 #endif // DOCUMENTATION
37761 
37762 
37764 // SgAsmBinaryConcat -- MACHINE GENERATED; DO NOT MODIFY --
37766 
37767 DECLARE_LEAF_CLASS(AsmBinaryConcat);
37768 IS_SERIALIZABLE(AsmBinaryConcat);
37769 
37770 #ifdef DOCUMENTATION
37771 
37773 #endif // DOCUMENTATION
37774 
37775  DECLARE_OTHERS(AsmBinaryConcat);
37776 #if defined(SgAsmBinaryConcat_OTHERS) || defined(DOCUMENTATION)
37777 
37778  //----------------------- Boost serialization for SgAsmBinaryConcat -----------------------
37779 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
37780 private:
37781  friend class boost::serialization::access;
37782 
37783  template<class S>
37784  void serialize(S &s, const unsigned /*version*/) {
37785  debugSerializationBegin("SgAsmBinaryConcat");
37786  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmBinaryExpression);
37787  debugSerializationEnd("SgAsmBinaryConcat");
37788  }
37789 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
37790 
37791 public:
37793  virtual ~SgAsmBinaryConcat();
37794 
37795 public:
37798 
37799 public:
37801  SgAsmBinaryConcat(SgAsmExpression* const& lhs,
37802  SgAsmExpression* const& rhs);
37803 
37804 protected:
37811  void initializeProperties();
37812 #endif // SgAsmBinaryConcat_OTHERS
37813 #ifdef DOCUMENTATION
37814 };
37815 #endif // DOCUMENTATION
37816 
37817 
37819 // SgAsmBinaryAsr -- MACHINE GENERATED; DO NOT MODIFY --
37821 
37822 DECLARE_LEAF_CLASS(AsmBinaryAsr);
37823 IS_SERIALIZABLE(AsmBinaryAsr);
37824 
37825 #ifdef DOCUMENTATION
37826 
37828 #endif // DOCUMENTATION
37829 
37830  DECLARE_OTHERS(AsmBinaryAsr);
37831 #if defined(SgAsmBinaryAsr_OTHERS) || defined(DOCUMENTATION)
37832 
37833  //----------------------- Boost serialization for SgAsmBinaryAsr -----------------------
37834 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
37835 private:
37836  friend class boost::serialization::access;
37837 
37838  template<class S>
37839  void serialize(S &s, const unsigned /*version*/) {
37840  debugSerializationBegin("SgAsmBinaryAsr");
37841  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmBinaryExpression);
37842  debugSerializationEnd("SgAsmBinaryAsr");
37843  }
37844 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
37845 
37846 public:
37848  virtual ~SgAsmBinaryAsr();
37849 
37850 public:
37852  SgAsmBinaryAsr();
37853 
37854 public:
37856  SgAsmBinaryAsr(SgAsmExpression* const& lhs,
37857  SgAsmExpression* const& rhs);
37858 
37859 protected:
37866  void initializeProperties();
37867 #endif // SgAsmBinaryAsr_OTHERS
37868 #ifdef DOCUMENTATION
37869 };
37870 #endif // DOCUMENTATION
37871 
37872 
37874 // SgAsmBinaryAdd -- MACHINE GENERATED; DO NOT MODIFY --
37876 
37877 DECLARE_LEAF_CLASS(AsmBinaryAdd);
37878 IS_SERIALIZABLE(AsmBinaryAdd);
37879 
37880 #ifdef DOCUMENTATION
37881 
37883 #endif // DOCUMENTATION
37884 
37885  DECLARE_OTHERS(AsmBinaryAdd);
37886 #if defined(SgAsmBinaryAdd_OTHERS) || defined(DOCUMENTATION)
37887 
37888  //----------------------- Boost serialization for SgAsmBinaryAdd -----------------------
37889 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
37890 private:
37891  friend class boost::serialization::access;
37892 
37893  template<class S>
37894  void serialize(S &s, const unsigned /*version*/) {
37895  debugSerializationBegin("SgAsmBinaryAdd");
37896  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmBinaryExpression);
37897  debugSerializationEnd("SgAsmBinaryAdd");
37898  }
37899 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
37900 
37901 public:
37903  virtual ~SgAsmBinaryAdd();
37904 
37905 public:
37907  SgAsmBinaryAdd();
37908 
37909 public:
37911  SgAsmBinaryAdd(SgAsmExpression* const& lhs,
37912  SgAsmExpression* const& rhs);
37913 
37914 protected:
37921  void initializeProperties();
37922 #endif // SgAsmBinaryAdd_OTHERS
37923 #ifdef DOCUMENTATION
37924 };
37925 #endif // DOCUMENTATION
37926 
37927 
37929 // SgAsmBinaryExpression -- MACHINE GENERATED; DO NOT MODIFY --
37931 
37932 #ifndef DOCUMENTATION
37933 AstNodeClass& AsmBinaryExpression = nonTerminalConstructor(
37934  "AsmBinaryExpression",
37935  *this,
37936  "AsmBinaryExpression",
37937  "AsmBinaryExpressionTag",
37938  SubclassListBuilder()
37939  | AsmBinaryAdd
37940  | AsmBinaryAsr
37941  | AsmBinaryConcat
37942  | AsmBinaryDivide
37943  | AsmBinaryLsl
37944  | AsmBinaryLsr
37945  | AsmBinaryMod
37946  | AsmBinaryMsl
37947  | AsmBinaryMultiply
37948  | AsmBinaryPostupdate
37949  | AsmBinaryPreupdate
37950  | AsmBinaryRor
37951  | AsmBinarySubtract
37952  , false);
37953 assert(AsmBinaryExpression.associatedGrammar != nullptr);
37954 AsmBinaryExpression.setCppCondition("!defined(DOCUMENTATION)");
37955 AsmBinaryExpression.isBoostSerializable(true);
37956 AsmBinaryExpression.setAutomaticGenerationOfConstructor(false);
37957 AsmBinaryExpression.setAutomaticGenerationOfDestructor(false);
37958 #endif // !DOCUMENTATION
37959 
37960 #ifdef DOCUMENTATION
37961 
37963 #endif // DOCUMENTATION
37964 
37965 #ifndef DOCUMENTATION
37966  AsmBinaryExpression.setDataPrototype(
37967  "SgAsmExpression*", "lhs", "= nullptr",
37968  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
37969 #endif // !DOCUMENTATION
37970 
37971 #ifndef DOCUMENTATION
37972  AsmBinaryExpression.setDataPrototype(
37973  "SgAsmExpression*", "rhs", "= nullptr",
37974  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
37975 #endif // !DOCUMENTATION
37976 
37977  DECLARE_OTHERS(AsmBinaryExpression);
37978 #if defined(SgAsmBinaryExpression_OTHERS) || defined(DOCUMENTATION)
37979 
37980  //----------------------- Boost serialization for SgAsmBinaryExpression -----------------------
37981 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
37982 private:
37983  friend class boost::serialization::access;
37984 
37985  template<class S>
37986  void serialize(S &s, const unsigned /*version*/) {
37987  debugSerializationBegin("SgAsmBinaryExpression");
37988  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExpression);
37989  s & BOOST_SERIALIZATION_NVP(p_lhs);
37990  s & BOOST_SERIALIZATION_NVP(p_rhs);
37991  debugSerializationEnd("SgAsmBinaryExpression");
37992  }
37993 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
37994 
37995 public:
37999  SgAsmExpression* const& get_lhs() const;
38000  void set_lhs(SgAsmExpression* const&);
38003 public:
38007  SgAsmExpression* const& get_rhs() const;
38008  void set_rhs(SgAsmExpression* const&);
38011 public:
38013  virtual ~SgAsmBinaryExpression();
38014 
38015 protected:
38018 
38019 protected:
38022  SgAsmExpression* const& rhs);
38023 
38024 protected:
38031  void initializeProperties();
38032 #endif // SgAsmBinaryExpression_OTHERS
38033 #ifdef DOCUMENTATION
38034 };
38035 #endif // DOCUMENTATION
38036 
38037 
38039 // SgAsmBasicString -- MACHINE GENERATED; DO NOT MODIFY --
38041 
38042 DECLARE_LEAF_CLASS(AsmBasicString);
38043 IS_SERIALIZABLE(AsmBasicString);
38044 
38045 #ifdef DOCUMENTATION
38046 
38051 #endif // DOCUMENTATION
38052 
38053 #ifndef DOCUMENTATION
38054  AsmBasicString.setDataPrototype(
38055  "std::string", "string", "",
38056  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
38057 #endif // !DOCUMENTATION
38058 
38059  DECLARE_OTHERS(AsmBasicString);
38060 #if defined(SgAsmBasicString_OTHERS) || defined(DOCUMENTATION)
38061 
38062  //----------------------- Boost serialization for SgAsmBasicString -----------------------
38063 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
38064 private:
38065  friend class boost::serialization::access;
38066 
38067  template<class S>
38068  void serialize(S &s, const unsigned /*version*/) {
38069  debugSerializationBegin("SgAsmBasicString");
38070  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmGenericString);
38071  s & BOOST_SERIALIZATION_NVP(p_string);
38072  debugSerializationEnd("SgAsmBasicString");
38073  }
38074 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
38075 
38076 public:
38077  virtual std::string get_string(bool escape=false) const override;
38078  virtual void set_string(const std::string&) override;
38079  virtual void set_string(rose_addr_t) override;
38080 
38081 public:
38085  explicit SgAsmBasicString(const std::string&);
38086  explicit SgAsmBasicString(const char*);
38089  // Overrides documented in base class
38090  virtual void dump(FILE*, const char *prefix, ssize_t idx) const override;
38091 public:
38093  virtual ~SgAsmBasicString();
38094 
38095 public:
38097  SgAsmBasicString();
38098 
38099 protected:
38106  void initializeProperties();
38107 #endif // SgAsmBasicString_OTHERS
38108 #ifdef DOCUMENTATION
38109 };
38110 #endif // DOCUMENTATION
38111 
38112 
38114 // SgAsmGenericString -- MACHINE GENERATED; DO NOT MODIFY --
38116 
38117 #ifndef DOCUMENTATION
38118 AstNodeClass& AsmGenericString = nonTerminalConstructor(
38119  "AsmGenericString",
38120  *this,
38121  "AsmGenericString",
38122  "AsmGenericStringTag",
38123  SubclassListBuilder()
38124  | AsmBasicString
38125  | AsmStoredString
38126  , false);
38127 assert(AsmGenericString.associatedGrammar != nullptr);
38128 AsmGenericString.setCppCondition("!defined(DOCUMENTATION)");
38129 AsmGenericString.isBoostSerializable(true);
38130 AsmGenericString.setAutomaticGenerationOfConstructor(false);
38131 AsmGenericString.setAutomaticGenerationOfDestructor(false);
38132 #endif // !DOCUMENTATION
38133 
38134 #ifdef DOCUMENTATION
38135 
38137 #endif // DOCUMENTATION
38138 
38139  DECLARE_OTHERS(AsmGenericString);
38140 #if defined(SgAsmGenericString_OTHERS) || defined(DOCUMENTATION)
38141 
38142  //----------------------- Boost serialization for SgAsmGenericString -----------------------
38143 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
38144 private:
38145  friend class boost::serialization::access;
38146 
38147  template<class S>
38148  void serialize(S &s, const unsigned /*version*/) {
38149  debugSerializationBegin("SgAsmGenericString");
38150  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExecutableFileFormat);
38151  debugSerializationEnd("SgAsmGenericString");
38152  }
38153 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
38154 public:
38156  static const rose_addr_t unallocated;
38157 
38166  virtual std::string get_string(bool escape=false) const;
38167  virtual void set_string(const std::string &s);
38168  virtual void set_string(rose_addr_t);
38171  virtual rose_addr_t get_offset() const {return unallocated;}
38172 
38173  virtual void dump(FILE*, const char *prefix, ssize_t idx) const;
38174 public:
38176  virtual ~SgAsmGenericString();
38177 
38178 protected:
38181 
38182 protected:
38189  void initializeProperties();
38190 #endif // SgAsmGenericString_OTHERS
38191 #ifdef DOCUMENTATION
38192 };
38193 #endif // DOCUMENTATION
38194 
38195 
38197 // SgAsmExecutableFileFormat -- MACHINE GENERATED; DO NOT MODIFY --
38199 
38200 #ifndef DOCUMENTATION
38201 AstNodeClass& AsmExecutableFileFormat = nonTerminalConstructor(
38202  "AsmExecutableFileFormat",
38203  *this,
38204  "AsmExecutableFileFormat",
38205  "AsmExecutableFileFormatTag",
38206  SubclassListBuilder()
38207  | AsmCoffSymbolList
38208  | AsmDwarfInformation
38209  | AsmElfDynamicEntry
38210  | AsmElfDynamicEntryList
38211  | AsmElfEHFrameEntryCI
38212  | AsmElfEHFrameEntryCIList
38213  | AsmElfEHFrameEntryFD
38214  | AsmElfEHFrameEntryFDList
38215  | AsmElfNoteEntry
38216  | AsmElfNoteEntryList
38217  | AsmElfRelocEntry
38218  | AsmElfRelocEntryList
38219  | AsmElfSectionTableEntry
38220  | AsmElfSegmentTableEntry
38221  | AsmElfSegmentTableEntryList
38222  | AsmElfSymbolList
38223  | AsmElfSymverDefinedAux
38224  | AsmElfSymverDefinedAuxList
38225  | AsmElfSymverDefinedEntry
38226  | AsmElfSymverDefinedEntryList
38227  | AsmElfSymverEntry
38228  | AsmElfSymverEntryList
38229  | AsmElfSymverNeededAux
38230  | AsmElfSymverNeededAuxList
38231  | AsmElfSymverNeededEntry
38232  | AsmElfSymverNeededEntryList
38233  | AsmGenericDLL
38234  | AsmGenericDLLList
38235  | AsmGenericFile
38236  | AsmGenericFormat
38237  | AsmGenericHeaderList
38238  | AsmGenericSection
38239  | AsmGenericSectionList
38240  | AsmGenericString
38241  | AsmGenericStrtab
38242  | AsmGenericSymbol
38243  | AsmGenericSymbolList
38244  | AsmLEEntryPoint
38245  | AsmLEPageTableEntry
38246  | AsmLESectionTableEntry
38247  | AsmNEEntryPoint
38248  | AsmNERelocEntry
38249  | AsmNESectionTableEntry
38250  | AsmPEExportDirectory
38251  | AsmPEExportEntry
38252  | AsmPEExportEntryList
38253  | AsmPEImportDirectory
38254  | AsmPEImportDirectoryList
38255  | AsmPEImportItem
38256  | AsmPEImportItemList
38257  | AsmPERVASizePair
38258  | AsmPERVASizePairList
38259  | AsmPESectionTableEntry
38260  | AsmStringStorage
38261  , false);
38262 assert(AsmExecutableFileFormat.associatedGrammar != nullptr);
38263 AsmExecutableFileFormat.setCppCondition("!defined(DOCUMENTATION)");
38264 AsmExecutableFileFormat.isBoostSerializable(true);
38265 AsmExecutableFileFormat.setAutomaticGenerationOfConstructor(false);
38266 AsmExecutableFileFormat.setAutomaticGenerationOfDestructor(false);
38267 #endif // !DOCUMENTATION
38268 
38269 #ifdef DOCUMENTATION
38270 
38272 #endif // DOCUMENTATION
38273 
38274  DECLARE_OTHERS(AsmExecutableFileFormat);
38275 #if defined(SgAsmExecutableFileFormat_OTHERS) || defined(DOCUMENTATION)
38276 
38277  //----------------------- Boost serialization for SgAsmExecutableFileFormat -----------------------
38278 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
38279 private:
38280  friend class boost::serialization::access;
38281 
38282  template<class S>
38283  void serialize(S &s, const unsigned /*version*/) {
38284  debugSerializationBegin("SgAsmExecutableFileFormat");
38285  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmNode);
38286  debugSerializationEnd("SgAsmExecutableFileFormat");
38287  }
38288 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
38289  // Local types
38292 public:
38296  class ShortRead: public Rose::Exception {
38297  public:
38299  rose_addr_t offset;
38300  rose_addr_t size;
38302  ShortRead(const class SgAsmGenericSection *section, size_t offset, size_t size)
38303  : Rose::Exception("short read"), section(section), offset(offset), size(size) {}
38304  ShortRead(const class SgAsmGenericSection *section, size_t offset, size_t size, const std::string &mesg)
38305  : Rose::Exception(mesg), section(section), offset(offset), size(size) {}
38306  ShortRead(const class SgAsmGenericSection *section, size_t offset, size_t size, const char *mesg)
38307  : Rose::Exception(mesg), section(section), offset(offset), size(size) {}
38308  ~ShortRead() throw () {}
38309  };
38310 
38314  class ShortWrite: public Rose::Exception {
38315  public:
38317  rose_addr_t offset;
38318  rose_addr_t size;
38320  ShortWrite(const class SgAsmGenericSection *section, size_t offset, size_t size)
38321  : Rose::Exception(""), section(section), offset(offset), size(size) {}
38322  ShortWrite(const class SgAsmGenericSection *section, size_t offset, size_t size, const std::string &mesg)
38323  : Rose::Exception(mesg), section(section), offset(offset), size(size) {}
38324  ShortWrite(const class SgAsmGenericSection *section, size_t offset, size_t size, const char *mesg)
38325  : Rose::Exception(mesg), section(section), offset(offset), size(size) {}
38326  };
38327 
38332  public:
38333  FormatError(const std::string &mesg)
38334  : Rose::Exception(mesg) {}
38335  FormatError(const char *mesg)
38336  : Rose::Exception(mesg) {}
38337  ~FormatError() throw () {}
38338  };
38339 
38341  typedef struct stat fileDetails;
38342 
38344  enum ExecFamily {
38353  };
38354 
38356  enum ExecABI {
38378  };
38379 
38382  ISA_UNSPECIFIED = 0x0000,
38383  ISA_OTHER = 0xffff,
38384  ISA_FAMILY_MASK = 0xff00,
38386  ISA_IA32_Family = 0x0100,
38387  ISA_IA32_286 = 0x0101,
38388  ISA_IA32_386 = 0x0102,
38389  ISA_IA32_486 = 0x0103,
38390  ISA_IA32_Pentium = 0x0104,
38392  ISA_IA32_AMDK5 = 0x0106,
38395  ISA_IA32_Athlon = 0x0109,
38399  ISA_X8664_Family = 0x0200,
38405  ISA_SPARC_Family = 0x0300,
38406  ISA_SPARC_V7 = 0x0301,
38407  ISA_SPARC_V8 = 0x0302,
38408  ISA_SPARC_V8E = 0x0303,
38409  ISA_SPARC_V9 = 0x0304,
38410  ISA_SPARC_V9JPS1 = 0x0305,
38411  ISA_SPARC_V9UA = 0x0306,
38412  ISA_SPARC_V9JPS2 = 0x0307,
38413 
38414  ISA_M68K_Family = 0x0400,
38415  ISA_M68K_68000 = 0x0401,
38416  ISA_M68K_68EC000 = 0x0402,
38417  ISA_M68K_68HC000 = 0x0403,
38418  ISA_M68K_68008 = 0x0404,
38419  ISA_M68K_68010 = 0x0405,
38420  ISA_M68K_68012 = 0x0406,
38421  ISA_M68K_68020 = 0x0407,
38422  ISA_M68K_68EC020 = 0x0408,
38423  ISA_M68K_68030 = 0x0409,
38424  ISA_M68K_68EC030 = 0x040a,
38425  ISA_M68K_68040 = 0x040b,
38426  ISA_M68K_68EC040 = 0x040c,
38427  ISA_M68K_68LC040 = 0x040d,
38428  ISA_M68K_68060 = 0x040e,
38432  ISA_M88K_Family = 0x0500,
38433  ISA_M88K_88100 = 0x0501,
38434  ISA_M88K_88110 = 0x0502,
38435  ISA_M88K_88110MP = 0x0503,
38436  ISA_M88K_88120 = 0x0504,
38438  ISA_MIPS_Family = 0x0600,
38439  ISA_MIPS_MarkI = 0x0601,
38440  ISA_MIPS_MarkII = 0x0602,
38441  ISA_MIPS_MarkIII = 0x0603,
38442  ISA_MIPS_R2000 = 0x0604,
38443  ISA_MIPS_R3000 = 0x0605,
38444  ISA_MIPS_R4000 = 0x0606,
38445  ISA_MIPS_R4200 = 0x0607,
38446  ISA_MIPS_R4300 = 0x0608,
38447  ISA_MIPS_R4600 = 0x0609,
38448  ISA_MIPS_R4650 = 0x060a,
38449  ISA_MIPS_R4700 = 0x060b,
38450  ISA_MIPS_R5000 = 0x060c,
38451  ISA_MIPS_RM7000 = 0x060d,
38452  ISA_MIPS_R8000 = 0x060e,
38453  ISA_MIPS_R10000 = 0x060f,
38454  ISA_MIPS_R12000 = 0x0610,
38455  ISA_MIPS_R14000 = 0x0611,
38456  ISA_MIPS_R16000 = 0x0612,
38457  ISA_MIPS_R16000A = 0x0613,
38458  ISA_MIPS_16 = 0x0614,
38459  ISA_MIPS_FPU = 0x0615,
38460  ISA_MIPS_16FPU = 0x0616,
38462  ISA_I860_Family = 0x0700,
38463  ISA_I860_860XR = 0x0701,
38464  ISA_I860_860XP = 0x0702,
38466  ISA_IA64_Family = 0x0800,
38467  ISA_IA64_Itanium = 0x0801,
38470  // See http://en.wikipedia.org/wiki/ARM_architecture
38471  ISA_ARM_Family = 0x0900,
38472  ISA_ARM_ARM1 = 0x0901,
38473  ISA_ARM_ARM2 = 0x0902,
38474  ISA_ARM_ARM3 = 0x0903,
38475  ISA_ARM_ARM6 = 0x0904,
38476  ISA_ARM_ARM7 = 0x0905,
38477  ISA_ARM_ARM7TDMI = 0x0906,
38479  ISA_ARM_ARM8 = 0x0908,
38480  ISA_ARM_ARM9TDMI = 0x0909,
38481  ISA_ARM_ARM9E = 0x090a,
38482  ISA_ARM_ARM10E = 0x090b,
38483  ISA_ARM_XScale = 0x090c,
38487  ISA_ARM_ARM11 = 0x090d,
38488  ISA_ARM_Cortex = 0x090e,
38489  ISA_ARM_A64 = 0x090f,
38491  ISA_JVM = 0x0a00,
38493  // Others, not yet incorporated into this enum
38494  ISA_OTHER_Family = 0xf000,
38495 
38496  ISA_ATT_WE_32100 = 0xf001,
38497  ISA_IBM_System_370 = 0xf002,
38498  ISA_HPPA = 0xf003,
38499  ISA_Fujitsu_VPP500 = 0xf004,
38500  ISA_Sun_v8plus = 0xf005,
38501  ISA_PowerPC = 0xf006,
38502  ISA_PowerPC_64bit = 0xf007,
38503  ISA_IBM_S390 = 0xf008,
38504  ISA_NEC_V800_series = 0xf009,
38505  ISA_Fujitsu_FR20 = 0xf00a,
38506  ISA_TRW_RH_32 = 0xf00b,
38507  ISA_Motorola_RCE = 0xf00c,
38508  ISA_Digital_Alpha_fake = 0xf00e,
38509  ISA_Hitachi_SH = 0xf00f,
38510  ISA_Siemens_Tricore = 0xf010,
38511  ISA_Argonaut_RISC_Core = 0xf011,
38512  ISA_Hitachi_H8_300 = 0xf012,
38513  ISA_Hitachi_H8_300H = 0xf013,
38514  ISA_Hitachi_H8S = 0xf014,
38515  ISA_Hitachi_H8_500 = 0xf015,
38516  ISA_Stanford_MIPS_X = 0xf016,
38517  ISA_Motorola_M68HC12 = 0xf017,
38518  ISA_Fujitsu_MMA_Multimedia_Accelerator=0xf018,
38519  ISA_Siemens_PCP = 0xf019,
38520  ISA_Sony_nCPU_embeeded_RISC = 0xf01a,
38521  ISA_Denso_NDR1_microprocessor=0xf01b,
38522  ISA_Motorola_Start_Core_processor=0xf01c,
38523  ISA_Toyota_ME16_processor = 0xf01d,
38524  ISA_STMicroelectronic_ST100_processor=0xf01e,
38525  ISA_Advanced_Logic_Corp_Tinyj_emb_family=0xf01f,
38526  ISA_AMD_x86_64_architecture = 0xf020,
38527  ISA_Sony_DSP_Processor = 0xf021,
38528  ISA_Siemens_FX66_microcontroller=0xf022,
38529  ISA_STMicroelectronics_ST9_plus_8_16_microcontroller=0xf023,
38530  ISA_STMicroelectronics_ST7_8bit_microcontroller=0xf024,
38531  ISA_Motorola_MC68HC16_microcontroller=0xf025,
38532  ISA_Motorola_MC68HC11_microcontroller=0xf026,
38533  ISA_Motorola_MC68HC08_microcontroller=0xf027,
38534  ISA_Motorola_MC68HC05_microcontroller=0xf028,
38535  ISA_Silicon_Graphics_SVx = 0xf029,
38536  ISA_STMicroelectronics_ST19_8bit_microcontroller=0xf02a,
38537  ISA_Digital_VAX = 0xf02b,
38538  ISA_Axis_Communications_32bit_embedded_processor=0xf02c,
38539  ISA_Infineon_Technologies_32bit_embedded_processor=0xf02d,
38540  ISA_Element_14_64bit_DSP_Processor=0xf02e,
38541  ISA_LSI_Logic_16bit_DSP_Processor=0xf02f,
38542  ISA_Donald_Knuths_educational_64bit_processor=0xf030,
38543  ISA_Harvard_University_machine_independent_object_files=0xf031,
38544  ISA_SiTera_Prism = 0xf032,
38545  ISA_Atmel_AVR_8bit_microcontroller=0xf033,
38546  ISA_Fujitsu_FR30 = 0xf034,
38547  ISA_Mitsubishi_D10V = 0xf035,
38548  ISA_Mitsubishi_D30V = 0xf036,
38549  ISA_NEC_v850 = 0xf037,
38550  ISA_Mitsubishi_M32R = 0xf038,
38551  ISA_Matsushita_MN10300 = 0xf039,
38552  ISA_Matsushita_MN10200 = 0xf03a,
38553  ISA_picoJava = 0xf03b,
38554  ISA_OpenRISC_32bit_embedded_processor=0xf03c,
38555  ISA_ARC_Cores_Tangent_A5 = 0xf03d,
38556  ISA_Tensilica_Xtensa_Architecture=0xf03e,
38557  ISA_Digital_Alpha = 0xf03f,
38558  ISA_Matsushita_AM33 = 0xf040,
38559  ISA_EFI_ByteCode = 0xf041
38560  };
38561 
38571  };
38572 
38574  // Functions
38576 public:
38578  static SgAsmGenericFile *parseBinaryFormat(const char *name);
38579 
38584  static void unparseBinaryFormat(const std::string &name, SgAsmGenericFile*);
38585 
38590  static void unparseBinaryFormat(std::ostream&, SgAsmGenericFile*);
38591 
38594 
38598  static void initDiagnostics();
38599 
38609  static void hexdump(std::ostream&, rose_addr_t base_addr, const unsigned char *data, size_t data_sz,
38610  const HexdumpFormat&);
38611  static void hexdump(std::ostream&, rose_addr_t base_addr, const std::string &prefix, const SgUnsignedCharList& data,
38612  bool multiline=true);
38613  static void hexdump(std::ostream&, rose_addr_t base_addr, const std::string &prefix, const SgFileContentList& data,
38614  bool multiline=true);
38615 
38616  // Same, but returning a string instead.
38617  static std::string hexdump(rose_addr_t base_addr, const unsigned char *data, size_t data_sz, const HexdumpFormat&);
38618  static std::string hexdump(rose_addr_t base_addr, const std::string &prefix, const SgUnsignedCharList& data,
38619  bool multiline=true);
38620  static std::string hexdump(rose_addr_t base_addr, const std::string &prefix, const SgFileContentList& data,
38621  bool multiline=true);
38622 
38623  // Same, but output to a FILE* instead.
38624  static void hexdump(FILE*, rose_addr_t base_addr, const unsigned char *data, size_t data_sz, const HexdumpFormat&);
38625  static void hexdump(FILE*, rose_addr_t base_addr, const std::string &prefix, const SgUnsignedCharList& data,
38626  bool multiline=true);
38627  static void hexdump(FILE*, rose_addr_t base_addr, const std::string &prefix, const SgFileContentList& data,
38628  bool multiline=true);
38631  // These convert enums to strings. It is better to use the automatic enum stringification instead. They have names like
38632  // Rose::stringifySgAsmExecutableFileFormatInsnSetArchitecture, etc. */
38633  static std::string isa_family_to_string(SgAsmExecutableFileFormat::InsSetArchitecture);
38634  static std::string isa_to_string(SgAsmExecutableFileFormat::InsSetArchitecture);
38635  static std::string to_string(SgAsmExecutableFileFormat::InsSetArchitecture);
38636  static std::string to_string(SgAsmExecutableFileFormat::ExecFamily);
38637  static std::string to_string(SgAsmExecutableFileFormat::ExecABI);
38638  static std::string to_string(SgAsmExecutableFileFormat::ExecPurpose);
38639 public:
38641  virtual ~SgAsmExecutableFileFormat();
38642 
38643 protected:
38646 
38647 protected:
38654  void initializeProperties();
38655 #endif // SgAsmExecutableFileFormat_OTHERS
38656 #ifdef DOCUMENTATION
38657 };
38658 #endif // DOCUMENTATION
38659 
38660 
38662 // SgAsmAarch64SysMoveOperand -- MACHINE GENERATED; DO NOT MODIFY --
38664 
38665 #ifdef ROSE_ENABLE_ASM_AARCH64
38666 DECLARE_LEAF_CLASS(AsmAarch64SysMoveOperand);
38667 IS_SERIALIZABLE(AsmAarch64SysMoveOperand);
38668 
38669 DECLARE_HEADERS(AsmAarch64SysMoveOperand);
38670 #if defined(SgAsmAarch64SysMoveOperand_HEADERS) || defined(DOCUMENTATION)
38671 #ifdef ROSE_ENABLE_ASM_AARCH64
38672 #endif
38673 #endif // SgAsmAarch64SysMoveOperand_HEADERS
38674 
38675 #ifdef DOCUMENTATION
38676 
38677 class SgAsmAarch64SysMoveOperand: public SgAsmExpression {
38678 #endif // DOCUMENTATION
38679 
38680  DECLARE_OTHERS(AsmAarch64SysMoveOperand);
38681 #if defined(SgAsmAarch64SysMoveOperand_OTHERS) || defined(DOCUMENTATION)
38682 
38683  //----------------------- Boost serialization for SgAsmAarch64SysMoveOperand -----------------------
38684 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
38685 private:
38686  friend class boost::serialization::access;
38687 
38688  template<class S>
38689  void serialize(S &s, const unsigned /*version*/) {
38690  debugSerializationBegin("SgAsmAarch64SysMoveOperand");
38691  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExpression);
38692  s & BOOST_SERIALIZATION_NVP(access_);
38693  debugSerializationEnd("SgAsmAarch64SysMoveOperand");
38694  }
38695 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
38696 
38697 private:
38698  unsigned access_;
38699 
38700 public:
38706  unsigned const& access() const;
38707  void access(unsigned const&);
38710 public:
38712  virtual ~SgAsmAarch64SysMoveOperand();
38713 
38714 public:
38716  SgAsmAarch64SysMoveOperand();
38717 
38718 public:
38720  explicit SgAsmAarch64SysMoveOperand(unsigned const& access);
38721 
38722 protected:
38729  void initializeProperties();
38730 #endif // SgAsmAarch64SysMoveOperand_OTHERS
38731 #ifdef DOCUMENTATION
38732 };
38733 #endif // DOCUMENTATION
38734 #endif
38735 
38736 
38738 // SgAsmAarch64PrefetchOperand -- MACHINE GENERATED; DO NOT MODIFY --
38740 
38741 #ifdef ROSE_ENABLE_ASM_AARCH64
38742 DECLARE_LEAF_CLASS(AsmAarch64PrefetchOperand);
38743 IS_SERIALIZABLE(AsmAarch64PrefetchOperand);
38744 
38745 DECLARE_HEADERS(AsmAarch64PrefetchOperand);
38746 #if defined(SgAsmAarch64PrefetchOperand_HEADERS) || defined(DOCUMENTATION)
38747 #ifdef ROSE_ENABLE_ASM_AARCH64
38748 
38749 #include <Rose/BinaryAnalysis/InstructionEnumsAarch64.h>
38750 #endif
38751 #endif // SgAsmAarch64PrefetchOperand_HEADERS
38752 
38753 #ifdef DOCUMENTATION
38754 
38755 class SgAsmAarch64PrefetchOperand: public SgAsmExpression {
38756 #endif // DOCUMENTATION
38757 
38758  DECLARE_OTHERS(AsmAarch64PrefetchOperand);
38759 #if defined(SgAsmAarch64PrefetchOperand_OTHERS) || defined(DOCUMENTATION)
38760 
38761  //----------------------- Boost serialization for SgAsmAarch64PrefetchOperand -----------------------
38762 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
38763 private:
38764  friend class boost::serialization::access;
38765 
38766  template<class S>
38767  void serialize(S &s, const unsigned /*version*/) {
38768  debugSerializationBegin("SgAsmAarch64PrefetchOperand");
38769  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExpression);
38770  s & BOOST_SERIALIZATION_NVP(operation_);
38771  debugSerializationEnd("SgAsmAarch64PrefetchOperand");
38772  }
38773 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
38774 
38775 private:
38776  Rose::BinaryAnalysis::Aarch64PrefetchOperation operation_;
38777 
38778 public:
38784  Rose::BinaryAnalysis::Aarch64PrefetchOperation const& operation() const;
38785  void operation(Rose::BinaryAnalysis::Aarch64PrefetchOperation const&);
38788 public:
38790  virtual ~SgAsmAarch64PrefetchOperand();
38791 
38792 public:
38794  SgAsmAarch64PrefetchOperand();
38795 
38796 public:
38798  explicit SgAsmAarch64PrefetchOperand(Rose::BinaryAnalysis::Aarch64PrefetchOperation const& operation);
38799 
38800 protected:
38807  void initializeProperties();
38808 #endif // SgAsmAarch64PrefetchOperand_OTHERS
38809 #ifdef DOCUMENTATION
38810 };
38811 #endif // DOCUMENTATION
38812 #endif
38813 
38814 
38816 // SgAsmAarch64Instruction -- MACHINE GENERATED; DO NOT MODIFY --
38818 
38819 #ifdef ROSE_ENABLE_ASM_AARCH64
38820 DECLARE_LEAF_CLASS(AsmAarch64Instruction);
38821 IS_SERIALIZABLE(AsmAarch64Instruction);
38822 
38823 DECLARE_HEADERS(AsmAarch64Instruction);
38824 #if defined(SgAsmAarch64Instruction_HEADERS) || defined(DOCUMENTATION)
38825 #ifdef ROSE_ENABLE_ASM_AARCH64
38826 #include <Rose/BinaryAnalysis/InstructionEnumsAarch64.h>
38827 #endif
38828 #endif // SgAsmAarch64Instruction_HEADERS
38829 
38830 #ifdef DOCUMENTATION
38831 
38832 class SgAsmAarch64Instruction: public SgAsmInstruction {
38833 #endif // DOCUMENTATION
38834 
38835 #ifndef DOCUMENTATION
38836  AsmAarch64Instruction.setDataPrototype(
38837  "Rose::BinaryAnalysis::Aarch64InstructionKind", "kind", "= Rose::BinaryAnalysis::Aarch64InstructionKind::ARM64_INS_INVALID",
38838  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
38839 #endif // !DOCUMENTATION
38840 
38841 #ifndef DOCUMENTATION
38842  AsmAarch64Instruction.setDataPrototype(
38843  "Rose::BinaryAnalysis::Aarch64InstructionCondition", "condition", "= Rose::BinaryAnalysis::Aarch64InstructionCondition::ARM64_CC_INVALID",
38844  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
38845 #endif // !DOCUMENTATION
38846 
38847 #ifndef DOCUMENTATION
38848  AsmAarch64Instruction.setDataPrototype(
38849  "bool", "updatesFlags", "= false",
38850  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
38851 #endif // !DOCUMENTATION
38852 
38853  DECLARE_OTHERS(AsmAarch64Instruction);
38854 #if defined(SgAsmAarch64Instruction_OTHERS) || defined(DOCUMENTATION)
38855 
38856  //----------------------- Boost serialization for SgAsmAarch64Instruction -----------------------
38857 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
38858 private:
38859  friend class boost::serialization::access;
38860 
38861  template<class S>
38862  void serialize(S &s, const unsigned /*version*/) {
38863  debugSerializationBegin("SgAsmAarch64Instruction");
38864  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmInstruction);
38865  s & BOOST_SERIALIZATION_NVP(p_kind);
38866  s & BOOST_SERIALIZATION_NVP(p_condition);
38867  debugSerializationEnd("SgAsmAarch64Instruction");
38868  }
38869 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
38870 
38871 public:
38878  Rose::BinaryAnalysis::Aarch64InstructionKind const& get_kind() const;
38879  void set_kind(Rose::BinaryAnalysis::Aarch64InstructionKind const&);
38882 public:
38886  Rose::BinaryAnalysis::Aarch64InstructionCondition const& get_condition() const;
38887  void set_condition(Rose::BinaryAnalysis::Aarch64InstructionCondition const&);
38889  // FIXME[Robb Matzke 2023-03-18]: is the no_serialize a bug?
38890 public:
38894  bool const& get_updatesFlags() const;
38895  void set_updatesFlags(bool const&);
38897 public:
38898  // Overrides are documented in the base class
38899  virtual std::string description() const override;
38900  virtual bool terminatesBasicBlock() override;
38901  virtual Rose::BinaryAnalysis::AddressSet getSuccessors(bool &complete) override;
38902  virtual bool isUnknown() const override;
38903  virtual unsigned get_anyKind() const override;
38904  virtual bool isFunctionCallFast(const std::vector<SgAsmInstruction*>&, rose_addr_t *target,
38905  rose_addr_t *return_va) override;
38906  virtual bool isFunctionCallSlow(const std::vector<SgAsmInstruction*>&, rose_addr_t *target,
38907  rose_addr_t *return_va) override;
38908  virtual bool isFunctionReturnFast(const std::vector<SgAsmInstruction*>&) override;
38909  virtual bool isFunctionReturnSlow(const std::vector<SgAsmInstruction*>&) override;
38910  virtual Sawyer::Optional<rose_addr_t> branchTarget() override;
38911 public:
38913  virtual ~SgAsmAarch64Instruction();
38914 
38915 public:
38917  SgAsmAarch64Instruction();
38918 
38919 public:
38921  SgAsmAarch64Instruction(rose_addr_t const& address,
38922  std::string const& mnemonic,
38923  Rose::BinaryAnalysis::Aarch64InstructionKind const& kind,
38924  Rose::BinaryAnalysis::Aarch64InstructionCondition const& condition);
38925 
38926 protected:
38933  void initializeProperties();
38934 #endif // SgAsmAarch64Instruction_OTHERS
38935 #ifdef DOCUMENTATION
38936 };
38937 #endif // DOCUMENTATION
38938 #endif
38939 
38940 
38942 // SgAsmAarch64CImmediateOperand -- MACHINE GENERATED; DO NOT MODIFY --
38944 
38945 #ifdef ROSE_ENABLE_ASM_AARCH64
38946 DECLARE_LEAF_CLASS(AsmAarch64CImmediateOperand);
38947 IS_SERIALIZABLE(AsmAarch64CImmediateOperand);
38948 
38949 DECLARE_HEADERS(AsmAarch64CImmediateOperand);
38950 #if defined(SgAsmAarch64CImmediateOperand_HEADERS) || defined(DOCUMENTATION)
38951 #ifdef ROSE_ENABLE_ASM_AARCH64
38952 #endif
38953 #endif // SgAsmAarch64CImmediateOperand_HEADERS
38954 
38955 #ifdef DOCUMENTATION
38956 
38957 class SgAsmAarch64CImmediateOperand: public SgAsmExpression {
38958 #endif // DOCUMENTATION
38959 
38960  DECLARE_OTHERS(AsmAarch64CImmediateOperand);
38961 #if defined(SgAsmAarch64CImmediateOperand_OTHERS) || defined(DOCUMENTATION)
38962 
38963  //----------------------- Boost serialization for SgAsmAarch64CImmediateOperand -----------------------
38964 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
38965 private:
38966  friend class boost::serialization::access;
38967 
38968  template<class S>
38969  void serialize(S &s, const unsigned /*version*/) {
38970  debugSerializationBegin("SgAsmAarch64CImmediateOperand");
38971  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExpression);
38972  s & BOOST_SERIALIZATION_NVP(immediate_);
38973  debugSerializationEnd("SgAsmAarch64CImmediateOperand");
38974  }
38975 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
38976 
38977 private:
38978  unsigned immediate_;
38979 
38980 public:
38986  unsigned const& immediate() const;
38987  void immediate(unsigned const&);
38990 public:
38992  virtual ~SgAsmAarch64CImmediateOperand();
38993 
38994 public:
38996  SgAsmAarch64CImmediateOperand();
38997 
38998 public:
39000  explicit SgAsmAarch64CImmediateOperand(unsigned const& immediate);
39001 
39002 protected:
39009  void initializeProperties();
39010 #endif // SgAsmAarch64CImmediateOperand_OTHERS
39011 #ifdef DOCUMENTATION
39012 };
39013 #endif // DOCUMENTATION
39014 #endif
39015 
39016 
39018 // SgAsmAarch64BarrierOperand -- MACHINE GENERATED; DO NOT MODIFY --
39020 
39021 #ifdef ROSE_ENABLE_ASM_AARCH64
39022 DECLARE_LEAF_CLASS(AsmAarch64BarrierOperand);
39023 IS_SERIALIZABLE(AsmAarch64BarrierOperand);
39024 
39025 DECLARE_HEADERS(AsmAarch64BarrierOperand);
39026 #if defined(SgAsmAarch64BarrierOperand_HEADERS) || defined(DOCUMENTATION)
39027 #ifdef ROSE_ENABLE_ASM_AARCH64
39028 
39029 #include <Rose/BinaryAnalysis/InstructionEnumsAarch64.h>
39030 #endif
39031 #endif // SgAsmAarch64BarrierOperand_HEADERS
39032 
39033 #ifdef DOCUMENTATION
39034 
39035 class SgAsmAarch64BarrierOperand: public SgAsmExpression {
39036 #endif // DOCUMENTATION
39037 
39038  DECLARE_OTHERS(AsmAarch64BarrierOperand);
39039 #if defined(SgAsmAarch64BarrierOperand_OTHERS) || defined(DOCUMENTATION)
39040 
39041  //----------------------- Boost serialization for SgAsmAarch64BarrierOperand -----------------------
39042 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
39043 private:
39044  friend class boost::serialization::access;
39045 
39046  template<class S>
39047  void serialize(S &s, const unsigned /*version*/) {
39048  debugSerializationBegin("SgAsmAarch64BarrierOperand");
39049  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExpression);
39050  s & BOOST_SERIALIZATION_NVP(operation_);
39051  debugSerializationEnd("SgAsmAarch64BarrierOperand");
39052  }
39053 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
39054 
39055 private:
39056  Rose::BinaryAnalysis::Aarch64BarrierOperation operation_;
39057 
39058 public:
39062  Rose::BinaryAnalysis::Aarch64BarrierOperation const& operation() const;
39063  void operation(Rose::BinaryAnalysis::Aarch64BarrierOperation const&);
39066 public:
39068  virtual ~SgAsmAarch64BarrierOperand();
39069 
39070 public:
39072  SgAsmAarch64BarrierOperand();
39073 
39074 public:
39076  explicit SgAsmAarch64BarrierOperand(Rose::BinaryAnalysis::Aarch64BarrierOperation const& operation);
39077 
39078 protected:
39085  void initializeProperties();
39086 #endif // SgAsmAarch64BarrierOperand_OTHERS
39087 #ifdef DOCUMENTATION
39088 };
39089 #endif // DOCUMENTATION
39090 #endif
39091 
39092 
39094 // SgAsmAarch64AtOperand -- MACHINE GENERATED; DO NOT MODIFY --
39096 
39097 #ifdef ROSE_ENABLE_ASM_AARCH64
39098 DECLARE_LEAF_CLASS(AsmAarch64AtOperand);
39099 IS_SERIALIZABLE(AsmAarch64AtOperand);
39100 
39101 DECLARE_HEADERS(AsmAarch64AtOperand);
39102 #if defined(SgAsmAarch64AtOperand_HEADERS) || defined(DOCUMENTATION)
39103 #ifdef ROSE_ENABLE_ASM_AARCH64
39104 
39105 #include <Rose/BinaryAnalysis/InstructionEnumsAarch64.h>
39106 #endif
39107 #endif // SgAsmAarch64AtOperand_HEADERS
39108 
39109 #ifdef DOCUMENTATION
39110 
39111 class SgAsmAarch64AtOperand: public SgAsmExpression {
39112 #endif // DOCUMENTATION
39113 
39114  DECLARE_OTHERS(AsmAarch64AtOperand);
39115 #if defined(SgAsmAarch64AtOperand_OTHERS) || defined(DOCUMENTATION)
39116 
39117  //----------------------- Boost serialization for SgAsmAarch64AtOperand -----------------------
39118 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
39119 private:
39120  friend class boost::serialization::access;
39121 
39122  template<class S>
39123  void serialize(S &s, const unsigned /*version*/) {
39124  debugSerializationBegin("SgAsmAarch64AtOperand");
39125  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExpression);
39126  s & BOOST_SERIALIZATION_NVP(operation_);
39127  debugSerializationEnd("SgAsmAarch64AtOperand");
39128  }
39129 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
39130 
39131 private:
39132  Rose::BinaryAnalysis::Aarch64AtOperation operation_;
39133 
39134 public:
39140  Rose::BinaryAnalysis::Aarch64AtOperation const& operation() const;
39141  void operation(Rose::BinaryAnalysis::Aarch64AtOperation const&);
39144 public:
39146  virtual ~SgAsmAarch64AtOperand();
39147 
39148 public:
39150  SgAsmAarch64AtOperand();
39151 
39152 public:
39154  explicit SgAsmAarch64AtOperand(Rose::BinaryAnalysis::Aarch64AtOperation const& operation);
39155 
39156 protected:
39163  void initializeProperties();
39164 #endif // SgAsmAarch64AtOperand_OTHERS
39165 #ifdef DOCUMENTATION
39166 };
39167 #endif // DOCUMENTATION
39168 #endif
39169 
39170 
39172 // SgAsmAarch32Instruction -- MACHINE GENERATED; DO NOT MODIFY --
39174 
39175 #ifdef ROSE_ENABLE_ASM_AARCH32
39176 DECLARE_LEAF_CLASS(AsmAarch32Instruction);
39177 IS_SERIALIZABLE(AsmAarch32Instruction);
39178 
39179 DECLARE_HEADERS(AsmAarch32Instruction);
39180 #if defined(SgAsmAarch32Instruction_HEADERS) || defined(DOCUMENTATION)
39181 #ifdef ROSE_ENABLE_ASM_AARCH32
39182 #include <Rose/BinaryAnalysis/InstructionEnumsAarch32.h>
39183 #endif
39184 #endif // SgAsmAarch32Instruction_HEADERS
39185 
39186 #ifdef DOCUMENTATION
39187 
39188 class SgAsmAarch32Instruction: public SgAsmInstruction {
39189 #endif // DOCUMENTATION
39190 
39191 #ifndef DOCUMENTATION
39192  AsmAarch32Instruction.setDataPrototype(
39193  "Rose::BinaryAnalysis::Aarch32InstructionKind", "kind", "= Rose::BinaryAnalysis::Aarch32InstructionKind::ARM_INS_INVALID",
39194  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
39195 #endif // !DOCUMENTATION
39196 
39197 #ifndef DOCUMENTATION
39198  AsmAarch32Instruction.setDataPrototype(
39199  "Rose::BinaryAnalysis::Aarch32InstructionCondition", "condition", "= Rose::BinaryAnalysis::Aarch32InstructionCondition::ARM_CC_INVALID",
39200  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
39201 #endif // !DOCUMENTATION
39202 
39203 #ifndef DOCUMENTATION
39204  AsmAarch32Instruction.setDataPrototype(
39205  "bool", "updatesFlags", "= false",
39206  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
39207 #endif // !DOCUMENTATION
39208 
39209 #ifndef DOCUMENTATION
39210  AsmAarch32Instruction.setDataPrototype(
39211  "bool", "writesBack", "= false",
39212  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
39213 #endif // !DOCUMENTATION
39214 
39215 #ifndef DOCUMENTATION
39216  AsmAarch32Instruction.setDataPrototype(
39217  "bool", "writesToIp", "= false",
39218  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
39219 #endif // !DOCUMENTATION
39220 
39221  DECLARE_OTHERS(AsmAarch32Instruction);
39222 #if defined(SgAsmAarch32Instruction_OTHERS) || defined(DOCUMENTATION)
39223 
39224  //----------------------- Boost serialization for SgAsmAarch32Instruction -----------------------
39225 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
39226 private:
39227  friend class boost::serialization::access;
39228 
39229  template<class S>
39230  void serialize(S &s, const unsigned /*version*/) {
39231  debugSerializationBegin("SgAsmAarch32Instruction");
39232  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmInstruction);
39233  s & BOOST_SERIALIZATION_NVP(p_kind);
39234  s & BOOST_SERIALIZATION_NVP(p_condition);
39235  s & BOOST_SERIALIZATION_NVP(p_updatesFlags);
39236  s & BOOST_SERIALIZATION_NVP(p_writesBack);
39237  s & BOOST_SERIALIZATION_NVP(p_writesToIp);
39238  debugSerializationEnd("SgAsmAarch32Instruction");
39239  }
39240 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
39241 public:
39242 public:
39249  Rose::BinaryAnalysis::Aarch32InstructionKind const& get_kind() const;
39250  void set_kind(Rose::BinaryAnalysis::Aarch32InstructionKind const&);
39253 public:
39259  Rose::BinaryAnalysis::Aarch32InstructionCondition const& get_condition() const;
39260  void set_condition(Rose::BinaryAnalysis::Aarch32InstructionCondition const&);
39263 public:
39267  bool const& get_updatesFlags() const;
39268  void set_updatesFlags(bool const&);
39271 public:
39275  bool const& get_writesBack() const;
39276  void set_writesBack(bool const&);
39279 public:
39286  bool const& get_writesToIp() const;
39287  void set_writesToIp(bool const&);
39289 public:
39290  // Overrides are documented in the base class
39291  virtual std::string description() const override;
39292  virtual bool terminatesBasicBlock() override;
39293  virtual Rose::BinaryAnalysis::AddressSet getSuccessors(bool &complete) override;
39294  virtual bool isUnknown() const override;
39295  virtual unsigned get_anyKind() const override;
39296  virtual bool isFunctionCallFast(const std::vector<SgAsmInstruction*>&, rose_addr_t *target,
39297  rose_addr_t *return_va) override;
39298  virtual bool isFunctionCallSlow(const std::vector<SgAsmInstruction*>&, rose_addr_t *target,
39299  rose_addr_t *return_va) override;
39300  virtual bool isFunctionReturnFast(const std::vector<SgAsmInstruction*>&) override;
39301  virtual bool isFunctionReturnSlow(const std::vector<SgAsmInstruction*>&) override;
39302  virtual Sawyer::Optional<rose_addr_t> branchTarget() override;
39303 public:
39305  virtual ~SgAsmAarch32Instruction();
39306 
39307 public:
39309  SgAsmAarch32Instruction();
39310 
39311 public:
39313  SgAsmAarch32Instruction(rose_addr_t const& address,
39314  std::string const& mnemonic,
39315  Rose::BinaryAnalysis::Aarch32InstructionKind const& kind,
39316  Rose::BinaryAnalysis::Aarch32InstructionCondition const& condition);
39317 
39318 protected:
39325  void initializeProperties();
39326 #endif // SgAsmAarch32Instruction_OTHERS
39327 #ifdef DOCUMENTATION
39328 };
39329 #endif // DOCUMENTATION
39330 #endif
39331 
39332 
39334 // SgAsmInstruction -- MACHINE GENERATED; DO NOT MODIFY --
39336 
39337 #ifndef DOCUMENTATION
39338 AstNodeClass& AsmInstruction = nonTerminalConstructor(
39339  "AsmInstruction",
39340  *this,
39341  "AsmInstruction",
39342  "AsmInstructionTag",
39343  SubclassListBuilder()
39344 #ifdef ROSE_ENABLE_ASM_AARCH32
39345  | AsmAarch32Instruction
39346 #endif
39347 #ifdef ROSE_ENABLE_ASM_AARCH64
39348  | AsmAarch64Instruction
39349 #endif
39350  | AsmCilInstruction
39351  | AsmJvmInstruction
39352  | AsmM68kInstruction
39353  | AsmMipsInstruction
39354  | AsmNullInstruction
39355  | AsmPowerpcInstruction
39356  | AsmX86Instruction
39357  , true);
39358 assert(AsmInstruction.associatedGrammar != nullptr);
39359 AsmInstruction.setCppCondition("!defined(DOCUMENTATION)");
39360 AsmInstruction.isBoostSerializable(true);
39361 AsmInstruction.setAutomaticGenerationOfConstructor(false);
39362 AsmInstruction.setAutomaticGenerationOfDestructor(false);
39363 #endif // !DOCUMENTATION
39364 
39365 DECLARE_HEADERS(AsmInstruction);
39366 #if defined(SgAsmInstruction_HEADERS) || defined(DOCUMENTATION)
39367 #include <Rose/BinaryAnalysis/MemoryMap.h>
39368 #endif // SgAsmInstruction_HEADERS
39369 
39370 #ifdef DOCUMENTATION
39371 
39393 #endif // DOCUMENTATION
39394 
39395 #ifndef DOCUMENTATION
39396  AsmInstruction.setDataPrototype(
39397  "std::string", "mnemonic", "",
39398  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
39399 #endif // !DOCUMENTATION
39400 
39401 #ifndef DOCUMENTATION
39402  AsmInstruction.setDataPrototype(
39403  "SgUnsignedCharList", "raw_bytes", "",
39404  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
39405 #endif // !DOCUMENTATION
39406 
39407 #ifndef DOCUMENTATION
39408  AsmInstruction.setDataPrototype(
39409  "SgAsmOperandList*", "operandList", "= nullptr",
39410  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
39411 #endif // !DOCUMENTATION
39412 
39413 #ifndef DOCUMENTATION
39414  AsmInstruction.setDataPrototype(
39415  "size_t", "cacheLockCount", "= 0",
39416  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
39417 #endif // !DOCUMENTATION
39418 
39419 #ifndef DOCUMENTATION
39420  AsmInstruction.setDataPrototype(
39421  "SgAsmStatementPtrList", "sources", "",
39422  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
39423 #endif // !DOCUMENTATION
39424 
39425 #ifndef DOCUMENTATION
39426  AsmInstruction.setDataPrototype(
39427  "int64_t", "stackDeltaIn", "= SgAsmInstruction::INVALID_STACK_DELTA",
39428  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
39429 #endif // !DOCUMENTATION
39430 
39431 #ifndef DOCUMENTATION
39432  AsmInstruction.setDataPrototype(
39433  "SgAsmExprListExp*", "semantics", "= nullptr",
39434  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
39435 #endif // !DOCUMENTATION
39436 
39437  DECLARE_OTHERS(AsmInstruction);
39438 #if defined(SgAsmInstruction_OTHERS) || defined(DOCUMENTATION)
39439 
39440  //----------------------- Boost serialization for SgAsmInstruction -----------------------
39441 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
39442 private:
39443  friend class boost::serialization::access;
39444 
39445  template<class S>
39446  void serialize(S &s, const unsigned /*version*/) {
39447  debugSerializationBegin("SgAsmInstruction");
39448  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmStatement);
39449  s & BOOST_SERIALIZATION_NVP(p_mnemonic);
39450  s & BOOST_SERIALIZATION_NVP(p_raw_bytes);
39451  s & BOOST_SERIALIZATION_NVP(p_operandList);
39452  s & BOOST_SERIALIZATION_NVP(p_cacheLockCount);
39453  s & BOOST_SERIALIZATION_NVP(p_sources);
39454  debugSerializationEnd("SgAsmInstruction");
39455  }
39456 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
39457  // Local types
39460 private:
39461  struct SemanticFailure {
39462  size_t n;
39463  SemanticFailure(): n(0) {}
39464 
39465 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
39466  private:
39467  friend class boost::serialization::access;
39468  template<class S>
39469  void serialize(S &s, const unsigned /*version*/) {
39470  s & BOOST_SERIALIZATION_NVP(n);
39471  }
39472 #endif
39473 };
39474 
39476  // Properties
39478 public:
39487  std::string const& get_mnemonic() const;
39488  void set_mnemonic(std::string const&);
39491 public:
39497  SgUnsignedCharList const& get_raw_bytes() const;
39498  void set_raw_bytes(SgUnsignedCharList const&);
39501 public:
39508  SgAsmOperandList* const& get_operandList() const;
39509  void set_operandList(SgAsmOperandList* const&);
39512 public:
39520  size_t cacheLockCount() const;
39521  void adjustCacheLockCount(int increment);
39522 
39523  // FIXME[Robb P Matzke 2017-02-13]: unused?
39524 public:
39528  void appendSources( SgAsmInstruction* instruction );
39529 
39530  // FIXME[Robb Matzke 2023-03-18]: is the no_serialize a bug?
39531 public:
39538  int64_t const& get_stackDeltaIn() const;
39539  void set_stackDeltaIn(int64_t const&);
39541  // FIXME[Robb Matzke 2023-03-18]: is the no_serialize a bug?
39542 public:
39550  SgAsmExprListExp* const& get_semantics() const;
39551  void set_semantics(SgAsmExprListExp* const&);
39553  // Non-property data members
39556 private:
39557  SemanticFailure semanticFailure_;
39558 
39559  // Synchronized data members. All the following data members (as listed in binaryInstruction.C, not the ROSETTA-generated
39560  // code) should be procted by the mutex_. Additionally, the p_cacheLockCount data member is synchronized.
39561  mutable SAWYER_THREAD_TRAITS::Mutex mutex_;
39562 
39563 public:
39568  static const int64_t INVALID_STACK_DELTA;
39569 
39571  // Functions
39573 public:
39579  virtual std::string description() const { return ""; }
39580 
39582  size_t nOperands() const;
39583 
39587  SgAsmExpression* operand(size_t) const;
39588 
39595  virtual bool terminatesBasicBlock();
39596 
39610  virtual bool isFunctionCallFast(const std::vector<SgAsmInstruction*>&, rose_addr_t *target, rose_addr_t *ret);
39611  virtual bool isFunctionCallSlow(const std::vector<SgAsmInstruction*>&, rose_addr_t *target, rose_addr_t *ret);
39623  virtual bool isFunctionReturnFast(const std::vector<SgAsmInstruction*>&);
39624  virtual bool isFunctionReturnSlow(const std::vector<SgAsmInstruction*>&);
39630  bool isFirstInBlock();
39631 
39635  bool isLastInBlock();
39636 
39642 
39643  // FIXME[Robb Matzke 2021-03-02]: deprecated
39644  bool getBranchTarget(rose_addr_t *target /*out*/) ROSE_DEPRECATED("use branchTarget instead");
39645 
39780  virtual bool hasEffect();
39781 
39790  virtual bool hasEffect(const std::vector<SgAsmInstruction*>&, bool allow_branch=false,
39791  bool relax_stack_semantics=false);
39792 
39802  virtual std::vector<std::pair<size_t,size_t> >
39803  findNoopSubsequences(const std::vector<SgAsmInstruction*>& insns, bool allow_branch=false,
39804  bool relax_stack_semantics=false);
39805 
39812  virtual Rose::BinaryAnalysis::AddressSet getSuccessors(bool &complete); /*subclasses must redefine*/
39813 
39822  virtual Rose::BinaryAnalysis::AddressSet getSuccessors(const std::vector<SgAsmInstruction*> &basicBlock,
39823  bool &complete,
39824  const Rose::BinaryAnalysis::MemoryMap::Ptr &initial_memory =
39826 
39832  virtual size_t get_size() const;
39833 
39839  virtual bool isUnknown() const;
39840 
39874  virtual unsigned get_anyKind() const;
39875 
39879  virtual std::string toString() const;
39880 
39885  virtual std::set<rose_addr_t> explicitConstants() const;
39886 
39896  size_t semanticFailure() const;
39897  void semanticFailure(size_t);
39898  void incrementSemanticFailure();
39909  bool normalizeOperands();
39910 public:
39912  virtual ~SgAsmInstruction();
39913 
39914 public:
39916  SgAsmInstruction();
39917 
39918 public:
39920  SgAsmInstruction(rose_addr_t const& address,
39921  std::string const& mnemonic);
39922 
39923 protected:
39930  void initializeProperties();
39931 #endif // SgAsmInstruction_OTHERS
39932 #ifdef DOCUMENTATION
39933 };
39934 #endif // DOCUMENTATION
39935 
39936 
39938 // SgAsmStatement -- MACHINE GENERATED; DO NOT MODIFY --
39940 
39941 #ifndef DOCUMENTATION
39942 AstNodeClass& AsmStatement = nonTerminalConstructor(
39943  "AsmStatement",
39944  *this,
39945  "AsmStatement",
39946  "AsmStatementTag",
39947  SubclassListBuilder()
39948  | AsmBlock
39949  | AsmInstruction
39950  | AsmStaticData
39951  | AsmSynthesizedDeclaration
39952  , false);
39953 assert(AsmStatement.associatedGrammar != nullptr);
39954 AsmStatement.setCppCondition("!defined(DOCUMENTATION)");
39955 AsmStatement.isBoostSerializable(true);
39956 AsmStatement.setAutomaticGenerationOfConstructor(false);
39957 AsmStatement.setAutomaticGenerationOfDestructor(false);
39958 #endif // !DOCUMENTATION
39959 
39960 #ifdef DOCUMENTATION
39961 
39965 class SgAsmStatement: public SgAsmNode {
39966 #endif // DOCUMENTATION
39967 
39968 #ifndef DOCUMENTATION
39969  AsmStatement.setDataPrototype(
39970  "rose_addr_t", "address", "= 0",
39971  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
39972 #endif // !DOCUMENTATION
39973 
39974 #ifndef DOCUMENTATION
39975  AsmStatement.setDataPrototype(
39976  "std::string", "comment", "",
39977  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
39978 #endif // !DOCUMENTATION
39979 
39980  DECLARE_OTHERS(AsmStatement);
39981 #if defined(SgAsmStatement_OTHERS) || defined(DOCUMENTATION)
39982 
39983  //----------------------- Boost serialization for SgAsmStatement -----------------------
39984 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
39985 private:
39986  friend class boost::serialization::access;
39987 
39988  template<class S>
39989  void serialize(S &s, const unsigned /*version*/) {
39990  debugSerializationBegin("SgAsmStatement");
39991  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmNode);
39992  s & BOOST_SERIALIZATION_NVP(p_address);
39993  s & BOOST_SERIALIZATION_NVP(p_comment);
39994  debugSerializationEnd("SgAsmStatement");
39995  }
39996 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
39997 
39998 public:
40004  rose_addr_t const& get_address() const;
40005  void set_address(rose_addr_t const&);
40008 public:
40012  std::string const& get_comment() const;
40013  void set_comment(std::string const&);
40016 public:
40018  virtual ~SgAsmStatement();
40019 
40020 protected:
40022  SgAsmStatement();
40023 
40024 protected:
40026  explicit SgAsmStatement(rose_addr_t const& address);
40027 
40028 protected:
40035  void initializeProperties();
40036 #endif // SgAsmStatement_OTHERS
40037 #ifdef DOCUMENTATION
40038 };
40039 #endif // DOCUMENTATION
40040 
40041 
40043 // SgAsmAarch32Coprocessor -- MACHINE GENERATED; DO NOT MODIFY --
40045 
40046 DECLARE_LEAF_CLASS(AsmAarch32Coprocessor);
40047 IS_SERIALIZABLE(AsmAarch32Coprocessor);
40048 
40049 #ifdef DOCUMENTATION
40050 
40052 #endif // DOCUMENTATION
40053 
40054  DECLARE_OTHERS(AsmAarch32Coprocessor);
40055 #if defined(SgAsmAarch32Coprocessor_OTHERS) || defined(DOCUMENTATION)
40056 
40057  //----------------------- Boost serialization for SgAsmAarch32Coprocessor -----------------------
40058 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
40059 private:
40060  friend class boost::serialization::access;
40061 
40062  template<class S>
40063  void serialize(S &s, const unsigned /*version*/) {
40064  debugSerializationBegin("SgAsmAarch32Coprocessor");
40065  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmExpression);
40066  s & BOOST_SERIALIZATION_NVP(coprocessor_);
40067  debugSerializationEnd("SgAsmAarch32Coprocessor");
40068  }
40069 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
40070 
40071 private:
40072  int coprocessor_;
40073 
40074 public:
40078  int const& coprocessor() const;
40079  void coprocessor(int const&);
40082 public:
40084  virtual ~SgAsmAarch32Coprocessor();
40085 
40086 public:
40089 
40090 public:
40092  explicit SgAsmAarch32Coprocessor(int const& coprocessor);
40093 
40094 protected:
40101  void initializeProperties();
40102 #endif // SgAsmAarch32Coprocessor_OTHERS
40103 #ifdef DOCUMENTATION
40104 };
40105 #endif // DOCUMENTATION
40106 
40107 
40109 // SgAsmExpression -- MACHINE GENERATED; DO NOT MODIFY --
40111 
40112 #ifndef DOCUMENTATION
40113 AstNodeClass& AsmExpression = nonTerminalConstructor(
40114  "AsmExpression",
40115  *this,
40116  "AsmExpression",
40117  "AsmExpressionTag",
40118  SubclassListBuilder()
40119  | AsmAarch32Coprocessor
40120 #ifdef ROSE_ENABLE_ASM_AARCH64
40121  | AsmAarch64AtOperand
40122 #endif
40123 #ifdef ROSE_ENABLE_ASM_AARCH64
40124  | AsmAarch64BarrierOperand
40125 #endif
40126 #ifdef ROSE_ENABLE_ASM_AARCH64
40127  | AsmAarch64CImmediateOperand
40128 #endif
40129 #ifdef ROSE_ENABLE_ASM_AARCH64
40130  | AsmAarch64PrefetchOperand
40131 #endif
40132 #ifdef ROSE_ENABLE_ASM_AARCH64
40133  | AsmAarch64SysMoveOperand
40134 #endif
40135  | AsmBinaryExpression
40136  | AsmByteOrder
40137  | AsmCommonSubExpression
40138  | AsmControlFlagsExpression
40139  | AsmExprListExp
40140  | AsmMemoryReferenceExpression
40141  | AsmRegisterNames
40142  | AsmRegisterReferenceExpression
40143  | AsmRiscOperation
40144  | AsmStackExpression
40145  | AsmUnaryExpression
40146  | AsmValueExpression
40147  , false);
40148 assert(AsmExpression.associatedGrammar != nullptr);
40149 AsmExpression.setCppCondition("!defined(DOCUMENTATION)");
40150 AsmExpression.isBoostSerializable(true);
40151 AsmExpression.setAutomaticGenerationOfConstructor(false);
40152 AsmExpression.setAutomaticGenerationOfDestructor(false);
40153 #endif // !DOCUMENTATION
40154 
40155 #ifdef DOCUMENTATION
40156 
40158 #endif // DOCUMENTATION
40159 
40160 #ifndef DOCUMENTATION
40161  AsmExpression.setDataPrototype(
40162  "SgAsmType*", "type", "= nullptr",
40163  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
40164 #endif // !DOCUMENTATION
40165 
40166 #ifndef DOCUMENTATION
40167  AsmExpression.setDataPrototype(
40168  "std::string", "comment", "",
40169  NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
40170 #endif // !DOCUMENTATION
40171 
40172  DECLARE_OTHERS(AsmExpression);
40173 #if defined(SgAsmExpression_OTHERS) || defined(DOCUMENTATION)
40174 
40175  //----------------------- Boost serialization for SgAsmExpression -----------------------
40176 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
40177 private:
40178  friend class boost::serialization::access;
40179 
40180  template<class S>
40181  void serialize(S &s, const unsigned /*version*/) {
40182  debugSerializationBegin("SgAsmExpression");
40183  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgAsmNode);
40184  s & BOOST_SERIALIZATION_NVP(p_type);
40185  s & BOOST_SERIALIZATION_NVP(p_comment);
40186  debugSerializationEnd("SgAsmExpression");
40187  }
40188 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
40189 
40190 public:
40196  SgAsmType* const& get_type() const;
40197  void set_type(SgAsmType* const&);
40200 public:
40206  std::string const& get_comment() const;
40207  void set_comment(std::string const&);
40209 public:
40213  size_t get_nBits() const;
40214 
40220 
40226 public:
40228  virtual ~SgAsmExpression();
40229 
40230 protected:
40232  SgAsmExpression();
40233 
40234 protected:
40241  void initializeProperties();
40242 #endif // SgAsmExpression_OTHERS
40243 #ifdef DOCUMENTATION
40244 };
40245 #endif // DOCUMENTATION
40246 
40247 
40249 // SgAsmNode -- MACHINE GENERATED; DO NOT MODIFY --
40251 
40252 #ifndef DOCUMENTATION
40253 AstNodeClass& AsmNode = nonTerminalConstructor(
40254  "AsmNode",
40255  *this,
40256  "AsmNode",
40257  "AsmNodeTag",
40258  SubclassListBuilder()
40259  | AsmCilNode
40260  | AsmExecutableFileFormat
40261  | AsmExpression
40262  | AsmGenericFileList
40263  | AsmInstructionList
40264  | AsmInterpretation
40265  | AsmInterpretationList
40266  | AsmJvmNode
40267  | AsmOperandList
40268  | AsmStatement
40269  | AsmType
40270  , false);
40271 assert(AsmNode.associatedGrammar != nullptr);
40272 AsmNode.setCppCondition("!defined(DOCUMENTATION)");
40273 AsmNode.isBoostSerializable(true);
40274 AsmNode.setAutomaticGenerationOfConstructor(false);
40275 AsmNode.setAutomaticGenerationOfDestructor(false);
40276 #endif // !DOCUMENTATION
40277 
40278 DECLARE_HEADERS(AsmNode);
40279 #if defined(SgAsmNode_HEADERS) || defined(DOCUMENTATION)
40280 #include <Sawyer/Attribute.h>
40281 #include <boost/format.hpp>
40282 #endif // SgAsmNode_HEADERS
40283 
40284 #ifdef DOCUMENTATION
40285 
40286 class SgAsmNode: public SgNode {
40287 #endif // DOCUMENTATION
40288 
40289  DECLARE_OTHERS(AsmNode);
40290 #if defined(SgAsmNode_OTHERS) || defined(DOCUMENTATION)
40291 
40292  //----------------------- Boost serialization for SgAsmNode -----------------------
40293 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
40294 private:
40295  friend class boost::serialization::access;
40296 
40297  template<class S>
40298  void serialize(S &s, const unsigned /*version*/) {
40299  debugSerializationBegin("SgAsmNode");
40300  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(SgNode);
40301  debugSerializationEnd("SgAsmNode");
40302  }
40303 #endif // ROSE_HAVE_BOOST_SERIALIZATION_LIB
40304 
40305 private:
40306  Sawyer::Attribute::Storage<> attributes_;
40307 
40308 public:
40323 public:
40325  virtual ~SgAsmNode();
40326 
40327 protected:
40329  SgAsmNode();
40330 
40331 protected:
40338  void initializeProperties();
40339 #endif // SgAsmNode_OTHERS
40340 #ifdef DOCUMENTATION
40341 };
40342 #endif // DOCUMENTATION
40343 
40344 #ifndef DOCUMENTATION
40345 } // Grammar::setUpBinaryInstructions
40346 #endif // !DOCUMENTATION
40347 #endif // defined(ROSE_ENABLE_BINARY_ANALYSIS)
rose_addr_t get_current_size() const
Returns current size of file based on section with highest ending address.
SgAsmPESectionTableEntry *const & get_section_entry() const
Property: Section table entry.
ARM{7TDMI,7TDMI-S,710T,720T,740T,7EJ-S} cores.
void set_AssemblyOSTable(SgAsmCilAssemblyOSTable *const &)
Property: AssemblyOSTable.
void set_MethodList(uint32_t const &)
Property: MethodList.
unsigned const & get_e_heap_commit_size() const
Property: Heap commit size.
virtual ~SgAsmElfStrtab()
Destructor.
virtual ~SgAsmBinaryLsl()
Destructor.
virtual Sawyer::Optional< rose_addr_t > branchTarget()
Obtains the virtual address for a branching instruction.
virtual ~SgAsmCilManifestResource()
Destructor.
rose_addr_t const & get_sh_offset() const
Property: sh_offset.
virtual void dump(FILE *f, const char *prefix, ssize_t idx) const
Print debugging information.
void set_neuter(bool const &)
Property: If set, refuse to unparse file.
SgAsmConstantExpression()
Default constructor.
void set_export_rva(rose_rva_t const &)
Property: Export RVA.
List of pointers to file sections.
void initializeProperties()
Initialize all properties that have explicit initial values.
size_t const & get_modulus() const
Property: Register descriptor modulus.
uint16_t const & get_cpool_index() const
Property: cpool_index.
32 bit signed PC relative offset to GOT
SgAsmCoffStrtab *const & get_strtab() const
Property: String table.
CIL ClassLayout node (II.22.8).
void set_Reserved0(uint32_t const &)
Property: Reserved space.
void set_successors_complete(bool const &)
Property: Whether the successors list is complete.
virtual void unparse(std::ostream &) const override
Write method table to a binary file.
unsigned char e_ident_file_class
1=>32-bit; 2=>64-bit; other is error
const char * format_name() const override
Returns the name of the file format.
virtual bool isFunctionCallSlow(const std::vector< SgAsmInstruction * > &, rose_addr_t *target, rose_addr_t *ret) override
Returns true if the specified basic block looks like a function call.
uint16_t const & get_RevisionNumber() const
Property: RevisionNumber.
uint64_t read_content_local_uleb128(rose_addr_t *rel_offset, bool strict=true)
Read an unsigned little-endian 128-bit value.
virtual void debugSerializationEnd(const char *className)
Called by generated serializers.
virtual void unparse(std::ostream &) const override
Write the BootstrapMethods attribute to a binary file.
void dump(FILE *, const char *prefix, ssize_t idx) const override
Print some debugging information.
void initializeProperties()
Initialize all properties that have explicit initial values.
virtual ~SgAsmInstructionList()
Destructor.
void set_isa(SgAsmGenericFormat::InsSetArchitecture const &)
Property: Machine for which this header and its sections, etc.
SgAsmGenericSectionPtrList get_sections(bool include_holes=true) const
Returns list of all sections in the file (including headers, holes, etc).
virtual ~SgAsmUnaryExpression()
Destructor.
virtual void dump(FILE *, const char *prefix, ssize_t idx) const override
Print some debugging info.
void initializeProperties()
Initialize all properties that have explicit initial values.
virtual void dump(FILE *f, const char *prefix, ssize_t idx) const
Prints some debugging info.
Second generation starting Nov 2007.
SgAsmElfSymbolPtrList const & get_symbols() const
Property: Symbol list.
SgAsmCilMethodSpec()
Default constructor.
uint16_t e_relocs_offset
0x18 file address of relocation table.
void set_classes(SgUnsigned16List const &)
Property: classes.
The GNU symbol version definitions.
virtual ~SgAsmJvmMethod()
Destructor.
SectionType
Section types (host order).
virtual bool isUnknown() const override
Returns true if this instruction is the special "unknown" instruction.
std::string read_content_local_str(rose_addr_t rel_offset, bool strict=true)
Reads a string from the file.
SgAsmDwarfMacro()
Default constructor.
void set_symbols(SgAsmElfSymbolPtrList const &)
Property: Symbol list.
void set_instructions(SgUnsignedCharList const &)
Property: Instructions.
SgAsmGenericSectionPtrList get_segtab_sections()
Get the list of sections defined in the ELF Segment Table.
void add_symbol(const std::string &s)
Add a needed symbol to the import list for this DLL.
void initializeProperties()
Initialize all properties that have explicit initial values.
void initializeProperties()
Initialize all properties that have explicit initial values.
virtual ~SgAsmJvmSourceFile()
Destructor.
virtual unsigned get_anyKind() const override
Returns instruction kind for any architecture.
uint16_t const & get_MajorVersion() const
Property: MajorVersion.
uint16_t const & get_length() const
Property: length.
void initializeProperties()
Initialize all properties that have explicit initial values.
virtual bool isFunctionReturnFast(const std::vector< SgAsmInstruction * > &insns) override
Returns true if the specified basic block looks like a function return.
void initializeProperties()
Initialize all properties that have explicit initial values.
SgAsmJvmFieldTable()
Default constructor.
void initializeProperties()
Initialize all properties that have explicit initial values.
void initializeProperties()
Initialize all properties that have explicit initial values.
void update_rvasize_pairs()
Update all the RVA/Size pair info from the section to which it points.
void set_HeapSizes(uint8_t const &)
Property: A 1-byte constant indicating the index sizes of streams.
SgAsmCilUint32Heap * get_GuidHeap() const
indices to efficienty access the different heaps
SgAsmPESection()
Default constructor.
SgAsmByteOrder()
Default constructor.
virtual ~SgAsmNEEntryPoint()
Destructor.
void initializeProperties()
Initialize all properties that have explicit initial values.
virtual ~SgAsmElfSymverDefinedAux()
Destructor.
virtual bool isFunctionCallFast(const std::vector< SgAsmInstruction * > &insns, rose_addr_t *target, rose_addr_t *ret) override
Returns true if the specified basic block looks like a function call.
Direct 32 bit for general dynamic thread local data.
virtual ~SgAsmCilAssemblyRefOS()
Destructor.
SgAsmCommonSubExpression()
Default constructor.
void set_e_file_checksum(unsigned const &)
Property: File checksum.
bool is_basic_block() const
Determine if a block contains instructions.
void set_Culture(uint32_t const &)
Property: Culture.
bool const & get_uses_addend() const
Property: Whether entries in this section use the addend format.
virtual void unparse(std::ostream &) const override
Write object to a binary file.
SgAsmJvmMethodPtrList const & get_methods() const
Property: List of pointers to methods.
virtual std::string toString() const override
Convert a type to a string.
void set_st_info(unsigned char const &)
Property: Info.
void set_methods(SgAsmJvmMethodPtrList const &)
Property: List of pointers to methods.
SgAsmDwarfCompilationUnitList()
Default constructor.
SgAsmRiscOperation::RiscOperator const & get_riscOperator() const
Property: Low-level semantic operation.
int const & get_flags() const
Property: Flags.
SgAsmStringStorage *const & get_dont_free() const
Property: Space that should never be freed.
void remove_statement(SgAsmStatement *)
Erase the specified statement.
SgAsmCilFieldRVATable()
Default constructor.
void set_e_code_size(unsigned const &)
Property: Code size.
Microsoft Portable Executable Format.
virtual ~SgAsmDwarfCommonInclusion()
Destructor.
Preserve order after combining.
void set_FileTable(SgAsmCilFileTable *const &)
Property: FileTable.
void set_class_index(uint16_t const &)
Property: class_index.
uint32_t const & get_Name() const
Property: Name.
SgAsmCilTypeDef()
Default constructor.
rose_addr_t get_va() const
Return the absolute address if known.
Definition: Rva.C:145
CIL TypeSpec tables.
uint16_t const & get_MinorVersion() const
Property: MinorVersion.
void set_ilt_rva(rose_rva_t const &)
Property: Starting address of the ILT.
SgAsmRegisterReferenceExpression()
Default constructor.
void set_max_locals(uint16_t const &)
Property: max_locals.
virtual ~SgAsmJvmEnclosingMethod()
Destructor.
4.4.7 CONSTANT_Utf8_info table entry.
void set_Generation(uint16_t const &)
Property: Generation.
void * encode(Rose::BinaryAnalysis::ByteOrder::Endianness, SgAsmElfSymbol::Elf32SymbolEntry_disk *) const
Encode a symbol into disk format.
int64_t const & get_stackDelta() const
Property: Net effect of function on the stack pointer.
virtual ~SgAsmM68kInstruction()
Destructor.
void dump(FILE *, const char *prefix, ssize_t idx) const
Print some debugging info.
SgAsmPEExportDirectory()
Default constructor.
void set_entryPointToken(uint32_t const &)
Property: EntryPointToken.
SgAsmPERVASizePairList()
Default constructor.
virtual void dump(FILE *, const char *prefix, ssize_t idx) const override
Print some debugging info.
void initializeProperties()
Initialize all properties that have explicit initial values.
virtual Sawyer::Optional< rose_addr_t > branchTarget() override
Obtains the virtual address for a branching instruction.
void set_forwarder(SgAsmGenericString *)
Property: Forwarder.
bool const & get_neuter() const
Property: If set, refuse to unparse file.
void set_value(rose_addr_t const &)
Property: Symbol value.
virtual ~SgAsmDwarfConstant()
Destructor.
16:16 alias required (80x86 specific)
void initializeProperties()
Initialize all properties that have explicit initial values.
virtual ~SgAsmDwarfLexicalBlock()
Destructor.
void initializeProperties()
Initialize all properties that have explicit initial values.
uint32_t const & get_Name() const
Property: Name.
void set_shextrasz(unsigned long const &)
Property: shextrasz.
void initializeProperties()
Initialize all properties that have explicit initial values.
virtual ~SgAsmDwarfBaseType()
Destructor.
virtual ~SgAsmDOSExtendedHeader()
Destructor.
virtual rose_addr_t get_storage_size(const SgAsmStringStorage *) override
Returns the number of bytes required to store the string in the string table.
One entry of the ELF symbol version needed table.
SgAsmCilAssemblyProcessorTable()
Default constructor.
void initializeProperties()
Initialize all properties that have explicit initial values.
virtual ~SgAsmCilDeclSecurity()
Destructor.
CIL StandAloneSig node (II.22.36).
unsigned char e_ident_file_version
Format version number (same as e_version); must be 1.
unsigned const & get_e_user_major() const
Property: User major number.
SgAsmNEEntryPoint()
Default constructor.
SgAsmLEPageTable()
Default constructor.
virtual ~SgAsmJvmMethodTable()
Destructor.
SgAsmJvmConstantPoolEntry * parse(SgAsmJvmConstantPool *pool)
Initialize a constant pool entry by parsing the file.
SgAsmCoffStrtab()
Default constructor.
static void dump_containing_sections(FILE *, const std::string &prefix, rose_rva_t, const SgAsmGenericSectionPtrList &)
Prints info about offsets into known sections.
CIL Constant tables.
uint16_t const & get_e_maxalloc() const
Property: Max alloc.
Reason
Reasons why a basic block might have been assigned to a function.
Block is used for padding.
void initializeProperties()
Initialize all properties that have explicit initial values.
void set_abi(SgAsmGenericFormat::ExecABI const &)
Property: Application binary interface.
uint64_t const & get_offset() const
Property: Offset.
SgAsmPEExportDirectory *const & get_export_dir() const
Property: Export directory.
void initializeProperties()
Initialize all properties that have explicit initial values.
virtual void unparse(std::ostream &) const override
Write a section back to the file.
uint64_t const & get_metaData() const
Property: MetaData.
String associated with a binary file.
void set_sh_type(SgAsmElfSectionTableEntry::SectionType const &)
Property: sh_type.
virtual ~SgAsmElfSymverSection()
Destructor.
uint32_t const & get_HashValue() const
Property: HashValue.
virtual ~SgAsmDwarfEnumerationType()
Destructor.
Expression that adds two operands.
virtual void unparse(std::ostream &) const override
Write data to note section.
SgAsmElfSymverDefinedSection()
Default constructor.
SgAsmCilEventMap()
Default constructor.
void initializeProperties()
Initialize all properties that have explicit initial values.
uint32_t const & get_OSMajorVersion() const
Property: OSMajorVersion.
SgAsmJvmLineNumberEntry * parse(SgAsmJvmConstantPool *)
Initialize the object by parsing content from the class file.
void set_inner_class_info_index(uint16_t const &)
Property: inner_class_info_index.
void set_code(const char *const &)
Property: code.
virtual void dump(FILE *, const char *prefix, ssize_t idx) const
Print some debugging info.
SgAsmDwarfFormatLabel()
Default constructor.
MayReturn
Whether a function returns.
SgAsmJvmConstantValue()
Default constructor.
JVM SourceFile attribute.
size_t const & get_ilt_nalloc() const
Property: Bytes allocated in the file for the ILT.
SgCharList const & get_magic() const
Property: Optional magic number in file byte order.
SgAsmNEModuleTable()
Default constructor.
size_t read_content(rose_addr_t offset, void *dst_buf, rose_addr_t size, bool strict=true)
Reads data from a file.
static const rose_addr_t unallocated
Constant for addresses of unallocated strings.
virtual bool isFunctionCallFast(const std::vector< SgAsmInstruction * > &, rose_addr_t *target, rose_addr_t *retva) override
Returns true if the specified basic block looks like a function call.
virtual ~SgAsmCilMemberRefTable()
Destructor.
SgAsmCilManifestResourceTable *const & get_ManifestResourceTable() const
Property: ManifestResourceTable.
void set_kind(Rose::BinaryAnalysis::M68kInstructionKind const &)
Property: Instruction kind.
SgAsmCilField()
Default constructor.
unsigned const & get_st_shndx() const
Property: shndx.
void * encode(Rose::BinaryAnalysis::ByteOrder::Endianness, SgAsmElfSymverNeededAux::ElfSymverNeededAux_disk *) const
Encode this auxiliary record into a format that can be written to a file.
SgAsmLEEntryTable()
Default constructor.
const SgFileContentList & content()
Property: Entire file contents.
List of dynamic linking section entries.
Tag for popl in LDM TLS code.
rose_rva_t const & get_begin_rva() const
Property: Beginning relative virtual address.
virtual void unparse(std::ostream &) const override
Write the InnerClasses attribute to a binary file.
void initializeProperties()
Initialize all properties that have explicit initial values.
Contiguous region of a file.
void set_TypeName(uint32_t const &)
Property: TypeName.
SgAsmGenericString *const & get_name() const
Property: Name if not by ordinal.
SgAsmDwarfSubrangeType()
Default constructor.
SgAsmGenericSection * parse_rm_section(rose_addr_t max_offset=0)
Parses the DOS real-mode text+data section and adds it to the AST.
rose_addr_t write_uleb128(unsigned char *, rose_addr_t offset, uint64_t) const
Write an unsigned little-endian 128-bit value.
int const & get_adjustment() const
Property: Post-increment or pre-decrement amount.
virtual void dump(FILE *, const char *prefix, ssize_t idx) const override
Print some debugging info.
Direct 32 bit sign extended.
std::vector< SgAsmGenericDLL * > & get_dlls()
Vector of dynamically loaded libraries.
SgAsmCilPropertyMapTable *const & get_PropertyMapTable() const
Property: PropertyMapTable.
Section header is inactive.
virtual void dump(FILE *, const char *prefix, ssize_t idx) const override
Print some debugging info.
uint8_t const & get_Padding() const
Property: Padding.
void set_referenced_extents(AddressIntervalSet const &)
Property: Addresses referenced during parsing.
SgAsmExpression *const & get_lhs() const
Property: Left-hand side operand.
Direct 32 bit zero extended.
void initializeProperties()
Initialize all properties that have explicit initial values.
void initializeProperties()
Initialize all properties that have explicit initial values.
SgAsmDwarfNamelistItem()
Default constructor.
void set_sh_link(unsigned long const &)
Property: sh_link.
void set_flags(unsigned const &)
Property: Flags.
R8000 on a single chip; 32kB caches; out-of-order.
virtual bool isFunctionReturnSlow(const std::vector< SgAsmInstruction * > &) override
Returns true if the specified basic block looks like a function return.
A purpose other than any defined below.
void initializeProperties()
Initialize all properties that have explicit initial values.
virtual ~SgAsmDwarfMacroList()
Destructor.
virtual void dump(FILE *, const char *prefix, ssize_t idx) const override
Print some debugging info.
Represents a JVM method_info table/array.
JVM BootstrapMethod.
SgAsmInstruction()
Default constructor.
Blocks of function are not contiguous in memory.
virtual ~SgAsmElfSymverNeededAuxList()
Destructor.
SgAsmElfSymverDefinedAux()
Default constructor.
SgAsmCilClassLayout()
Default constructor.
virtual void unparse(std::ostream &) const override
Write constant value to a binary file.
ExecPurpose
General purpose of a binary executable file.
4.4.11 CONSTANT_Module_info table entry.
virtual ~SgAsmDwarfInlinedSubroutine()
Destructor.
SgAsmDwarfConstruct()
Default constructor.
SgAsmGenericSectionPtrList get_sections_by_rva(rose_addr_t rva) const
Find sections by address.
SgAsmCilFieldTable()
Default constructor.
int const & get_id() const
Property: Non-unique section ID or negative.
void set_MethodImplTable(SgAsmCilMethodImplTable *const &)
Property: MethodImplTable.
static bool is_JVM(SgAsmGenericFile *)
Returns true if a cursory look at the file indicates that it could be a JVM class file...
uint32_t const & get_Flags() const
Property: Flags.
SgAsmBinaryDivide()
Default constructor.
This block created because it seems to belong to the function although CFG traversal did not find it...
void set_Signature(uint32_t const &)
Property: Signature.
uint32_t const & get_HashValue() const
Property: HashValue.
void set_flags(int const &)
Property: Flags.
uint32_t vna_name
Offset (in bytes) to strings table to name string.
Section is member of a group.
uint32_t const & get_Type() const
Property: Type.
void set_e_header_paragraphs(uint16_t const &)
Property: Number of header paragraphs.
void set_strtab(SgAsmElfStrtab *const &)
Property: String table.
virtual ~SgAsmLEEntryPoint()
Destructor.
uint16_t const & get_signature_index() const
Property: signature_index.
SgAsmJvmNode()
Default constructor.
SgAsmDwarfVariable()
Default constructor.
virtual bool isFunctionReturnSlow(const std::vector< SgAsmInstruction * > &insns) override
Returns true if the specified basic block looks like a function return.
virtual ~SgAsmRiscOperation()
Destructor.
void set_e_shnum(unsigned long const &)
Property: shnum.
SgAsmGenericSectionPtrList get_sections_by_va(rose_addr_t va) const
Find sections by address.
virtual void unparse(std::ostream &) const override
Write a section back to the file.
SgAsmBinaryMultiply()
Default constructor.
uint32_t const & get_hi_bytes() const
Properties: hi_bytes.
uint16_t const & get_name_index() const
Property: name_index.
SgAsmDwarfVolatileType()
Default constructor.
virtual ~SgAsmPEImportDirectory()
Destructor.
void initializeProperties()
Initialize all properties that have explicit initial values.
virtual std::string description() const override
Return a description of this instruction.
SgAsmDwarfTemplateTypeParameter()
Default constructor.
virtual ~SgAsmElfDynamicEntryList()
Destructor.
static void initDiagnostics()
Initialize diagnostic streams.
void set_short_name(const std::string &)
Property: Abbreviated name.
void set_main_class_index(uint16_t const &)
Property: main_class_index.
void initializeProperties()
Initialize all properties that have explicit initial values.
void set_RevisionNumber(uint16_t const &)
Property: RevisionNumber.
void set_Processor(uint32_t const &)
Property: Processor.
SgAsmElfNoteEntry()
Default constructor.
void remove_statement(SgAsmStatement *statement)
Erases statement from statement list.
void set_header(SgAsmGenericHeader *const &)
Property: File header that owns this section.
void set_nameptr_n(size_t const &)
Property: Nameptr_n.
uint16_t e_phnum
Number of program headers, or PN_XNUM, or zero.
virtual void dump(FILE *, const char *prefix, ssize_t idx) const override
Print some debugging info.
void set_export_dir(SgAsmPEExportDirectory *const &)
Property: Export directory.
void set_operandList(SgAsmOperandList *const &)
Property: AST node that holds all operands.
SgAsmCilUint8Heap * get_UsHeap() const
indices to efficienty access the different heaps
void * encode(Rose::BinaryAnalysis::ByteOrder::Endianness, SgAsmElfSymverDefinedAux::ElfSymverDefinedAux_disk *) const
Convert this object into the disk format record to be written back to the Symbol Version Definition T...
SgAsmOperandList()
Default constructor.
void initializeProperties()
Initialize all properties that have explicit initial values.
size_t index_of(SgAsmElfSymbol *)
Given a symbol, return its index in this symbol table.
SgAsmDwarfImportedUnit()
Default constructor.
SgAsmElfSymbol::ElfSymBinding get_elf_binding() const
Returns binding as an enum constant.
void set_Flags(uint16_t const &)
Property: Flags.
rose_addr_t offset
Byte offset into section (or file).
void set_AssemblyRefOSTable(SgAsmCilAssemblyRefOSTable *const &)
Property: AssemblyRefOSTable.
void update_from_rm_section()
Update DOS header with data from real-mode section.
void set_data(SgFileContentList const &)
Property: Contents of the file.
SgAsmGenericSymbolList()
Default constructor.
SgAsmGenericSectionPtrList get_sections_by_id(int id) const
Returns sections having specified ID across all headers, including headers and holes.
unsigned const & get_e_data_size() const
Property: Data size.
virtual SgAsmElfRelocSection * parse() override
Parse an existing ELF Rela Section.
CIL DeclSecurity node (II.22.11).
SgAsmCilGenericParamConstraintTable *const & get_GenericParamConstraintTable() const
Property: GenericParamConstraintTable.
void set_NumberOfRows(std::vector< uint32_t > const &)
Property: A vector indicating how many rows the present tables contain.
virtual void dump(FILE *, const char *prefix, ssize_t idx) const
Print some debugging information.
virtual ~SgAsmStaticData()
Destructor.
void set_Implementation(uint32_t const &)
Property: Implementation.
virtual bool reallocate() override
Pre-unparsing adjustments.
void set_rva(rose_addr_t const &)
Property: RVA.
rose_addr_t get_mapped_preferred_va() const
Virtual address where section prefers to be mapped.
void set_reference_index(uint16_t const &)
Property: reference_index.
uint16_t ExportOrdinal_disk
The PE Export Ordinal Table is an array of nameptr_n (yes) 2-byte indices into the Export Address Tab...
SgAsmElfSymverDefinedEntry()
Default constructor.
void set_abi_version(unsigned const &)
Property: Application binary interface version.
void initializeProperties()
Initialize all properties that have explicit initial values.
Intel i860 family; 1989-mid 90's; RISC VLIW.
SgAsmGenericFile *const & get_file() const
Property: File to which this section belongs.
virtual ~SgAsmCoffSymbolTable()
Destructor.
SgAsmGenericSection *const & get_relocs() const
Property: Section containing relocation information.
SgAsmPEImportItemList *const & get_imports() const
Property: List of imports.
double const & get_code_likelihood() const
Property: Likelihood that this block represents real instructions.
uint32_t const & get_Value() const
Property: Value.
void initializeProperties()
Initialize all properties that have explicit initial values.
virtual ~SgAsmElfRelocEntryList()
Destructor.
void initializeProperties()
Initialize all properties that have explicit initial values.
void set_name(SgAsmGenericString *name)
Property: Note name.
size_t const & get_version() const
Property: Version.
Microsft Linear Executable format.
JVM ModuleMainClass attribute.
Expression representing a (no-op) unary plus operation.
CIL TypeRef tables.
virtual ~SgAsmDwarfLabel()
Destructor.
uint32_t const & get_Name() const
Property: Name.
Base class for references to a machine register.
void initializeProperties()
Initialize all properties that have explicit initial values.
SgAsmDwarfUpcStrictType()
Default constructor.
SgAsmJvmStackMapVerificationTypePtrList const & get_stack() const
Property: List of verification_type_info stack variables.
SgAsmNERelocTable()
Default constructor.
size_t reallocate_iats(rose_rva_t start_at)
Reallocate space for all Import Address Table.
virtual void finish_parsing() override
Finish initializing the section entries.
SgAsmCilFieldLayoutTable *const & get_FieldLayoutTable() const
Property: FieldLayoutTable.
CIL AssemblyRef tables.
virtual bool terminatesBasicBlock() override
Determines if this instruction normally terminates a basic block.
void set_vmajor(unsigned const &)
Property: VMajor.
Flag
Individual bit flags for this floating-point type.
void set_time(time_t const &)
Property: Time.
void set_VersionPadding(uint32_t const &)
Property: Padding to next 4-byte boundary.
virtual ~SgAsmCilConstant()
Destructor.
SgAsmCilAssemblyOSTable()
Default constructor.
unsigned const & get_sh_name() const
Property: sh_name.
virtual void unparse(std::ostream &) const override
Write ELF contents back to a file.
void set_e_stack_reserve_size(unsigned const &)
Property: Stack reserve size.
virtual void dump(FILE *, const char *prefix, ssize_t idx) const override
Print some debugging information.
void initializeProperties()
Initialize all properties that have explicit initial values.
SgAsmVectorType()
Default constructor.
void set_PropertyMapTable(SgAsmCilPropertyMapTable *const &)
Property: PropertyMapTable.
Expression that performs a right rotate.
uint16_t e_ss
0x0e initial value of SS register relative to program load segment.
This function may return or not, depending on how it is called.
int64_t get_relativeValue() const
Get relative value.
virtual ~SgAsmGenericHeader()
Destructor.
void set_entries(SgAsmJvmConstantPoolEntryPtrList const &)
Property: List of constant pool entries.
bool is_function_call(rose_addr_t &target_va, rose_addr_t &return_va)
Returns true if basic block appears to be a function call.
virtual ~SgAsmCilAssemblyRef()
Destructor.
static const std::string ID_GUID_HEAP
Define constant strings for the known stream types.
SgAsmCilModule()
Default constructor.
void set_Type(uint32_t const &)
Property: Type.
virtual SgAsmJvmConstantPool * parse() override
Parses a JVM Constant Pool.
Auxiliary info for needed symbol version.
virtual Sawyer::Optional< rose_addr_t > branchTarget() override
Obtains the virtual address for a branching instruction.
void initializeProperties()
Initialize all properties that have explicit initial values.
void initializeProperties()
Initialize all properties that have explicit initial values.
std::string rvasize_pair_name(PairPurpose, const char **short_name)
Convert an RVA/Size Pair index number into a section name.
virtual void dump(FILE *, const char *prefix, ssize_t idx) const override
Print some debugging information.
void set_e_rva(rose_rva_t const &)
Property: RVA.
SgAsmCilCustomAttribute()
Default constructor.
De-normalized signifand when exponent field is clear.
SgAsmGenericString *const & get_name() const
Property: Name.
virtual size_t get_size() const
Returns the size of an instruction in bytes.
Instruction basic block.
virtual void dump(FILE *, const char *prefix, ssize_t idx) const override
Print some debugging information.
Base class for all binary analysis IR nodes.
SgAsmBinaryLsr()
Default constructor.
uint32_t const & get_Implementation() const
Property: Implementation.
virtual ~SgAsmPowerpcInstruction()
Destructor.
void set_Flags(uint16_t const &)
Property: Flags.
SgAsmGenericSection * get_best_section_by_va(rose_addr_t va, bool use_preferred, size_t *nfound=0) const
Like SgAsmGenericFile::get_best_section_by_va() except considers only sections defined in this header...
rose_addr_t const & get_st_name_offset() const
Property: Symbol name offset.
void initializeProperties()
Initialize all properties that have explicit initial values.
void set_Class(uint32_t const &)
Property: Class.
void initializeProperties()
Initialize all properties that have explicit initial values.
void set_name_index(uint16_t const &)
Property: name_index.
SgAsmDwarfCompilationUnitList *const & get_dwarf_info() const
Property: DWARF debugging hiearchy.
std::string const & get_mnemonic() const
Property: Instruction mnemonic string.
void set_exception_index_table(SgUnsigned16List const &)
Property: exception_index_table.
uint16_t const & get_e_nrelocs() const
Property: Number of relocations.
virtual ~SgAsmBinaryLsr()
Destructor.
size_t get_size() const
Property: Size of static data in bytes.
void set_r_addend(rose_addr_t const &)
Property: Addend.
virtual ~SgAsmCilNestedClass()
Destructor.
SgAsmCilInterfaceImplTable *const & get_InterfaceImplTable() const
Property: InterfaceImplTable.
virtual void dump(FILE *, const char *prefix, ssize_t idx) const override
Print some debugging info.
void set_offset(rose_addr_t const &)
Property: Location of string in storage table.
uint16_t e_shnum
Number of section headers, or zero for extended entries.
Rose::BinaryAnalysis::X86RepeatPrefix const & get_repeatPrefix() const
Property: An enum constant describing whether the instruction is repeated.
virtual ~SgAsmJvmLineNumberTable()
Destructor.
List of entries for the ELF symbol version definition table.
void set_d_val(rose_rva_t const &)
Property: Value.
void set_e_res3(unsigned const &)
Property: Rerserved area 3.
virtual void unparse(std::ostream &) const override
Write attribute to a binary file.
by PMC-Sierra; 256kB L2 and optional L3
rose_addr_t get_orig_size() const
Returns original size of file, based on file system.
virtual void dump(FILE *, const char *prefix, ssize_t idx) const override
Print some debugging info.
SgAsmMipsInstruction()
Default constructor.
SgAsmGenericStrtab * get_strtab()
Returns the string table that holds this string.
One entry of an ELF relocation table.
virtual ~SgAsmCilInterfaceImpl()
Destructor.
void set_e_maxalloc(uint16_t const &)
Property: Max alloc.
void updateBitVector()
Update bit vector from native representation.
void initializeProperties()
Initialize all properties that have explicit initial values.
SgAsmStatement()
Default constructor.
SgAsmJvmCodeAttribute()
Default constructor.
Expression that represents an update to a storage location.
void remove_section(SgAsmGenericSection *)
Removes a secton from the header's section list.
void set_registers(SgAsmRegisterReferenceExpressionPtrList const &)
Property: List of registers.
virtual ~SgAsmDwarfTypedef()
Destructor.
void set_data_alignment_factor(int64_t const &)
Property: Data alignment factor.
SgUnsignedCharList const & get_aux_data() const
Property: Auxilliary data.
SgAsmGenericSectionPtrList const & get_sections() const
Property: List of section pointers.
void set_bootstrap_arguments(SgUnsigned16List const &)
Property: bootstrap_arguments.
void set_symbols(SgAsmCoffSymbolList *const &)
Property: List of symbols.
SgAsmGenericHeaderPtrList const & get_headers() const
Property: List of file header nodes.
virtual ~SgAsmElfSegmentTableEntryList()
Destructor.
uint16_t const & get_name_index() const
Property: name_index.
4.4.2 CONSTANT_Fieldref_info, CONSTANT_Methodref_info, and CONSTANT_InterfaceMethodref_info table ent...
void set_size(rose_addr_t const &)
Property: Symbol size in bytes.
virtual void unparse(std::ostream &) const override
Write section back to disk.
M68kInstructionKind
M68k instruction types.
32-bit, integrated FPU mated with 88200 MMU and cache controller
Function or other code.
int const & get_addr_encoding() const
Property: Address encoding.
virtual void unparse(std::ostream &) const override
Write enclosing method to a binary file.
virtual ~SgAsmJvmFileHeader()
Destructor.
virtual ~SgAsmDwarfWithStmt()
Destructor.
SgUnsignedCharList read_content_local_ucl(rose_addr_t rel_offset, rose_addr_t size)
Reads content of a section and returns it as a container.
void set_target_section(SgAsmElfSection *const &)
Property: Section targeted by these relocations.
void initializeProperties()
Initialize all properties that have explicit initial values.
SgAsmCilAssemblyProcessorTable *const & get_AssemblyProcessorTable() const
Property: AssemblyProcessorTable.
Represents the file header of an ELF binary container.
uint32_t const & get_PropertyList() const
Property: PropertyList.
void initializeProperties()
Initialize all properties that have explicit initial values.
virtual std::string description() const override
Return a description of this instruction.
void set_e_sp(uint16_t const &)
Property: SP.
SgAsmJvmStackMapVerificationType()
Default constructor.
void initializeProperties()
Initialize all properties that have explicit initial values.
User-defined algorithm.
virtual ~SgAsmCoffSymbol()
Destructor.
SgAsmPEFileHeader()
Default constructor.
virtual ~SgAsmExprListExp()
Destructor.
4.4.8 CONSTANT_MethodHandle_info table entry.
void set_MethodDeclaration(uint32_t const &)
Property: MethodDeclaration.
virtual ~SgAsmBinaryAdd()
Destructor.
void set_cpool_index(uint16_t const &)
Property: cpool_index.
virtual bool terminatesBasicBlock() override
Determines if this instruction normally terminates a basic block.
uint16_t const & get_MajorVersion() const
Property: MajorVersion.
virtual ~SgAsmLERelocTable()
Destructor.
uint16_t const & get_class_index() const
Property: class_index.
SgAsmDwarfCommonBlock()
Default constructor.
virtual ~SgAsmDwarfPointerType()
Destructor.
virtual void unparse(std::ostream &) const override
Write a section back to the file.
void set_e_nrelocs(uint16_t const &)
Property: Number of relocations.
void initializeProperties()
Initialize all properties that have explicit initial values.
void set_import_directories(SgAsmPEImportDirectoryList *const &)
Property: List of import directories.
Rose::BinaryAnalysis::X86InstructionSize const & get_addressSize() const
Property: An enum describing the x86 address size.
virtual ~SgAsmElfFileHeader()
Destructor.
uint32_t vd_next
Offset (in bytes) to next verdef entry.
SgAsmGenericSymbol::SymbolType const & get_type() const
Property: Symbol type.
void set_augmentation_data(SgUnsignedCharList const &)
Property: Augmentation data.
unsigned const & get_res1() const
Property: Reserved aread #1.
void serialize(std::ostream &output, Graph &graph)
Serialize a graph into a stream of bytes.
Definition: GraphUtility.h:17
void parse(std::vector< uint8_t > &buf, size_t startOfMetaData) override
}@
SgAsmDwarfImportedDeclaration()
Default constructor.
Contains nul-terminated strings.
int find_import_item(const SgAsmPEImportItem *item, int hint=0) const
Find an import item in an import directory.
virtual SgAsmElfEHFrameSection * parse() override
Initialize by parsing a file.
virtual ~SgAsmByteOrder()
Destructor.
unsigned const & get_e_oeminfo() const
Property: OEM info.
void set_string_index(uint16_t const &)
Property: string_index.
virtual ~SgAsmPEImportSection()
Destructor.
virtual void dump(FILE *, const char *prefix, ssize_t idx) const
Print some debugging info.
void set_lhs(SgAsmExpression *const &)
Property: Left-hand side operand.
SgAsmLEEntryPoint()
Default constructor.
Section hold thread-local data.
void initializeProperties()
Initialize all properties that have explicit initial values.
virtual void unparse(std::ostream &) const
Write a section back to the file.
virtual bool isFunctionCallSlow(const std::vector< SgAsmInstruction * > &, rose_addr_t *target, rose_addr_t *ret) override
Returns true if the specified basic block looks like a function call.
void set_managedNativeHeader(uint64_t const &)
Property: ManagedNativeHeader.
void set_ModuleRefTable(SgAsmCilModuleRefTable *const &)
Property: ModuleRefTable.
unsigned const & get_reason() const
Property: Reasons this block was created.
void set_metaData(uint64_t const &)
Property: MetaData.
Portable Executable Import Section.
void initializeProperties()
Initialize all properties that have explicit initial values.
virtual ~SgAsmDwarfCatchBlock()
Destructor.
void set_mapped_rperm(bool const &)
Property: Whether mapped with read permission.
virtual ~SgAsmCilFieldMarshal()
Destructor.
unsigned const & get_coff_line_nums() const
Property: COFF line numbers.
uint32_t const & get_ReservedAlwaysZero() const
Property: 4 reserved bytes.
void set_vminor(unsigned const &)
Property: VMinor.
void initializeProperties()
Initialize all properties that have explicit initial values.
Information that marks the file in some way.
void set_code_alignment_factor(uint64_t const &)
Property: Code alignment factor.
void set_forwarder_chain(unsigned const &)
Property: Forwarder chain.
No type or type is unknown.
void set_bit_offset(unsigned short const &)
Property: Where this expression is encoded within the instruction.
Rose::BinaryAnalysis::JvmInstructionKind const & get_kind() const
Property: Instruction kind.
void initializeProperties()
Initialize all properties that have explicit initial values.
virtual ~SgAsmExpression()
Destructor.
SgAsmBinaryConcat()
Default constructor.
void set_is_dynamic(bool const &)
Property: Whether this section represents dynamic linking symbols.
Relocation entries with explicit addends (e.g., Elf32_Rela types)
void set_RevisionNumber(uint16_t const &)
Property: RevisionNumber.
CIL InterfaceImpl tables.
SgAsmCilMetadata * get_CodedMetadataNode(std::uint32_t refcode, ReferenceKind knd) const
looks up the node associated with the coded index refcode in the metadata tables under the assumption...
uint16_t const & get_Number() const
Property: Number.
SgAsmJvmConstantPoolEntry::Kind const & get_tag() const
Property: tag.
void set_iat_written(bool const &)
Property: Whether the resolved address has been written to the memory map.
void * encode(Rose::BinaryAnalysis::ByteOrder::Endianness, SgAsmElfSymverNeededEntry::ElfSymverNeededEntry_disk *) const
Encode object to disk representation.
virtual SgAsmJvmFileHeader * parse() override
Parse header from file.
void initializeProperties()
Initialize all properties that have explicit initial values.
SgAsmJvmInnerClasses()
Default constructor.
Section is conforming for code (80x86 specific)
void initializeProperties()
Initialize all properties that have explicit initial values.
void initializeProperties()
Initialize all properties that have explicit initial values.
void initializeProperties()
Initialize all properties that have explicit initial values.
SgAsmExpression *const & get_rhs() const
Property: Right-hand side operand.
SgAsmUnaryRrx()
Default constructor.
virtual bool isFunctionCallSlow(const std::vector< SgAsmInstruction * > &, rose_addr_t *target, rose_addr_t *ret) override
Returns true if the specified basic block looks like a function call.
SgAsmValueExpression *const & get_unfolded_expression_tree() const
Property: Alternate expression without constant folding.
virtual ~SgAsmJvmCodeAttribute()
Destructor.
SgAsmLEFileHeader()
Default constructor.
virtual ~SgAsmCilParamTable()
Destructor.
virtual SgAsmStringStorage * create_storage(rose_addr_t offset, bool shared) override
Creates the storage item for the string at the specified offset.
void set_storage(SgAsmStringStorage *const &)
Property: Storage area for this string.
void set_MajorVersion(uint16_t const &)
Property: MajorVersion.
static const std::string ID_METADATA_HEAP
Define constant strings for the known stream types.
uint32_t const & get_OSMinorVersion() const
Property: OSMinorVersion.
uint16_t const & get_e_total_pages() const
Property: Total number of pages.
unsigned const & get_e_subsys_minor() const
Property: Subsystem minor number.
Block was added by a third pass of CFG analysis.
void set_constantvalue_index(uint16_t const &)
Property: constantvalue_index.
rose_addr_t const & get_align() const
Property: Alignment.
SgAsmCilMemberRefTable()
Default constructor.
uint16_t const & get_NumberOfStreams() const
Property: Reserved space.
void set_name_and_type_index(uint16_t const &)
Property: name_and_type_index.
void initializeProperties()
Initialize all properties that have explicit initial values.
uint32_t const & get_NativeType() const
Property: NativeType.
virtual ~SgAsmCilStandAloneSigTable()
Destructor.
SgSymbol *const & get_symbol() const
Property: Symbol corresponding to this expression.
void initializeProperties()
Initialize all properties that have explicit initial values.
List of generic file headers.
SgAsmExpression *const & get_segment() const
Property: Optional memory segment register.
ReferenceKind
reference kinds in the metadata tables
void set_EnclosingClass(uint32_t const &)
Property: EnclosingClass.
void unfill_holes()
Deletes "hole" sections.
virtual void dump(FILE *, const char *prefix, ssize_t idx) const override
Print some debugging information.
SgAsmPEImportItem()
Default constructor.
virtual void unparse(std::ostream &) const override
Write a section back to the file.
void set_prh_arg(unsigned const &)
Property: PRH argument.
uint16_t const & get_sourcefile_index() const
Property: sourcefile_index.
SgAsmElfEHFrameEntryCIList()
Default constructor.
void set_hash(uint32_t const &)
Property: Hash.
virtual ~SgAsmBasicString()
Destructor.
std::string const & get_st_name() const
Property: Symbol name.
void set_stack(SgAsmJvmStackMapVerificationTypePtrList const &)
Property: List of verification_type_info stack variables.
void set_entries(SgAsmJvmStackMapFramePtrList const &)
Property: List of stack map table entries/frames.
CIL AssemblyRef node (II.22.5).
uint32_t const & get_Parent() const
Property: Parent.
void set_Version(std::string const &)
Property: Version string.
Base class for machine instructions.
void set_AssemblyRefOS(uint32_t const &)
Property: AssemblyRefOS.
void set_ParamList(uint32_t const &)
Property: ParamList.
virtual void unparse(std::ostream &) const override
Write field table to a binary file.
uint32_t const & get_Parent() const
Property: Parent.
virtual ~SgAsmElfSymverDefinedAuxList()
Destructor.
X86BranchPrediction
Intel x86 branch prediction types.
Collection of streams.
Definition: Message.h:1606
void initializeProperties()
Initialize all properties that have explicit initial values.
void initializeProperties()
Initialize all properties that have explicit initial values.
void set_TypeName(uint32_t const &)
Property: TypeName.
uint32_t ExportAddress_disk
The PE Export Address Table is an array of expaddr_n 4-byte RVAs.
void set_e_lmajor(unsigned const &)
Property: lmajor.
SgAsmRegisterReferenceExpressionPtrList const & get_registers() const
Property: List of registers.
uint16_t e_last_page_size
0x02 bytes used on last page of file (1 page == 512 bytes); zero implies if last page is full...
low-cost version of R4000 with 32-bit external bus
void set_access_flags(uint16_t const &)
Property: access_flags.
SgAsmPESectionTableEntry()
Default constructor.
Segment contains the segment table itself (program header array)
CIL Managed Code section.
void set_addr_encoding(int const &)
Property: Address encoding.
Section table entry.
SgAsmGenericSymbol::SymbolDefState const & get_def_state() const
Property: Definition state.
unsigned char const & get_e_ident_data_encoding() const
Property: Data encoding.
R14000 + increased freq, more L1, smaller die.
SgAsmCilStandAloneSigTable *const & get_StandAloneSigTable() const
Property: StandAloneSigTable.
virtual ~SgAsmCoffStrtab()
Destructor.
void set_e_res1(unsigned const &)
Property: Rerserved area 1.
void initializeProperties()
Initialize all properties that have explicit initial values.
Byte order specification.
virtual void unparse(std::ostream &) const override
Write inner classes entry to a binary file.
unsigned const & get_e_heap_reserve_size() const
Property: Heap reserve size.
virtual bool terminatesBasicBlock() override
Determines if this instruction normally terminates a basic block.
void initializeProperties()
Initialize all properties that have explicit initial values.
uint32_t const & get_NamePadding() const
Property: Name of the byte stream.
SgAsmElfSegmentTableEntry()
Default constructor.
SgAsmGenericString *const & get_name() const
Property: Name.
uint64_t const & get_augmentation_data_length() const
Property: Augmentation data length.
static Rose::BinaryAnalysis::RegisterDictionaryPtr registersForWidth(size_t)
Return the register dictionary for an x86 architecture.
SgAsmDwarfCondition()
Default constructor.
SgAsmCilModuleRefTable *const & get_ModuleRefTable() const
Property: ModuleRefTable.
AddressSpace
Section modification functions for shift_extend.
void free_all_strings(bool blow_away_holes=false)
Free all strings so they will be reallocated later.
SgAsmElfStrtab *const & get_strtab() const
Property: String table.
Rose::BinaryAnalysis::ByteOrder::Endianness const & get_sex() const
Property: Byte order.
SgAsmInterpretation()
Default constructor.
virtual void dump(FILE *, const char *prefix, ssize_t idx) const override
Dump debugging information.
SgAsmDwarfFileType()
Default constructor.
rose_addr_t get_mapped_size() const
Property: Mapped size.
uint16_t const & get_class_index() const
Property: class_index.
void set_e_cpu_type(unsigned const &)
Property: CPU type.
SgAsmCilStandAloneSigTable()
Default constructor.
SgAsmCilNestedClass()
Default constructor.
Represents an entry in a JVM constant pool.
virtual ~SgAsmCilCustomAttributeTable()
Destructor.
SgAsmCilDeclSecurityTable *const & get_DeclSecurityTable() const
Property: DeclSecurityTable.
SgAsmBlock * get_entry_block() const
Function entry basic block.
void initializeProperties()
Initialize all properties that have explicit initial values.
virtual ~SgAsmCilEvent()
Destructor.
SgAsmDwarfArrayType()
Default constructor.
bool const & get_mapped_wperm() const
Property: Whether mapped with write permission.
uint32_t vn_next
Offset (in bytes) to next verneed entry.
SgAsmElfSymbol()
Default constructor.
uint32_t d_tag
Entry type, one of the DT_* constants.
virtual ~SgAsmBinaryConcat()
Destructor.
virtual ~SgAsmDwarfTemplateValueParameter()
Destructor.
void initializeProperties()
Initialize all properties that have explicit initial values.
void set_e_oeminfo(unsigned const &)
Property: OEM info.
16 bit sign extended pc relative
void set_rhs(SgAsmExpression *const &)
Property: Right-hand side operand.
Offset relative to static TLS block.
SgAsmSynthesizedFieldDeclaration()
Default constructor.
SgAsmDwarfCatchBlock()
Default constructor.
uint32_t p_align
0x2c alignment for file and memory (0,1=>none); power of two
uint16_t const & get_attribute_name_index() const
Property: attribute_name_index.
void initializeProperties()
Initialize all properties that have explicit initial values.
SgRVAList const & get_entry_rvas() const
Property: Code entry point wrt base virtual address.
virtual ~SgAsmCilAssemblyOS()
Destructor.
void set_attribute_name_index(uint16_t const &)
Property: attribute_name_index.
SgAsmJvmField()
Default constructor.
SgUnsignedCharList const & get_augmentation_data() const
Property: Augmentation data.
CIL FieldRVA node (II.22.18).
std::list< uint16_t > const & get_interfaces() const
Property: Interfaces.
void set_e_ident_file_class(unsigned char const &)
Property: File class.
rose_addr_t const & get_rva() const
Property: RVA.
void set_st_type(unsigned const &)
Property: Symbol type constant.
virtual ~SgAsmCilAssemblyTable()
Destructor.
SgAsmCilNestedClassTable()
Default constructor.
Motorola m88k family (not very popular)
SgAsmElfRelocSection()
Default constructor.
virtual void finish_parsing() override
Update section pointers for locally-bound symbols.
OS/2 LX (Windows 9x VxD device drivers, extension of LE).
SgAsmCilTypeRefTable()
Default constructor.
void set_MemberForwarded(uint32_t const &)
Property: MemberForwarded.
bool normalizeOperands()
Rewrite certain addressing modes for operands.
void initializeProperties()
Initialize all properties that have explicit initial values.
virtual void dump(FILE *, const char *prefix, ssize_t idx) const override
Print some debugging info.
Offset in static TLS block.
unsigned long const & get_sh_info() const
Property: sh_info.
RiscOperator
One enum per RISC operator.
Rose::BinaryAnalysis::RegisterDescriptor const & get_descriptor() const
Property: Descriptor for accessed register.
virtual ~SgAsmDirectRegisterExpression()
Destructor.
unsigned const & get_e_section_align() const
Property: Section alignment.
uint32_t st_name
Name offset into string table.
virtual void dump(FILE *, const char *prefix, ssize_t idx) const
Print some debugging information.
void initializeProperties()
Initialize all properties that have explicit initial values.
rose_addr_t size
Number of bytes of attempted write.
void set_low_bytes(uint32_t const &)
Properties: low_bytes.
virtual void dump(FILE *, const char *prefix, ssize_t idx) const override
Print some debugging information.
virtual void unparse(std::ostream &) const override
Write a section back to the file.
unsigned long const & get_shextrasz() const
Property: shextrasz.
Rose::BinaryAnalysis::X86InstructionSize const & get_operandSize() const
Property: An enum describing the x86 instruction operand size.
void initializeProperties()
Initialize all properties that have explicit initial values.
virtual bool reallocate() override
Update prior to unparsing.
void initializeProperties()
Initialize all properties that have explicit initial values.
virtual ~SgAsmJvmLineNumberEntry()
Destructor.
CIL AssemblyProcessor node (II.22.4).
virtual void destructorHelper() override
This gets called by all Rosebud-generated destructors.
Base class for scalar types.
void set_immediate_dominator(SgAsmBlock *const &)
Property: Holds the immediate dominator block in the control flow graph.
uint64_t d_tag
Entry type, one of the DT_* constants.
CIL NestedClass node (II.22.32).
void set_dll_name(SgAsmGenericString *const &)
Property: Name of library from which to import.
Three or four args depending on whether segment reg is present.
CIL FieldMarshal tables.
SgAsmBinarySubtract()
Default constructor.
void set_PublicKey(uint32_t const &)
Property: PublicKey.
void initializeProperties()
Initialize all properties that have explicit initial values.
void initializeProperties()
Initialize all properties that have explicit initial values.
unsigned const & get_st_type() const
Property: Symbol type constant.
SgAsmCilInstruction()
Default constructor.
Represents a JVM exception_info table/array.
uint16_t const & get_Semantics() const
Property: Semantics.
void set_Name(uint32_t const &)
Property: Name.
void initializeProperties()
Initialize all properties that have explicit initial values.
int64_t get_signedValue() const
Returns the current absolute value (base+offset) as a signed value.
Offset relative to TLS block.
SgAsmInstructionList()
Default constructor.
virtual ~SgAsmCilAssemblyRefTable()
Destructor.
void initializeProperties()
Initialize all properties that have explicit initial values.
void set_length(uint16_t const &)
Property: length.
SgAsmGenericSymbol::SymbolBinding const & get_binding() const
Property: Symbol binding.
uint32_t const & get_Name() const
Property: Name.
SgAsmCilGenericParam()
Default constructor.
void set_Type(uint32_t const &)
Property: Type.
uint32_t const & get_OSPlatformID() const
Property: OSPlatformID.
SgAsmElfRelocEntryList *const & get_entries() const
Property: List of entries.
List of expression nodes.
SgAsmDwarfInformation()
Default constructor.
void set_pairs(SgAsmPERVASizePairPtrList const &)
Property: List of pointers to other nodes.
SgUnsignedCharList const & get_payload() const
Property: Note name.
virtual SgAsmCliHeader * parse() override
Initialize the object by parsing content from the PE file.
SgAsmCilGenericParamConstraint()
Default constructor.
virtual ~SgAsmStringStorage()
Destructor.
virtual ~SgAsmCilFieldRVA()
Destructor.
virtual void unparse(std::ostream &) const override
Unparse headers and all they point to.
virtual bool isFunctionReturnFast(const std::vector< SgAsmInstruction * > &) override
Returns true if the specified basic block looks like a function return.
SgAsmIntegerType()
Default constructor.
void set_access_flags(uint16_t const &)
Property: Access flags.
virtual SgAsmElfFileHeader * parse() override
Parse header from file.
virtual void unparse(std::ostream &) const override
Write module main class to a binary file.
A contiguous range of values.
Definition: rangemap.h:50
bool gradualUnderflow() const
Property: Whether type has gradual underflow.
Anything other than values below.
std::string const & get_Version() const
Property: Version string.
SgAsmCilEventMapTable()
Default constructor.
virtual ~SgAsmDwarfSubprogram()
Destructor.
SgAsmDwarfCompilationUnit()
Default constructor.
SgAsmCilAssembly()
Default constructor.
virtual ~SgAsmElfSymbol()
Destructor.
SgAsmGenericFilePtrList get_files() const
Returns a list of all files referenced by an interpretation.
void initializeProperties()
Initialize all properties that have explicit initial values.
size_t read_content_local(rose_addr_t rel_offset, void *dst_buf, rose_addr_t size, bool strict=true)
Reads data from a file.
void initializeProperties()
Initialize all properties that have explicit initial values.
virtual void unparse(std::ostream &) const override
Write method to a binary file.
virtual ~SgAsmDwarfCommonBlock()
Destructor.
SgAsmGenericFormat()
Default constructor.
void initializeProperties()
Initialize all properties that have explicit initial values.
Expression that performs an arithmetic, sign-bit preserving right shift.
SgAsmCilAssemblyRefProcessorTable *const & get_AssemblyRefProcessorTable() const
Property: AssemblyRefProcessorTable.
void set_ordinal(unsigned const &)
Property: Ordinal number.
virtual bool isFunctionCallFast(const std::vector< SgAsmInstruction * > &insns, rose_addr_t *target, rose_addr_t *ret) override
Returns true if the specified basic block looks like a function call.
CIL StandAloneSig tables.
void initializeProperties()
Initialize all properties that have explicit initial values.
InsSetArchitecture
Instruction sets organized by families.
static Sawyer::Message::Facility mlog
Diagnostic stream.
unsigned const & get_e_res6() const
Property: Rerserved area 6.
void set_TypeDefTable(SgAsmCilTypeDefTable *const &)
Property: TypeDefTable.
SgUnsignedCharList const & get_extra() const
Property: Extra bytes not officially part of the table entry.
void set_e_heap_commit_size(unsigned const &)
Property: Heap commit size.
SgAsmElfDynamicEntryList *const & get_entries() const
Property: List of entries.
SgAsmJvmInnerClassesEntry * parse(SgAsmJvmConstantPool *)
Initialize the object by parsing content from the class file.
32 bit signed PC relative offset to two GOT entries for LD symbol
size_t iat_required_size() const
Number of bytes required for the table.
void set_e_total_pages(uint16_t const &)
Property: Total number of pages.
virtual ~SgAsmCilDataStream()
Destructor.
void set_Name(uint32_t const &)
Property: Name.
SgAsmCilTypeRef()
Default constructor.
Expression that performs a logical, sign-bit non-preserving right shift.
uint16_t const & get_e_cksum() const
Property: Checksum.
Rose::BinaryAnalysis::X86BranchPrediction const & get_branchPrediction() const
Property: An enum constant describing branch prediction.
SgAsmElfSymverEntry()
Default constructor.
void set_name(std::string const &)
Property: Name.
virtual ~SgAsmDwarfModule()
Destructor.
SgAsmCilAssemblyRefProcessor()
Default constructor.
SgAsmSynthesizedDataStructureDeclaration()
Default constructor.
virtual size_t get_nBits() const override
Property: Number of bits.
SgAsmElfSymverEntryList *const & get_entries() const
Property: List of table entries.
SgAsmIndirectRegisterExpression()
Default constructor.
uint32_t const & get_ImportName() const
Property: ImportName.
virtual ~SgAsmDwarfNamelist()
Destructor.
virtual ~SgAsmDwarfNamelistItem()
Destructor.
bool isLastInBlock()
Returns true if this instruction is the last instruction in a basic block.
void set_extra(SgUnsignedCharList const &)
Property: Extra bytes not officially part of the table entry.
Represents an JVM constant pool.
void set_stride(Rose::BinaryAnalysis::RegisterDescriptor const &)
Property: Register descriptor stride.
SgAsmDwarfPtrToMemberType()
Default constructor.
unsigned const & get_e_nsections() const
Property: Number of sections.
void initializeProperties()
Initialize all properties that have explicit initial values.
SgAsmGenericSectionPtrList get_sections_by_name(std::string, char sep=0) const
Returns sections in this header that have the specified name.
void set_entries(SgAsmElfSymverDefinedEntryList *const &)
Property: List of entries.
void initializeProperties()
Initialize all properties that have explicit initial values.
void add_section(SgAsmGenericSection *)
Adds a new section to the header.
virtual ~SgAsmValueExpression()
Destructor.
void set_r_offset(rose_addr_t const &)
Property: Offset.
size_t get_nElmts() const
Property: Number of elements in vector.
Section has zero-filled pages.
virtual ~SgAsmGenericFile()
Destructor.
uint64_t const & get_Sorted() const
Property: A 4-byte value.
virtual void set_linked_section(SgAsmElfSection *)
Property: Linked section.
SgAsmElfEHFrameEntryFDPtrList const & get_entries() const
Property: List of pointers to error handling frame descriptor entries.
void initializeProperties()
Initialize all properties that have explicit initial values.
virtual ~SgAsmOperandList()
Destructor.
virtual size_t get_nBits() const
Width of type in bits.
void set_major_version(uint16_t const &)
Property: Major version.
Some operating system specific purpose.
virtual void unparse(std::ostream &) const override
Unparse headers and all they point to.
SgAsmCilMethodSemanticsTable *const & get_MethodSemanticsTable() const
Property: MethodSemanticsTable.
uint32_t const & get_Size() const
Property: Length of the byte stream.
Exception for writing past the end of something.
void initializeProperties()
Initialize all properties that have explicit initial values.
void set_Name(uint32_t const &)
Property: Name.
virtual ~SgAsmBinaryMod()
Destructor.
Normal variable definitions.
void set_HashAlgId(uint32_t const &)
Property: HashAlgId.
void set_Processor(uint32_t const &)
Property: Processor.
Function is the target of a thunk.
rose_addr_t const & get_address() const
Property: Starting virtual address.
void set_symbols(SgAsmElfSymbolList *const &)
Property: Symbols.
uint32_t const & get_Class() const
Property: Class.
On-disk format of DOS file header.
Tag for popl in GD TLS code.
void set_Interface(uint32_t const &)
Property: Interface.
virtual ~SgAsmSynthesizedDataStructureDeclaration()
Destructor.
Non-standard OS specific handling required.
virtual ~SgAsmStatement()
Destructor.
void initializeProperties()
Initialize all properties that have explicit initial values.
void initializeProperties()
Initialize all properties that have explicit initial values.
void initializeProperties()
Initialize all properties that have explicit initial values.
void set_address(rose_addr_t const &)
Property: Starting virtual address.
bool isFirstInBlock()
Returns true if this instruction is the first instruction in a basic block.
Strings stored in an ELF or PE container.
virtual ~SgAsmUnaryTruncate()
Destructor.
virtual ~SgAsmCilPropertyMapTable()
Destructor.
void * encode(SgAsmPEImportDirectory::PEImportDirectory_disk *) const
Encode an import directory entry back into disk format.
void initializeProperties()
Initialize all properties that have explicit initial values.
void set_kind(Rose::BinaryAnalysis::MipsInstructionKind const &)
Property: Instruction kind.
SgAsmMemoryReferenceExpression()
Default constructor.
virtual SgAsmJvmAttribute * parse(SgAsmJvmConstantPool *pool) override
Initialize the attribute by parsing the file.
bool const & get_hasMoreSections() const
Property: hasMoreSections.
size_t read_content(rose_addr_t abs_offset, void *dst_buf, rose_addr_t size, bool strict=true)
Reads data from a file.
void set_e_code_rva(rose_rva_t const &)
Property: Code RVA.
void set_ReservedAlwaysOne(uint8_t const &)
Property: A 1-byte constant.
SgAsmJvmExceptionTable *const & get_exception_table() const
Property: Exception table.
virtual void unparse(std::ostream &) const override
Unparse headers and all they point to.
Expression that returns the remainder when dividing the first operand by the second.
void initializeProperties()
Initialize all properties that have explicit initial values.
virtual ~SgAsmNullInstruction()
Destructor.
void set_MethodSemanticsTable(SgAsmCilMethodSemanticsTable *const &)
Property: MethodSemanticsTable.
Node to hold a list of symbol node pointers.
rose_addr_t const & get_sh_addralign() const
Property: sh_addralign.
virtual ~SgAsmCilModuleRef()
Destructor.
virtual ~SgAsmPESectionTableEntry()
Destructor.
void set_Flags(uint32_t const &)
Property: Flags.
ARM{1020E,1022E,1026EJ-S} cores.
void set_Mvid(uint32_t const &)
Property: Mvid.
void set_segment_entry(SgAsmElfSegmentTableEntry *const &)
Property: The segment table entry corresponding to this section.
Rose::BinaryAnalysis::MemoryMap::Ptr const & get_map() const
Property: Memory map.
Base class for ELF file sections.
rose_addr_t size
Number of bytes of attempted read.
SgAsmElfSection * init_from_segment_table(SgAsmElfSegmentTableEntry *, bool mmap_only=false)
Initializes the section from data parse from the ELF Segment Table.
unsigned const & get_prh_arg() const
Property: PRH argument.
void set_OSMinorVersion(uint32_t const &)
Property: OSMinorVersion.
void initializeProperties()
Initialize all properties that have explicit initial values.
unsigned char const & get_st_info() const
Property: Info.
void initializeProperties()
Initialize all properties that have explicit initial values.
Block is being assigned to a FUNC_LEFTOVERS function because it could not be assigned to any other fu...
File-specified purpose other than any given in this enum.
Number of operators in this enum.
virtual ~SgAsmSynthesizedDeclaration()
Destructor.
CilInstructionKind
CIL instruction types.
rose_rva_t const & get_ilt_rva() const
Property: Starting address of the ILT.
uint32_t const & get_EventFlags() const
Property: EventFlags.
uint16_t vd_flags
Version information flag bitmask.
SgAsmGenericSection * get_section_by_name(const std::string &, char sep=0, size_t *nfound=0) const
Find section by name.
void set_repeatPrefix(Rose::BinaryAnalysis::X86RepeatPrefix const &)
Property: An enum constant describing whether the instruction is repeated.
unsigned const & get_e_bss_size() const
Property: BSS size.
uint32_t const & get_Class() const
Property: Class.
void set_attribute_table(SgAsmJvmAttributeTable *const &)
Property: Attribute table.
SgAsmBinaryMsl()
Default constructor.
virtual ~SgAsmJvmExceptionTable()
Destructor.
size_t const & get_num_freed() const
Property: Number of strings freed thus far.
rose_addr_t const & get_mapped_alignment() const
Property: Alignment in virtual memory.
void set_offset(rose_addr_t const &)
Property: Offset of segment in the file.
void set_stackDeltaIn(int64_t const &)
Property: Stack pointer at start of instruction relative to start of instruction's function...
void set_OSPlatformID(uint32_t const &)
Property: OSPlatformID.
virtual ~SgAsmElfSymverNeededEntryList()
Destructor.
SgAsmCilNestedClassTable *const & get_NestedClassTable() const
Property: NestedClassTable.
void set_tag(uint8_t const &)
Property: tag.
SgAsmValueExpression()
Default constructor.
void set_headers(SgAsmGenericHeaderList *const &)
Property: File headers.
virtual void dump(FILE *, const char *prefix, ssize_t idx) const override
Print some debugging info.
virtual unsigned get_anyKind() const override
Returns instruction kind for any architecture.
SgAsmPERVASizePairPtrList const & get_pairs() const
Property: List of pointers to other nodes.
rose_addr_t get_offset() const
Property: Offset to start of section in file.
SgAsmCilModuleTable *const & get_ModuleTable() const
Property: ModuleTable.
Rose::BinaryAnalysis::X86InstructionKind const & get_kind() const
Property: Instruction kind.
80200, IOP310, IOP315, 80219, IOP321, IOP33x, IOP34x, PXA210, PXA250, PXA255, PXA26x, PXA27x, PXA800(E)F, Monahans, PXA900, IXC1100, IXP2400, IXP2800, IXP2850, IXP2325, IXP2350, IXP42x, IXP460, IXP465 cores
virtual ~SgAsmGenericString()
Destructor.
virtual rose_addr_t get_offset() const override
Returns the offset into the string table where the string is allocated.
void set_name_md5(std::string const &)
Property: Hash of the function.
virtual void set_mapped_preferred_rva(rose_addr_t)
Property: Relative virtual address where section prefers to be mapped.
Expression representing truncation.
SgAsmGenericSection * get_section_by_rva(rose_addr_t rva, size_t *nfound=0) const
Returns the single section having a preferred mapping that includes the specified relative virtual ad...
SgAsmCilInterfaceImplTable()
Default constructor.
void initializeProperties()
Initialize all properties that have explicit initial values.
User says block belongs to the function.
SgAsmElfSymbolSection()
Default constructor.
virtual ~SgAsmElfSymverEntryList()
Destructor.
virtual ~SgAsmPEImportItemList()
Destructor.
void set_Flags(uint32_t const &)
Property: Flags.
virtual ~SgAsmDwarfUnknownConstruct()
Destructor.
SgAsmElfSymverDefinedAuxPtrList const & get_entries() const
Property: List of entries.
uint16_t const & get_access_flags() const
Property: access_flags.
void set_ordinal(unsigned const &)
Property: Ordinal.
uint16_t const & get_Flags() const
Property: Flags.
SgAsmGenericString * get_name() const
Property: Note name.
static uint64_t virtualAddress(SgNode *)
Returns the base address of an addressable IR node.
SgAsmJvmAttribute()
Default constructor.
CIL Event node (II.22.13).
void initializeProperties()
Initialize all properties that have explicit initial values.
SgAsmElfSymverNeededAuxPtrList const & get_entries() const
Property: List of entries.
Base class for PE sections.
bool get_isSigned() const
Property: whether the integral type is signed or unsigned.
Function mentioned on the command-line.
SgAsmCilGenericParamConstraintTable()
Default constructor.
size_t const & get_index() const
Property: Index into table.
Array of some other type.
SgAsmElfRelocEntryPtrList const & get_entries() const
Property: List of relocation entries.
Info defined by the program; format and meaning determined by prog.
Settings that control how the lowest-level SgAsmExecutableFileFormat::hexdump function behaves...
Definition: Cxx_Grammar.h:8514
virtual ~SgAsmFunction()
Destructor.
Represents a synthesized function.
RelocType
Relocation Type.
void set_instruction_list(SgAsmInstructionList *const &)
Property: Instruction list.
SgAsmElfDynamicEntryList()
Default constructor.
SgAsmElfSegmentTableEntry::SegmentFlags const & get_flags() const
Property: Segment flags.
SgAsmGenericSection * get_section_by_offset(rose_addr_t offset, rose_addr_t size, size_t *nfound=0) const
Find section by file offset.
void set_Method(uint32_t const &)
Property: Method.
32/64-bit RISC; MIPS Technologies, Inc.
Reserved, unspecified semantics; Present only in non-conforming files.
SgUnsignedCharList const & get_extra() const
Property: Padding byte values.
virtual ~SgAsmCilMethodSemanticsTable()
Destructor.
uint32_t const & get_hash() const
Property: Hash.
uint32_t const & get_Name() const
Property: Name.
uint16_t const & get_e_minalloc() const
Property: Min alloc.
void initializeProperties()
Initialize all properties that have explicit initial values.
virtual ~SgAsmDwarfSubroutineType()
Destructor.
JvmInstructionKind
The Java Virtual Machine (JVM) instruction set.
virtual ~SgAsmCilEventTable()
Destructor.
virtual ~SgAsmNESectionTableEntry()
Destructor.
JVM EnclosingMethod attribute.
void initializeProperties()
Initialize all properties that have explicit initial values.
uint32_t const & get_stackSize() const
Property: stackSize.
std::string conditionalBranchDescription() const
Description of conditional branch BO constant.
SgAsmCilConstantTable()
Default constructor.
void initializeProperties()
Initialize all properties that have explicit initial values.
virtual ~SgAsmJvmClass()
Destructor.
unsigned const & get_version() const
Property: File format version number.
bool const & get_lockPrefix() const
Property: Whether the x86 lock prefix was present.
void initializeProperties()
Initialize all properties that have explicit initial values.
SgAsmDwarfInheritance()
Default constructor.
void initializeProperties()
Initialize all properties that have explicit initial values.
virtual bool isUnknown() const override
Returns true if this instruction is the special "unknown" instruction.
void initializeProperties()
Initialize all properties that have explicit initial values.
rose_rva_t const & get_expaddr_rva() const
Property: Expaddr RVA.
uint32_t const & get_Parent() const
Property: Parent.
void set_AssemblyTable(SgAsmCilAssemblyTable *const &)
Property: AssemblyTable.
void set_sh_addralign(rose_addr_t const &)
Property: sh_addralign.
virtual void unparse(std::ostream &) const override
Write a section back to the file.
CIL MethodImpl node (II.22.27).
virtual const char * format_name() const override
Returns the name of the file format.
void initializeProperties()
Initialize all properties that have explicit initial values.
virtual bool isUnknown() const override
Returns true if this instruction is the special "unknown" instruction.
void set_Signature(uint32_t const &)
Property: Magic signature for physical metadata (always 0x424A5342)
virtual ~SgAsmJvmFieldTable()
Destructor.
SgAsmGenericSectionList *const & get_sections() const
Property: List of file sections.
void parse(std::vector< uint8_t > &buf, size_t startOfMetaData) override
parses the metadata objects from the buffer.
Result containing a value or an error.
Definition: Result.h:270
static constexpr uint32_t MAGIC_SIGNATURE
}@
virtual void dump(FILE *, const char *prefix, ssize_t idx) const override
Print some debugging information.
void set_entries(SgAsmElfSymverNeededEntryPtrList const &)
Property: List of entries.
void set_e_opt_magic(unsigned const &)
Property: Magic.
void set_entries(SgAsmElfSymverEntryPtrList const &)
Property: List of symbol version table entries.
void set_st_size(rose_addr_t const &)
Property: size.
Represents one JVS machine instruction.
SgAsmJvmMethod()
Default constructor.
uint16_t const & get_descriptor_index() const
Property: descriptor_index.
SgAsmElfDynamicSection()
Default constructor.
virtual ~SgAsmCilAssemblyProcessorTable()
Destructor.
virtual ~SgAsmCilStandAloneSig()
Destructor.
uint32_t const & get_low_bytes() const
Properties: low_bytes.
void initializeProperties()
Initialize all properties that have explicit initial values.
uint16_t const & get_inner_name_index() const
Property: inner_name_index.
Exception for reading past the end of something.
SgAsmCilMetadataRoot()
Default constructor.
void initializeProperties()
Initialize all properties that have explicit initial values.
void set_e_minalloc(uint16_t const &)
Property: Min alloc.
Initial instructions not in any other function.
unsigned const & get_n_relocs() const
Property: Number of relocations.
void set_Offset(uint32_t const &)
Property: Offset.
void set_Padding(uint8_t const &)
Property: Padding.
SgUnsigned16List const & get_classes() const
Property: classes.
Expression that divides the first operand by the second.
virtual ~SgAsmDwarfSharedType()
Destructor.
unsigned long const & get_sh_link() const
Property: sh_link.
CIL AssemblyRefProcessor node (II.22.7).
virtual void dump(FILE *, const char *prefix, ssize_t idx) const override
Print some debugging info.
rose_addr_t parse(rose_addr_t starting_offset)
Initialize a note by parsing it from the specified location in the note section.
SgAsmPEImportDirectoryList()
Default constructor.
unsigned long const & get_e_type() const
Property: Type.
const char *const & get_code() const
Property: code.
void set_bound(SgAsmGenericSection *const &)
Property: Associated file section.
virtual ~SgAsmDwarfStructureType()
Destructor.
SgAsmAarch32Coprocessor()
Default constructor.
virtual std::string toString() const override
Convert a type to a string.
void set_Flags(uint32_t const &)
Property: Flags.
SgAsmM68kInstruction()
Default constructor.
void initializeProperties()
Initialize all properties that have explicit initial values.
void set_entries(SgAsmElfRelocEntryPtrList const &)
Property: List of relocation entries.
uint32_t const & get_Method() const
Property: Method.
Hods a list of symbol version aux entries.
SgAsmCilTypeDefTable()
Default constructor.
void initializeProperties()
Initialize all properties that have explicit initial values.
Big/default bit setting (80x86 specific); see note above.
uint16_t const & get_e_cs() const
Property: CS.
void set_symbols(SgStringList const &)
Property: Symbols.
void set_NativeType(uint32_t const &)
Property: NativeType.
void set_descriptor(Rose::BinaryAnalysis::RegisterDescriptor const &)
Property: Descriptor for accessed register.
Relocation for call to __tls_get_addr()
64-bit; others in the series had larger caches and bug fixes
CIL ModuleRef tables.
void initializeProperties()
Initialize all properties that have explicit initial values.
virtual ~SgAsmCilUint8Heap()
Destructor.
void set_StandAloneSigTable(SgAsmCilStandAloneSigTable *const &)
Property: StandAloneSigTable.
uint32_t const & get_Signature() const
Property: Signature.
void set_handlers(SgAsmJvmExceptionHandlerPtrList const &)
Property: List of pointers to exceptions.
rose_addr_t const & get_physical_size() const
Property: Physical size.
BitRange significandBits() const
Property: Offset to significand least significant bit.
size_t hintname_table_extent(AddressIntervalSet &extent) const
Obtains the virtual address of the Hint/Name Table.
SgAsmCilNode()
Default constructor.
Rose::BinaryAnalysis::X86SegmentRegister const & get_segmentOverride() const
Property: The segment override register.
void set_extra(SgUnsignedCharList const &)
Property: Extra bytes.
void initializeProperties()
Initialize all properties that have explicit initial values.
void set_PropertyTable(SgAsmCilPropertyTable *const &)
Property: PropertyTable.
void set_operand(SgAsmExpression *const &)
Property: Operand for a unary expression.
SgAsmX86Instruction()
Default constructor.
SgAsmGenericString *const & get_name() const
Property: Name.
It is unknown whether this function ever returns or not.
virtual ~SgAsmDwarfInheritance()
Destructor.
void initializeProperties()
Initialize all properties that have explicit initial values.
virtual ~SgAsmCilGenericParamTable()
Destructor.
void set_dont_free(SgAsmStringStorage *const &)
Property: Space that should never be freed.
SymbolDefState
Symbol definition state.
CIL SgAsmCilMetadataHeap node.
virtual ~SgAsmNERelocTable()
Destructor.
size_t hintname_required_size() const
Bytes needed to store hint/name pair.
void updateNativeValue() const
Update cached native value from bit vector.
Detected by Partitioner::FindInterPadFunctions, which looks for unassigned space between two inter-fu...
bool const & get_is_current_version() const
Property: Whether version is considered current.
void set_vaddr(rose_addr_t const &)
Property: Virtual address.
void set_baseSize(Rose::BinaryAnalysis::X86InstructionSize const &)
Property: An enum constant describing the base size of an x86 instruction.
virtual ~SgAsmElfNoteSection()
Destructor.
void initializeProperties()
Initialize all properties that have explicit initial values.
SgAsmElfSymverDefinedEntryPtrList const & get_entries() const
Property: List of table entries.
void set_imports(SgAsmPEImportItemList *const &)
Property: List of imports.
unsigned const & get_e_code_size() const
Property: Code size.
COFF symbol string table.
void set_stackDeltaOut(int64_t const &)
Property: Stack pointer at block exit w.r.t.
SgAsmGenericHeader * get_header(SgAsmExecutableFileFormat::ExecFamily)
Returns the header for the specified format.
uint32_t const & get_TypeNamespace() const
Property: TypeNamespace.
Basic information about an executable container.
uint32_t const & get_Offset() const
Property: Offset.
void set_section_entry(SgAsmPESectionTableEntry *const &)
Property: Section table entry.
SgAsmCilFieldLayoutTable()
Default constructor.
virtual void unparse(std::ostream &) const override
Write attribute table to a binary file.
bool reallocate(bool shrink)
Allocates storage for strings that have been modified but not allocated.
void set_entries(SgAsmElfSymverNeededEntryList *const &)
Property: List of entries.
void initializeProperties()
Initialize all properties that have explicit initial values.
void initializeProperties()
Initialize all properties that have explicit initial values.
virtual const char * format_name() const override
Returns the name of the file format.
SgAsmElfSection()
Default constructor.
uint32_t const & get_Parent() const
Property: Parent.
JVM Code attribute.
void set_stackDelta(int64_t const &)
Property: Net effect of function on the stack pointer.
Base class for CIL branch of binary analysis IR nodes.
void initializeProperties()
Initialize all properties that have explicit initial values.
CIL MemberRef tables.
void initializeProperties()
Initialize all properties that have explicit initial values.
void set_name_rva(rose_rva_t const &)
Property: RVA for name.
uint64_t const & get_strongNameSignature() const
Property: StrongNameSignature.
void initializeProperties()
Initialize all properties that have explicit initial values.
void set_e_cs(uint16_t const &)
Property: CS.
SgAsmControlFlagsExpression()
Default constructor.
SgAsmRiscOperation()
Default constructor.
uint32_t p_filesz
0x20 bytes in file (may be zero or other value smaller than p_memsz)
Main namespace for the ROSE library.
SgAsmCilMetadataRoot *const & get_metadataRoot() const
Property: pointer to the root of the CIL Metadata.
OS-specific range end.
void initializeProperties()
Initialize all properties that have explicit initial values.
SgAsmJvmAttributePtrList const & get_attributes() const
Property: List of pointers to attributes.
Stores a vector of enum bit flags.
Definition: Rose/BitFlags.h:59
SgAsmJvmInnerClassesEntryPtrList const & get_classes() const
Property: List of pointers to InnerClasses attribute entry.
void initializeProperties()
Initialize all properties that have explicit initial values.
virtual ~SgAsmPEExportDirectory()
Destructor.
void initializeProperties()
Initialize all properties that have explicit initial values.
virtual ~SgAsmCilMetadataHeap()
Destructor.
Selection functor for SgAsmFunction::get_extent().
rose_addr_t const & get_file_alignment() const
Property: Required file alignment.
rose_addr_t const & get_st_size() const
Property: size.
virtual bool reallocate() override
Pre-unparsing adjustments.
rose_addr_t write(std::ostream &f, rose_addr_t offset, size_t bufsize, const void *buf) const
Write data to a file section.
void set_st_num_aux_entries(unsigned const &)
Property: Number of auxilliary entries.
void set_raw_bytes(SgUnsignedCharList const &)
Property: Raw bytes of an instruction.
void reallocate()
Call this before unparsing to make sure everything is consistent.
Rose::BitFlags< Flag > Flags
Collective bit flags for this floating-point type.
uint16_t const & get_MajorVersion() const
Property: Major version number.
SgAsmUnaryMinus()
Default constructor.
SgAsmCilFieldMarshal()
Default constructor.
virtual void dump(FILE *, const char *prefix, ssize_t idx) const override
Print some debugging info.
SgAsmGenericDLLList *const & get_dlls() const
Property: List of dynamically linked libraries.
struct stat fileDetails
Information about the file in the filesystem.
uint32_t const & get_Value() const
Property: Value.
void initializeProperties()
Initialize all properties that have explicit initial values.
void initializeProperties()
Initialize all properties that have explicit initial values.
SgAsmJvmNestMembers()
Default constructor.
Architecture is something other than below.
std::string const & get_augmentation_string() const
Property: Augmentation string.
void set_vTableFixups(uint64_t const &)
Property: VTableFixups.
rose_addr_t const & get_physical_offset() const
Property: Physical offset.
virtual void unparse(std::ostream &) const override
Write the stack map table frame to a binary file.
Unix Executable and Linking Format.
CIL FieldLayout tables.
OS-specific range start.
Does not have size/value yet.
void initializeProperties()
Initialize all properties that have explicit initial values.
CIL FieldLayout node (II.22.16).
SgUnsignedCharList const & get_extra() const
Property: Value of padding bytes.
void initializeProperties()
Initialize all properties that have explicit initial values.
uint64_t max_page_size()
Maximum page size according to the ABI.
unsigned const & get_type() const
Property: Type of note.
SgAsmElfSection * get_linked_section() const
Property: Linked section.
void initializeProperties()
Initialize all properties that have explicit initial values.
void initializeProperties()
Initialize all properties that have explicit initial values.
Added by Partitioner::FindData, which attaches unassigned parts of the disassembly address space to t...
void initializeProperties()
Initialize all properties that have explicit initial values.
Java Virtual Machine (JVM).
void initializeProperties()
Initialize all properties that have explicit initial values.
rose_addr_t const & get_id() const
Property: Identification.
virtual ~SgAsmCilAssemblyRefProcessor()
Destructor.
void initializeProperties()
Initialize all properties that have explicit initial values.
Exception for container syntax errors.
void initializeProperties()
Initialize all properties that have explicit initial values.
bool is_mapped() const
Whether section desires to be mapped to memory.
virtual ~SgAsmDwarfDwarfProcedure()
Destructor.
void set_symbols(SgAsmGenericSymbolPtrList const &)
Property: List of symbol nodes.
virtual Rose::BinaryAnalysis::AddressSet getSuccessors(bool &complete) override
Control flow successors for a single instruction.
Entry in an ELF symbol version table.
std::string read_content_str(const Rose::BinaryAnalysis::MemoryMap::Ptr &map, rose_rva_t rva, bool strict=true)
Reads a string from the file.
void unparse_holes(std::ostream &) const
Write holes (unreferenced areas) back to the file.
void set_Signature(uint32_t const &)
Property: Signature.
uint32_t e_res1
0x1c unknown purpose.
Base class for string tables.
Rose::BinaryAnalysis::RegisterDescriptor const & get_stride() const
Property: Register descriptor stride.
void initializeProperties()
Initialize all properties that have explicit initial values.
void initializeProperties()
Initialize all properties that have explicit initial values.
void set_branchPrediction(Rose::BinaryAnalysis::X86BranchPrediction const &)
Property: An enum constant describing branch prediction.
virtual ~SgAsmGenericDLLList()
Destructor.
SgAsmDwarfNamespace()
Default constructor.
virtual void check() const override
Validate properties collectively.
Block serves as an explicit starting point for CFG analysis.
void set_index(size_t const &)
Property: Register descriptor index.
uint16_t const & get_access_flags() const
Property: access_flags.
void set_FieldTable(SgAsmCilFieldTable *const &)
Property: FieldTable.
uint16_t const & get_bootstrap_method_attr_index() const
Property: bootstrap_method_attr_index.
size_t get_nBits() const
Property: Width of expression in bits.
void set_operands(SgAsmExpressionPtrList const &)
Property: Ordered list of instruction operands.
void initializeProperties()
Initialize all properties that have explicit initial values.
Base class for references to a machine register.
SgAsmOperandList *const & get_operandList() const
Property: AST node that holds all operands.
uint16_t const & get_BuildNumber() const
Property: BuildNumber.
Appears to be a function based on pattern of instructions.
void initializeProperties()
Initialize all properties that have explicit initial values.
void set_e_nt_hdr_size(rose_addr_t const &)
Property: Size of NT header.
SgAsmCilMetadataHeap()
Default constructor.
SgAsmElfNoteSection()
Default constructor.
SgAsmUnaryExpression()
Default constructor.
void set_ManifestResourceTable(SgAsmCilManifestResourceTable *const &)
Property: ManifestResourceTable.
static std::string to_string(SgAsmElfSymbol::ElfSymBinding)
Converts enum constant to string.
uint32_t const & get_Name() const
Property: Name.
void set_strtab(SgAsmGenericSection *const &)
Property: String table.
void set_contains_code(bool const &)
Property: Whether a section is known to contain code.
virtual ~SgAsmInstruction()
Destructor.
uint64_t const & get_codeManagerTable() const
Property: CodeManagerTable.
void initializeProperties()
Initialize all properties that have explicit initial values.
void set_entry_va(rose_addr_t const &)
Property: Primary entry address.
void initializeProperties()
Initialize all properties that have explicit initial values.
void initializeProperties()
Initialize all properties that have explicit initial values.
deeply pipelined, high frequency, SSE3
SgAsmGenericString *const & get_forwarder() const
Property: Forwarder.
SgUnsignedCharList const & get_raw_bytes() const
Property: Raw bytes.
std::string const & get_reasonComment() const
Property: Additional function existance reason comment.
virtual ~SgAsmUnaryUnsignedExtend()
Destructor.
SgAsmGenericDLLPtrList const & get_dlls() const
Property: List of AST node pointers.
uint32_t const & get_Culture() const
Property: Culture.
virtual SgAsmElfSymverDefinedSection * parse() override
Initializes this ELF SymverDefined Section by parsing a file.
virtual void dump(FILE *, const char *prefix, ssize_t idx) const override
Print some debugging info.
void set_mnemonic(std::string const &)
Property: Instruction mnemonic string.
Like SHT_PROGBITS but occupies no file space.
SgAsmJvmSourceFile()
Default constructor.
uint16_t const & get_e_sp() const
Property: SP.
unsigned long const & get_e_shstrndx() const
Property: shstrndx.
virtual ~SgAsmDwarfVariant()
Destructor.
void set_sig_frame(bool const &)
Property: Signal frame.
virtual bool isFunctionReturnSlow(const std::vector< SgAsmInstruction * > &insns) override
Returns true if the specified basic block looks like a function return.
SgAsmCilDataStream()
Default constructor.
unsigned char st_info
Type and binding attributes.
virtual ~SgAsmCilEventMapTable()
Destructor.
void initializeProperties()
Initialize all properties that have explicit initial values.
SgAsmCilFileTable *const & get_FileTable() const
Property: FileTable.
virtual void dump(FILE *, const char *prefix, ssize_t idx) const override
Print some debugging information.
int64_t const & get_stackDeltaIn() const
Property: Stack pointer at start of instruction relative to start of instruction's function...
void set_PackingSize(uint16_t const &)
Property: PackingSize.
SgAsmGenericSectionPtrList get_mapped_sections() const
Returns list of all sections in the file that are memory mapped, including headers and holes...
void set_version(size_t const &)
Property: Version.
Sawyer::Optional< uint64_t > asUnsigned() const
Return a constant if possible.
virtual ~SgAsmCilImplMapTable()
Destructor.
SgAsmDwarfDwarfProcedure()
Default constructor.
void append_declaration(SgAsmSynthesizedDeclaration *declaration)
Appends another declaration.
void set_GenericParamConstraintTable(SgAsmCilGenericParamConstraintTable *const &)
Property: GenericParamConstraintTable.
virtual ~SgAsmLESectionTableEntry()
Destructor.
virtual unsigned get_anyKind() const override
Returns instruction kind for any architecture.
void initializeProperties()
Initialize all properties that have explicit initial values.
void initializeProperties()
Initialize all properties that have explicit initial values.
SgAsmElfNoteEntryList()
Default constructor.
unsigned isa_to_machine(SgAsmExecutableFileFormat::InsSetArchitecture isa) const
Convert architecture value to an ELF "machine" value.
CIL Module tables.
SgAsmJvmConstantPoolEntry * get_entry(size_t index) const
Returns constant pool entry at given index.
SgAsmElfSymverSection()
Default constructor.
void set_dlls(SgAsmGenericDLLPtrList const &)
Property: List of AST node pointers.
virtual unsigned get_anyKind() const override
Returns instruction kind for any architecture.
void set_max_stack(uint16_t const &)
Property: max_stack.
virtual ~SgAsmJvmInnerClassesEntry()
Destructor.
uint8_t const & get_HeapSizes() const
Property: A 1-byte constant indicating the index sizes of streams.
void initializeProperties()
Initialize all properties that have explicit initial values.
uint32_t const & get_Owner() const
Property: Owner.
virtual SgAsmElfSymverSection * parse() override
Initializes section by parsing the file.
void initializeProperties()
Initialize all properties that have explicit initial values.
virtual void unparse(std::ostream &) const override
Write a section back to the file.
virtual ~SgAsmX86Instruction()
Destructor.
virtual void dump(FILE *, const char *prefix, ssize_t idx) const override
Print some debugging info.
void set_e_res5(unsigned const &)
Property: Rerserved area 5.
CIL ClassLayout tables.
ExecABI
Application binary interface.
SgAsmCilAssemblyRefOSTable()
Default constructor.
on-chip comm for use in multi-processor systems
SgAsmGenericSection *const & get_bound() const
Property: Associated file section.
rose_addr_t get_entry_rva() const
Returns the RVA of the first entry point.
SgAsmPEExportEntryList()
Default constructor.
SgAsmElfEHFrameEntryCIList *const & get_ci_entries() const
Property: CI entries.
CIL CustomAttribute tables.
Base class for CIL branch of binary analysis IR nodes.
Address was found in read-only data referenced by an existing instruction.
uint16_t const & get_Action() const
Property: Action.
void parse()
Declares the parse function as called from the Cli section header object.
ELF error handling frame entry frame description entry.
void set_flags(SgAsmElfSegmentTableEntry::SegmentFlags const &)
Property: Segment flags.
void set_file(SgAsmGenericFile *const &)
Property: File to which this section belongs.
CIL ImplMap node (II.22.22).
std::string get_short_name() const
Property: Abbreviated name.
virtual ~SgAsmDwarfLine()
Destructor.
rose_addr_t const & get_paddr() const
Property: ELF paddr field.
Negated offset in static TLS block.
uint32_t st_size
Symbol size in bytes.
SgAsmGenericString *const & get_name() const
Property: Name.
double const & get_percentageCoverage() const
Property: code coverage percent.
void parse(Rose::BinaryAnalysis::ByteOrder::Endianness, const SgAsmElfSymverDefinedAux::ElfSymverDefinedAux_disk *)
Initialize this object with data parsed from a file.
Cortex-{A8,A9,A9 MPCore,R4(F),M3,M1} cores.
virtual ~SgAsmJvmConstantValue()
Destructor.
File format for an RVA/Size pair.
void set_addressSize(Rose::BinaryAnalysis::X86InstructionSize const &)
Property: An enum describing the x86 address size.
JVM Exceptions attribute.
SgAsmDwarfSharedType()
Default constructor.
SgAsmCilMetadata * get_MetadataNode(std::uint32_t idx, TableKind tblcode) const
looks up the node associated with the coded index idx in the metadata table associated with tblcode...
Represents an ELF relocation section.
virtual void dump(FILE *, const char *prefix, ssize_t idx) const override
Print some debugging info.
void initializeProperties()
Initialize all properties that have explicit initial values.
virtual SgAsmJvmNestHost * parse(SgAsmJvmConstantPool *pool) override
Initialize the attribute by parsing the file.
virtual ~SgAsmMemoryReferenceExpression()
Destructor.
virtual ~SgAsmElfEHFrameEntryFDList()
Destructor.
void initializeProperties()
Initialize all properties that have explicit initial values.
void initializeProperties()
Initialize all properties that have explicit initial values.
void set_name(SgAsmGenericString *)
Property: Name.
void initializeProperties()
Initialize all properties that have explicit initial values.
void set_statementList(SgAsmStatementPtrList const &)
Property: Statements of which this block is composed.
virtual ~SgAsmLEEntryTable()
Destructor.
unsigned const & get_mask() const
Property: Bit mask.
Extent get_file_extent() const
Returns the file extent for the section.
void initializeProperties()
Initialize all properties that have explicit initial values.
virtual ~SgAsmDwarfMember()
Destructor.
void parse(Rose::BinaryAnalysis::ByteOrder::Endianness, const SgAsmElfSymbol::Elf32SymbolEntry_disk *)
Initialize symbol by parsing a symbol table entry.
virtual void unparse(std::ostream &) const override
Write the section to a binary file.
virtual ~SgAsmCilProperty()
Destructor.
CIL MethodSpec tables.
void initializeProperties()
Initialize all properties that have explicit initial values.
void set_EventList(uint32_t const &)
Property: EventList.
void set_e_phnum(unsigned long const &)
Property: phnum.
void initializeProperties()
Initialize all properties that have explicit initial values.
void set_start_pc(uint16_t const &)
Property: start_pc.
void initializeProperties()
Initialize all properties that have explicit initial values.
virtual void unparse(std::ostream &) const override
Write source file to a binary file.
std::string const & get_callingConvention() const
Property: Primary calling convention.
unsigned const & get_e_res5() const
Property: Rerserved area 5.
virtual bool terminatesBasicBlock() override
Determines if this instruction normally terminates a basic block.
32 bit PC relative offset to GOT
Block is an entry point for the function.
bool const & get_initLocals() const
Property: initLocals.
Base class for CIL branch of binary analysis IR nodes.
SgAsmDwarfTypedef()
Default constructor.
virtual void dump(FILE *, const char *prefix, ssize_t idx) const
Print some debugging info.
void set_augmentation_data_length(uint64_t const &)
Property: Augmentation data length.
void set_code_length(uint32_t const &)
Property: code_length.
SgAsmRegisterNames()
Default constructor.
uint32_t vn_file
Offset (in bytes) to strings table to file string.
SgAsmCoffSymbolList()
Default constructor.
Loadable by mapping file contents into memory.
uint32_t const & get_RVA() const
Property: RVA.
void set_descriptor_index(uint16_t const &)
Property: descriptor_index.
void set_mask(unsigned const &)
Property: Bit mask.
void set_NestedClassTable(SgAsmCilNestedClassTable *const &)
Property: NestedClassTable.
superscalar (never actually released)
virtual bool isFunctionCallSlow(const std::vector< SgAsmInstruction * > &, rose_addr_t *target, rose_addr_t *ret) override
Returns true if the specified basic block looks like a function call.
Section contains resource objects.
SgAsmNEFileHeader()
Default constructor.
void initializeProperties()
Initialize all properties that have explicit initial values.
SgAsmCilCustomAttributeTable *const & get_CustomAttributeTable() const
Property: CustomAttributeTable.
virtual bool isFunctionCallSlow(const std::vector< SgAsmInstruction * > &, rose_addr_t *target, rose_addr_t *ret) override
Returns true if the specified basic block looks like a function call.
virtual std::vector< std::pair< size_t, size_t > > findNoopSubsequences(const std::vector< SgAsmInstruction * > &insns, bool allow_branch=false, bool relax_stack_semantics=false)
Determines what subsequences of an instruction sequence have no cumulative effect.
SgAsmDwarfModule()
Default constructor.
SgAsmCilUint32Heap()
Default constructor.
virtual ~SgAsmElfSymverEntry()
Destructor.
void initializeProperties()
Initialize all properties that have explicit initial values.
virtual ~SgAsmConstantExpression()
Destructor.
void initializeProperties()
Initialize all properties that have explicit initial values.
void initializeProperties()
Initialize all properties that have explicit initial values.
SgAsmType *const & get_type() const
Property: Type of expression.
uint16_t const & get_Generation() const
Property: Generation.
void set_InterfaceImplTable(SgAsmCilInterfaceImplTable *const &)
Property: InterfaceImplTable.
void set_name_index(uint16_t const &)
Property: name_index.
PowerpcInstructionKind
PowerPC instruction types.
SgAsmDwarfImportedModule()
Default constructor.
void initializeProperties()
Initialize all properties that have explicit initial values.
virtual ~SgAsmCilTypeDefTable()
Destructor.
SgAsmCoffSymbol()
Default constructor.
SgAsmGenericFormat::InsSetArchitecture const & get_isa() const
Property: Machine for which this header and its sections, etc.
void initializeProperties()
Initialize all properties that have explicit initial values.
void set_entries(SgAsmElfSymverDefinedEntryPtrList const &)
Property: List of table entries.
virtual const char * format_name() const
Returns the name of the file format.
virtual void dump(FILE *f, const char *prefix, ssize_t idx) const override
Print some debugging info.
void set_version(unsigned const &)
Property: File format version number.
bool const & get_by_ordinal() const
Property: Whether ordinal number is stored.
void initializeProperties()
Initialize all properties that have explicit initial values.
void set_Class(uint32_t const &)
Property: Class.
SgAsmStringStorage *const & get_storage() const
Property: Storage area for this string.
virtual ~SgAsmDwarfVariable()
Destructor.
rose_addr_t get_fallthrough_va()
Fall-through virtual address.
virtual SgAsmElfSymverNeededSection * parse() override
Parse a GNU Symbol Version Requirements Table.
unsigned char e_ident_padding[9]
Padding to byte 16; must be zero.
void set_Encld(uint32_t const &)
Property: Encld.
One import directory per library.
virtual void unparse(std::ostream &) const override
Write a section back to the file.
rose_addr_t const & get_r_addend() const
Property: Addend.
void set_vector(SgAsmPEImportDirectoryPtrList const &)
Property: List of nodes.
CIL File tables.
SgAsmNEStringTable()
Default constructor.
SgAsmLERelocTable()
Default constructor.
virtual ~SgAsmDwarfStringType()
Destructor.
virtual void check() const override
Validate properties collectively.
void initializeProperties()
Initialize all properties that have explicit initial values.
uint32_t const & get_TypeName() const
Property: TypeName.
void initializeProperties()
Initialize all properties that have explicit initial values.
virtual void dump(FILE *, const char *prefix, ssize_t idx) const override
Print some debugging information.
void set_operands(SgAsmExprListExp *const &)
Property: Operands for the low-level operation.
uint16_t const & get_this_class() const
Property: This class index.
virtual void unparse(std::ostream &) const override
Unparse an ElfStringSection by unparsing the ElfStrtab.
unsigned const & get_e_image_size() const
Property: Image size.
size_t reallocate(rose_rva_t starting_rva)
Allocates space for this import directory's name, import lookup table, and import address table...
CIL FieldRVA tables.
Symbol Version Table [gnu extension] .gnu.version.
void initializeProperties()
Initialize all properties that have explicit initial values.
SgAsmPERVASizePairList *const & get_rvasize_pairs() const
Property: RVA/size pairs.
size_t const & get_dll_name_nalloc() const
Property: Bytes allocated in the file for the name.
virtual ~SgAsmCilManifestResourceTable()
Destructor.
SgAsmGenericStrtab()
Default constructor.
void initializeProperties()
Initialize all properties that have explicit initial values.
void initializeProperties()
Initialize all properties that have explicit initial values.
GNU symbol version requirements table.
void remove_hole(SgAsmGenericSection *)
Removes a hole from the list of holes in a file.
SgAsmDirectRegisterExpression()
Default constructor.
virtual ~SgAsmElfEHFrameEntryCIList()
Destructor.
void set_name(SgAsmGenericString *const &)
Property: Name if not by ordinal.
bool implicitBitConvention() const
Property: Whether the type follows the IEEE 754 significand implicit bit convention.
uint32_t const & get_Implementation() const
Property: Implementation.
virtual ~SgAsmCilModule()
Destructor.
void initializeProperties()
Initialize all properties that have explicit initial values.
uint32_t const & get_EnclosingClass() const
Property: EnclosingClass.
void initializeProperties()
Initialize all properties that have explicit initial values.
void set_semantics(SgAsmExprListExp *const &)
Property: Ordered list of instruction semantics.
unsigned const & get_e_res1() const
Property: Reserved field 1.
virtual ~SgAsmNENameTable()
Destructor.
rose_addr_t get_va_offset(rose_addr_t va) const
File offset for specified virtual address.
virtual ~SgAsmFloatType()
Destructor.
void initializeProperties()
Initialize all properties that have explicit initial values.
virtual bool reallocate() override
Allow all sections to reallocate themselves.
void set_name(SgAsmGenericString *const &)
Property: Name.
virtual bool isFunctionReturnFast(const std::vector< SgAsmInstruction * > &) override
Returns true if the specified basic block looks like a function return.
List of ELF relocation entries.
void set_attribute_table(SgAsmJvmAttributeTable *const &)
Property: Table of attributes.
rose_addr_t get_base_va() const
Base virtual address for a section.
void set_e_last_page_size(uint16_t const &)
Property: Last page size.
SgUnsignedCharList const & get_instructions() const
Property: Instructions.
void set_offset_delta(uint16_t const &)
Property: offset_delta.
SgAsmBlock *const & get_global_block() const
Property: Global block.
void set_tag(SgAsmJvmConstantPoolEntry::Kind const &)
Property: tag.
void update_from_section(SgAsmPESection *section)
Update this section table entry with newer information from the section.
unsigned short const & get_bit_offset() const
Property: Where this expression is encoded within the instruction.
virtual ~SgAsmElfNoteEntry()
Destructor.
SgAsmCilConstantTable *const & get_ConstantTable() const
Property: ConstantTable.
uint16_t e_shstrndx
Index of name section, or SHN_UNDEF, or SHN_XINDEX.
uint32_t const & get_MethodList() const
Property: MethodList.
Rose::BinaryAnalysis::X86InstructionSize const & get_baseSize() const
Property: An enum constant describing the base size of an x86 instruction.
void set_stackSize(uint32_t const &)
Property: stackSize.
SgAsmGenericFile * parse(std::string file_name)
Loads file contents into memory.
void set_ReservedAlwaysZero(uint32_t const &)
Property: 4 reserved bytes.
virtual rose_addr_t calculate_sizes(size_t *total, size_t *required, size_t *optional, size_t *nentries) const override
Return sizes for various parts of the table.
virtual SgAsmElfSegmentTable * parse() override
Parses an ELF Segment (Program Header) Table.
SgAsmPEExportSection()
Default constructor.
uint16_t e_phentsize
Size of each entry in the program header table.
void set_st_storage_class(unsigned const &)
Property: Symbol storage class.
CIL AssemblyRefProcessor tables.
SgAsmExprListExp()
Default constructor.
Function is defined in a configuration file.
uint32_t const & get_Constraint() const
Property: Constraint.
CIL ExportedType tables.
virtual ~SgAsmDwarfAccessDeclaration()
Destructor.
SgAsmElfSegmentTableEntry::SegmentType const & get_type() const
Property: Segment type.
SgUnsigned16List const & get_exception_index_table() const
Property: exception_index_table.
SgAsmType()
Default constructor.
"Orion" by Qauntum Effect Devices (QED); larger caches
static const int64_t INVALID_STACK_DELTA
Represents an invalid stack delta.
List of AST file node pointers.
SgAsmStoredString()
Default constructor.
Section is resident and contiguous.
void set_may_return(SgAsmFunction::MayReturn const &)
Property: Whether a function could return to its caller.
unsigned char e_ident_data_encoding
1=>LSB; 2=>MSB; other is error
virtual ~SgAsmCilMethodSpecTable()
Destructor.
void initializeProperties()
Initialize all properties that have explicit initial values.
This class represents the concept of a name within the compiler.
SgAsmElfSegmentTable()
Default constructor.
virtual ~SgAsmElfDynamicSection()
Destructor.
size_t const & get_hintname_nalloc() const
Property: File bytes allocated for hint/name pair.
Reserved w/unspecified semantics.
virtual rose_addr_t calculate_sizes(size_t *total, size_t *required, size_t *optional, size_t *entcount) const override
Return sizes for various parts of the table.
ELF section containing dynamic linking information.
SgAsmGenericSectionPtrList get_sections_by_name(std::string, char sep='\0') const
Returns all sections having specified name across all headers, including headers and holes...
void set_filesz(rose_addr_t const &)
Property: Size of segment in file.
void initializeProperties()
Initialize all properties that have explicit initial values.
uint32_t const & get_ImplFlags() const
Property: ImplFlags.
SgUnsignedCharList const & get_raw_bytes() const
Property: Raw bytes of an instruction.
Program-supplied data, code, etc.
SgAsmDwarfUnionType()
Default constructor.
void set_fd(int const &)
Property: Read-only file descriptor.
virtual void dump(FILE *, const char *prefix, ssize_t idx) const override
Print some debugging info.
SgAsmElfDynamicEntry::EntryType const & get_d_tag() const
Property: Tag.
virtual std::string get_string(bool escape=false) const override
Property: String value.
size_t const & get_word_size() const
Property: Natural word size in bytes.
No particular reason.
void set_Offset(uint32_t const &)
Property: Start offset of the byte stream.
SgAsmElfSymverNeededEntryList()
Default constructor.
SgAsmCilFieldRVATable *const & get_FieldRVATable() const
Property: FieldRVATable.
virtual ~SgAsmLESection()
Destructor.
rose_addr_t const & get_entry_va() const
Property: Primary entry address.
uint32_t const & get_bytes() const
Property: bytes.
int const & get_st_section_num() const
Property: Section number.
uint16_t const & get_end_pc() const
Property: end_pc.
void initializeProperties()
Initialize all properties that have explicit initial values.
uint16_t const & get_RevisionNumber() const
Property: RevisionNumber.
void initializeProperties()
Initialize all properties that have explicit initial values.
void initializeProperties()
Initialize all properties that have explicit initial values.
void initializeProperties()
Initialize all properties that have explicit initial values.
unsigned const & get_e_reserved9() const
Property: Reserved area #9.
virtual ~SgAsmBinaryMsl()
Destructor.
unsigned const & get_reason() const
Property: Reason that function exists.
void initializeProperties()
Initialize all properties that have explicit initial values.
Purpose is not specified and could not be inferred.
uint16_t e_type
Object file type: relocatable, executable, lib, core.
uint32_t vda_name
Offset (in bytes) to strings table to name string.
virtual bool isFunctionReturnSlow(const std::vector< SgAsmInstruction * > &insns) override
Returns true if the specified basic block looks like a function return.
This function is known to never return.
uint32_t const & get_Signature() const
Property: Signature.
virtual std::string toString() const override
Convert a type to a string.
void initializeProperties()
Initialize all properties that have explicit initial values.
void set_entries(SgAsmElfEHFrameEntryFDPtrList const &)
Property: List of pointers to error handling frame descriptor entries.
uint32_t const & get_MemberForwarded() const
Property: MemberForwarded.
SgAsmType * get_elmtType() const
Property: Type of each vector element.
void initializeProperties()
Initialize all properties that have explicit initial values.
void set_metadataRoot(SgAsmCilMetadataRoot *const &)
Property: pointer to the root of the CIL Metadata.
virtual rose_addr_t calculate_sizes(size_t *total, size_t *required, size_t *optional, size_t *entcount) const override
Return sizes for various parts of the table.
void set_cb(uint32_t const &)
Property: Cb.
void set_e_nsections(unsigned const &)
Property: Number of sections.
32-bit format of an ELF symbol.
void set_Name(uint32_t const &)
Property: Name.
Represents the file header for DOS executables.
void set_e_subsys_minor(unsigned const &)
Property: Subsystem minor number.
static SgAsmGenericFile * parseBinaryFormat(const char *name)
Factory method that parses a binary file.
Section I/O privilege level (80x86 specific; used only for 16:16 alias objects)
void initializeProperties()
Initialize all properties that have explicit initial values.
rose_addr_t const & get_e_relocs_offset() const
Property: Relocs offset.
SgAsmJvmExceptionHandlerPtrList const & get_handlers() const
Property: List of pointers to exceptions.
SgAsmPEExportEntry()
Default constructor.
virtual ~SgAsmPEExportEntryList()
Destructor.
void set_kind(Rose::BinaryAnalysis::CilInstructionKind const &)
Property: Instruction kind.
JVM NestMembers attribute.
void set_string(std::string const &)
Property: String value.
uint64_t const & get_exportAddressTableJumps() const
Property: ExportAddressTableJumps.
SgAsmCilEvent()
Default constructor.
std::vector< uint32_t > const & get_NumberOfRows() const
Property: A vector indicating how many rows the present tables contain.
virtual ~SgAsmScalarType()
Destructor.
bool const & get_is_dynamic() const
Property: Whether this section represents dynamic linking symbols.
uint32_t const & get_Encld() const
Property: Encld.
rose_addr_t const & get_offset() const
Property: Offset of segment in the file.
void initializeProperties()
Initialize all properties that have explicit initial values.
uint16_t const & get_Flags() const
Property: Flags.
void set_purpose(SgAsmGenericSection::SectionPurpose const &)
Property: General contents of the section.
void initializeProperties()
Initialize all properties that have explicit initial values.
void initializeProperties()
Initialize all properties that have explicit initial values.
unsigned const & get_e_res3() const
Property: Rerserved area 3.
void initializeProperties()
Initialize all properties that have explicit initial values.
JVM LineNumberTable attribute.
uint32_t const & get_Name() const
Property: Name.
void set_FieldLayoutTable(SgAsmCilFieldLayoutTable *const &)
Property: FieldLayoutTable.
void set_Parent(uint32_t const &)
Property: Parent.
std::string read_content_str(const Rose::BinaryAnalysis::MemoryMap::Ptr &, rose_addr_t va, bool strict=true)
Reads a string from the file.
void initializeProperties()
Initialize all properties that have explicit initial values.
virtual rose_addr_t calculate_sizes(size_t *total, size_t *required, size_t *optional, size_t *nentries) const override
Return sizes for various parts of the table.
std::string const & get_name() const
Property: Name.
void set_majorRuntimeVersion(uint16_t const &)
Property: MajorRuntimeVersion.
SgAsmDwarfConstType()
Default constructor.
List of ELF EH frame CI entries.
void set_st_name(std::string const &)
Property: Symbol name.
unsigned long const & get_e_shnum() const
Property: shnum.
4.4.9 CONSTANT_MethodType_info table entry.
void initializeProperties()
Initialize all properties that have explicit initial values.
virtual ~SgAsmControlFlagsExpression()
Destructor.
std::string const & get_name() const
Property: Name.
CIL GenericParamConstraint node (II.22.21).
void initializeProperties()
Initialize all properties that have explicit initial values.
void initializeProperties()
Initialize all properties that have explicit initial values.
virtual ~SgAsmCilAssemblyRefProcessorTable()
Destructor.
void set_address(SgAsmExpression *const &)
Property: Memory address expression.
virtual ~SgAsmPERVASizePairList()
Destructor.
virtual void set_offset(rose_addr_t)
Property: Offset to start of section in file.
SgAsmGenericSectionPtrList get_sections_by_offset(rose_addr_t offset, rose_addr_t size) const
Find sections by their offset.
size_t const & get_index() const
Property: Register descriptor index.
SgAsmJvmStackMapVerificationType * parse(SgAsmJvmConstantPool *pool)
Initialize the object by parsing content from the class file.
Rose::BinaryAnalysis::M68kInstructionKind const & get_kind() const
Property: Instruction kind.
void set_coff_line_nums(unsigned const &)
Property: COFF line numbers.
void set_e_ss(uint16_t const &)
Property: SS.
SgAsmPEImportSection()
Default constructor.
static SgAsmExecutableFileFormat::InsSetArchitecture machine_to_isa(unsigned machine)
Convert ELF "machine" identifier to generic instruction set architecture value.
unsigned long const & get_e_ehsize() const
Property: ehsize.
void set_dll_name_nalloc(size_t const &)
Property: Bytes allocated in the file for the name.
SgAsmGenericSectionList()
Default constructor.
virtual bool isFunctionReturnSlow(const std::vector< SgAsmInstruction * > &insns) override
Returns true if the specified basic block looks like a function return.
void initializeProperties()
Initialize all properties that have explicit initial values.
SgAsmGenericSection * get_section_by_va(rose_addr_t va, bool use_preferred, size_t *nfound=0) const
Returns the section having a preferred or actual mapping that includes the specified virtual address...
virtual ~SgAsmDwarfArrayType()
Destructor.
uint32_t vna_next
Offset (in bytes) to next vernaux entry.
void set_name_index(uint16_t const &)
Property: name_index.
SgAsmGenericFile()
Default constructor.
virtual bool isFunctionReturnSlow(const std::vector< SgAsmInstruction * > &)
Returns true if the specified basic block looks like a function return.
Represents an ELF EH frame section.
void set_entries(SgAsmElfSymverDefinedAuxList *const &)
Property: Entries.
void initializeProperties()
Initialize all properties that have explicit initial values.
void initializeProperties()
Initialize all properties that have explicit initial values.
bool const & get_mapped_xperm() const
Property: Whether mapped with execute permission.
SgAsmElfEHFrameEntryCI()
Default constructor.
virtual ~SgAsmJvmStackMapVerificationType()
Destructor.
void initializeProperties()
Initialize all properties that have explicit initial values.
void set_absoluteValue(uint64_t)
Set absolute value.
SgAsmExecutableFileFormat()
Default constructor.
virtual ~SgAsmDwarfRestrictType()
Destructor.
virtual rose_addr_t calculate_sizes(size_t *total, size_t *required, size_t *optional, size_t *nentries) const override
Return sizes for various parts of the table.
void initializeProperties()
Initialize all properties that have explicit initial values.
std::string unparse(const SgAsmElfEHFrameSection *, SgAsmElfEHFrameEntryCI *) const
Unparse to string.
CIL FieldMarshal node (II.22.17).
CIL MethodSpec node (II.22.29).
virtual Rose::BinaryAnalysis::AddressSet getSuccessors(bool &complete) override
Control flow successors for a single instruction.
void set_Name(std::string const &)
Property: Name of the byte stream.
SgAsmPESectionTable *const & get_section_table() const
Property: Section table.
virtual Rose::BinaryAnalysis::AddressSet getSuccessors(bool &complete) override
Control flow successors for a single instruction.
void set_locals(SgAsmJvmStackMapVerificationTypePtrList const &)
Property: List of verification_type_info local variables.
SgAsmCilTypeDefTable *const & get_TypeDefTable() const
Property: TypeDefTable.
uint32_t const & get_TypeNamespace() const
Property: TypeNamespace.
virtual ~SgAsmCilUint32Heap()
Destructor.
unsigned long const & get_e_flags() const
Property: Flags.
One entry of an ELF notes table.
virtual ~SgAsmPEImportDirectoryList()
Destructor.
void initializeProperties()
Initialize all properties that have explicit initial values.
void set_MemberRefTable(SgAsmCilMemberRefTable *const &)
Property: MemberRefTable.
size_t const & get_nameptr_n() const
Property: Nameptr_n.
uint32_t const & get_flags() const
Property: Flags.
SgAsmNode()
Default constructor.
Not specified in file and could not be inferred.
uint32_t const & get_Flags() const
Property: Flags.
virtual bool reallocate() override
Update prior to unparsing.
uint16_t const & get_MinorVersion() const
Property: MinorVersion.
SgAsmInstructionPtrList const & get_instructions() const
Property: List of SgAsmInstruction entries.
virtual SgAsmJvmAttribute * parse(SgAsmJvmConstantPool *pool) override
Initialize the attribute by parsing the file.
SgAsmGenericHeaderList *const & get_headers() const
Property: List of all headers in file.
void set_prh_encoding(int const &)
Property: PRH encoding.
void set_Number(uint16_t const &)
Property: Number.
void set_def_state(SgAsmGenericSymbol::SymbolDefState const &)
Property: Definition state.
ELF string table section.
virtual void unparse(std::ostream &) const override
Write SymverDefined section back to disk.
CIL SgAsmCilMetadataRoot.
uint16_t const & get_MinorVersion() const
Property: Minor version number.
SgAsmElfSectionTableEntry *const & get_section_entry() const
Property: The section table entry corresponding to this section.
void set_e_lminor(unsigned const &)
Property: lminor.
void set_fields(SgAsmJvmFieldPtrList const &)
Property: List of pointers to fields.
virtual ~SgAsmBlock()
Destructor.
SgAsmGenericFormat::ExecFamily const & get_family() const
Property: Family.
void set_PermissionSet(uint32_t const &)
Property: PermissionSet.
rose_addr_t const & get_filesz() const
Property: Size of segment in file.
Implied by inter-basicblock branching.
void initializeProperties()
Initialize all properties that have explicit initial values.
uint32_t const & get_TypeDefIdName() const
Property: TypeDefIdName.
SgUnsigned16List const & get_bootstrap_arguments() const
Property: bootstrap_arguments.
Reference to memory locations.
void set_e_stack_commit_size(unsigned const &)
Property: Stack commit size.
virtual ~SgAsmNEStringTable()
Destructor.
void set_MethodBody(uint32_t const &)
Property: MethodBody.
virtual SgAsmJvmMethodTable * parse() override
Parses a JVM method table.
GOT entry for static TLS block offset.
SgAsmElfSectionTable()
Default constructor.
virtual ~SgAsmCilClassLayoutTable()
Destructor.
SgAsmCilPropertyMapTable()
Default constructor.
virtual ~SgAsmCilMetadata()
Destructor.
void set_EventMapTable(SgAsmCilEventMapTable *const &)
Property: EventMapTable.
void set_body(SgAsmBlock *const &)
Property: body.
void initializeProperties()
Initialize all properties that have explicit initial values.
void set_BuildNumber(uint16_t const &)
Property: BuildNumber.
void set_type(SgAsmType *const &)
Property: Type of expression.
SgAsmGenericHeader *const & get_header() const
Property: File header that owns this section.
SgUnsignedCharList const & get_instructions() const
Property: Instructions.
int const & get_flags() const
Property: Flags.
void set_DataSizeFlags(uint64_t const &)
Property: precomputed flags that determine whether a metadata reference is stored as 2 or 4 byte valu...
virtual ~SgAsmGenericFileList()
Destructor.
void initializeProperties()
Initialize all properties that have explicit initial values.
void set_ImportName(uint32_t const &)
Property: ImportName.
uint32_t const & get_Type() const
Property: Type.
SgAsmJvmAttributeTable *const & get_attribute_table() const
Property: Attribute table.
uint32_t const & get_Signature() const
Property: Signature.
virtual const char * format_name() const override
Returns the name of the file format.
void destructorHelper() override
This gets called by all Rosebud-generated destructors.
void dump(FILE *, const char *prefix, ssize_t idx) const override
Print some debugging information.
SgAsmCilFieldMarshalTable()
Default constructor.
uint32_t const & get_Processor() const
Property: Processor.
void initializeProperties()
Initialize all properties that have explicit initial values.
void initializeProperties()
Initialize all properties that have explicit initial values.
void set_reason(unsigned const &)
Property: Reason that function exists.
void initializeProperties()
Initialize all properties that have explicit initial values.
virtual ~SgAsmDwarfUpcSharedType()
Destructor.
SgAsmPEImportDirectory()
Default constructor.
void initializeProperties()
Initialize all properties that have explicit initial values.
virtual void destructorHelper() override
This gets called by all Rosebud-generated destructors.
virtual void parse(std::vector< uint8_t > &buf, size_t startOfMetaData)
}@
SgAsmDwarfLabel()
Default constructor.
virtual void dump(FILE *, const char *prefix, ssize_t idx) const
Print some debugging info.
virtual ~SgAsmDwarfInformation()
Destructor.
virtual size_t get_nBits() const override
Width of type in bits.
void set_comment(std::string const &)
Property: Commentary.
SgAsmElfSymbolList *const & get_symbols() const
Property: Symbols.
CIL ExportedType node (II.22.14).
void set_Size(uint32_t const &)
Property: Length of the byte stream.
void set_type(SgAsmElfRelocEntry::RelocType const &)
Property: Type.
uint32_t const & get_Name() const
Property: Name.
virtual ~SgAsmJvmAttributeTable()
Destructor.
SgAsmJvmStackMapTable()
Default constructor.
SgAsmExpression *const & get_address() const
Property: Memory address expression.
void initializeProperties()
Initialize all properties that have explicit initial values.
SgAsmElfSectionTableEntry()
Default constructor.
void initializeProperties()
Initialize all properties that have explicit initial values.
void initializeProperties()
Initialize all properties that have explicit initial values.
virtual ~SgAsmIntegerValueExpression()
Destructor.
SgAsmCoffSymbolPtrList const & get_symbols() const
Property: List of symbol pointers.
uint32_t const & get_code_length() const
Property: code_length.
virtual ~SgAsmGenericStrtab()
Destructor.
Direct 32 bit for local dynamic thread local data in LE code.
static Type * registerOrDelete(Type *toInsert)
Registers a type with the type system.
uint32_t const & get_Parent() const
Property: Parent.
void set_e_file_align(unsigned const &)
Property: File alignment.
32 bit signed PC relative offset to two GOT entries for GD symbol
virtual SgAsmJvmAttribute * parse(SgAsmJvmConstantPool *pool) override
Initialize the attribute by parsing the file.
virtual std::string toString() const
Convert a type to a string.
void set_modulus(size_t const &)
Property: Register descriptor modulus.
Segment contains NUL-terminated path name of interpreter.
SgAsmCilMemberRef()
Default constructor.
virtual ~SgAsmElfEHFrameEntryFD()
Destructor.
void set_attributes(SgAsmJvmAttributePtrList const &)
Property: List of pointers to attributes.
SgAsmPESection * init_from_section_table(SgAsmPESectionTableEntry *entry, int id)
Initializes the section from data parsed from the PE Section Table.
void set_stack_position(int const &)
Property: Position of element referenced on the stack.
void set_RVA(uint32_t const &)
Property: RVA.
void initializeProperties()
Initialize all properties that have explicit initial values.
unsigned const & get_e_header_size() const
Property: Header size.
void initializeProperties()
Initialize all properties that have explicit initial values.
void extend_to_eof(std::ostream &) const
Extend the output file by writing the last byte if it hasn't been written yet.
void set_instructions(SgUnsignedCharList const &)
Property: Instructions.
uint16_t const & get_host_class_index() const
Property: classes.
rose_rva_t const & get_dll_name_rva() const
Property: Address of the import library name.
uint32_t const & get_Extends() const
Property: Extends.
virtual ~SgAsmJvmNode()
Destructor.
uint32_t const & get_HashAlgId() const
Property: HashAlgId.
An ordered list of registers.
void set_ParamTable(SgAsmCilParamTable *const &)
Property: ParamTable.
virtual ~SgAsmCilMemberRef()
Destructor.
void set_name(SgAsmGenericString *const &)
Property: Name.
Block was added by the main CFG analysis.
void set_nativeValue(double)
Set AST node value to specified native value.
Microsoft New Executable Format.
unsigned const & get_flags() const
Property: Flags.
void initializeProperties()
Initialize all properties that have explicit initial values.
void set_GenericParamTable(SgAsmCilGenericParamTable *const &)
Property: GenericParamTable.
uint32_t ExportNamePtr_disk
The PE Export Name Pointer Table is an array of nameptr_n 4-byte RVAs pointing into the Export Name T...
uint16_t const & get_Flags() const
Property: Reserved space.
void initializeProperties()
Initialize all properties that have explicit initial values.
void set_version(size_t const &)
Property: Version.
rose_rva_t const & get_e_code_rva() const
Property: Code RVA.
SgAsmGenericDLLList()
Default constructor.
virtual void unparse(std::ostream &) const
Write string table back to disk.
static std::string reason_key(const std::string &prefix="")
Multi-line description of function reason keys from unparser.
uint16_t const & get_descriptor_index() const
Property: descriptor_index.
SgAsmDwarfInterfaceType()
Default constructor.
FunctionReason
Reasons why an instruction might be considered the beginning of a function.
virtual ~SgAsmCilInterfaceImplTable()
Destructor.
void set_e_bss_size(unsigned const &)
Property: BSS size.
void set_e_ident_data_encoding(unsigned char const &)
Property: Data encoding.
rose_rva_t const & get_hintname_rva() const
Property: RVA of hint/name pair.
int const & get_fd() const
Property: Read-only file descriptor.
void set_Flags(uint32_t const &)
Property: Flags.
virtual ~SgAsmCilPropertyMap()
Destructor.
SgAsmCilImplMap()
Default constructor.
void initializeProperties()
Initialize all properties that have explicit initial values.
virtual ~SgAsmCilImplMap()
Destructor.
Rose::BinaryAnalysis::CilInstructionKind const & get_kind() const
Property: Instruction kind.
uint32_t const & get_ParamList() const
Property: ParamList.
void set_relocs(SgAsmGenericSection *const &)
Property: Section containing relocation information.
SymbolBinding
Symbol binding.
SgAsmDwarfFunctionTemplate()
Default constructor.
rose_addr_t const & get_sh_entsize() const
Property: sh_entsize.
void set_NumberOfStreams(uint16_t const &)
Property: Reserved space.
void set_ImportScope(uint32_t const &)
Property: ImportScope.
SgAsmBinaryRor()
Default constructor.
std::string read_content_str(const Rose::BinaryAnalysis::MemoryMap::Ptr &, rose_addr_t va, bool strict=true)
Reads a string from a file.
uint8_t const & get_reference_kind() const
Property: reference_kind.
uint32_t const & get_hash() const
Property: Hash.
CIL Event tables.
void initializeProperties()
Initialize all properties that have explicit initial values.
virtual ~SgAsmElfSymbolList()
Destructor.
void set_TypeNamespace(uint32_t const &)
Property: TypeNamespace.
Base class for container file headers.
virtual ~SgAsmGenericFormat()
Destructor.
virtual void dump(FILE *, const char *prefix, ssize_t idx) const override
Print some debugging info.
void set_NestedClass(uint32_t const &)
Property: NestedClass.
virtual ~SgAsmUnarySignedExtend()
Destructor.
void initializeProperties()
Initialize all properties that have explicit initial values.
void dump(FILE *, const char *prefix, ssize_t idx) const override
Print some debugging information.
rose_addr_t const & get_r_offset() const
Property: Offset.
CIL Assembly tables.
void initializeProperties()
Initialize all properties that have explicit initial values.
bool const & get_contains_code() const
Property: Whether a section is known to contain code.
CIL EventMap tables.
SgAsmDwarfStringType()
Default constructor.
void initializeProperties()
Initialize all properties that have explicit initial values.
CIL GenericParam node (II.22.20).
low power, multi-core, lower clock frequency
std::string unparse(const SgAsmElfEHFrameSection *) const
Unparse an entry.
void initializeProperties()
Initialize all properties that have explicit initial values.
void set_minor_version(uint16_t const &)
Property: Minor version.
virtual ~SgAsmBinaryPreupdate()
Destructor.
void set_map(Rose::BinaryAnalysis::MemoryMap::Ptr const &)
Property: Memory map.
void set_e_cksum(uint16_t const &)
Property: Checksum.
uint16_t e_ip
0x14 initial value for IP register.
void set_CustomAttributeTable(SgAsmCilCustomAttributeTable *const &)
Property: CustomAttributeTable.
void set_entries(SgAsmElfSymverNeededAuxList *const &)
Property: List of entries.
CIL MemberRef node (II.22.25).
SPARC family of architectures; Sun Microsystems.
void initializeProperties()
Initialize all properties that have explicit initial values.
SgAsmPEStringSection()
Default constructor.
SgAsmDwarfSetType()
Default constructor.
std::string get_label(bool quiet=false) const
Returns a label for the value.
CIL AssemblyRefOS node (II.22.6).
Processor-specific range end.
CIL Module node (II.22.30).
An entry point specified in the file header.
std::string reloc_name() const
Convert relocation to string for debugging.
virtual ~SgAsmLENameTable()
Destructor.
void set_MethodDefTable(SgAsmCilMethodDefTable *const &)
Property: MethodDefTable.
void set_d_tag(SgAsmElfDynamicEntry::EntryType const &)
Property: Tag.
void set_strtab(SgAsmCoffStrtab *const &)
Property: String table.
virtual ~SgAsmUnaryPlus()
Destructor.
SgAsmBinaryAdd()
Default constructor.
SgAsmCilCustomAttributeTable()
Default constructor.
rose_addr_t const & get_e_size() const
Property: Size.
void set_begin_rva(rose_rva_t const &)
Property: Beginning relative virtual address.
SgAsmJvmField * parse(SgAsmJvmConstantPool *pool)
Initialize the object by parsing content from the class file.
void set_e_num_rvasize_pairs(unsigned const &)
Property: Number of RVA/size pairs.
SgAsmNESectionTableEntry()
Default constructor.
void set_Extends(uint32_t const &)
Property: Extends.
void set_rm_section(SgAsmGenericSection *const &)
Property: Real mode section.
void initializeProperties()
Initialize all properties that have explicit initial values.
void initializeProperties()
Initialize all properties that have explicit initial values.
virtual ~SgAsmCilParam()
Destructor.
virtual ~SgAsmSynthesizedFieldDeclaration()
Destructor.
SgAsmGenericSectionPtrList get_sections_by_offset(rose_addr_t offset, rose_addr_t size) const
Returns sectons in this header that contain all of the specified portion of the file.
SgAsmDwarfLineList()
Default constructor.
virtual void set_string(const std::string &s)
Property: String value.
uint16_t const & get_Flags() const
Property: Flags.
virtual ~SgAsmCoffSymbolList()
Destructor.
void initializeProperties()
Initialize all properties that have explicit initial values.
void set_Constraint(uint32_t const &)
Property: Constraint.
virtual ~SgAsmCommonSubExpression()
Destructor.
virtual ~SgAsmCilCustomAttribute()
Destructor.
void set_file_name(SgAsmGenericString *const &)
Property: File name.
void display(const std::string &label)
Output information about instruction address <–> source position.
void set_timestamp(time_t const &)
Property: Time stamp.
SgAsmGenericFormat *const & get_exec_format() const
Property: General info about the executable format.
void destructorHelper() override
Free StringStorage objects associated with this string table.
virtual ~SgAsmPERVASizePair()
Destructor.
JVM Signature attribute.
CIL AssemblyProcessor tables.
Java Virtual Machine (JVM) instruction set.
void dump(FILE *, const char *prefix, ssize_t idx) const override
Print some debugging information.
virtual void unparse(std::ostream &) const override
Write a section back to the file.
void parse(Rose::BinaryAnalysis::ByteOrder::Endianness sex, const SgAsmElfRelocEntry::Elf32RelaEntry_disk *disk)
Initialize object by parsing from file.
void dump(FILE *, const char *prefix, ssize_t idx) const override
Print some debugging information.
size_t get_extent(AddressIntervalSet *emap=NULL, rose_addr_t *lo_addr=NULL, rose_addr_t *hi_addr=NULL, NodeSelector *selector=NULL)
Returns information about the function addresses.
Section is resident and "long-lockable" (VDDs and PDDs only)
void set_Implementation(uint32_t const &)
Property: Implementation.
SgAsmElfSymverEntryList()
Default constructor.
void set_dwarf_info(SgAsmDwarfCompilationUnitList *const &)
Property: DWARF debugging hiearchy.
Expression represting negation.
void set_Action(uint16_t const &)
Property: Action.
uint16_t const & get_max_locals() const
Property: max_locals.
void set_Valid(uint64_t const &)
Property: A 4-byte value indicating which metadata tables are present.
List of pointers to other AST nodes.
Expression representing a machine register.
unsigned long const & get_phextrasz() const
Property: phextrasz.
void set_entry_rvas(SgRVAList const &)
Property: Code entry point wrt base virtual address.
virtual void dump(FILE *, const char *prefix, ssize_t idx) const
Print some debugging info.
uint32_t e_entry
Entry virtual address or zero if none.
Unreferenced address space is elastic.
void parse(std::vector< uint8_t > &buf, size_t startOfMetaData) override
}@
void set_iat_rva(rose_rva_t const &)
Property: IAT RVA.
void initializeProperties()
Initialize all properties that have explicit initial values.
void set_id(rose_addr_t const &)
Property: Identification.
Values reserved for processor-specific semantics.
risc-like pipelining, integrated FPU, on-chip cache
void set_coff_symtab(SgAsmCoffSymbolTable *const &)
Property: COFF symbol table.
virtual bool isFunctionReturnSlow(const std::vector< SgAsmInstruction * > &) override
Returns true if the specified basic block looks like a function return.
rose_addr_t get_size() const
Property: Size of section in file in bytes.
rose_addr_t const & get_e_nt_hdr_size() const
Property: Size of NT header.
virtual unsigned get_anyKind() const override
Returns instruction kind for any architecture.
uint16_t const & get_PackingSize() const
Property: PackingSize.
CIL GenericParamConstraint tables.
virtual SgAsmElfStrtab * parse() override
Parses the string table.
Base class for integer values.
virtual ~SgAsmDwarfReferenceType()
Destructor.
size_t const & get_index() const
Property: Index.
void set_baseNode(SgNode *const &)
Property: Base node associated with an integer.
void set_Sorted(uint64_t const &)
Property: A 4-byte value.
SgUnsignedCharList const & get_extra() const
Property: Extra bytes.
void set_flags(uint32_t const &)
Property: Flags.
SgAsmGenericSectionPtrList get_sections_by_va(rose_addr_t va, bool use_preferred) const
Returns sections having a preferred or actual mapping that includes the specified virtual address...
SgAsmLESection()
Default constructor.
virtual void dump(FILE *, const char *prefix, ssize_t idx) const override
Print some debugging info.
uint64_t const & get_sh_flags() const
Property: sh_flags.
void set_this_class(uint16_t const &)
Property: This class index.
uint32_t vd_aux
Offset (in bytes) to start of array of verdaux entries.
void set_line_number(uint16_t const &)
Property: line_number.
SgAsmCilInterfaceImpl()
Default constructor.
void set_function_kind(SgAsmFunction::function_kind_enum const &)
Property: Kind of function.
void set_EventType(uint32_t const &)
Property: EventType.
void set_Name(uint32_t const &)
Property: Name.
void set_family(SgAsmGenericFormat::ExecFamily const &)
Property: Family.
static Rose::BinaryAnalysis::X86InstructionSize instructionSizeForWidth(size_t)
Converts a size to an instruction size enum.
Describes (part of) a physical CPU register.
virtual void unparse(std::ostream &) const override
Write data to .eh_frame section.
virtual ~SgAsmElfSymbolSection()
Destructor.
SegmentType
Segment types (host order).
void set_Value(uint32_t const &)
Property: Value.
void dump(FILE *, const char *prefix, ssize_t idx) const override
Print some debugging information.
SgAsmCilMethodSpecTable()
Default constructor.
virtual void dump(FILE *, const char *prefix, ssize_t idx) const override
Print some debugging information.
SgAsmJvmMethodTable *const & get_method_table() const
Property: Method table.
void set_percentageCoverage(double const &)
Property: code coverage percent.
virtual SgAsmJvmAttribute * parse(SgAsmJvmConstantPool *pool) override
Initialize the attribute by parsing the file.
SgAsmDwarfPackedType()
Default constructor.
SgAsmGenericString *const & get_name() const
Property: Name.
void set_other(size_t const &)
Property: Other.
void set_symbols(SgAsmCoffSymbolPtrList const &)
Property: List of symbol pointers.
ELF file section containing symbols.
void set_iat_nalloc(size_t const &)
Property: Bytes allocated in the file for the IAT.
SgAsmStatementPtrList const & get_statementList() const
Property: Statements that make up a function.
void initializeProperties()
Initialize all properties that have explicit initial values.
ARM{946E-S,966E-S,968E-S,926EJ-S,966HS} cores.
uint16_t const & get_constantvalue_index() const
Property: constantvalue_index.
void initializeProperties()
Initialize all properties that have explicit initial values.
Sawyer::Optional< int64_t > asSigned() const
Return a signed constant if possible.
bool const & get_mapped_rperm() const
Property: Whether mapped with read permission.
Function contains basic blocks that were inserted by searching the address space between the blocks d...
uint32_t const & get_Signature() const
Property: Signature.
void initializeProperties()
Initialize all properties that have explicit initial values.
SgFileContentList const & get_data() const
Property: Contents of the file.
uint16_t const & get_Sequence() const
Property: Sequence.
virtual SgAsmJvmAttribute * parse(SgAsmJvmConstantPool *pool) override
Initialize the attribute by parsing the file.
void set_magic(SgCharList const &)
Property: Optional magic number in file byte order.
uint16_t const & get_method_index() const
Property: method_index.
void set_Parent(uint32_t const &)
Property: Parent.
virtual ~SgAsmGenericSymbolList()
Destructor.
uint16_t const & get_e_last_page_size() const
Property: Last page size.
Minimal set of dynamic linking symbols.
void set_e_res1(unsigned const &)
Property: Reserved field 1.
void parse(Rose::BinaryAnalysis::ByteOrder::Endianness, const SgAsmElfDynamicEntry::Elf32DynamicEntry_disk *)
Initialize object by parsing the file.
SgAsmElfRelocEntryList()
Default constructor.
virtual SgAsmGenericStrtab * parse()
Parse a string table.
unsigned const & get_e_os_minor() const
Property: OS minor number.
void set_e_os_major(unsigned const &)
Property: OS major number.
void initializeProperties()
Initialize all properties that have explicit initial values.
virtual ~SgAsmDOSFileHeader()
Destructor.
virtual ~SgAsmDwarfPackedType()
Destructor.
virtual ~SgAsmElfSectionTableEntry()
Destructor.
void set_sh_offset(rose_addr_t const &)
Property: sh_offset.
int64_t read_content_local_sleb128(rose_addr_t *rel_offset, bool strict=true)
Read a signed little-endian 128-bit value.
SgAsmCilModuleTable()
Default constructor.
Write permission granted when mapped.
Functions dynamically linked.
virtual ~SgAsmDwarfClassTemplate()
Destructor.
size_t cacheLockCount() const
Property: Cache lock count.
uint32_t p_memsz
0x24 number of bytes when mapped (may be zero)
void initializeProperties()
Initialize all properties that have explicit initial values.
void dump(FILE *f, const char *prefix, ssize_t idx, SgAsmElfSymbolSection *symtab) const
Print debugging information.
void set_inner_class_access_flags(uint16_t const &)
Property: inner_class_access_flags.
CIL InterfaceImpl node (II.22.23).
virtual SgAsmJvmAttribute * parse(SgAsmJvmConstantPool *pool) override
Initialize the attribute by parsing the file.
uint32_t const & get_Parent() const
Property: Parent.
void set_EventFlags(uint32_t const &)
Property: EventFlags.
This class represents the base class for all IR nodes within Sage III.
Definition: Cxx_Grammar.h:9846
List of operands for an instruction.
virtual void destructorHelper() override
This gets called by all Rosebud-generated destructors.
virtual bool isUnknown() const override
Returns true if this instruction is the special "unknown" instruction.
uint16_t const & get_e_ip() const
Property: IP.
SgAsmScalarType()
Default constructor.
void set_e_coff_symtab(rose_addr_t const &)
Property: COFF symbol table.
unsigned const & get_vminor() const
Property: VMinor.
SgAsmCilAssemblyRefOSTable *const & get_AssemblyRefOSTable() const
Property: AssemblyRefOSTable.
void initializeProperties()
Initialize all properties that have explicit initial values.
void initializeProperties()
Initialize all properties that have explicit initial values.
void set_entries(SgAsmElfSegmentTableEntryPtrList const &)
Property: Segment table entries.
void initializeProperties()
Initialize all properties that have explicit initial values.
void dump_all(bool in_cwd=true, const char *ext=NULL)
Print text file containing all known information about a binary file.
4.4.10 CONSTANT_Dynamic_info table entry.
virtual void unparse(std::ostream &) const
Write node to a binary file.
void set_TypeNamespace(uint32_t const &)
Property: TypeNamespace.
void set_host_class_index(uint16_t const &)
Property: classes.
void set_entries(SgAsmElfDynamicEntryPtrList const &)
Property: List of entries.
void set_callingConvention(std::string const &)
Property: Primary calling convention.
Base class for dynamically linked library information.
std::string const & get_comment() const
Property: Comment.
virtual SgAsmJvmNestMembers * parse(SgAsmJvmConstantPool *pool) override
Initialize the attribute by parsing the file.
virtual ~SgAsmCilModuleRefTable()
Destructor.
SgAsmCilPropertyMap()
Default constructor.
void set_exports(SgAsmPEExportEntryList *const &)
Property: List of export entries.
void set_inner_name_index(uint16_t const &)
Property: inner_name_index.
virtual SgAsmJvmStackMapTable * parse(SgAsmJvmConstantPool *pool) override
Initialize the object by parsing content from the class file.
virtual ~SgAsmDwarfEnumerator()
Destructor.
int const & get_version() const
Property: Version number.
SgAsmBinaryMod()
Default constructor.
void initializeProperties()
Initialize all properties that have explicit initial values.
uint32_t e_version
Object file version, currently zero or one.
x86 IA-32 family of architectures; Intel, AMD, VIA, ...
void * encode(Rose::BinaryAnalysis::ByteOrder::Endianness, SgAsmElfSegmentTableEntry::Elf32SegmentTableEntry_disk *) const
Converts segment table entry back into disk structure.
void set_exports(SgAsmPEExportEntryPtrList const &)
Property: List of pointers to nodes.
SgAsmGenericSymbol()
Default constructor.
virtual ~SgAsmCilExportedTypeTable()
Destructor.
virtual ~SgAsmCilNestedClassTable()
Destructor.
virtual ~SgAsmGenericSection()
Destructor.
SgAsmElfRelocEntry()
Default constructor.
SgAsmJvmClass()
Default constructor.
void set_attribute_table(SgAsmJvmAttributeTable *const &)
Property: Table of attributes.
void set_reference_kind(uint8_t const &)
Property: reference_kind.
SgAsmElfEHFrameSection()
Default constructor.
void set_e_header_size(unsigned const &)
Property: Header size.
void shift_extend(SgAsmGenericSection *s, rose_addr_t sa, rose_addr_t sn)
Moves and enlarges a section.
static void unparseBinaryFormat(const std::string &name, SgAsmGenericFile *)
Dump debugging information into a named text file.
void set_OSMinorVersion(uint32_t const &)
Property: OSMinorVersion.
void initializeProperties()
Initialize all properties that have explicit initial values.
Represents the file header of an JVM binary container.
uint16_t e_minalloc
0x0a number of extra paragraphs needed, similar to BSS in Unix.
List of ELF error handling frame descriptor entries.
void initializeProperties()
Initialize all properties that have explicit initial values.
void grab_content()
Saves a reference to the original file data for a section based on the section's current offset and s...
void set_sex(Rose::BinaryAnalysis::ByteOrder::Endianness const &)
Property: Byte order.
void set_name(SgAsmGenericString *)
Property: Name.
void set_ConstantTable(SgAsmCilConstantTable *const &)
Property: ConstantTable.
void dump(FILE *, const char *prefix, ssize_t idx) const override
Print some debugging information.
SgAsmJvmExceptions * parse(SgAsmJvmConstantPool *) override
Initialize the object by parsing content from the class file.
void initializeProperties()
Initialize all properties that have explicit initial values.
SgAsmDwarfVariant()
Default constructor.
virtual void dump(FILE *, const char *prefix, ssize_t idx) const override
Print some debugging info.
virtual void dump(FILE *, const char *prefix, ssize_t idx) const
Print some debugging info.
virtual bool reallocate() override
Reallocate space for the string section if necessary.
void set_bitVector(Sawyer::Container::BitVector const &)
Property: Bits for constant.
uint32_t const & get_Parent() const
Property: Parent.
void set_physical_size(rose_addr_t const &)
Property: Physical size.
unsigned const & get_e_stack_commit_size() const
Property: Stack commit size.
void initializeProperties()
Initialize all properties that have explicit initial values.
CIL PropertyMap tables.
Rose::BinaryAnalysis::ByteOrder::Endianness get_majorOrder() const
Property: Major byte order for mixed-order types.
R12000 + support for DDR SRAM; 200MHz front side bus.
uint16_t e_nrelocs
0x06 number of relocation entries stored after this header.
rose_addr_t const & get_virtual_size() const
Property: Virtual size.
SgAsmBlock *const & get_immediate_dominator() const
Property: Holds the immediate dominator block in the control flow graph.
virtual ~SgAsmElfSegmentTable()
Destructor.
void set_type(unsigned const &)
Property: Type of note.
SgAsmCilTypeRefTable *const & get_TypeRefTable() const
Property: TypeRefTable.
SgAsmGenericFormat::ExecABI const & get_abi() const
Property: Application binary interface.
void set_extra(SgUnsignedCharList const &)
Property: Value of padding bytes.
void set_Type(uint8_t const &)
Property: Type.
SgAsmPEImportDirectoryPtrList const & get_vector() const
Property: List of nodes.
A relative virtual address optionally associated with a SgAsmSection.
Definition: Cxx_Grammar.h:8423
virtual void unparse(std::ostream &) const override
Write constant pool entry to a binary file.
Carries from a 3-arg add operation.
void set_AssemblyProcessorTable(SgAsmCilAssemblyProcessorTable *const &)
Property: AssemblyProcessorTable.
void set_entries(SgAsmElfSymverNeededAuxPtrList const &)
Property: List of entries.
SgAsmElfEHFrameEntryCIPtrList const & get_entries() const
Property: List of pointers to ELF EH frame CI entries.
SgAsmCilMethodSemantics()
Default constructor.
virtual ~SgAsmElfSymverNeededEntry()
Destructor.
void add_hole(SgAsmGenericSection *)
Adds a new hole to the file.
uint32_t e_flags
Processor-specific flags (EF_* constants in docs)
void set_e_data_rva(rose_rva_t const &)
Property: Data RVA.
SgAsmGenericSection * get_section_by_offset(rose_addr_t offset, rose_addr_t size, size_t *nfound=0) const
Returns single section in this header that contains all of the specified portion of the file...
SgNode *const & get_baseNode() const
Property: Base node associated with an integer.
virtual ~SgAsmElfRelocSection()
Destructor.
void initializeProperties()
Initialize all properties that have explicit initial values.
CIL Field tables.
void set_ordinals_rva(rose_rva_t const &)
Property: Ordinals RVA.
Rose::BinaryAnalysis::ByteOrder::Endianness const & byteOrder() const
Property: Byte order.
void initializeProperties()
Initialize all properties that have explicit initial values.
void set_HashValue(uint32_t const &)
Property: HashValue.
Address mentioned in the ELF .eh_frame section.
Rose::BinaryAnalysis::PowerpcInstructionKind const & get_kind() const
Property: Instruction kind.
rose_rva_t const & get_ordinals_rva() const
Property: Ordinals RVA.
void initializeProperties()
Initialize all properties that have explicit initial values.
size_t get_significantBits() const
Return the number of significant bits in the value.
uint32_t const & get_PublicKeyOrToken() const
Property: PublicKeyOrToken.
void set_TypeDefIdName(uint32_t const &)
Property: TypeDefIdName.
size_t const & get_other() const
Property: Other.
SgAsmDwarfFriend()
Default constructor.
void set_reasonComment(std::string const &)
Property: Additional function existance reason comment.
SgAsmDwarfFormalParameter()
Default constructor.
void append_statement(SgAsmStatement *)
Add the specified statement to the end of the statement list.
virtual ~SgAsmGenericDLL()
Destructor.
Base class for a JVM attribute.
A single imported object.
SgAsmNullInstruction()
Default constructor.
void set_name(std::string const &)
Property: Name.
SgAsmCilMethodDefTable()
Default constructor.
uint64_t get_baseAddress() const
Returns the base address.
Rose::BinaryAnalysis::ByteOrder::Endianness get_minorOrder() const
Property: Minor byte order.
SgAsmGenericSection * get_section() const
Returns the section associated with an RVA/size pair.
SgAsmCilMethodImpl()
Default constructor.
register renaming, speculative execution
virtual bool reallocate() override
Called prior to unparse to make things consistent.
Processor-specific range start.
SgAsmJvmExceptions()
Default constructor.
int64_t const & get_stackDeltaOut() const
Property: Stack pointer at block exit w.r.t.
void initializeProperties()
Initialize all properties that have explicit initial values.
CIL NestedClass tables.
virtual unsigned get_anyKind() const override
Returns instruction kind for any architecture.
void set_DeclSecurityTable(SgAsmCilDeclSecurityTable *const &)
Property: DeclSecurityTable.
Associated with a section.
SgAsmGenericHeaderList()
Default constructor.
unsigned const & get_e_coff_nsyms() const
Property: Number of COFF symbols.
uint16_t const & get_outer_class_info_index() const
Property: outer_class_info_index.
Function for handling an exception.
SgAsmDwarfReferenceType()
Default constructor.
virtual ~SgAsmElfSymverDefinedEntry()
Destructor.
void initializeProperties()
Initialize all properties that have explicit initial values.
Represents one PowerPC machine instruction.
void initializeProperties()
Initialize all properties that have explicit initial values.
void set_aux_data(SgUnsignedCharList const &)
Property: Auxilliary data.
void set_e_lfanew(rose_addr_t const &)
Property: lfanew.
void set_base_va(rose_addr_t const &)
Property: Base virtual address used by all relative virtual addresses.
void initializeProperties()
Initialize all properties that have explicit initial values.
SgAsmElfSegmentTable *const & get_segment_table() const
Property: Segment table.
virtual bool isFunctionReturnFast(const std::vector< SgAsmInstruction * > &insns) override
Returns true if the specified basic block looks like a function return.
SgAsmDwarfMacroList()
Default constructor.
void add_section(SgAsmPESection *section)
Attaches a previously unattached PE Section to the PE Section Table.
SgAsmGenericSectionPtrList get_mapped_sections() const
Returns the list of sections that are memory mapped.
SgAsmDwarfAccessDeclaration()
Default constructor.
virtual ~SgAsmInterpretationList()
Destructor.
void set_mapped_alignment(rose_addr_t const &)
Property: Alignment in virtual memory.
virtual SgAsmElfStringSection * parse() override
Initialize object by parsing binary specimen.
One entry from an ELF symbol version definition table.
SgAsmDwarfTryBlock()
Default constructor.
virtual void debugSerializationBegin(const char *className)
Called by generated serializers.
unsigned const & get_hint() const
Property: Export name table hint if not ordinal.
virtual ~SgAsmJvmConstantPool()
Destructor.
void set_descriptor_index(uint16_t const &)
Property: descriptor_index.
void set_symbol(SgSymbol *const &)
Property: Symbol corresponding to this expression.
Address of a function symbol in a symbol table.
void initializeProperties()
Initialize all properties that have explicit initial values.
uint16_t const & get_EventFlags() const
Property: EventFlags.
SgAsmCilClassLayoutTable()
Default constructor.
void set_cached_vertex(size_t const &)
Property: Cached vertex for control flow graphs.
Represents a single ELF symbol.
SgAsmPEExportEntryPtrList const & get_exports() const
Property: List of pointers to nodes.
SgAsmJvmMethodTable()
Default constructor.
void set_type(SgAsmElfSegmentTableEntry::SegmentType const &)
Property: Segment type.
void initializeProperties()
Initialize all properties that have explicit initial values.
virtual ~SgAsmBinaryRor()
Destructor.
virtual void unparse(std::ostream &) const override
Write the object to a binary file.
void dump(FILE *, const char *prefix, ssize_t idx) const override
Print some debugging information.
std::string const & get_Name() const
Property: Name of the byte stream.
void set_st_name_offset(rose_addr_t const &)
Property: Symbol name offset.
CIL TypeRef node (II.22.38).
uint32_t vn_aux
Offset (in bytes) to start of array of vernaux entries.
SgAsmJvmModuleMainClass()
Default constructor.
void makeRelativeTo(SgNode *baseNode)
Makes the value of this integer relative to some other addressable node.
void initializeProperties()
Initialize all properties that have explicit initial values.
Target of call, possibly not in the CFG (see Partitioner::mark_call_insns).
SgAsmCilAssemblyTable *const & get_AssemblyTable() const
Property: AssemblyTable.
uint16_t const & get_access_flags() const
Property: Access flags.
void set_section_table(SgAsmPESectionTable *const &)
Property: Section table.
void set_Parent(uint32_t const &)
Property: Parent.
void set_signature_index(uint16_t const &)
Property: signature_index.
virtual ~SgAsmElfSymverDefinedEntryList()
Destructor.
bool has_instructions() const
Determins if a block contains instructions.
rose_rva_t const & get_name_rva() const
Property: RVA for name.
virtual void set_size(rose_addr_t newsize) override
Adjust size of table.
Thread-local data object.
void set_sh_addr(rose_addr_t const &)
Property: sh_addr.
Base class for strings related to binary specimens.
void set_entries(SgAsmElfSymverEntryList *const &)
Property: List of table entries.
SgAsmCilClassLayoutTable *const & get_ClassLayoutTable() const
Property: ClassLayoutTable.
uint16_t const & get_minorRuntimeVersion() const
Property: MinorRuntimeVersion.
void set_entries(SgAsmElfSymverDefinedAuxPtrList const &)
Property: List of entries.
SgAsmJvmLineNumberTable()
Default constructor.
void set_kind(Rose::BinaryAnalysis::JvmInstructionKind const &)
Property: Instruction kind.
void set_constant_pool(SgAsmJvmConstantPool *const &)
Property: Constant pool.
virtual bool terminatesBasicBlock() override
Determines if this instruction normally terminates a basic block.
virtual ~SgAsmPEExportEntry()
Destructor.
uint16_t const & get_e_ss() const
Property: SS.
SgAsmFunction()
Default constructor.
void set_FieldRVATable(SgAsmCilFieldRVATable *const &)
Property: FieldRVATable.
void set_bytes(uint32_t const &)
Property: bytes.
size_t const & get_version() const
Property: Version.
void set_NamePadding(uint32_t const &)
Property: Name of the byte stream.
SgAsmBinaryPreupdate()
Default constructor.
void set_Association(uint32_t const &)
Property: Association.
uint32_t const & get_Method() const
Property: Method.
rose_addr_t get_next_section_offset(rose_addr_t offset)
File offset of next section.
Default value for Partitioner class.
SectionFlags
Section Flags (host order).
rose_addr_t const & get_sh_addr() const
Property: sh_addr.
uint32_t const & get_Name() const
Property: Name.
void set_dlls(SgAsmGenericDLLList *const &)
Property: List of dynamically linked libraries.
virtual void unparse(std::ostream &) const override
Write the Exceptions attribute to a binary file.
void set_Flags(uint16_t const &)
Property: Flags.
CIL MethodSemantics node (II.22.28).
void set_bootstrap_method_attr_index(uint16_t const &)
Property: bootstrap_method_attr_index.
time_t const & get_timestamp() const
Property: Time stamp.
SgAsmPEImportItemPtrList const & get_vector() const
Property: List of pointers to other nodes.
void set_index(size_t const &)
Property: Index.
void set_TypeRefTable(SgAsmCilTypeRefTable *const &)
Property: TypeRefTable.
virtual ~SgAsmDwarfImportedModule()
Destructor.
virtual bool isFunctionReturnFast(const std::vector< SgAsmInstruction * > &)
Returns true if the specified basic block looks like a function return.
virtual Rose::BinaryAnalysis::AddressSet getSuccessors(bool &complete)
Control flow successors for a single instruction.
deeply pipelined, high frequency, SSE2, hyper-threading
virtual ~SgAsmMipsInstruction()
Destructor.
void initializeProperties()
Initialize all properties that have explicit initial values.
void set_e_image_size(unsigned const &)
Property: Image size.
DOS exteded header.
void set_e_overlay(uint16_t const &)
Property: Overlay.
uint16_t const & get_majorRuntimeVersion() const
Property: MajorRuntimeVersion.
void initializeProperties()
Initialize all properties that have explicit initial values.
SgAsmStringStorage()
Default constructor.
SgAsmElfSectionTableEntry::SectionType const & get_sh_type() const
Property: sh_type.
SgAsmDOSExtendedHeader()
Default constructor.
double get_nativeValue() const
Get value in native format.
uint16_t const & get_ResolutionScope() const
Property: ResolutionScope.
uint32_t const & get_Signature() const
Property: Signature.
SgAsmDwarfEnumerationType()
Default constructor.
virtual ~SgAsmBinaryPostupdate()
Destructor.
void set_sections(SgAsmGenericSectionList *const &)
Property: List of file sections.
GOT entry for negated static TLS block offset.
virtual ~SgAsmNode()
Destructor.
void initializeProperties()
Initialize all properties that have explicit initial values.
virtual ~SgAsmCilGenericParam()
Destructor.
SgAsmGenericString * get_name() const
Property: Name.
SgAsmBlock()
Default constructor.
void set_MinorVersion(uint16_t const &)
Property: MinorVersion.
CIL TypeDef node (II.22.37).
virtual SgAsmJvmAttribute * parse(SgAsmJvmConstantPool *pool)
Initialize an attribute by parsing the file.
SgAsmInstructionList *const & get_instruction_list() const
Property: Instruction list.
File does not specify an architecture.
virtual void dump(FILE *, const char *prefix, ssize_t idx) const override
Print some debugging info.
void set_size(rose_addr_t const &)
Property: Size in bytes.
void set_mapped_wperm(bool const &)
Property: Whether mapped with write permission.
void parse(Rose::BinaryAnalysis::ByteOrder::Endianness, const SgAsmElfSymverNeededEntry::ElfSymverNeededEntry_disk *)
Initialize object by parsing file.
CIL File node (II.22.19).
void set_attribute_length(uint32_t const &)
Property: attribute_length.
uint32_t vda_next
Offset (in bytes) to next verdaux entry.
void set_MajorVersion(uint16_t const &)
Property: Major version number.
virtual ~SgAsmDwarfCondition()
Destructor.
static Rose::BinaryAnalysis::RegisterDictionaryPtr registersForWidth(size_t)
Return the register dictionary for a PowerPC architecture.
SectionPurpose
Reason for section's existence.
virtual std::string toString() const override
Convert a type to a string.
void initializeProperties()
Initialize all properties that have explicit initial values.
List of COFF symbols.
PairPurpose
Reason for each rva/size pair in the PE header.
void initializeProperties()
Initialize all properties that have explicit initial values.
Represents static data in an executable.
SgAsmCilFieldRVA()
Default constructor.
void set_Signature(uint32_t const &)
Property: Signature.
void initializeProperties()
Initialize all properties that have explicit initial values.
SgAsmCilAssemblyProcessor()
Default constructor.
void set_PublicKeyOrToken(uint32_t const &)
Property: PublicKeyOrToken.
void initializeProperties()
Initialize all properties that have explicit initial values.
virtual void set_size(rose_addr_t)
Property: Size of section in file in bytes.
unsigned const & get_forwarder_chain() const
Property: Forwarder chain.
void initializeProperties()
Initialize all properties that have explicit initial values.
void set_eh_data(uint64_t const &)
Property: Data value.
virtual ~SgAsmElfStringSection()
Destructor.
virtual ~SgAsmDwarfImportedUnit()
Destructor.
SgAsmCilAssemblyRefProcessorTable()
Default constructor.
virtual ~SgAsmCilDeclSecurityTable()
Destructor.
virtual ~SgAsmJvmNestHost()
Destructor.
uint16_t const & get_name_and_type_index() const
Property: name_and_type_index.
Represents a JVM attribute_info table/array.
SgAsmPowerpcInstruction()
Default constructor.
CIL AssemblyOS node (II.22.3).
void set_method_table(SgAsmJvmMethodTable *const &)
Property: Method table.
Base class for unary expressions.
SgAsmFunction::MayReturn const & get_may_return() const
Property: Whether a function could return to its caller.
SgAsmCilMemberRefTable *const & get_MemberRefTable() const
Property: MemberRefTable.
SgAsmElfSection *const & get_target_section() const
Property: Section targeted by these relocations.
SgAsmUnaryTruncate()
Default constructor.
void set_Sequence(uint16_t const &)
Property: Sequence.
virtual ~SgAsmCilFieldMarshalTable()
Destructor.
void set_e_oemid(unsigned const &)
Property: OEM ID.
virtual ~SgAsmCilTypeSpec()
Destructor.
void set_MajorVersion(uint8_t const &)
Property: A 1-byte constant.
SgAsmStaticData()
Default constructor.
virtual ~SgAsmCilModuleTable()
Destructor.
bool get_sha1(uint8_t digest[20], NodeSelector *selector=NULL)
Computes the SHA1 message digest for the bytes of a function.
void set_sh_flags(uint64_t const &)
Property: sh_flags.
Base class for many binary analysis nodes.
Represents one Intel x86 machine instruction.
uint32_t const & get_Field() const
Property: Field.
Execute permission granted when mapped.
virtual void dump(FILE *, const char *prefix, ssize_t idx) const override
Print some debugging info.
Base class for CIL branch of binary analysis IR nodes.
void set_interfaces(std::list< uint16_t > const &)
Property: Interfaces.
virtual bool reallocate() override
Called prior to unparse to make things consistent.
SgAsmJvmSignature()
Default constructor.
virtual ~SgAsmCilFile()
Destructor.
virtual bool reallocate() override
Allow all sections to reallocate themselves.
void set_MinorVersion(uint16_t const &)
Property: Minor version number.
void set_prh_addr(rose_addr_t const &)
Property: PRH address.
virtual ~SgAsmStackExpression()
Destructor.
uint32_t const & get_Offset() const
Property: Offset.
void set_Signature(uint32_t const &)
Property: Signature.
SgAsmElfEHFrameEntryFDList *const & get_fd_entries() const
Property: FD entries.
void initializeProperties()
Initialize all properties that have explicit initial values.
void initializeProperties()
Initialize all properties that have explicit initial values.
SgAsmElfSymverDefinedEntryList()
Default constructor.
void set_name(SgAsmGenericString *s)
Property: Name.
Base class for statement-like subclasses.
SgAsmNERelocEntry()
Default constructor.
4.4.4 CONSTANT_Integer_info table entry.
virtual ~SgAsmDwarfFormatLabel()
Destructor.
rose_rva_t const & get_bound_rva() const
Property: Bound RVA from IAT if not a copy of ILT.
unsigned const & get_e_lminor() const
Property: lminor.
void set_align(rose_addr_t const &)
Property: Alignment.
size_t signBit() const
Property: Offset to significand sign bit.
virtual ~SgAsmVectorType()
Destructor.
void set_word_size(size_t const &)
Property: Natural word size in bytes.
void initializeProperties()
Initialize all properties that have explicit initial values.
SgAsmCilAssemblyTable()
Default constructor.
void set_flags(int const &)
Property: Flags.
virtual ~SgAsmBinarySubtract()
Destructor.
void set_sections(SgAsmGenericSectionPtrList const &)
Property: List of section pointers.
virtual ~SgAsmCilMethodDef()
Destructor.
void set_segment_table(SgAsmElfSegmentTable *const &)
Property: Segment table.
virtual void unparse(std::ostream &) const override
Write the section table section back to disk.
size_t const & get_expaddr_n() const
Property: Expaddr_n.
Target of a function call instruction sequence in the CFG.
uint16_t const & get_major_version() const
Property: Major version.
void set_ResolutionScope(uint16_t const &)
Property: ResolutionScope.
CIL TypeSpec node (II.22.39).
void initializeProperties()
Initialize all properties that have explicit initial values.
Base class for CIL branch of binary analysis IR nodes.
virtual ~SgAsmCilMetadataRoot()
}@
virtual ~SgAsmDwarfConstructList()
Destructor.
uint32_t const & get_TypeNamespace() const
Property: TypeNamespace.
SgAsmJvmStackMapFrame * parse(SgAsmJvmConstantPool *pool)
Initialize the object by parsing content from the class file.
ExecFamily
Architecture family.
void set_Name(uint32_t const &)
Property: Name.
uint32_t const & get_Name() const
Property: Name.
SgAsmPESectionTable()
Default constructor.
unsigned char st_res1
Reserved; always zero.
SgAsmJvmInstruction()
Default constructor.
void set_e_res2(unsigned const &)
Property: Rerserved area 2.
void initializeProperties()
Initialize all properties that have explicit initial values.
This function returns each time it is called.
void set_dll_name_rva(rose_rva_t const &)
Property: Address of the import library name.
virtual ~SgAsmCilExportedType()
Destructor.
void set_e_ip(uint16_t const &)
Property: IP.
Rose::BinaryAnalysis::RegisterDescriptor const & get_offset() const
Property: Register descriptor offset.
SgAsmCilModuleRefTable()
Default constructor.
virtual ~SgAsmCilConstantTable()
Destructor.
virtual ~SgAsmDwarfMacro()
Destructor.
void set_entries(SgAsmElfRelocEntryList *const &)
Property: List of entries.
void set_Signature(uint32_t const &)
Property: Signature.
SgAsmJvmExceptionTable()
Default constructor.
uint32_t const & get_OSMajorVersion() const
Property: OSMajorVersion.
virtual ~SgAsmJvmExceptions()
Destructor.
void set_descriptor_index(uint16_t const &)
Property: descriptor_index.
virtual ~SgAsmCilInstruction()
Destructor.
uint64_t const & get_DataSizeFlags() const
Property: precomputed flags that determine whether a metadata reference is stored as 2 or 4 byte valu...
void set_sh_entsize(rose_addr_t const &)
Property: sh_entsize.
SgAsmGenericSymbolPtrList const & get_symbols() const
Property: List of symbol nodes.
unsigned const & get_ordinal() const
Property: Ordinal number.
SgAsmCilParam()
Default constructor.
void initializeProperties()
Initialize all properties that have explicit initial values.
int const & get_prh_encoding() const
Property: PRH encoding.
Represents one entry of a segment table.
void dump(FILE *, const char *prefix, ssize_t idx) const override
Print some debugging information.
uint8_t const & get_ReservedAlwaysOne() const
Property: A 1-byte constant.
void initializeProperties()
Initialize all properties that have explicit initial values.
uint32_t const & get_attribute_length() const
Property: attribute_length.
void set_kind(Rose::BinaryAnalysis::X86InstructionKind const &)
Property: Instruction kind.
Expression representing sign extending.
virtual identical: Pacempi's R3400, IDT's R3500, Toshiba R3900
void initializeProperties()
Initialize all properties that have explicit initial values.
virtual void dump(FILE *, const char *prefix, ssize_t idx) const override
Print some debugging info.
virtual void dump(FILE *, const char *prefix, ssize_t idx) const override
Print some debugging info.
void set_section(SgAsmGenericSection *section)
Sets or removes the section associated with an RVA/size pair.
SgAsmLESectionTableEntry()
Default constructor.
std::string const & get_name_md5() const
Property: Hash of the function.
SgAsmCilFieldLayout()
Default constructor.
void set_Length(uint32_t const &)
Property: Number of bytes allocated to hold version string (including null terminator).
Base class for expressions.
uint8_t const & get_MinorVersion() const
Property: A 1-byte constant.
virtual bool terminatesBasicBlock() override
Determines if this instruction normally terminates a basic block.
uint16_t const & get_BuildNumber() const
Property: BuildNumber.
SgAsmCilFieldTable *const & get_FieldTable() const
Property: FieldTable.
CIL ModuleRef node (II.22.31).
SgAsmCilEventTable *const & get_EventTable() const
Property: EventTable.
SgAsmSynthesizedDeclaration()
Default constructor.
virtual ~SgAsmElfSymverNeededAux()
Destructor.
virtual bool reallocate() override
Pre-unparsing updates.
void append_operand(SgAsmExpression *operand)
Append another operand expression to this node.
SgAsmFloatType()
Default constructor.
virtual ~SgAsmIndirectRegisterExpression()
Destructor.
void add_entry_rva(const rose_rva_t &rva)
Append an RVA to the list of entry points.
uint16_t const & get_MappingFlags() const
Property: MappingFlags.
uint16_t const & get_offset_delta() const
Property: offset_delta.
4.4.12 CONSTANT_Package_info table entry.
SgAsmDwarfTemplateValueParameter()
Default constructor.
virtual void unparse(std::ostream &) const override
Write field to a binary file.
SgAsmDwarfSubroutineType()
Default constructor.
SgAsmElfSymverDefinedEntryList *const & get_entries() const
Property: List of entries.
Table of code addresses used by indirect branches.
CIL MethodImpl tables.
SgAsmGenericSection *const & get_rm_section() const
Property: Real mode section.
virtual ~SgAsmCilAssembly()
Destructor.
void initializeProperties()
Initialize all properties that have explicit initial values.
uint16_t const & get_inner_class_access_flags() const
Property: inner_class_access_flags.
static bool is_ELF(SgAsmGenericFile *)
Return true if the file looks like it might be an ELF file according to the magic number...
void initializeProperties()
Initialize all properties that have explicit initial values.
SgAsmStatementPtrList const & get_statementList() const
Property: Statements of which this block is composed.
4.4.3 CONSTANT_String_info table entry.
virtual ~SgAsmElfEHFrameEntryCI()
Destructor.
SgUnsignedCharList const & get_e_ident_padding() const
Property: Padding.
SgAsmGenericString *const & get_dll_name() const
Property: Name of library from which to import.
virtual ~SgAsmDwarfCompilationUnit()
Destructor.
SgAsmDwarfInlinedSubroutine()
Default constructor.
SgAsmNESectionTable()
Default constructor.
void set_MinorVersion(uint16_t const &)
Property: MinorVersion.
void set_Parent(uint32_t const &)
Property: Parent.
void initializeProperties()
Initialize all properties that have explicit initial values.
virtual void dump(FILE *, const char *prefix, ssize_t idx) const override
Print some debugging info.
virtual void check() const override
Validate properties collectively.
SgAsmElfDynamicEntryPtrList const & get_entries() const
Property: List of entries.
SgAsmElfSegmentTableEntryList()
Default constructor.
uint32_t e_phoff
File offset of program header table or zero if none.
SgAsmCilEventMapTable *const & get_EventMapTable() const
Property: EventMapTable.
void set_AssemblyRef(uint32_t const &)
Property: AssemblyRef.
SgAsmLENameTable()
Default constructor.
SgAsmExpressionPtrList const & get_expressions() const
Property: Pointers to expressions.
SgAsmElfSection * init_from_section_table(SgAsmElfSectionTableEntry *, SgAsmElfStringSection *, int id)
Initializes the section from data parsed from the ELF Section Table.
virtual SgAsmJvmLineNumberTable * parse(SgAsmJvmConstantPool *pool) override
Initialize the attribute by parsing the file.
MipsInstructionKind
Kinds of MIPS instructions.
uint16_t e_header_paragraphs
0x08 header size in paragraphs (16-byte blocks) inc.
virtual void dump(FILE *, const char *prefix, ssize_t idx) const override
Print some debugging info.
SgAsmJvmFieldTable *const & get_field_table() const
Property: Field table.
static size_t widthForInstructionSize(Rose::BinaryAnalysis::X86InstructionSize)
Converts a size enum constant to a size.
SgAsmElfSymverNeededAux()
Default constructor.
virtual ~SgAsmCilMethodImplTable()
Destructor.
void set_ModuleTable(SgAsmCilModuleTable *const &)
Property: ModuleTable.
void set_ImplMapTable(SgAsmCilImplMapTable *const &)
Property: ImplMapTable.
virtual ~SgAsmDwarfMutableType()
Destructor.
SgAsmFunction * get_enclosing_function() const
Returns the function that owns this block.
void set_e_flags(unsigned const &)
Property: Flags.
virtual ~SgAsmDwarfSetType()
Destructor.
void set_instructions(SgAsmInstructionPtrList const &)
Property: List of SgAsmInstruction entries.
PC relative 32 bit signed.
SgAsmCilUint8Heap * get_StringHeap() const
accessor functions to return specific heaps
SgAsmUnaryUnsignedExtend()
Default constructor.
ID of module containing symbol.
SgAsmJvmConstantPool()
Default constructor.
void set_hintname_nalloc(size_t const &)
Property: File bytes allocated for hint/name pair.
SgAsmElfSymverNeededSection()
Default constructor.
uint16_t e_ehsize
Size of ELF header in bytes.
unsigned const & get_e_res2() const
Property: Rerserved area 2.
void initializeProperties()
Initialize all properties that have explicit initial values.
uint32_t const & get_EventType() const
Property: EventType.
SgAsmCilStandAloneSig()
Default constructor.
virtual ~SgAsmType()
Destructor.
uint8_t const & get_frame_type() const
Property: frame_type.
virtual rose_addr_t calculate_sizes(size_t *total, size_t *required, size_t *optional, size_t *nentries) const override
Return sizes for various parts of the table.
void set_ExportedTypeTable(SgAsmCilExportedTypeTable *const &)
Property: ExportedTypeTable.
rose_addr_t const & get_value() const
Property: Symbol value.
void initializeProperties()
Initialize all properties that have explicit initial values.
virtual ~SgAsmNEFileHeader()
Destructor.
SgAsmJvmFileHeader()
Default constructor.
unsigned const & get_e_subsystem() const
Property: Subsystem.
void set_container(SgAsmGenericSection *const &)
Property: Section storing this string table.
SgAsmCilModuleRef()
Default constructor.
virtual void dump(FILE *f, const char *prefix, ssize_t idx) const
Print debugging information.
virtual bool isFunctionCallFast(const std::vector< SgAsmInstruction * > &insns, rose_addr_t *target, rose_addr_t *ret) override
Returns true if the specified basic block looks like a function call.
Expression that performs a logical left shift operation.
virtual void dump(FILE *, const char *prefix, ssize_t idx) const override
Print some debugging info.
void set_catch_type(uint16_t const &)
Property: catch_type.
List of pointers to other nodes.
void initializeProperties()
Initialize all properties that have explicit initial values.
virtual ~SgAsmBinaryDivide()
Destructor.
uint64_t const & get_managedNativeHeader() const
Property: ManagedNativeHeader.
virtual ~SgAsmCilFieldRVATable()
Destructor.
SgAsmDwarfEntryPoint()
Default constructor.
rose_addr_t calculate_sizes(size_t *entsize, size_t *required, size_t *optional, size_t *entcount) const
Returns info about the size of the entries based on information already available.
void initializeProperties()
Initialize all properties that have explicit initial values.
virtual void dump(FILE *, const char *prefix, ssize_t idx) const override
Print some debugging info.
SgAsmJvmInnerClassesEntry()
Default constructor.
uint32_t const & get_Mvid() const
Property: Mvid.
virtual ~SgAsmCilFieldLayout()
Destructor.
void initializeProperties()
Initialize all properties that have explicit initial values.
virtual void unparse(std::ostream &) const override
Write object to a binary file.
Expression that multiplies two operands.
void initializeProperties()
Initialize all properties that have explicit initial values.
void initializeProperties()
Initialize all properties that have explicit initial values.
virtual Rose::BinaryAnalysis::AddressSet getSuccessors(bool &complete) override
Control flow successors for a single instruction.
SgAsmGenericSection::SectionPurpose const & get_purpose() const
Property: General contents of the section.
SgAsmGenericSection()
Default constructor.
virtual ~SgAsmCilClassLayout()
Destructor.
uint32_t const & get_Flags() const
Property: Flags.
SgAsmDwarfRestrictType()
Default constructor.
uint32_t p_vaddr
0x08 desired mapped address of segment
Unreferenced and "hole" sections are elastic.
void * encode(Rose::BinaryAnalysis::ByteOrder::Endianness, SgAsmElfSymverDefinedEntry::ElfSymverDefinedEntry_disk *) const
Convert to the disk format.
void initializeProperties()
Initialize all properties that have explicit initial values.
virtual std::string description() const
Return a description of this instruction.
static std::string to_string(SgAsmElfSegmentTableEntry::SegmentType)
Convert segment type to string.
void set_Field(uint32_t const &)
Property: Field.
void set_res1(unsigned const &)
Property: Reserved aread #1.
void set_e_ident_file_version(unsigned char const &)
Property: File version.
SgAsmGenericSectionPtrList get_sectab_sections()
Get the list of sections defined in the ELF Section Table.
Direct 32 bit for GNU version of local dynamic thread local data in LE code.
void set_adjustment(int const &)
Property: Post-increment or pre-decrement amount.
Expression that performs a logical left shift operation filling low-order bits with one...
virtual ~SgAsmNESectionTable()
Destructor.
void initializeProperties()
Initialize all properties that have explicit initial values.
virtual void dump(FILE *f, const char *prefix, ssize_t idx) const
Print debugging information.
void set_mapped_xperm(bool const &)
Property: Whether mapped with execute permission.
void initializeProperties()
Initialize all properties that have explicit initial values.
SgAsmDwarfUpcSharedType()
Default constructor.
SgAsmElfSymverDefinedAuxList()
Default constructor.
uint8_t const & get_Type() const
Property: Type.
rose_addr_t const & get_mapped_actual_va() const
Property: Virtual address where ROSE maps this section.
void initializeProperties()
Initialize all properties that have explicit initial values.
void set_instruction_map(const InstructionMap &)
Property: Cached map of instructions by address.
virtual Sawyer::Optional< rose_addr_t > branchTarget() override
Obtains the virtual address for a branching instruction.
std::string const & get_name() const
Property: Name of file.
void initializeProperties()
Initialize all properties that have explicit initial values.
SgAsmCilTypeSpec()
Default constructor.
SgAsmElfSectionTableEntry * add_section(SgAsmElfSection *)
Attaches a previously unattached ELF Section to the section table.
rose_addr_t const & get_vaddr() const
Property: Virtual address.
SgAsmDwarfMutableType()
Default constructor.
void set_Name(uint32_t const &)
Property: Name.
uint16_t st_shndx
Section index or special meaning.
void set_e_dll_flags(unsigned const &)
Property: DLL flags.
Negated offset relative to static TLS block.
void set_hintname_rva(rose_rva_t const &)
Property: RVA of hint/name pair.
SgAsmCilPropertyTable *const & get_PropertyTable() const
Property: PropertyTable.
virtual ~SgAsmNEModuleTable()
Destructor.
virtual std::string description() const override
Return a description of this instruction.
void initializeProperties()
Initialize all properties that have explicit initial values.
Represents one MIPS machine instruction.
void set_offset(uint16_t const &)
Property: offset.
void set_e_flags(unsigned long const &)
Property: Flags.
void set_e_heap_reserve_size(unsigned const &)
Property: Heap reserve size.
void set_initLocals(bool const &)
Property: initLocals.
void initializeProperties()
Initialize all properties that have explicit initial values.
void set_sym(unsigned long const &)
Property: Sym.
Represents an entry in a stack map table.
void set_offset(Rose::BinaryAnalysis::RegisterDescriptor const &)
Property: Register descriptor offset.
Node to hold list of ELF note entries.
void initializeProperties()
Initialize all properties that have explicit initial values.
void mark_referenced_extent(rose_addr_t start_rva, rose_addr_t size)
Marks part of a file as having been referenced if tracking references.
void set_augmentation_string(std::string const &)
Property: Augmentation string.
void set_OSPlatformID(uint32_t const &)
Property: OSPlatformID.
CIL CustomAttribute node (II.22.10).
void parse(Rose::BinaryAnalysis::ByteOrder::Endianness, const SgAsmElfSymverDefinedEntry::ElfSymverDefinedEntry_disk *)
Initialize by parsing information from the file.
rose_rva_t const & get_export_rva() const
Property: Export RVA.
virtual void check() const override
Validate properties collectively.
BitRange exponentBits() const
Property: Number of bits in the exponent.
JVM LineNumberEntry.
virtual std::set< rose_addr_t > explicitConstants() const
Explicit constants.
void set_successors(SgAsmIntegerValuePtrList const &)
Property: Control flow successors.
uint16_t e_shentsize
Size of each entry in the section header table.
virtual ~SgAsmCilMethodDefTable()
Destructor.
bool const & get_tracking_references() const
Property: Whether to track referenced areas during parsing.
void set_codeManagerTable(uint64_t const &)
Property: CodeManagerTable.
uint16_t const & get_name_index() const
Property: name_index.
SgAsmLESectionTable()
Default constructor.
SgAsmElfSymverNeededAuxList *const & get_entries() const
Property: List of entries.
virtual ~SgAsmDwarfLineList()
Destructor.
SgAsmElfSymbolList()
Default constructor.
Exception(const std::string &s)
Construct an exception with an error message.
virtual void unparse(std::ostream &) const override
Write a section back to the file.
void initializeProperties()
Initialize all properties that have explicit initial values.
List of entries from a symbol version table.
quad core, 128-bit FPUs, SSE4a, native mem ctrl, on-die L3 cache
void initializeProperties()
Initialize all properties that have explicit initial values.
size_t get_majorNBytes() const
Property: Stride of major byte order for mixed order types.
virtual void set_string(const std::string &) override
Give the string a new value.
void set_hi_bytes(uint32_t const &)
Properties: hi_bytes.
Represents a frame in a stack map table.
SgAsmCilDeclSecurityTable()
Default constructor.
SgAsmCilFileTable()
Default constructor.
virtual bool isUnknown() const
Returns true if this instruction is the special "unknown" instruction.
SgAsmJvmBootstrapMethod()
Default constructor.
unsigned char * writable_content(size_t nbytes)
Obtain a local, writable pool to hold content.
SgAsmDwarfConstructList()
Default constructor.
void set_TypeNamespace(uint32_t const &)
Property: TypeNamespace.
SgAsmGenericHeader * is_file_header()
Predicate determining whether this section is also a top-level file header.
void set_hint(unsigned const &)
Property: Export name table hint if not ordinal.
SgAsmElfNoteEntryPtrList const & get_entries() const
Property: List of ELF not entries.
void set_payload(SgUnsignedCharList const &)
Property: Note name.
SgAsmElfStringSection()
Default constructor.
void set_offset(uint64_t const &)
Property: Offset.
SgStringList const & get_symbols() const
Property: Symbols.
uint32_t const & get_Field() const
Property: Field.
SgAsmGenericSection * get_section_by_va(rose_addr_t va, size_t *nfound=0) const
Find section by address.
uint32_t const & get_MethodDeclaration() const
Property: MethodDeclaration.
virtual ~SgAsmDwarfTryBlock()
Destructor.
unsigned const & get_e_loader_flags() const
Property: Loader flags.
unsigned char const & get_st_res1() const
Property: Reserved byte.
void initializeProperties()
Initialize all properties that have explicit initial values.
virtual ~SgAsmLEPageTable()
Destructor.
List of SgAsmPERVASizePair AST nodes.
virtual bool isFunctionReturnFast(const std::vector< SgAsmInstruction * > &insns) override
Returns true if the specified basic block looks like a function return.
Expression representing unsigned extending.
void set_FieldMarshalTable(SgAsmCilFieldMarshalTable *const &)
Property: FieldMarshalTable.
virtual Rose::BinaryAnalysis::AddressSet getSuccessors(bool &complete) override
Control flow successors for a single instruction.
uint32_t const & get_Offset() const
Property: Start offset of the byte stream.
void set_memsz(rose_addr_t const &)
Property: Size of segment in memory.
SgAsmJvmAttributeTable *const & get_attribute_table() const
Property: Table of attributes.
virtual bool isUnknown() const override
Returns true if this instruction is the special "unknown" instruction.
x86-64 family of architectures: Intel, AMD, VIA, ...
void set_minorRuntimeVersion(uint16_t const &)
Property: MinorRuntimeVersion.
virtual ~SgAsmElfSection()
Destructor.
Base class for binary types.
virtual ~SgAsmStoredString()
Destructor.
void initializeProperties()
Initialize all properties that have explicit initial values.
void set_headers(SgAsmGenericHeaderPtrList const &)
Property: List of file header nodes.
void set_e_coff_nsyms(unsigned const &)
Property: Number of COFF symbols.
void initializeProperties()
Initialize all properties that have explicit initial values.
uint32_t const & get_Processor() const
Property: Processor.
std::string get_utf8_string(size_t index) const
Return a string at the given index.
virtual ~SgAsmJvmBootstrapMethods()
Destructor.
Used for initialization; not a bit flag.
SgAsmCilManifestResource()
Default constructor.
void set_e_res6(unsigned const &)
Property: Rerserved area 6.
void initializeProperties()
Initialize all properties that have explicit initial values.
std::string reason_str(bool pad) const
Returns reason string for this block.
void set_e_ehsize(unsigned long const &)
Property: ehsize.
virtual size_t get_nBytes() const
Width of type in bytes.
rose_addr_t get_rva_offset(rose_addr_t rva) const
File offset for specified relative virtual address.
void initializeProperties()
Initialize all properties that have explicit initial values.
rose_rva_t const & get_iat_rva() const
Property: IAT RVA.
SgAsmBinaryAsr()
Default constructor.
virtual SgAsmJvmBootstrapMethods * parse(SgAsmJvmConstantPool *pool) override
Initialize the object by parsing content from the class file.
virtual ~SgAsmLEFileHeader()
Destructor.
SgAsmCilAssemblyRef()
Default constructor.
void initializeProperties()
Initialize all properties that have explicit initial values.
virtual ~SgAsmCilTypeDef()
Destructor.
SegmentFlags
Segment bit flags.
SgFileContentList const & get_data() const
Property: Original content of just this section.
virtual ~SgAsmJvmConstantPoolEntry()
Destructor.
void update_from_section(SgAsmElfSection *)
Update this section table entry with newer information from the section.
Export file section.
virtual void unparse(std::ostream &) const override
Write a section back to the file.
uint32_t const & get_NestedClass() const
Property: NestedClass.
virtual void set_string(const std::string &) override
Property: String value.
const char * format_name() const
Return a string describing the file format.
virtual std::string toString() const
Converts the instruction to a string.
Indicates stack executability.
SgAsmDwarfPartialUnit()
Default constructor.
SgAsmJvmAttributeTable *const & get_attribute_table() const
Property: Attribute table.
uint64_t exponentBias() const
Property: Zero-point of exponent.
virtual bool isFunctionCallFast(const std::vector< SgAsmInstruction * > &, rose_addr_t *target, rose_addr_t *ret)
Returns true if the specified basic block looks like a function call.
SgAsmElfSegmentTableEntryPtrList const & get_entries() const
Property: Segment table entries.
File format did not specify a reason and none could be determined.
Registers accessed indirectly.
rose_addr_t const & get_prh_addr() const
Property: PRH address.
void set_truncate_zeros(bool const &)
Property: Whether to truncate zeros on writes.
void set_uses_addend(bool const &)
Property: Whether entries in this section use the addend format.
uint8_t const & get_tag() const
Property: tag.
virtual void unparse(std::ostream &) const override
Write code attribute to a binary file.
void set_num_freed(size_t const &)
Property: Number of strings freed thus far.
void set_relativeValue(int64_t v, size_t nbits=64)
Set relative value without changing the base value.
void set_type(SgAsmGenericSymbol::SymbolType const &)
Property: Symbol type.
void remove_children()
Removes all statements from the block.
SgAsmPEExportEntryList *const & get_exports() const
Property: List of export entries.
A JVM InnerClasses attribute array entry.
virtual ~SgAsmCilAssemblyProcessor()
Destructor.
uint32_t const & get_ImportScope() const
Property: ImportScope.
void initializeProperties()
Initialize all properties that have explicit initial values.
void initializeProperties()
Initialize all properties that have explicit initial values.
8 bit sign extended pc relative
SgAsmGenericSection *const & get_strtab() const
Property: String table.
void initializeProperties()
Initialize all properties that have explicit initial values.
virtual void dump(FILE *, const char *prefix, ssize_t idx) const override
Print some debugging information.
void set_name(std::string const &)
Property: Name of file.
virtual void unparse(std::ostream &) const override
Write constant pool to a binary file.
void set_e_user_major(unsigned const &)
Property: User major number.
void set_operandSize(Rose::BinaryAnalysis::X86InstructionSize const &)
Property: An enum describing the x86 instruction operand size.
rose_rva_t const & get_e_data_rva() const
Property: Data RVA.
void set_by_ordinal(bool const &)
Property: Whether ordinal number is stored.
virtual ~SgAsmPEStringSection()
Destructor.
rose_addr_t get_end_offset() const
File offset for end of section.
void set_sh_size(rose_addr_t const &)
Property: sh_size.
virtual ~SgAsmUnaryRrx()
Destructor.
virtual ~SgAsmCilFieldTable()
Destructor.
void set_entries(SgAsmElfNoteEntryPtrList const &)
Property: List of ELF not entries.
virtual ~SgAsmLESectionTable()
Destructor.
SgAsmCilGenericParamTable()
Default constructor.
Block was added by a second pass of CFG analysis.
SgAsmJvmExceptionTable * parse(SgAsmJvmConstantPool *)
Parses a JVM exception table.
void allocate_name_to_storage(SgAsmElfStringSection *)
Make this section's name to be stored in the specified string table.
SgAsmElfFileHeader * get_elf_header() const
Obtain ELF header.
virtual ~SgAsmRegisterReferenceExpression()
Destructor.
SgAsmInterpretationPtrList const & get_interpretations() const
Property: Interpretation list.
void set_comment(std::string const &)
Property: Comment.
uint32_t e_shoff
File offset of section header table or zero if none.
rose_rva_t const & get_e_rva() const
Property: RVA.
SgAsmJvmBootstrapMethods()
Default constructor.
virtual bool isUnknown() const override
Returns true if this instruction is the special "unknown" instruction.
SgAsmElfSegmentTableEntry *const & get_segment_entry() const
Property: The segment table entry corresponding to this section.
SgAsmCilAssemblyOS()
Default constructor.
unsigned const & get_e_user_minor() const
Property: User minor number.
void set_reason(unsigned const &)
Property: Reasons this block was created.
rose_addr_t const & get_e_coff_symtab() const
Property: COFF symbol table.
SgAsmElfSymverNeededEntryPtrList const & get_entries() const
Property: List of entries.
Extent get_mapped_preferred_extent() const
Returns the memory extent for a mapped section.
static const std::string ID_US_HEAP
Define constant strings for the known stream types.
void set_Flags(uint32_t const &)
Property: Flags.
Base class for values.
CIL ManifestResource node (II.22.24).
virtual ~SgAsmPEExportSection()
Destructor.
Floating-point value.
virtual void dump(FILE *, const char *prefix, ssize_t idx) const override
Print some debugging information.
static bool is_DOS(SgAsmGenericFile *)
Returns true if a cursory look at the file indicates that it could be a DOS executable file...
void initializeProperties()
Initialize all properties that have explicit initial values.
void initializeProperties()
Initialize all properties that have explicit initial values.
virtual ~SgAsmCilTypeSpecTable()
Destructor.
uint32_t const & get_entryPointToken() const
Property: EntryPointToken.
void set_e_relocs_offset(rose_addr_t const &)
Property: Relocs offset.
rose_addr_t const & get_code_offset() const
Property: Code offset.
virtual void dump(FILE *, const char *prefix, ssize_t idx) const override
Print some debugging information.
Added by Partitioner::FindPostFunctionInsns, which adds unassigned instructions to the immediately pr...
bool align()
Increase file offset and mapping address to satisfy alignment constraints.
void set_e_reserved9(unsigned const &)
Property: Reserved area #9.
SgAsmGenericString()
Default constructor.
void update_from_section(SgAsmElfSection *)
Update this segment table entry with newer information from the section.
void set_bootstrap_methods(SgAsmJvmBootstrapMethodPtrList const &)
Property: List of bootstrap method entries.
unsigned const & get_e_subsys_major() const
Property: Subsystem major number.
virtual ~SgAsmElfSectionTable()
Destructor.
Address was found in read-only data area by scanning the data.
SgAsmDwarfMember()
Default constructor.
virtual void unparse(std::ostream &) const override
Write signature to a binary file.
CIL GenericParam tables.
virtual SgAsmJvmFieldTable * parse() override
Parses a JVM field table.
SgAsmDwarfCommonInclusion()
Default constructor.
SgAsmCilMethodSemanticsTable()
Default constructor.
virtual bool isFunctionReturnFast(const std::vector< SgAsmInstruction * > &insns) override
Returns true if the specified basic block looks like a function return.
virtual ~SgAsmJvmSignature()
Destructor.
void set_bootstrap_method_ref(uint16_t const &)
Property: bootstrap_method_ref.
virtual ~SgAsmRegisterNames()
Destructor.
virtual ~SgAsmDwarfUpcRelaxedType()
Destructor.
virtual void unparse(std::ostream &) const override
Write object to a binary file.
SgAsmStackExpression()
Default constructor.
void set_exec_format(SgAsmGenericFormat *const &)
Property: General info about the executable format.
void set_Class(uint32_t const &)
Property: Class.
virtual void destructorHelper() override
This gets called by all Rosebud-generated destructors.
CIL Assembly node (II.22.2).
void initializeProperties()
Initialize all properties that have explicit initial values.
void set_PropertyList(uint32_t const &)
Property: PropertyList.
virtual void check() const
Validate properties collectively.
void set_hash(uint32_t const &)
Property: Hash.
X86SegmentRegister
Intel x86 segment registers.
size_t const & get_cached_vertex() const
Property: Cached vertex for control flow graphs.
const AddressIntervalSet & get_freelist() const
Property: Free space list.
CIL AssemblyOS tables.
uint32_t const & get_OSPlatformID() const
Property: OSPlatformID.
size_t semanticFailure() const
Property: Whether instruction semantics failed at this location.
unsigned const & get_e_num_rvasize_pairs() const
Property: Number of RVA/size pairs.
SgAsmCilMethodSpecTable *const & get_MethodSpecTable() const
Property: MethodSpecTable.
SgAsmCilAssemblyRefTable *const & get_AssemblyRefTable() const
Property: AssemblyRefTable.
virtual void unparse(std::ostream &) const override
Write the segment table to disk.
unsigned const & get_e_stack_reserve_size() const
Property: Stack reserve size.
uint32_t const & get_Interface() const
Property: Interface.
SgAsmExpression *const & get_operand() const
Property: Operand for a unary expression.
rose_addr_t calculate_sizes(size_t *entsize, size_t *required, size_t *optional, size_t *entcount) const
Returns info about the size of the entries based on information already available.
virtual void dump(FILE *f, const char *prefix, ssize_t idx) const override
Print some debugging info.
SgAsmJvmStackMapFramePtrList const & get_entries() const
Property: List of stack map table entries/frames.
void initializeProperties()
Initialize all properties that have explicit initial values.
void initializeProperties()
Initialize all properties that have explicit initial values.
Rose::BinaryAnalysis::MipsInstructionKind const & get_kind() const
Property: Instruction kind.
virtual void dump(FILE *, const char *prefix, ssize_t idx) const override
Print some debugging info.
void dump(FILE *, const char *prefix, ssize_t idx) const override
Print some debugging information.
unsigned const & get_st_storage_class() const
Property: Symbol storage class.
void set_section_entry(SgAsmElfSectionTableEntry *const &)
Property: The section table entry corresponding to this section.
SgAsmCilImplMapTable *const & get_ImplMapTable() const
Property: ImplMapTable.
size_t const & get_iat_nalloc() const
Property: Bytes allocated in the file for the IAT.
SgAsmLEPageTableEntry()
Default constructor.
void remove_header(SgAsmGenericHeader *)
Removes a header from the header list in a file.
SgAsmCilMethodDefTable *const & get_MethodDefTable() const
Property: MethodDefTable.
SgAsmGenericDLL()
Default constructor.
CIL ImplMap tables.
void set_ClassSize(uint32_t const &)
Property: ClassSize.
Symbol Version Definitions [gnu extension] .gnu.version_d.
unsigned const & get_e_file_align() const
Property: File alignment.
virtual bool isFunctionReturnSlow(const std::vector< SgAsmInstruction * > &insns) override
Returns true if the specified basic block looks like a function return.
JVM ConstantValue attribute.
void set_method_index(uint16_t const &)
Property: method_index.
virtual void unparse(std::ostream &) const override
Unparse headers and all they point to.
bool const & get_iat_written() const
Property: Whether the resolved address has been written to the memory map.
Windows PE file header.
void incrementSemanticFailure()
Property: Whether instruction semantics failed at this location.
uint16_t vna_other
Version index of this entry (bit 15 is special)
uint16_t vna_flags
Version information flag bitmask.
Section contains a header for the executable file format.
SgAsmElfSymverNeededEntry()
Default constructor.
virtual void unparse(std::ostream &) const override
Write a section back to the file.
SgAsmJvmStackMapVerificationTypePtrList const & get_locals() const
Property: List of verification_type_info local variables.
uint16_t const & get_inner_class_info_index() const
Property: inner_class_info_index.
void set_id(int const &)
Property: Non-unique section ID or negative.
Read permission granted when mapped.
void initializeProperties()
Initialize all properties that have explicit initial values.
SgAsmJvmAttributeTable *const & get_attribute_table() const
Property: Table of attributes.
virtual void unparse(std::ostream &) const override
Write exception table to a binary file.
virtual Rose::BinaryAnalysis::AddressSet getSuccessors(bool &complete) override
Control flow successors for a single instruction.
Dispatcher function for code generated by pescrambler.
void shift_extend(SgAsmGenericSection *, rose_addr_t sa, rose_addr_t sn, AddressSpace, Elasticity)
Moves and enlarges a section.
virtual ~SgAsmJvmInnerClasses()
Destructor.
Symbol has not been defined yet.
Java Virtual Machine (JVM) format.
void set_RVA(uint32_t const &)
Property: RVA.
void set_Method(uint32_t const &)
Property: Method.
virtual ~SgAsmInterpretation()
Destructor.
This class represents the symbol tables used in both SgScopeStatement and the SgFunctionTypeSymbolTab...
virtual bool isFunctionCallSlow(const std::vector< SgAsmInstruction * > &, rose_addr_t *target, rose_addr_t *retva) override
Returns true if the specified basic block looks like a function call.
CIL Property tables.
SgAsmJvmExceptionHandler()
Default constructor.
void initializeProperties()
Initialize all properties that have explicit initial values.
uint32_t const & get_Flags() const
Property: Flags.
SgAsmCilMetadata()
Default constructor.
SgAsmIntegerValuePtrList const & get_successors() const
Property: Control flow successors.
virtual void set_mapped_size(rose_addr_t)
Property: Mapped size.
void dump(FILE *, const char *prefix, ssize_t idx) const override
Print some debugging information.
CIL Field node (II.22.15).
Use IEEE 754 implicit bit convention for signicand.
unsigned const & get_e_flags() const
Property: Flags.
void initializeProperties()
Initialize all properties that have explicit initial values.
Expression that subtracts the second operand from the first.
virtual ~SgAsmIntegerType()
Destructor.
virtual ~SgAsmDwarfConstType()
Destructor.
void initializeProperties()
Initialize all properties that have explicit initial values.
void set_index(size_t const &)
Property: Index into table.
void set_binding(SgAsmGenericSymbol::SymbolBinding const &)
Property: Symbol binding.
virtual bool isFunctionReturnFast(const std::vector< SgAsmInstruction * > &insns) override
Returns true if the specified basic block looks like a function return.
void set_expressions(SgAsmExpressionPtrList const &)
Property: Pointers to expressions.
void set_fd_entries(SgAsmElfEHFrameEntryFDList *const &)
Property: FD entries.
void initializeProperties()
Initialize all properties that have explicit initial values.
void set_st_res1(unsigned char const &)
Property: Reserved byte.
on-die memory controller, 40-bit phys address space
rose_addr_t get_mapped_preferred_rva() const
Property: Relative virtual address where section prefers to be mapped.
void set_lsda_encoding(int const &)
Property: LSDA encoding.
void set_OSMajorVersion(uint32_t const &)
Property: OSMajorVersion.
void set_ord_base(unsigned const &)
Property: Ordinal base.
void set_segment(SgAsmExpression *const &)
Property: Optional memory segment register.
void set_Culture(uint32_t const &)
Property: Culture.
uint64_t const & get_Valid() const
Property: A 4-byte value indicating which metadata tables are present.
virtual ~SgAsmUnaryMinus()
Destructor.
SgAsmBinaryPostupdate()
Default constructor.
SgAsmCilMethodDef()
Default constructor.
SgAsmDwarfThrownType()
Default constructor.
Flags flags() const
Property: Bit vector of all boolean properties.
uint32_t const & get_Flags() const
Property: Flags.
SgAsmGenericSection * get_section_by_id(int id, size_t *nfound=0) const
Returns single section in this header that has the specified ID.
Represents a JVM field_info table/array.
uint32_t const & get_OSMinorVersion() const
Property: OSMinorVersion.
SgAsmJvmMethod * parse(SgAsmJvmConstantPool *)
Initialize the object by parsing content from the class file.
void initializeProperties()
Initialize all properties that have explicit initial values.
uint32_t const & get_EventList() const
Property: EventList.
virtual bool terminatesBasicBlock() override
Determines if this instruction normally terminates a basic block.
virtual rose_addr_t calculate_sizes(size_t *total, size_t *required, size_t *optional, size_t *entcount) const override
Return sizes for various parts of the table.
void set_line_number_table(SgAsmJvmLineNumberEntryPtrList const &)
Property: line_number_table.
void unparse(std::ostream &) const
Mirror image of parsing an executable file.
SgAsmElfSegmentTableEntry * add_section(SgAsmElfSection *)
Attaches new segments to the segment table.
void free(SgAsmStringStorage *)
Free area of this string table that corresponds to the string currently stored.
virtual std::string get_string(bool escape=false) const
Property: String value.
int const & get_lsda_encoding() const
Property: LSDA encoding.
SgAsmCilAssemblyRefTable()
Default constructor.
SgAsmDwarfBaseType()
Default constructor.
void set_value(size_t const &)
Property: Value.
void set_code_offset(rose_addr_t const &)
Property: Code offset.
void set_e_subsys_major(unsigned const &)
Property: Subsystem major number.
bool const & get_sig_frame() const
Property: Signal frame.
void set_purpose(SgAsmGenericFormat::ExecPurpose const &)
Property: Purpose.
void set_super_class(uint16_t const &)
Property: Super class.
void initializeProperties()
Initialize all properties that have explicit initial values.
virtual ~SgAsmDwarfClassType()
Destructor.
SgAsmDwarfPointerType()
Default constructor.
static std::string to_string(SgAsmJvmConstantPoolEntry::Kind)
Convert constant pool entry kind to a string.
virtual bool hasEffect()
Determines whether a single instruction has an effect.
virtual ~SgAsmDwarfInterfaceType()
Destructor.
uint32_t const & get_Name() const
Property: Name.
void set_exportAddressTableJumps(uint64_t const &)
Property: ExportAddressTableJumps.
CIL EventMap node (II.22.12).
SgAsmElfStrtab()
Default constructor.
void set_name(SgAsmGenericString *const &)
Property: Name.
virtual Sawyer::Optional< rose_addr_t > branchTarget() override
Obtains the virtual address for a branching instruction.
static Rose::BinaryAnalysis::RegisterDictionaryPtr registersForInstructionSize(Rose::BinaryAnalysis::X86InstructionSize)
Return the register dictionary for an x86 architecture.
SgAsmExprListExp *const & get_operands() const
Property: Operands for the low-level operation.
unsigned const & get_e_os_major() const
Property: OS major number.
uint32_t const & get_Name() const
Property: Name.
void set_symbol_table(SgSymbolTable *const &)
Property: Symbol table.
SgAsmGenericSection * get_section_by_rva(rose_addr_t rva, size_t *nfound=0) const
Find section by address.
void set_expaddr_rva(rose_rva_t const &)
Property: Expaddr RVA.
void initializeProperties()
Initialize all properties that have explicit initial values.
void set_coverageComputed(bool const &)
Property: code coverage percent.
uint16_t const & get_max_stack() const
Property: max_stack.
Expression that represents an update to a storage location.
void append_statement(SgAsmStatement *)
Adds statement to end of statement list.
void initializeProperties()
Initialize all properties that have explicit initial values.
virtual bool isFunctionCallSlow(const std::vector< SgAsmInstruction * > &, rose_addr_t *target, rose_addr_t *ret)
Returns true if the specified basic block looks like a function call.
void initializeProperties()
Initialize all properties that have explicit initial values.
virtual ~SgAsmNEEntryTable()
Destructor.
uint32_t const & get_AssemblyRefOS() const
Property: AssemblyRefOS.
void set_st_shndx(unsigned const &)
Property: shndx.
void set_resources(uint64_t const &)
Property: Resources.
virtual ~SgAsmCliHeader()
Destructor.
SgAsmCilUint8Heap * get_BlobHeap() const
indices to efficienty access the different heaps
virtual ~SgAsmDwarfUnspecifiedType()
Destructor.
void set_BuildNumber(uint16_t const &)
Property: BuildNumber.
void set_st_section_num(int const &)
Property: Section number.
unsigned const & get_e_oemid() const
Property: OEM ID.
SgAsmGenericString * get_name() const
Property: Non-unique name of section.
void set_Owner(uint32_t const &)
Property: Owner.
SgAsmDwarfEnumerator()
Default constructor.
Base class for synthesized declarations.
void dump(FILE *, const char *prefix, ssize_t idx) const override
Print some debugging information.
size_t nOperands() const
Number of operands.
virtual ~SgAsmElfDynamicEntry()
Destructor.
virtual ~SgAsmJvmStackMapFrame()
Destructor.
std::vector< SgAsmCilDataStream * > const & get_Streams() const
Property: Metadata streams.
void initializeProperties()
Initialize all properties that have explicit initial values.
SgAsmGenericSectionPtrList get_sections_by_rva(rose_addr_t rva) const
Returns sections that have a preferred mapping that includes the specified relative virtual address...
void set_virtual_size(rose_addr_t const &)
Property: Virtual size.
rose_addr_t const & get_size() const
Property: Size in bytes.
rose_addr_t const & get_base_va() const
Property: Base virtual address used by all relative virtual addresses.
void initializeProperties()
Initialize all properties that have explicit initial values.
uint16_t const & get_super_class() const
Property: Super class.
These following structs are documented below to indicate which fields are active for each tag of an S...
void initializeProperties()
Initialize all properties that have explicit initial values.
virtual void set_size(rose_addr_t newsize) override
Property: Size of section in file in bytes.
uint32_t const & get_Owner() const
Property: Owner.
SgAsmJvmConstantPool *const & get_constant_pool() const
Property: Constant pool.
void set_field_table(SgAsmJvmFieldTable *const &)
Property: Field table.
SgAsmCilPropertyTable()
Default constructor.
void set_MajorVersion(uint16_t const &)
Property: MajorVersion.
SgAsmGenericSection *const & get_container() const
Property: Section storing this string table.
uint16_t const & get_e_header_paragraphs() const
Property: Number of header paragraphs.
SgAsmJvmBootstrapMethodPtrList const & get_bootstrap_methods() const
Property: List of bootstrap method entries.
void initializeProperties()
Initialize all properties that have explicit initial values.
Operand referencing a Co-processor.
void initializeProperties()
Initialize all properties that have explicit initial values.
void extend(rose_addr_t nbytes)
Extend a section by some number of bytes during the construction and/or parsing phase.
void erase_instructions(InstructionMap &)
Erase instructions from a map.
static DwarfInstructionSourceMapReturnType buildInstructionAddressSourcePositionMaps(SgAsmDwarfCompilationUnit *dwarf_cu=NULL)
Support for building maps to and from instruction addresses to source positions (files, line numbers, column numbers).
Represents a JVM InnerClasses attribute.
SgAsmGenericHeader()
Default constructor.
SgAsmJvmLineNumberEntry()
Default constructor.
void set_lockPrefix(bool const &)
Property: Whether the x86 lock prefix was present.
virtual SgAsmElfDynamicSection * parse() override
Initialize object by parsing file.
static std::string reason_key(const std::string &prefix="")
Multi-line string describing the letters used for basic block reasons.
virtual ~SgAsmElfRelocEntry()
Destructor.
unsigned char const & get_e_ident_file_class() const
Property: File class.
SgAsmPERVASizePair()
Default constructor.
void add_import_directory(SgAsmPEImportDirectory *)
Add an import directory to the end of the import directory list.
SgAsmGenericStrtab *const & get_strtab() const
Property: String table holding the string.
void initializeProperties()
Initialize all properties that have explicit initial values.
uint32_t const & get_FieldList() const
Property: FieldList.
void set_Flags(uint16_t const &)
Property: Flags.
virtual void unparse(std::ostream &) const override
Write line number entry to a binary file.
SgAsmNESection()
Default constructor.
void set_strongNameSignature(uint64_t const &)
Property: StrongNameSignature.
Address of GOT entry for static TLS block offset.
SgAsmBlock *const & get_body() const
Property: body.
std::string const & get_comment() const
Property: Commentary.
void * encode(Rose::BinaryAnalysis::ByteOrder::Endianness, SgAsmElfDynamicEntry::Elf32DynamicEntry_disk *) const
Convert object to disk representation.
void initializeProperties()
Initialize all properties that have explicit initial values.
SgAsmJvmConstantPoolEntry()
Default constructor.
static bool is_PE(SgAsmGenericFile *)
Return true if the file looks like it might be a PE file according to the magic number.
void initializeProperties()
Initialize all properties that have explicit initial values.
unsigned long const & get_e_phnum() const
Property: phnum.
uint32_t const & get_Length() const
Property: Number of bytes allocated to hold version string (including null terminator).
void set_entries(SgAsmElfDynamicEntryList *const &)
Property: List of entries.
const SgAsmGenericSection * section
Section to which write occurred; null implies file-level write.
void initializeProperties()
Initialize all properties that have explicit initial values.
void initializeProperties()
Initialize all properties that have explicit initial values.
SgAsmElfSymverNeededEntryList *const & get_entries() const
Property: List of entries.
Section is resident (valid for VDDs and PDDs only)
virtual void dump(FILE *, const char *prefix, ssize_t idx) const override
Print some debugging information.
virtual ~SgAsmDwarfFormalParameter()
Destructor.
static Flags ieeeFlags()
Default IEEE 754 flags.
void initializeProperties()
Initialize all properties that have explicit initial values.
One entry from the dynamic linking table.
void set_e_size(rose_addr_t const &)
Property: Size.
SgAsmCoffSymbolTable()
Default constructor.
void set_utf8_bytes(char *const &)
Property: utf8_bytes (bytes in CONSTANT_Utf8_info structure).
uint16_t vd_version
version of this struct: This field shall be set to 1
Expression that concatenates two values to form a wider value.
virtual bool isFunctionCallSlow(const std::vector< SgAsmInstruction * > &, rose_addr_t *target, rose_addr_t *ret) override
Returns true if the specified basic block looks like a function call.
void set_Parent(uint32_t const &)
Property: Parent.
virtual ~SgAsmDwarfImportedDeclaration()
Destructor.
SgAsmDwarfSubprogram()
Default constructor.
uint32_t const & get_TypeName() const
Property: TypeName.
Created to represent NOP padding between other functions.
void initializeProperties()
Initialize all properties that have explicit initial values.
virtual bool terminatesBasicBlock()
Determines if this instruction normally terminates a basic block.
void set_data(SgFileContentList const &)
Property: Original content of just this section.
virtual void dump(FILE *, const char *prefix, ssize_t idx) const override
Print some debugging info.
SgAsmCilConstant()
Default constructor.
virtual ~SgAsmJvmStackMapTable()
Destructor.
SgAsmExpressionPtrList const & get_operands() const
Property: Ordered list of instruction operands.
virtual void dump(FILE *, const char *prefix, ssize_t idx) const override
Print some debugging info.
virtual void unparse(std::ostream &) const override
Write a section back to the file.
int const & coprocessor() const
Property: Coprocessor number.
unsigned const & get_abi_version() const
Property: Application binary interface version.
SgAsmGenericFormat::ExecPurpose const & get_purpose() const
Property: Purpose.
virtual void unparse(std::ostream &) const override
Write symbol table sections back to disk.
SgAsmGenericSection * get_best_section_by_va(rose_addr_t va, size_t *nfound=0) const
Find section by address.
Direct 16 bit zero extended.
void initializeProperties()
Initialize all properties that have explicit initial values.
char *const & get_utf8_bytes() const
Property: utf8_bytes (bytes in CONSTANT_Utf8_info structure).
SgAsmCilGenericParamTable *const & get_GenericParamTable() const
Property: GenericParamTable.
virtual void dump(FILE *, const char *prefix, ssize_t idx) const override
Print some debugging info.
virtual ~SgAsmPESection()
Destructor.
virtual void unparse(std::ostream &) const override
Write a section back to the file.
virtual void allocate_overlap(SgAsmStringStorage *) override
Find offset for a string.
const AddressIntervalSet & get_unreferenced_extents() const
Returns the parts of the file that have never been referenced.
uint16_t e_cksum
0x12 checksum; 16-bit sum of all words in file should be zero (usually not filled in)...
std::string reason_str(bool pad) const
Returns a very short string describing the reason mask.
virtual ~SgAsmJvmExceptionHandler()
Destructor.
uint32_t const & get_Name() const
Property: Name.
void set_raw_bytes(SgUnsignedCharList const &)
Property: Raw bytes.
virtual std::string description() const override
Return a description of this instruction.
uint16_t const & get_offset() const
Property: offset.
void initializeProperties()
Initialize all properties that have explicit initial values.
void set_phextrasz(unsigned long const &)
Property: phextrasz.
virtual ~SgAsmBinaryMultiply()
Destructor.
uint16_t const & get_e_overlay() const
Property: Overlay.
unsigned char const & get_e_ident_file_version() const
Property: File version.
void set_code_likelihood(double const &)
Property: Likelihood that this block represents real instructions.
SgAsmCliHeader()
Default constructor.
virtual void dump(FILE *, const char *prefix, ssize_t idx) const override
Print some debugging info.
CIL Constant node (II.22.9).
void initializeProperties()
Initialize all properties that have explicit initial values.
rose_addr_t calculate_sizes(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
Returns info about the size of the entries based on information already available.
unsigned const & get_e_file_checksum() const
Property: File checksum.
void set_start_pc(uint16_t const &)
Property: start_pc.
void set_kind(Rose::BinaryAnalysis::PowerpcInstructionKind const &)
Property: Instruction kind.
void set_unfolded_expression_tree(SgAsmValueExpression *const &)
Property: Alternate expression without constant folding.
SgAsmElfNoteEntryList *const & get_entries() const
Property: List of note entries.
virtual ~SgAsmDwarfNamespace()
Destructor.
SgAsmJvmConstantPoolEntryPtrList const & get_entries() const
Property: List of constant pool entries.
SgAsmJvmFieldPtrList const & get_fields() const
Property: List of pointers to fields.
void set_e_data_size(unsigned const &)
Property: Data size.
SgAsmBasicString()
Default constructor.
virtual ~SgAsmJvmNestMembers()
Destructor.
Sawyer::Container::BitVector::BitRange BitRange
Range of bits used for various purposes within the values of this type.
void set_ilt_nalloc(size_t const &)
Property: Bytes allocated in the file for the ILT.
X86InstructionKind
List of all x86 instructions known to the ROSE disassembler/assembler.
Symbol hash table (used by dynamic linking)
void parse(Rose::BinaryAnalysis::ByteOrder::Endianness, const SgAsmElfSymverNeededAux::ElfSymverNeededAux_disk *)
Initialize this auxiliary record by parsing data from the file.
CIL MethodDef node (II.22.26).
virtual ~SgAsmPEFileHeader()
Destructor.
SgAsmInterpretationList()
Default constructor.
void clear_mapped()
Causes section to not be mapped to memory.
void initializeProperties()
Initialize all properties that have explicit initial values.
virtual ~SgAsmDwarfUpcStrictType()
Destructor.
virtual ~SgAsmDwarfTemplateTypeParameter()
Destructor.
uint32_t const & get_PublicKey() const
Property: PublicKey.
SgAsmDwarfStructureType()
Default constructor.
void set_e_loader_flags(unsigned const &)
Property: Loader flags.
static const std::string ID_STRING_HEAP
Define constant strings for the known stream types.
rose_addr_t const & get_e_lfanew() const
Property: lfanew.
void set_e_res4(unsigned const &)
Property: Rerserved area 4.
rose_addr_t write_sleb128(unsigned char *, rose_addr_t offset, int64_t) const
Write a signed little-endian 128-bit value.
void initializeProperties()
Initialize all properties that have explicit initial values.
uint16_t e_overlay
0x1a overlay number (zero indicates main program).
SgAsmCilAssemblyRefOS()
Default constructor.
void set_e_time(unsigned const &)
Property: Time.
Values reserved for OS-specific semantics.
virtual ~SgAsmBinaryAsr()
Destructor.
SgSymbolTable *const & get_symbol_table() const
Property: Symbol table.
virtual ~SgAsmDwarfPtrToMemberType()
Destructor.
Base class for JVM branch of binary analysis IR nodes.
SgAsmCoffSymbolList *const & get_symbols() const
Property: List of symbols.
SgAsmDwarfLine()
Default constructor.
virtual void dump(FILE *, const char *prefix, ssize_t idx) const override
Print some debugging info.
uint64_t const & get_resources() const
Property: Resources.
unsigned long const & get_sym() const
Property: Sym.
bool const & get_successors_complete() const
Property: Whether the successors list is complete.
ObjectType
Enum for the e_type property.
virtual void dump(FILE *, const char *prefix, ssize_t idx) const override
Print some debugging information.
SgAsmGenericFilePtrList const & get_files() const
Property: List of AST node pointers.
SgAsmGenericFileList()
Default constructor.
void set_FieldList(uint32_t const &)
Property: FieldList.
virtual ~SgAsmDwarfVariantPart()
Destructor.
CIL DeclSecurity tables.
SgAsmGenericSectionList *const & get_holes() const
Property: Addresses unreferenced during parsing.
bool const & get_synthesized() const
Property: Whether section really exists.
void set_OSMajorVersion(uint32_t const &)
Property: OSMajorVersion.
void set_HashValue(uint32_t const &)
Property: HashValue.
InstructionMap & get_instruction_map(bool recompute=false)
Property: Cached map of instructions by address.
virtual ~SgAsmJvmBootstrapMethod()
Destructor.
virtual ~SgAsmCilMethodSpec()
Destructor.
virtual ~SgAsmNESection()
Destructor.
CIL MethodSemantics tables.
int64_t const & get_data_alignment_factor() const
Property: Data alignment factor.
SgAsmCilManifestResourceTable()
Default constructor.
void set_is_current_version(bool const &)
Property: Whether version is considered current.
uint16_t const & get_minor_version() const
Property: Minor version.
virtual ~SgAsmCilFileTable()
Destructor.
std::string const & get_string() const
Property: String value.
SgAsmCilFile()
Default constructor.
SgAsmDwarfClassTemplate()
Default constructor.
Relocation for call to __tls_get_addr() in LDM code.
uint32_t const & get_ClassSize() const
Property: ClassSize.
uint16_t const & get_catch_type() const
Property: catch_type.
static std::string to_string(SgAsmElfDynamicEntry::EntryType)
Convert Dynamic Entry Tag to a string.
virtual bool reallocate() override
Allow all sections to reallocate themselves.
uint64_t const & get_eh_data() const
Property: Data value.
virtual ~SgAsmCilMethodImpl()
Destructor.
void initializeProperties()
Initialize all properties that have explicit initial values.
uint16_t const & get_start_pc() const
Property: start_pc.
virtual bool isFunctionCallFast(const std::vector< SgAsmInstruction * > &insns, rose_addr_t *target, rose_addr_t *ret) override
Returns true if the specified basic block looks like a function call.
SgAsmCilMethodImplTable()
Default constructor.
void set_sh_info(unsigned long const &)
Property: sh_info.
void set_physical_offset(rose_addr_t const &)
Property: Physical offset.
void initializeProperties()
Initialize all properties that have explicit initial values.
rose_addr_t const & get_size() const
Property: Symbol size in bytes.
void set_expaddr_n(size_t const &)
Property: Expaddr_n.
SgAsmJvmBootstrapMethod * parse(SgAsmJvmConstantPool *)
Initialize the object by parsing content from the class file.
static const std::string ID_BLOB_HEAP
Define constant strings for the known stream types.
SgAsmCilTypeSpecTable()
Default constructor.
void initializeProperties()
Initialize all properties that have explicit initial values.
SgAsmJvmAttributeTable()
Default constructor.
void set_EventFlags(uint16_t const &)
Property: EventFlags.
unsigned const & get_ord_base() const
Property: Ordinal base.
void set_storage_list(SgAsmGenericStrtab::referenced_t const &)
Property: String storage list.
CIL Property node (II.22.34).
virtual ~SgAsmCilField()
Destructor.
virtual void unparse(std::ostream &) const override
Write the dynamic section back to disk.
SgAsmIntegerValueExpression()
Default constructor.
void initializeProperties()
Initialize all properties that have explicit initial values.
Two args + optional carry bit.
void set_attribute_table(SgAsmJvmAttributeTable *const &)
Property: Attribute table.
SgAsmUnaryPlus()
Default constructor.
virtual bool isFunctionCallFast(const std::vector< SgAsmInstruction * > &insns, rose_addr_t *target, rose_addr_t *ret) override
Returns true if the specified basic block looks like a function call.
uint16_t e_cs
0x16 initial value for CS register relative to program load segment.
void initializeProperties()
Initialize all properties that have explicit initial values.
virtual ~SgAsmJvmField()
Destructor.
void set_Name(uint32_t const &)
Property: Name.
SgAsmElfFileHeader()
Default constructor.
void initializeProperties()
Initialize all properties that have explicit initial values.
Three or four args depending on whether segment reg is present.
void set_nameptr_rva(rose_rva_t const &)
Property: Name pointer RVA.
void initializeProperties()
Initialize all properties that have explicit initial values.
void initializeProperties()
Initialize all properties that have explicit initial values.
Offset in initial TLS block.
virtual Rose::BinaryAnalysis::AddressSet getSuccessors(bool &complete) override
Control flow successors for a single instruction.
virtual ~SgAsmElfSymverNeededSection()
Destructor.
virtual unsigned get_anyKind() const override
Returns instruction kind for any architecture.
void initializeProperties()
Initialize all properties that have explicit initial values.
void set_Offset(uint32_t const &)
Property: Offset.
void set_bit_size(unsigned short const &)
Property: Where this expression is encoded within the instruction.
virtual void unparse(std::ostream &) const override
Write stack map table to a binary file.
virtual Sawyer::Optional< rose_addr_t > branchTarget() override
Obtains the virtual address for a branching instruction.
virtual ~SgAsmCilFieldLayoutTable()
Destructor.
SgAsmElfSectionTable *const & get_section_table() const
Property: Section table.
Direct 32 bit for GNU version of general dynamic thread local data.
virtual SgAsmElfSymbolSection * parse() override
Initialize by parsing a file.
SgAsmExprListExp *const & get_semantics() const
Property: Ordered list of instruction semantics.
virtual ~SgAsmDwarfFriend()
Destructor.
static SgAsmDwarfConstruct * createDwarfConstruct(int tag, int nesting_level, uint64_t offset, uint64_t overall_offset)
Factory pattern to build IR nodes based on the tag.
void set_extra(SgUnsignedCharList const &)
Property: Padding byte values.
SgAsmBinaryExpression()
Default constructor.
void set_rvasize_pair(PairPurpose, SgAsmPESection *)
Define an RVA/Size pair in the PE file header.
void initializeProperties()
Initialize all properties that have explicit initial values.
ARM{700,710,710a,7100,7500,7500FE} cores.
SgAsmJvmNestHost()
Default constructor.
SgAsmCilDeclSecurity()
Default constructor.
void set_e_machine(unsigned long const &)
Property: Machine.
uint32_t const & get_Instantiation() const
Property: Instantiation.
SgAsmGenericStrtab::referenced_t const & get_storage_list() const
Property: String storage list.
rose_addr_t const & get_sh_size() const
Property: sh_size.
static void hexdump(std::ostream &, rose_addr_t base_addr, const unsigned char *data, size_t data_sz, const HexdumpFormat &)
Display binary data.
void set_TypeName(uint32_t const &)
Property: TypeName.
virtual void dump(FILE *f, const char *prefix, ssize_t idx) const
Print debugging information.
SgAsmElfEHFrameEntryFD()
Default constructor.
virtual bool reallocate() override
Called prior to unparsing.
void initializeProperties()
Initialize all properties that have explicit initial values.
uint64_t get_absoluteValue(size_t nbits=0) const
Returns the current absolute value zero filled to 64 bits.
void initializeProperties()
Initialize all properties that have explicit initial values.
virtual ~SgAsmJvmInstruction()
Destructor.
void set_Name(uint32_t const &)
Property: Name.
SgAsmCilImplMapTable()
Default constructor.
void set_MethodSpecTable(SgAsmCilMethodSpecTable *const &)
Property: MethodSpecTable.
virtual ~SgAsmPESectionTable()
Destructor.
void initializeProperties()
Initialize all properties that have explicit initial values.
uint16_t const & get_Flags() const
Property: Flags.
void initializeProperties()
Initialize all properties that have explicit initial values.
Base class for all ROSE exceptions.
Definition: Rose/Exception.h:9
void set_entries(SgAsmElfEHFrameEntryCIPtrList const &)
Property: List of pointers to ELF EH frame CI entries.
uint16_t e_total_pages
0x04 number of pages (inc.
uint16_t const & get_Flags() const
Property: Flags.
SgUnsignedCharList const & get_extra() const
Property: Extra data.
SgAsmCilParamTable()
Default constructor.
void initializeProperties()
Initialize all properties that have explicit initial values.
void initializeProperties()
Initialize all properties that have explicit initial values.
void initializeProperties()
Initialize all properties that have explicit initial values.
rose_addr_t const & get_memsz() const
Property: Size of segment in memory.
SgAsmNENameTable()
Default constructor.
ARM AArch64 A64 instruction set.
SgAsmDwarfLexicalBlock()
Default constructor.
JVM NestHost attribute.
void initializeProperties()
Initialize all properties that have explicit initial values.
void set_Name(uint32_t const &)
Property: Name.
The ELF symbol version table.
SgAsmCilMethodImplTable *const & get_MethodImplTable() const
Property: MethodImplTable.
Represents one entry in an ELF section table.
void set_e_shstrndx(unsigned long const &)
Property: shstrndx.
virtual void dump(FILE *, const char *prefix, ssize_t idx) const override
Print some debugging info.
virtual void dump(FILE *, const char *prefix, ssize_t idx) const override
Print some debugging information.
void initializeProperties()
Initialize all properties that have explicit initial values.
Relocation entries without explicit addends (e.g., Elf32_Rel types)
void set_classes(SgAsmJvmInnerClassesEntryPtrList const &)
Property: List of pointers to InnerClasses attribute entry.
32 bit signed PC relative offset to GOT entry for IE symbol
time_t const & get_time() const
Property: Time.
SgAsmUnarySignedExtend()
Default constructor.
Represents an ELF segment table.
void dump(FILE *) const
Print basic info about the sections of a file.
SgAsmCilExportedTypeTable *const & get_ExportedTypeTable() const
Property: ExportedTypeTable.
void set_rvasize_pairs(SgAsmPERVASizePairList *const &)
Property: RVA/size pairs.
SgAsmCilFieldMarshalTable *const & get_FieldMarshalTable() const
Property: FieldMarshalTable.
Symbol Version Requirements [gnu extension] .gnu.version_r.
virtual void dump(FILE *, const char *prefix, ssize_t idx) const override
Print some debugging information.
virtual void unparse(std::ostream &) const override
Write stack map table to a binary file.
virtual void dump(FILE *f, const char *prefix, ssize_t idx) const
Print some debugging info.
SgAsmCilExportedType()
Default constructor.
AddressIntervalSet get_unreferenced_extents() const
Returns a list of parts of a single section that have not been referenced.
Strings stored in an ELF or PE container.
virtual ~SgAsmElfEHFrameSection()
Destructor.
bool const & get_truncate_zeros() const
Property: Whether to truncate zeros on writes.
virtual ~SgAsmDwarfVolatileType()
Destructor.
void set_section_table(SgAsmElfSectionTable *const &)
Property: Section table.
uint16_t const & get_reference_index() const
Property: reference_index.
unsigned const & get_ordinal() const
Property: Ordinal.
SgAsmCilEventTable()
Default constructor.
unsigned long const & get_e_machine() const
Property: Machine.
void set_Name(uint32_t const &)
Property: Name.
void set_n_relocs(unsigned const &)
Property: Number of relocations.
void initializeProperties()
Initialize all properties that have explicit initial values.
void adjustCacheLockCount(int increment)
Property: Cache lock count.
unsigned const & get_vmajor() const
Property: VMajor.
SgAsmDwarfConstant()
Default constructor.
uint16_t const & get_line_number() const
Property: line_number.
void initializeProperties()
Initialize all properties that have explicit initial values.
uint16_t const & get_bootstrap_method_ref() const
Property: bootstrap_method_ref.
Represents an ELF section table.
rose_addr_t get_iat_entry_va() const
Virtual address of an IAT entry.
void insert_instructions(InstructionMap &)
Populate a map of instructions indexed by their virtual addresses.
void initializeProperties()
Initialize all properties that have explicit initial values.
SgAsmElfEHFrameEntryFDList()
Default constructor.
Information for dynamic linking.
void set_Owner(uint32_t const &)
Property: Owner.
virtual ~SgAsmCilTypeRef()
Destructor.
virtual ~SgAsmExecutableFileFormat()
Destructor.
ELF string table.
void initializeProperties()
Initialize all properties that have explicit initial values.
Sawyer::Result< unsigned, std::string > biasedOrdinal() const
Property: Biased ordinal.
rose_addr_t offset
Byte offset into section (or file).
SgAsmElfDynamicEntry()
Default constructor.
uint32_t const & get_AssemblyRef() const
Property: AssemblyRef.
The following discriminated union is documented below and indicates which item of the union is in use...
SgAsmCilUint8Heap()
Default constructor.
unsigned const & get_e_time() const
Property: Time.
void set_AssemblyRefProcessorTable(SgAsmCilAssemblyRefProcessorTable *const &)
Property: AssemblyRefProcessorTable.
void set_sh_name(unsigned const &)
Property: sh_name.
uint16_t const & get_main_class_index() const
Property: main_class_index.
void set_exception_table(SgAsmJvmExceptionTable *const &)
Property: Exception table.
void set_Field(uint32_t const &)
Property: Field.
A list of imported items.
virtual ~SgAsmFloatValueExpression()
Destructor.
void initializeProperties()
Initialize all properties that have explicit initial values.
void set_headers(SgAsmGenericHeaderList *const &)
Property: List of all headers in file.
Represents an interpretation of a binary container.
virtual ~SgAsmGenericSectionList()
Destructor.
Sawyer::Container::BitVector const & get_bitVector() const
Property: Bits for constant.
uint16_t const & get_string_index() const
Property: string_index.
CIL Param tables.
void initializeProperties()
Initialize all properties that have explicit initial values.
unsigned short const & get_bit_size() const
Property: Where this expression is encoded within the instruction.
Offset in module's TLS block.
void set_AssemblyRefTable(SgAsmCilAssemblyRefTable *const &)
Property: AssemblyRefTable.
SgAsmCilProperty()
Default constructor.
generation one: 16/32 internal; 8-, 16-, 32-bit interface
void fill_holes()
Find holes in file and create sections to fill them.
virtual ~SgAsmDwarfUnionType()
Destructor.
Offset in initial TLS block.
void set_statementList(SgAsmStatementPtrList const &)
Property: Statements that make up a function.
virtual ~SgAsmDwarfSubrangeType()
Destructor.
virtual ~SgAsmCilPropertyTable()
Destructor.
void initializeProperties()
Initialize all properties that have explicit initial values.
X86InstructionSize
Intel x86 instruction size constants.
virtual ~SgAsmDwarfFunctionTemplate()
Destructor.
void set_bound_rva(rose_rva_t const &)
Property: Bound RVA from IAT if not a copy of ILT.
rose_addr_t unparse(std::ostream &f, rose_addr_t starting_offset)
Write a note at the specified offset to the section containing the note.
void set_name(std::string const &)
Property: Name.
Acorn RISC Machine, Advanced RISC Machines, ARM Limited.
virtual ~SgAsmDwarfFileType()
Destructor.
void set_EncBaseId(uint32_t const &)
Property: EncBaseId.
void add_header(SgAsmGenericHeader *)
Adds a new header to the file.
void set_e_ident_padding(SgUnsignedCharList const &)
Property: Padding.
virtual bool isUnknown() const override
Returns true if this instruction is the special "unknown" instruction.
unsigned const & get_e_res4() const
Property: Rerserved area 4.
void set_ClassLayoutTable(SgAsmCilClassLayoutTable *const &)
Property: ClassLayoutTable.
virtual void destructorHelper() override
This gets called by all Rosebud-generated destructors.
SgAsmJvmLineNumberEntryPtrList const & get_line_number_table() const
Property: line_number_table.
SgAsmDwarfVariantPart()
Default constructor.
virtual bool isFunctionCallFast(const std::vector< SgAsmInstruction * > &, rose_addr_t *target, rose_addr_t *ret) override
Returns true if the specified basic block looks like a function call.
CIL PropertyMap node (II.22.35).
void set_file_alignment(rose_addr_t const &)
Property: Required file alignment.
Elasticity
Elasticity argument for shift_extend.
bool const & get_coverageComputed() const
Property: code coverage percent.
Encodes and decodes a buffer using an algorithm defined in subclasses.
virtual unsigned get_anyKind() const
Returns instruction kind for any architecture.
void initializeProperties()
Initialize all properties that have explicit initial values.
4.4.6 CONSTANT_NameAndType_info table entry.
uint16_t const & get_start_pc() const
Property: start_pc.
void initializeProperties()
Initialize all properties that have explicit initial values.
void initializeProperties()
Initialize all properties that have explicit initial values.
uint8_t const & get_MajorVersion() const
Property: A 1-byte constant.
(code named N11) larger caches; 40-50MHz; same IS as XR
virtual const char * format_name() const override
Returns the name of the file format.
void set_Semantics(uint16_t const &)
Property: Semantics.
void set_tracking_references(bool const &)
Property: Whether to track referenced areas during parsing.
SgAsmExpression * operand(size_t) const
Nth operand.
void initializeProperties()
Initialize all properties that have explicit initial values.
virtual void dump(FILE *, const char *prefix, ssize_t idx) const override
Print some debugging info.
virtual ~SgAsmAarch32Coprocessor()
Destructor.
SgAsmCilAssemblyOSTable *const & get_AssemblyOSTable() const
Property: AssemblyOSTable.
void set_outer_class_info_index(uint16_t const &)
Property: outer_class_info_index.
SgAsmGenericSection * get_section_by_name(const std::string &, char sep=0, size_t *nfound=0) const
Returns single section in this header that has the specified name.
void set_files(SgAsmGenericFilePtrList const &)
Property: List of AST node pointers.
List of symbol version needed entries.
void set_holes(SgAsmGenericSectionList *const &)
Property: Addresses unreferenced during parsing.
void initializeProperties()
Initialize all properties that have explicit initial values.
uint32_t const & get_PermissionSet() const
Property: PermissionSet.
void set_global_block(SgAsmBlock *const &)
Property: Global block.
rose_rva_t const & get_d_val() const
Property: Value.
unsigned const & get_e_res1() const
Property: Rerserved area 1.
void initializeProperties()
Initialize all properties that have explicit initial values.
void set_end_pc(uint16_t const &)
Property: end_pc.
uint32_t const & get_RVA() const
Property: RVA.
The StackMapTable attribute is a variable-length attribute in the attributes table of a Code attribut...
virtual void dump(FILE *, const char *prefix, ssize_t idx) const
Print some debugging info.
SgAsmJvmEnclosingMethod()
Default constructor.
uint16_t const & get_handler_pc() const
Property: handler_pc.
void set_segmentOverride(Rose::BinaryAnalysis::X86SegmentRegister const &)
Property: The segment override register.
uint32_t const & get_Class() const
Property: Class.
SgAsmGenericHeaderList *const & get_headers() const
Property: File headers.
static SgAsmGenericSection * best_section_by_va(const SgAsmGenericSectionPtrList &sections, rose_addr_t va)
Definition for "best".
SgAsmDwarfClassType()
Default constructor.
void initializeProperties()
Initialize all properties that have explicit initial values.
void initializeProperties()
Initialize all properties that have explicit initial values.
void set_e_user_minor(unsigned const &)
Property: User minor number.
Tag for pushl in LDM TLS code.
AddressIntervalSet const & get_referenced_extents() const
Property: Addresses referenced during parsing.
SgAsmCilTypeSpecTable *const & get_TypeSpecTable() const
Property: TypeSpecTable.
function_kind_enum
Constants for the "function_kind" property.
SgAsmStoredString * create_string(rose_addr_t offset, bool shared)
Constructs an SgAsmStoredString from an offset into this string table.
SgAsmGenericString *const & get_file_name() const
Property: File name.
Floating point types.
rose_rva_t const & get_nameptr_rva() const
Property: Name pointer RVA.
static SgAsmJvmAttribute * instance(SgAsmJvmConstantPool *pool, SgAsmJvmAttributeTable *parent)
Factory method returning a derived class instance.
void remove_import_directory(SgAsmPEImportDirectory *)
Remove an import directory from the import directory list.
virtual ~SgAsmDwarfCompilationUnitList()
Destructor.
SgAsmCilExportedTypeTable()
Default constructor.
void set_extra(SgUnsignedCharList const &)
Property: Extra data.
virtual std::string get_string(bool escape=false) const override
Returns the std::string associated with the SgAsmStoredString.
uint32_t const & get_Signature() const
Property: Magic signature for physical metadata (always 0x424A5342)
SgAsmElfRelocEntry::RelocType const & get_type() const
Property: Type.
Invalid section flag (added for rose)
void * encode(Rose::BinaryAnalysis::ByteOrder::Endianness sex, SgAsmElfSectionTableEntry::Elf32SectionTableEntry_disk *disk) const
Encode a section table entry into the disk structure.
void set_TypeSpecTable(SgAsmCilTypeSpecTable *const &)
Property: TypeSpecTable.
SgAsmCilMetadataHeap * get_MetadataHeap() const
indices to efficienty access the different heaps
void set_mapped_actual_va(rose_addr_t const &)
Property: Virtual address where ROSE maps this section.
void set_data_converter(DataConverter *dc)
Property: Data converter.
Nothing is elastic; other parts of space are shifted.
void set_Name(uint32_t const &)
Property: Name.
void set_name(SgAsmGenericString *s)
Property: Non-unique name of section.
void initializeProperties()
Initialize all properties that have explicit initial values.
void initializeProperties()
Initialize all properties that have explicit initial values.
SgAsmElfSymverEntryPtrList const & get_entries() const
Property: List of symbol version table entries.
void set_riscOperator(SgAsmRiscOperation::RiscOperator const &)
Property: Low-level semantic operation.
The BootstrapMethods attribute is a variable-length attribute in the attributes table of a ClassFile ...
unsigned char e_ident_magic[4]
0x7f, 'E', 'L', 'F'
void set_ImplFlags(uint32_t const &)
Property: ImplFlags.
virtual void unparse(std::ostream &) const override
Write symver table sections back to disk.
virtual void dump(FILE *, const char *prefix, ssize_t idx) const override
Print some debugging info.
virtual ~SgAsmDwarfPartialUnit()
Destructor.
virtual ~SgAsmCilMethodSemantics()
Destructor.
uint16_t e_maxalloc
0x0c max paragraphs to allocate for BSS.
virtual ~SgAsmElfNoteEntryList()
Destructor.
SgAsmGenericSection * get_section_by_id(int id, size_t *nfound=0) const
Find section with specified ID.
SgAsmDwarfUpcRelaxedType()
Default constructor.
SgAsmBinaryLsl()
Default constructor.
void set_handler_pc(uint16_t const &)
Property: handler_pc.
uint16_t const & get_descriptor_index() const
Property: descriptor_index.
virtual ~SgAsmElfSymverDefinedSection()
Destructor.
uint16_t e_sp
0x10 initial value for SP register.
std::string const & get_name() const
Property: Name.
virtual ~SgAsmCilTypeRefTable()
Destructor.
virtual ~SgAsmCilAssemblyOSTable()
Destructor.
void set_frame_type(uint8_t const &)
Property: frame_type.
int const & get_stack_position() const
Property: Position of element referenced on the stack.
void set_Name(uint32_t const &)
Property: Name.
unsigned const & get_e_opt_magic() const
Property: Magic.
JVM ExceptionHandler.
uint64_t const & get_code_alignment_factor() const
Property: Code alignment factor.
virtual void unparse(std::ostream &) const override
Write SymverNeeded section back to disk.
Direct 8 bit sign extended.
uint64_t const & get_vTableFixups() const
Property: VTableFixups.
void set_version(int const &)
Property: Version number.
Value & insertMaybe(const Key &key, const Value &value)
Conditionally insert a new key/value pair.
Definition: Sawyer/Map.h:682
virtual void unparse(std::ostream &) const override
Unparse headers and all they point to.
void add_dll(SgAsmGenericDLL *dll)
Add a new DLL to the header DLL list.
SgAsmFunction::function_kind_enum const & get_function_kind() const
Property: Kind of function.
Base class for binary files.
Occupies memory during execution.
virtual SgAsmElfSectionTable * parse() override
Parses an ELF Section Table.
SgAsmDOSFileHeader()
Default constructor.
void set_e_subsystem(unsigned const &)
Property: Subsystem.
virtual ~SgAsmDwarfEntryPoint()
Destructor.
SgAsmJvmInnerClasses * parse(SgAsmJvmConstantPool *) override
Parses a JVM InnerClasses attribute.
void initializeProperties()
Initialize all properties that have explicit initial values.
Base class for binary expressions.
SgAsmExpression()
Default constructor.
void set_e_type(unsigned long const &)
Property: Type.
DataConverter * get_data_converter() const
Property: Data converter.
Declaration-like nodes that encapsulate multiple instructions.
virtual ~SgAsmJvmModuleMainClass()
Destructor.
virtual ~SgAsmGenericHeaderList()
Destructor.
virtual ~SgAsmLEPageTableEntry()
Destructor.
void set_MinorVersion(uint8_t const &)
Property: A 1-byte constant.
void set_e_section_align(unsigned const &)
Property: Section alignment.
SgAsmCoffSymbolTable *const & get_coff_symtab() const
Property: COFF symbol table.
void initializeProperties()
Initialize all properties that have explicit initial values.
SgAsmCilParamTable *const & get_ParamTable() const
Property: ParamTable.
void initializeProperties()
Initialize all properties that have explicit initial values.
uint16_t vn_version
version of this struct: This field shall be set to 1
virtual void dump(FILE *, const char *prefix, ssize_t idx) const override
Print some debugging info.
Base class for vector types.
AddressIntervalSet get_referenced_extents() const
Returns a list of parts of a single section that have been referenced.
SgAsmDwarfUnspecifiedType()
Default constructor.
void set_sourcefile_index(uint16_t const &)
Property: sourcefile_index.
void dump(FILE *, const char *prefix, ssize_t idx) const override
Print some debugging information.
CIL ManifestResource tables.
SgAsmElfSymbol::ElfSymType get_elf_type() const
Returns type as an enum constant.
void initializeProperties()
Initialize all properties that have explicit initial values.
virtual ~SgAsmGenericSymbol()
Destructor.
virtual ~SgAsmCilNode()
Destructor.
void * encode(Rose::BinaryAnalysis::ByteOrder::Endianness, SgAsmElfRelocEntry::Elf32RelaEntry_disk *) const
Convert object to on-disk format.
Base class for constants.
void set_Flags(uint16_t const &)
Property: Flags.
SgAsmDwarfWithStmt()
Default constructor.
void set_Parent(uint32_t const &)
Property: Parent.
SgAsmDwarfUnspecifiedParameters()
Default constructor.
unsigned const & get_e_cpu_type() const
Property: CPU type.
void initializeProperties()
Initialize all properties that have explicit initial values.
void initializeProperties()
Initialize all properties that have explicit initial values.
CIL Param node (II.22.33).
List of symbol version aux entries.
virtual std::string description() const override
Return a description of this instruction.
Created and assigned storage.
uint32_t const & get_Culture() const
Property: Culture.
virtual ~SgAsmCilEventMap()
Destructor.
void initializeProperties()
Initialize all properties that have explicit initial values.
void set_n_coff_line_nums(unsigned const &)
Property: Number of COFF line numbers.
void set_name(SgAsmGenericString *)
Property: Name.
void initializeProperties()
Initialize all properties that have explicit initial values.
uint32_t const & get_cb() const
Property: Cb.
virtual ~SgAsmCilGenericParamConstraint()
Destructor.
X86RepeatPrefix
Intel x86 instruction repeat prefix.
void set_strtab(SgAsmGenericStrtab *const &)
Property: String table holding the string.
void set_e_os_minor(unsigned const &)
Property: OS minor number.
size_t const & get_value() const
Property: Value.
void set_Parent(uint32_t const &)
Property: Parent.
void set_ci_entries(SgAsmElfEHFrameEntryCIList *const &)
Property: CI entries.
virtual ~SgAsmPEImportItem()
Destructor.
void set_hasMoreSections(bool const &)
Property: hasMoreSections.
void set_interpretations(SgAsmInterpretationPtrList const &)
Property: Interpretation list.
virtual ~SgAsmCilAssemblyRefOSTable()
Destructor.
virtual void dump(FILE *, const char *prefix, ssize_t idx) const
Print some debugging info.
Sawyer::Attribute::Storage const & attributes() const
Attribute storage.
void set_EventTable(SgAsmCilEventTable *const &)
Property: EventTable.
List of SgAsmInstruction nodes.
Miscellaneous reasons go here.
rose_addr_t calculate_size() const
Returns the number of bytes needed to store this note.
rose_addr_t const & get_offset() const
Property: Location of string in storage table.
virtual void dump(FILE *, const char *prefix, ssize_t idx) const
Print some debugging info.
virtual void unparse(std::ostream &) const override
Write line number table to a binary file.
unsigned const & get_e_lmajor() const
Property: lmajor.
virtual ~SgAsmCilGenericParamConstraintTable()
Destructor.
uint32_t const & get_MethodBody() const
Property: MethodBody.
void initializeProperties()
Initialize all properties that have explicit initial values.
virtual ~SgAsmDwarfConstruct()
Destructor.
virtual ~SgAsmBinaryExpression()
Destructor.
SgAsmPEImportDirectoryList *const & get_import_directories() const
Property: List of import directories.
uint32_t const & get_Association() const
Property: Association.
CIL TypeDef tables.
SgAsmFloatValueExpression()
Default constructor.
virtual Sawyer::Optional< rose_addr_t > branchTarget() override
Obtains the virtual address for a branching instruction.
uint32_t st_value
Value: absolute value, address, etc.
uint32_t const & get_EncBaseId() const
Property: EncBaseId.
uint32_t const & get_TypeName() const
Property: TypeName.
virtual void dump(FILE *, const char *prefix, ssize_t idx) const override
Print some debugging information.
void set_access_flags(uint16_t const &)
Property: access_flags.
Static representation of instruction semantics.
SgAsmGenericSectionPtrList get_sections_by_id(int id) const
Returns sections in this header that have the specified ID.
unsigned const & get_e_dll_flags() const
Property: DLL flags.
CIL AssemblyRefOS tables.
uint32_t p_paddr
0x0c physical address where supported (unused by System V)
CIL MethodDef tables.
unsigned const & get_st_num_aux_entries() const
Property: Number of auxilliary entries.
A list of PE Import Directories.
virtual ~SgAsmJvmAttribute()
Destructor.
SgAsmPEImportItemList()
Default constructor.
void initializeProperties()
Initialize all properties that have explicit initial values.
void set_vector(SgAsmPEImportItemPtrList const &)
Property: List of pointers to other nodes.
void set_Value(uint32_t const &)
Property: Value.
virtual void rebind(SgAsmStringStorage *, rose_addr_t) override
Similar to create_storage() but uses a storage object that's already been allocated.
virtual ~SgAsmNERelocEntry()
Destructor.
SgAsmDwarfNamelist()
Default constructor.
virtual ~SgAsmDwarfUnspecifiedParameters()
Destructor.
SgAsmElfSymverNeededAuxList()
Default constructor.
void set_entries(SgAsmElfNoteEntryList *const &)
Property: List of note entries.
ELF error handling frame entry, common information entry.
void set_Instantiation(uint32_t const &)
Property: Instantiation.
uint16_t e_machine
Required architecture for an individual file.
SgAsmGenericString *const & get_name() const
Property: Name.
SgAsmPEImportDirectory * parse(rose_addr_t va, bool isLastEntry)
Parse an import directory.
void set_Flags(uint16_t const &)
Property: Reserved space.
void set_class_index(uint16_t const &)
Property: class_index.
void initializeProperties()
Initialize all properties that have explicit initial values.
void initializeProperties()
Initialize all properties that have explicit initial values.
virtual void unparse(std::ostream &) const override
Write a section back to the file.
SgAsmElfSymverDefinedAuxList *const & get_entries() const
Property: Entries.
void set_paddr(rose_addr_t const &)
Property: ELF paddr field.
void initializeProperties()
Initialize all properties that have explicit initial values.
ID of module containing symbol.
virtual ~SgAsmElfSegmentTableEntry()
Destructor.
void set_synthesized(bool const &)
Property: Whether section really exists.
void initializeProperties()
Initialize all properties that have explicit initial values.
virtual ~SgAsmDwarfThrownType()
Destructor.
SgAsmNEEntryTable()
Default constructor.
void initializeProperties()
Initialize all properties that have explicit initial values.
COFF symbol table.
SgAsmDwarfUnknownConstruct()
Default constructor.
SgAsmJvmStackMapFrame()
Default constructor.
void set_MappingFlags(uint16_t const &)
Property: MappingFlags.
uint32_t const & get_VersionPadding() const
Property: Padding to next 4-byte boundary.
uint32_t const & get_Reserved0() const
Property: Reserved space.
Tag for pushl in GD TLS code.
Generated function to hold blocks that are otherwise not part of any function.
const SgAsmGenericSection * section
Section from which read occurred; null implies file-level write.
void initializeProperties()
Initialize all properties that have explicit initial values.
unsigned const & get_n_coff_line_nums() const
Property: Number of COFF line numbers.
SgAsmJvmExceptionHandler * parse(SgAsmJvmConstantPool *)
Initialize the object by parsing content from the class file.