1 #include <featureTests.h>
2 #ifdef ROSE_ENABLE_BINARY_ANALYSIS
40 #include "ROSETTA_macros.h"
42 #include "AstNodeClass.h"
99 DOCUMENTATION_should_never_be_defined;
103 #define DECLARE_LEAF_CLASS(CLASS_WITHOUT_Sg)
105 #define DECLARE_LEAF_CLASS(CLASS_WITHOUT_Sg) \
106 NEW_TERMINAL_MACRO(CLASS_WITHOUT_Sg, #CLASS_WITHOUT_Sg, #CLASS_WITHOUT_Sg "Tag"); \
107 CLASS_WITHOUT_Sg.setCppCondition("!defined(DOCUMENTATION)")
111 #define DECLARE_HEADERS(CLASS_WITHOUT_Sg)
113 #define DECLARE_HEADERS(CLASS_WITHOUT_Sg) \
114 CLASS_WITHOUT_Sg.setPredeclarationString("Sg" #CLASS_WITHOUT_Sg "_HEADERS", \
115 ROSE_AUTOMAKE_ABSOLUTE_PATH_TOP_SRCDIR + "/src/ROSETTA/src/binaryInstruction.C")
119 #define DECLARE_OTHERS(CLASS_WITHOUT_Sg)
121 #define DECLARE_OTHERS(CLASS_WITHOUT_Sg) \
122 CLASS_WITHOUT_Sg.setFunctionPrototype("Sg" #CLASS_WITHOUT_Sg "_OTHERS", \
123 ROSE_AUTOMAKE_ABSOLUTE_PATH_TOP_SRCDIR + "/src/ROSETTA/src/binaryInstruction.C")
127 #define IS_SERIALIZABLE()
129 #define IS_SERIALIZABLE(CLASS_WITHOUT_Sg) \
130 CLASS_WITHOUT_Sg.isBoostSerializable(true)
146 class SgAsmGenericStrtab;
154 class AsmSynthesizedFieldDeclaration;
161 #ifndef DOCUMENTATION
162 void Grammar::setUpBinaryInstructions() {
174 #ifdef ROSE_ENABLE_ASM_AARCH32
175 DECLARE_LEAF_CLASS(AsmAarch32Instruction);
176 IS_SERIALIZABLE(AsmAarch32Instruction);
178 DECLARE_HEADERS(AsmAarch32Instruction);
179 #if defined(SgAsmAarch32Instruction_HEADERS) || defined(DOCUMENTATION)
180 #include <InstructionEnumsAarch32.h>
181 #endif // SgAsmAarch32Instruction_HEADERS
196 Rose::BinaryAnalysis::AArch32InstructionKind get_kind()
const;
197 void set_kind(Rose::BinaryAnalysis::Aarch32InstructionKind);
200 AsmAarch32Instruction.setDataPrototype(
"Rose::BinaryAnalysis::Aarch32InstructionKind",
"kind",
201 "= Rose::BinaryAnalysis::Aarch32InstructionKind::ARM_INS_INVALID",
202 CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
211 Rose::BinaryAnalysis::Aarch32InstructionCondition get_condition()
const;
212 void set_condition(Rose::BinaryAnalysis::Aarch32InstructionCondition);
215 AsmAarch32Instruction.setDataPrototype(
"Rose::BinaryAnalysis::Aarch32InstructionCondition",
"condition",
216 "= Rose::BinaryAnalysis::Aarch32InstructionCondition::ARM_CC_INVALID",
217 CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
224 bool get_updatesFlags()
const;
225 void set_updatesFlags(
bool);
228 AsmAarch32Instruction.setDataPrototype(
"bool",
"updatesFlags",
"= false",
229 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
232 DECLARE_OTHERS(AsmAarch32Instruction);
233 #if defined(SgAsmAarch32Instruction_OTHERS) || defined(DOCUMENTATION)
234 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
236 friend class boost::serialization::access;
239 void serialize(S &s,
const unsigned ) {
241 s & BOOST_SERIALIZATION_NVP(p_kind);
247 virtual std::string
description() const $ROSE_OVERRIDE;
248 virtual
bool terminatesBasicBlock() $ROSE_OVERRIDE;
249 virtual
Rose::
BinaryAnalysis::AddressSet getSuccessors(
bool &complete) $ROSE_OVERRIDE;
250 virtual
bool isUnknown() const $ROSE_OVERRIDE;
251 virtual
unsigned get_anyKind() const $ROSE_OVERRIDE;
252 virtual
bool isFunctionCallFast(const
std::vector<
SgAsmInstruction*>&, rose_addr_t *target,
253 rose_addr_t *return_va) $ROSE_OVERRIDE;
254 virtual
bool isFunctionCallSlow(const
std::vector<SgAsmInstruction*>&, rose_addr_t *target,
255 rose_addr_t *return_va) $ROSE_OVERRIDE;
256 virtual
bool isFunctionReturnFast(const
std::vector<SgAsmInstruction*>&) $ROSE_OVERRIDE;
257 virtual
bool isFunctionReturnSlow(const
std::vector<SgAsmInstruction*>&) $ROSE_OVERRIDE;
258 virtual
bool getBranchTarget(rose_addr_t *target) $ROSE_OVERRIDE;
260 #endif // SgAsmAarch32Instruction_OTHERS
268 #ifdef ROSE_ENABLE_ASM_AARCH64
269 DECLARE_LEAF_CLASS(AsmAarch64Instruction);
270 IS_SERIALIZABLE(AsmAarch64Instruction);
272 DECLARE_HEADERS(AsmAarch64Instruction);
273 #if defined(SgAsmAarch64Instruction_HEADERS) || defined(DOCUMENTATION)
274 #include <InstructionEnumsAarch64.h>
275 #endif // SgAsmAarch64Instruction_HEADERS
290 Rose::BinaryAnalysis::Aarch64InstructionKind get_kind()
const;
291 void set_kind(Rose::BinaryAnalysis::Aarch64InstructionKind);
294 AsmAarch64Instruction.setDataPrototype(
"Rose::BinaryAnalysis::Aarch64InstructionKind",
"kind",
295 "= Rose::BinaryAnalysis::Aarch64InstructionKind::ARM64_INS_INVALID",
296 CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
303 Rose::BinaryAnalysis::Aarch64InstructionCondition get_condition()
const;
304 void set_condition(Rose::BinaryAnalysis::Aarch64InstructionCondition);
307 AsmAarch64Instruction.setDataPrototype(
"Rose::BinaryAnalysis::Aarch64InstructionCondition",
"condition",
308 "= Rose::BinaryAnalysis::Aarch64InstructionCondition::ARM64_CC_INVALID",
309 CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
316 bool get_updatesFlags()
const;
317 void set_updatesFlags(
bool);
320 AsmAarch64Instruction.setDataPrototype(
"bool",
"updatesFlags",
"= false",
321 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
324 DECLARE_OTHERS(AsmAarch64Instruction);
325 #if defined(SgAsmAarch64Instruction_OTHERS) || defined(DOCUMENTATION)
326 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
328 friend class boost::serialization::access;
331 void serialize(S &s,
const unsigned ) {
333 s & BOOST_SERIALIZATION_NVP(p_kind);
334 s & BOOST_SERIALIZATION_NVP(p_condition);
340 virtual std::string
description() const $ROSE_OVERRIDE;
341 virtual
bool terminatesBasicBlock() $ROSE_OVERRIDE;
342 virtual
Rose::
BinaryAnalysis::AddressSet getSuccessors(
bool &complete) $ROSE_OVERRIDE;
343 virtual
bool isUnknown() const $ROSE_OVERRIDE;
344 virtual
unsigned get_anyKind() const $ROSE_OVERRIDE;
345 virtual
bool isFunctionCallFast(const
std::vector<
SgAsmInstruction*>&, rose_addr_t *target,
346 rose_addr_t *return_va) $ROSE_OVERRIDE;
347 virtual
bool isFunctionCallSlow(const
std::vector<SgAsmInstruction*>&, rose_addr_t *target,
348 rose_addr_t *return_va) $ROSE_OVERRIDE;
349 virtual
bool isFunctionReturnFast(const
std::vector<SgAsmInstruction*>&) $ROSE_OVERRIDE;
350 virtual
bool isFunctionReturnSlow(const
std::vector<SgAsmInstruction*>&) $ROSE_OVERRIDE;
351 virtual
bool getBranchTarget(rose_addr_t *target) $ROSE_OVERRIDE;
353 #endif // SgAsmAarch64Instruction_OTHERS
361 DECLARE_LEAF_CLASS(AsmX86Instruction);
362 IS_SERIALIZABLE(AsmX86Instruction);
363 DECLARE_HEADERS(AsmX86Instruction);
364 #if defined(SgAsmX86Instruction_HEADERS) || defined(DOCUMENTATION)
365 #include <InstructionEnumsX86.h>
367 #endif // SgAsmX86Instruction_HEADERS
386 AsmX86Instruction.setDataPrototype(
"Rose::BinaryAnalysis::X86InstructionKind",
"kind",
387 "= Rose::BinaryAnalysis::x86_unknown_instruction",
388 CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
399 AsmX86Instruction.setDataPrototype(
"Rose::BinaryAnalysis::X86InstructionSize",
"baseSize",
400 "= Rose::BinaryAnalysis::x86_insnsize_none",
401 CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
412 AsmX86Instruction.setDataPrototype(
"Rose::BinaryAnalysis::X86InstructionSize",
"operandSize",
413 "= Rose::BinaryAnalysis::x86_insnsize_none",
414 CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
425 AsmX86Instruction.setDataPrototype(
"Rose::BinaryAnalysis::X86InstructionSize",
"addressSize",
426 "= Rose::BinaryAnalysis::x86_insnsize_none",
427 CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
440 AsmX86Instruction.setDataPrototype(
"bool",
"lockPrefix",
"= false",
441 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
452 AsmX86Instruction.setDataPrototype(
"Rose::BinaryAnalysis::X86RepeatPrefix",
"repeatPrefix",
453 "= Rose::BinaryAnalysis::x86_repeat_none",
454 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
465 AsmX86Instruction.setDataPrototype(
"Rose::BinaryAnalysis::X86BranchPrediction",
"branchPrediction",
466 "= Rose::BinaryAnalysis::x86_branch_prediction_none",
467 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
481 AsmX86Instruction.setDataPrototype(
"Rose::BinaryAnalysis::X86SegmentRegister",
"segmentOverride",
482 "= Rose::BinaryAnalysis::x86_segreg_none",
483 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
487 DECLARE_OTHERS(AsmX86Instruction);
488 #if defined(SgAsmX86Instruction_OTHERS) || defined(DOCUMENTATION)
489 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
491 friend class boost::serialization::access;
494 void serialize(S &s,
const unsigned ) {
496 s & BOOST_SERIALIZATION_NVP(p_kind);
497 s & BOOST_SERIALIZATION_NVP(p_baseSize);
498 s & BOOST_SERIALIZATION_NVP(p_operandSize);
499 s & BOOST_SERIALIZATION_NVP(p_addressSize);
500 s & BOOST_SERIALIZATION_NVP(p_lockPrefix);
501 s & BOOST_SERIALIZATION_NVP(p_repeatPrefix);
502 s & BOOST_SERIALIZATION_NVP(p_branchPrediction);
503 s & BOOST_SERIALIZATION_NVP(p_segmentOverride);
533 rose_addr_t *target, rose_addr_t *ret) $ROSE_OVERRIDE;
535 rose_addr_t *target, rose_addr_t *ret) $ROSE_OVERRIDE;
539 virtual Rose::BinaryAnalysis::AddressSet
getSuccessors(
bool &complete) $ROSE_OVERRIDE;
540 virtual Rose::BinaryAnalysis::AddressSet
getSuccessors(
const std::vector<SgAsmInstruction*>&,
544 virtual bool isUnknown()
const $ROSE_OVERRIDE;
545 virtual unsigned get_anyKind()
const $ROSE_OVERRIDE;
546 #endif // SgAsmX86Instruction_OTHERS
553 DECLARE_LEAF_CLASS(AsmPowerpcInstruction);
554 IS_SERIALIZABLE(AsmPowerpcInstruction);
555 DECLARE_HEADERS(AsmPowerpcInstruction);
556 #if defined(SgAsmPowerpcInstruction_HEADERS) || defined(DOCUMENTATION)
557 #include <InstructionEnumsPowerpc.h>
558 #endif // SgAsmPowerpcInstruction_HEADERS
578 AsmPowerpcInstruction.setDataPrototype(
"Rose::BinaryAnalysis::PowerpcInstructionKind",
"kind",
579 "= Rose::BinaryAnalysis::powerpc_unknown_instruction",
580 CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE,
584 DECLARE_OTHERS(AsmPowerpcInstruction);
585 #if defined(SgAsmPowerpcInstruction_OTHERS) || defined(DOCUMENTATION)
586 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
588 friend class boost::serialization::access;
591 void serialize(S &s,
const unsigned ) {
593 s & BOOST_SERIALIZATION_NVP(p_kind);
612 virtual std::string
description()
const $ROSE_OVERRIDE;
614 virtual Rose::BinaryAnalysis::AddressSet
getSuccessors(
bool &complete) $ROSE_OVERRIDE;
615 virtual bool isUnknown()
const $ROSE_OVERRIDE;
616 virtual unsigned get_anyKind()
const $ROSE_OVERRIDE;
618 rose_addr_t *target, rose_addr_t *retva) $ROSE_OVERRIDE;
620 rose_addr_t *target, rose_addr_t *retva) $ROSE_OVERRIDE;
623 #endif // SgAsmPowerpcInstruction_OTHERS
631 DECLARE_LEAF_CLASS(AsmMipsInstruction);
632 IS_SERIALIZABLE(AsmMipsInstruction);
633 DECLARE_HEADERS(AsmMipsInstruction);
634 #if defined(SgAsmMipsInstruction_HEADERS) || defined(DOCUMENTATION)
635 #include <InstructionEnumsMips.h>
636 #endif // SgAsmMipsInstruction_HEADERS
655 AsmMipsInstruction.setDataPrototype(
"Rose::BinaryAnalysis::MipsInstructionKind",
"kind",
656 "= Rose::BinaryAnalysis::mips_unknown_instruction",
657 CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE,
661 DECLARE_OTHERS(AsmMipsInstruction);
662 #if defined(SgAsmMipsInstruction_OTHERS) || defined(DOCUMENTATION)
663 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
665 friend class boost::serialization::access;
668 void serialize(S &s,
const unsigned ) {
670 s & BOOST_SERIALIZATION_NVP(p_kind);
676 virtual std::string
description()
const $ROSE_OVERRIDE;
679 rose_addr_t *target, rose_addr_t *ret) $ROSE_OVERRIDE;
681 rose_addr_t *target, rose_addr_t *ret) $ROSE_OVERRIDE;
684 virtual Rose::BinaryAnalysis::AddressSet
getSuccessors(
bool &complete) $ROSE_OVERRIDE;
685 virtual bool isUnknown()
const $ROSE_OVERRIDE;
687 virtual unsigned get_anyKind()
const $ROSE_OVERRIDE;
688 #endif // SgAsmMipsInstruction_OTHERS
695 DECLARE_LEAF_CLASS(AsmM68kInstruction);
696 IS_SERIALIZABLE(AsmM68kInstruction);
697 DECLARE_HEADERS(AsmM68kInstruction);
698 #if defined(SgAsmM68kInstruction_HEADERS) || defined(DOCUMENTATION)
699 #include "InstructionEnumsM68k.h"
700 #endif // SgAsmM68kInstruction_HEADERS
718 AsmM68kInstruction.setDataPrototype(
"Rose::BinaryAnalysis::M68kInstructionKind",
"kind",
719 " = Rose::BinaryAnalysis::m68k_unknown_instruction",
720 CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE,
724 DECLARE_OTHERS(AsmM68kInstruction);
725 #if defined(SgAsmM68kInstruction_OTHERS) || defined(DOCUMENTATION)
726 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
728 friend class boost::serialization::access;
731 void serialize(S &s,
const unsigned ) {
733 s & BOOST_SERIALIZATION_NVP(p_kind);
739 virtual std::string
description()
const $ROSE_OVERRIDE;
742 rose_addr_t *target, rose_addr_t *ret) $ROSE_OVERRIDE;
744 rose_addr_t *target, rose_addr_t *ret) $ROSE_OVERRIDE;
748 virtual Rose::BinaryAnalysis::AddressSet
getSuccessors(
bool &complete) $ROSE_OVERRIDE;
749 virtual Rose::BinaryAnalysis::AddressSet
getSuccessors(
const std::vector<SgAsmInstruction*>&,
753 virtual bool isUnknown()
const $ROSE_OVERRIDE;
754 virtual unsigned get_anyKind()
const $ROSE_OVERRIDE;
755 #endif // SgAsmM68kInstruction_OTHERS
762 DECLARE_LEAF_CLASS(AsmNullInstruction);
763 IS_SERIALIZABLE(AsmNullInstruction);
770 DECLARE_OTHERS(AsmNullInstruction);
771 #if defined(SgAsmNullInstruction_OTHERS) || defined(DOCUMENTATION)
772 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
774 friend class boost::serialization::access;
777 void serialize(S & s,
const unsigned ) {
784 enum Kind { null_unknown };
789 rose_addr_t *target, rose_addr_t *ret) $ROSE_OVERRIDE;
791 rose_addr_t *target, rose_addr_t *ret) $ROSE_OVERRIDE;
795 virtual Rose::BinaryAnalysis::AddressSet
getSuccessors(
bool &complete) $ROSE_OVERRIDE;
796 virtual Rose::BinaryAnalysis::AddressSet
getSuccessors(
const std::vector<SgAsmInstruction*>&,
800 virtual bool isUnknown()
const $ROSE_OVERRIDE;
801 virtual unsigned get_anyKind()
const $ROSE_OVERRIDE;
802 #endif // SgAsmNullInstruction_OTHERS
809 NEW_NONTERMINAL_MACRO(AsmInstruction,
811 #ifdef ROSE_ENABLE_ASM_AARCH32
812 | AsmAarch32Instruction
814 #ifdef ROSE_ENABLE_ASM_AARCH64
815 | AsmAarch64Instruction
817 | AsmPowerpcInstruction | AsmMipsInstruction | AsmM68kInstruction | AsmNullInstruction,
818 "AsmInstruction",
"AsmInstructionTag",
true);
819 AsmInstruction.setCppCondition(
"!defined(DOCUMENTATION)");
820 IS_SERIALIZABLE(AsmInstruction);
822 DECLARE_HEADERS(AsmInstruction);
823 #if defined(SgAsmInstruction_HEADERS) || defined(DOCUMENTATION)
824 #include <MemoryMap.h>
825 #endif // SgAsmInstruction_HEADERS
866 AsmInstruction.setDataPrototype(
"std::string",
"mnemonic",
"= \"\"",
867 CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
880 AsmInstruction.setDataPrototype(
"SgUnsignedCharList",
"raw_bytes",
"",
881 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
895 AsmInstruction.setDataPrototype(
"SgAsmOperandList*",
"operandList",
"= NULL",
896 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
904 AsmInstruction.setDataPrototype(
"size_t",
"cacheLockCount",
"= 0",
905 NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
911 AsmInstruction.setDataPrototype(
"SgAsmStatementPtrList",
"sources",
"",
912 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
926 AsmInstruction.setDataPrototype(
"int64_t",
"stackDeltaIn",
"= SgAsmInstruction::INVALID_STACK_DELTA",
927 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
937 AsmInstruction.setDataPrototype(
"SgAsmExprListExp*",
"semantics",
"= NULL",
938 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE, COPY_DATA);
941 DECLARE_OTHERS(AsmInstruction);
942 #if defined(SgAsmInstruction_OTHERS) || defined(DOCUMENTATION)
943 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
945 friend class boost::serialization::access;
948 void serialize(S &s,
const unsigned version) {
950 s & BOOST_SERIALIZATION_NVP(p_mnemonic);
951 s & BOOST_SERIALIZATION_NVP(p_raw_bytes);
952 s & BOOST_SERIALIZATION_NVP(p_operandList);
953 s & BOOST_SERIALIZATION_NVP(p_sources);
955 s & BOOST_SERIALIZATION_NVP(semanticFailure_);
961 struct SemanticFailure {
963 SemanticFailure(): n(0) {}
965 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
967 friend class boost::serialization::access;
969 void serialize(S &s,
const unsigned ) {
970 s & BOOST_SERIALIZATION_NVP(n);
974 SemanticFailure semanticFailure_;
978 mutable SAWYER_THREAD_TRAITS::Mutex mutex_;
1026 virtual bool isFunctionCallFast(
const std::vector<SgAsmInstruction*>&, rose_addr_t *target, rose_addr_t *ret);
1027 virtual bool isFunctionCallSlow(
const std::vector<SgAsmInstruction*>&, rose_addr_t *target, rose_addr_t *ret);
1203 virtual bool hasEffect(
const std::vector<SgAsmInstruction*>&,
bool allow_branch=
false,
1204 bool relax_stack_semantics=
false);
1215 virtual std::vector<std::pair<size_t,size_t> >
1217 bool relax_stack_semantics=
false);
1225 virtual Rose::BinaryAnalysis::AddressSet
getSuccessors(
bool &complete);
1235 virtual Rose::BinaryAnalysis::AddressSet
getSuccessors(
const std::vector<SgAsmInstruction*> &basicBlock,
1292 virtual std::string
toString()
const;
1324 #endif // SgAsmInstruction_OTHERS
1326 #ifdef DOCUMENTATION
1341 DECLARE_LEAF_CLASS(AsmOperandList);
1342 IS_SERIALIZABLE(AsmOperandList);
1344 #ifdef DOCUMENTATION
1350 #ifdef DOCUMENTATION
1361 AsmOperandList.setDataPrototype(
"SgAsmExpressionPtrList",
"operands",
"",
1362 NO_CONSTRUCTOR_PARAMETER, BUILD_LIST_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE);
1365 DECLARE_OTHERS(AsmOperandList);
1366 #if defined(SgAsmOperandList_OTHERS) || defined(DOCUMENTATION)
1367 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
1369 friend class boost::serialization::access;
1372 void serialize(S &s,
const unsigned ) {
1373 s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(
SgAsmNode);
1374 s & BOOST_SERIALIZATION_NVP(p_operands);
1381 #endif // SgAsmOperandList_OTHERS
1383 #ifdef DOCUMENTATION
1388 AsmOperandList.setFunctionSource(
"SOURCE_BINARY_OPERAND_LIST",
"../Grammar/BinaryInstruction.code");
1392 DECLARE_LEAF_CLASS(AsmBinaryAdd);
1393 IS_SERIALIZABLE(AsmBinaryAdd);
1395 #ifdef DOCUMENTATION
1401 DECLARE_OTHERS(AsmBinaryAdd);
1402 #if defined(SgAsmBinaryAdd_OTHERS) || defined(DOCUMENTATION)
1403 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
1405 friend class boost::serialization::access;
1408 void serialize(S &s,
const unsigned ) {
1412 #endif // SgAsmBinaryAdd_OTHERS
1414 #ifdef DOCUMENTATION
1420 DECLARE_LEAF_CLASS(AsmBinarySubtract);
1421 IS_SERIALIZABLE(AsmBinarySubtract);
1423 #ifdef DOCUMENTATION
1429 DECLARE_OTHERS(AsmBinarySubtract);
1430 #if defined(SgAsmBinarySubtract_OTHERS) || defined(DOCUMENTATION)
1431 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
1433 friend class boost::serialization::access;
1436 void serialize(S &s,
const unsigned ) {
1440 #endif // SgAsmBinarySubtract_OTHERS
1442 #ifdef DOCUMENTATION
1448 DECLARE_LEAF_CLASS(AsmBinaryMultiply);
1449 IS_SERIALIZABLE(AsmBinaryMultiply);
1451 #ifdef DOCUMENTATION
1457 DECLARE_OTHERS(AsmBinaryMultiply);
1458 #if defined(SgAsmBinaryMultiply_OTHERS) || defined(DOCUMENTATION)
1459 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
1461 friend class boost::serialization::access;
1464 void serialize(S &s,
const unsigned ) {
1468 #endif // SgAsmBinaryMultiply_OTHERS
1470 #ifdef DOCUMENTATION
1476 DECLARE_LEAF_CLASS(AsmBinaryDivide);
1477 IS_SERIALIZABLE(AsmBinaryDivide);
1479 #ifdef DOCUMENTATION
1485 DECLARE_OTHERS(AsmBinaryDivide);
1486 #if defined(SgAsmBinaryDivide_OTHERS) || defined(DOCUMENTATION)
1487 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
1489 friend class boost::serialization::access;
1492 void serialize(S &s,
const unsigned ) {
1496 #endif // SgAsmBinaryDivide_OTHERS
1498 #ifdef DOCUMENTATION
1504 DECLARE_LEAF_CLASS(AsmBinaryMod);
1505 IS_SERIALIZABLE(AsmBinaryMod);
1507 #ifdef DOCUMENTATION
1513 DECLARE_OTHERS(AsmBinaryMod);
1514 #if defined(SgAsmBinaryMod_OTHERS) || defined(DOCUMENTATION)
1515 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
1517 friend class boost::serialization::access;
1520 void serialize(S &s,
const unsigned ) {
1524 #endif // SgAsmBinaryMod_OTHERS
1526 #ifdef DOCUMENTATION
1532 DECLARE_LEAF_CLASS(AsmBinaryAddPreupdate);
1533 IS_SERIALIZABLE(AsmBinaryAddPreupdate);
1535 #ifdef DOCUMENTATION
1541 DECLARE_OTHERS(AsmBinaryAddPreupdate);
1542 #if defined(SgAsmBinaryAddPreupdate_OTHERS) || defined(DOCUMENTATION)
1543 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
1545 friend class boost::serialization::access;
1548 void serialize(S &s,
const unsigned ) {
1552 #endif // SgAsmBinaryAddPreupdate_OTHERS
1554 #ifdef DOCUMENTATION
1560 DECLARE_LEAF_CLASS(AsmBinarySubtractPreupdate);
1561 IS_SERIALIZABLE(AsmBinarySubtractPreupdate);
1563 #ifdef DOCUMENTATION
1569 DECLARE_OTHERS(AsmBinarySubtractPreupdate);
1570 #if defined(SgAsmBinarySubtractPreupdate_OTHERS) || defined(DOCUMENTATION)
1571 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
1573 friend class boost::serialization::access;
1576 void serialize(S &s,
const unsigned ) {
1580 #endif // SgAsmBinarySubtractPreupdate_OTHERS
1582 #ifdef DOCUMENTATION
1588 DECLARE_LEAF_CLASS(AsmBinaryAddPostupdate);
1589 IS_SERIALIZABLE(AsmBinaryAddPostupdate);
1591 #ifdef DOCUMENTATION
1597 DECLARE_OTHERS(AsmBinaryAddPostupdate);
1598 #if defined(SgAsmBinaryAddPostupdate_OTHERS) || defined(DOCUMENTATION)
1599 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
1601 friend class boost::serialization::access;
1604 void serialize(S &s,
const unsigned ) {
1608 #endif // SgAsmBinaryAddPostupdate_OTHERS
1610 #ifdef DOCUMENTATION
1616 DECLARE_LEAF_CLASS(AsmBinarySubtractPostupdate);
1617 IS_SERIALIZABLE(AsmBinarySubtractPostupdate);
1619 #ifdef DOCUMENTATION
1625 DECLARE_OTHERS(AsmBinarySubtractPostupdate);
1626 #if defined(SgAsmBinarySubtractPostupdate_OTHERS) || defined(DOCUMENTATION)
1627 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
1629 friend class boost::serialization::access;
1632 void serialize(S &s,
const unsigned ) {
1636 #endif // SgAsmBinarySubtractPostupdate_OTHERS
1638 #ifdef DOCUMENTATION
1644 DECLARE_LEAF_CLASS(AsmBinaryLsl);
1645 IS_SERIALIZABLE(AsmBinaryLsl);
1647 #ifdef DOCUMENTATION
1653 DECLARE_OTHERS(AsmBinaryLsl);
1654 #if defined(SgAsmBinaryLsl_OTHERS) || defined(DOCUMENTATION)
1655 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
1657 friend class boost::serialization::access;
1660 void serialize(S &s,
const unsigned ) {
1664 #endif // SgAsmBinaryLsl_OTHERS
1666 #ifdef DOCUMENTATION
1672 DECLARE_LEAF_CLASS(AsmBinaryMsl);
1673 IS_SERIALIZABLE(AsmBinaryMsl);
1675 #ifdef DOCUMENTATION
1683 DECLARE_OTHERS(AsmBinaryMsl);
1684 #if defined(SgAsmBinaryMsl_OTHERS) || defined(DOCUMENTATION)
1685 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
1687 friend class boost::serialization::access;
1690 void serialize(S &s,
const unsigned ) {
1694 #endif // SgAsmBinaryMsl_OTHERS
1696 #ifdef DOCUMENTATION
1702 DECLARE_LEAF_CLASS(AsmBinaryLsr);
1703 IS_SERIALIZABLE(AsmBinaryLsr);
1705 #ifdef DOCUMENTATION
1711 DECLARE_OTHERS(AsmBinaryLsr);
1712 #if defined(SgAsmBinaryLsr_OTHERS) || defined(DOCUMENTATION)
1713 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
1715 friend class boost::serialization::access;
1718 void serialize(S &s,
const unsigned ) {
1722 #endif // SgAsmBinaryLsr_OTHERS
1724 #ifdef DOCUMENTATION
1730 DECLARE_LEAF_CLASS(AsmBinaryAsr);
1731 IS_SERIALIZABLE(AsmBinaryAsr);
1733 #ifdef DOCUMENTATION
1739 DECLARE_OTHERS(AsmBinaryAsr);
1740 #if defined(SgAsmBinaryAsr_OTHERS) || defined(DOCUMENTATION)
1741 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
1743 friend class boost::serialization::access;
1746 void serialize(S &s,
const unsigned ) {
1750 #endif // SgAsmBinaryAsr_OTHERS
1752 #ifdef DOCUMENTATION
1758 DECLARE_LEAF_CLASS(AsmBinaryRor);
1759 IS_SERIALIZABLE(AsmBinaryRor);
1761 #ifdef DOCUMENTATION
1767 DECLARE_OTHERS(AsmBinaryRor);
1768 #if defined(SgAsmBinaryRor_OTHERS) || defined(DOCUMENTATION)
1769 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
1771 friend class boost::serialization::access;
1774 void serialize(S &s,
const unsigned ) {
1778 #endif // SgAsmBinaryRor_OTHERS
1780 #ifdef DOCUMENTATION
1786 DECLARE_LEAF_CLASS(AsmBinaryConcat);
1787 IS_SERIALIZABLE(AsmBinaryConcat);
1789 #ifdef DOCUMENTATION
1795 DECLARE_OTHERS(AsmBinaryConcat);
1796 #if defined(SgAsmBinaryConcat_OTHERS) || defined(DOCUMENTATION)
1797 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
1799 friend class boost::serialization::access;
1802 void serialize(S &s,
const unsigned ) {
1806 #endif // SgAsmBinaryConcat_OTHERS
1808 #ifdef DOCUMENTATION
1814 NEW_NONTERMINAL_MACRO(AsmBinaryExpression,
1815 AsmBinaryAdd | AsmBinarySubtract | AsmBinaryMultiply |
1816 AsmBinaryDivide | AsmBinaryMod | AsmBinaryAddPreupdate |
1817 AsmBinarySubtractPreupdate | AsmBinaryAddPostupdate | AsmBinarySubtractPostupdate |
1818 AsmBinaryLsl | AsmBinaryLsr | AsmBinaryAsr |
1819 AsmBinaryRor | AsmBinaryMsl | AsmBinaryConcat,
1820 "AsmBinaryExpression",
"AsmBinaryExpressionTag",
false);
1821 AsmBinaryExpression.setCppCondition(
"!defined(DOCUMENTATION)");
1822 IS_SERIALIZABLE(AsmBinaryExpression);
1824 #ifdef DOCUMENTATION
1830 #ifdef DOCUMENTATION
1838 AsmBinaryExpression.setDataPrototype(
"SgAsmExpression*",
"lhs",
"= NULL",
1839 CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE);
1842 #ifdef DOCUMENTATION
1850 AsmBinaryExpression.setDataPrototype(
"SgAsmExpression*",
"rhs",
"= NULL",
1851 CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE);
1854 DECLARE_OTHERS(AsmBinaryExpression);
1855 #if defined(SgAsmBinaryExpression_OTHERS) || defined(DOCUMENTATION)
1856 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
1858 friend class boost::serialization::access;
1861 void serialize(S &s,
const unsigned ) {
1863 s & BOOST_SERIALIZATION_NVP(p_lhs);
1864 s & BOOST_SERIALIZATION_NVP(p_rhs);
1867 #endif // SgAsmBinaryExpression_OTHERS
1869 #ifdef DOCUMENTATION
1875 DECLARE_LEAF_CLASS(AsmUnaryPlus);
1876 IS_SERIALIZABLE(AsmUnaryPlus);
1878 #ifdef DOCUMENTATION
1884 DECLARE_OTHERS(AsmUnaryPlus);
1885 #if defined(SgAsmUnaryPlus_OTHERS) || defined(DOCUMENTATION)
1886 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
1888 friend class boost::serialization::access;
1891 void serialize(S &s,
const unsigned ) {
1895 #endif // SgAsmUnaryPlus_OTHERS
1897 #ifdef DOCUMENTATION
1903 DECLARE_LEAF_CLASS(AsmUnaryMinus);
1904 IS_SERIALIZABLE(AsmUnaryMinus);
1906 #ifdef DOCUMENTATION
1912 DECLARE_OTHERS(AsmUnaryMinus);
1913 #if defined(SgAsmUnaryMinus_OTHERS) || defined(DOCUMENTATION)
1914 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
1916 friend class boost::serialization::access;
1919 void serialize(S &s,
const unsigned ) {
1923 #endif // SgAsmUnaryMinus_OTHERS
1925 #ifdef DOCUMENTATION
1931 DECLARE_LEAF_CLASS(AsmUnaryRrx);
1932 IS_SERIALIZABLE(AsmUnaryRrx);
1934 #ifdef DOCUMENTATION
1940 DECLARE_OTHERS(AsmUnaryRrx);
1941 #if defined(SgAsmUnaryRrx_OTHERS) || defined(DOCUMENTATION)
1942 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
1944 friend class boost::serialization::access;
1947 void serialize(S &s,
const unsigned ) {
1951 #endif // SgAsmUnaryRrx_OTHERS
1953 #ifdef DOCUMENTATION
1959 DECLARE_LEAF_CLASS(AsmUnaryTruncate);
1960 IS_SERIALIZABLE(AsmUnaryTruncate);
1962 #ifdef DOCUMENTATION
1972 DECLARE_OTHERS(AsmUnaryTruncate);
1973 #if defined(SgAsmUnaryTruncate_OTHERS) || defined(DOCUMENTATION)
1974 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
1976 friend class boost::serialization::access;
1979 void serialize(S &s,
const unsigned ) {
1983 #endif // SgAsmUnaryTruncate_OTHERS
1985 #ifdef DOCUMENTATION
1991 DECLARE_LEAF_CLASS(AsmUnarySignedExtend);
1992 IS_SERIALIZABLE(AsmUnarySignedExtend);
1994 #ifdef DOCUMENTATION
2004 DECLARE_OTHERS(AsmUnarySignedExtend);
2005 #if defined(SgAsmUnarySignedExtend_OTHERS) || defined(DOCUMENTATION)
2006 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
2008 friend class boost::serialization::access;
2011 void serialize(S &s,
const unsigned ) {
2015 #endif // SgAsmUnarySignedExtend_OTHERS
2017 #ifdef DOCUMENTATION
2023 DECLARE_LEAF_CLASS(AsmUnaryUnsignedExtend);
2024 IS_SERIALIZABLE(AsmUnaryUnsignedExtend);
2026 #ifdef DOCUMENTATION
2036 DECLARE_OTHERS(AsmUnaryUnsignedExtend);
2037 #if defined(SgAsmUnaryUnsignedExtend_OTHERS) || defined(DOCUMENTATION)
2038 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
2040 friend class boost::serialization::access;
2043 void serialize(S &s,
const unsigned ) {
2047 #endif // SgAsmUnaryUnsignedExtend_OTHERS
2049 #ifdef DOCUMENTATION
2055 #ifdef ROSE_ENABLE_ASM_AARCH64
2056 DECLARE_LEAF_CLASS(AsmAarch64AtOperand);
2057 IS_SERIALIZABLE(AsmAarch64AtOperand);
2059 #ifdef DOCUMENTATION
2065 DECLARE_OTHERS(AsmAarch64AtOperand);
2066 #if defined(SgAsmAarch64AtOperand_OTHERS) || defined(DOCUMENTATION)
2067 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
2069 friend class boost::serialization::access;
2072 void serialize(S &s,
const unsigned ) {
2074 s & BOOST_SERIALIZATION_NVP(operation_);
2079 Rose::BinaryAnalysis::Aarch64AtOperation operation_;
2083 explicit SgAsmAarch64AtOperand(Rose::BinaryAnalysis::Aarch64AtOperation op)
2091 Rose::BinaryAnalysis::Aarch64AtOperation operation()
const {
2094 void operation(Rose::BinaryAnalysis::Aarch64AtOperation op) {
2098 #endif // SgAsmAarch64AtOperand_OTHERS
2100 #ifdef DOCUMENTATION
2107 #ifdef ROSE_ENABLE_ASM_AARCH64
2108 DECLARE_LEAF_CLASS(AsmAarch64PrefetchOperand);
2109 IS_SERIALIZABLE(AsmAarch64PrefetchOperand);
2111 #ifdef DOCUMENTATION
2117 DECLARE_OTHERS(AsmAarch64PrefetchOperand);
2118 #if defined(SgAsmAarch64PrefetchOperand_OTHERS) || defined(DOCUMENTATION)
2119 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
2121 friend class boost::serialization::access;
2124 void serialize(S &s,
const unsigned ) {
2126 s & BOOST_SERIALIZATION_NVP(operation_);
2131 Rose::BinaryAnalysis::Aarch64PrefetchOperation operation_;
2135 explicit SgAsmAarch64PrefetchOperand(Rose::BinaryAnalysis::Aarch64PrefetchOperation op)
2143 Rose::BinaryAnalysis::Aarch64PrefetchOperation operation()
const {
2146 void operation(Rose::BinaryAnalysis::Aarch64PrefetchOperation op) {
2150 #endif // SgAsmAarch64PrefetchOperand_OTHERS
2152 #ifdef DOCUMENTATION
2159 #ifdef ROSE_ENABLE_ASM_AARCH64
2160 DECLARE_LEAF_CLASS(AsmAarch64SysMoveOperand);
2161 IS_SERIALIZABLE(AsmAarch64SysMoveOperand);
2163 #ifdef DOCUMENTATION
2169 DECLARE_OTHERS(AsmAarch64SysMoveOperand);
2170 #if defined(SgAsmAarch64SysMoveOperand_OTHERS) || defined(DOCUMENTATION)
2171 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
2173 friend class boost::serialization::access;
2176 void serialize(S &s,
const unsigned ) {
2178 s & BOOST_SERIALIZATION_NVP(access_);
2187 explicit SgAsmAarch64SysMoveOperand(
unsigned access)
2188 : access_(access) {}
2195 unsigned access()
const {
2198 void access(
unsigned ac) {
2202 #endif // SgAsmAarch64SysMoveOperand_OTHERS
2204 #ifdef DOCUMENTATION
2211 #ifdef ROSE_ENABLE_ASM_AARCH64
2212 DECLARE_LEAF_CLASS(AsmAarch64CImmediateOperand);
2213 IS_SERIALIZABLE(AsmAarch64CImmediateOperand);
2215 #ifdef DOCUMENTATION
2221 DECLARE_OTHERS(AsmAarch64CImmediateOperand);
2222 #if defined(SgAsmAarch64CImmediateOperand_OTHERS) || defined(DOCUMENTATION)
2223 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
2225 friend class boost::serialization::access;
2228 void serialize(S &s,
const unsigned ) {
2230 s & BOOST_SERIALIZATION_NVP(imm_);
2239 explicit SgAsmAarch64CImmediateOperand(
unsigned imm)
2247 unsigned immediate()
const {
2250 void immediate(
unsigned imm) {
2254 #endif // SgAsmAarch64CImmediateOperand_OTHERS
2256 #ifdef DOCUMENTATION
2263 #ifdef ROSE_ENABLE_ASM_AARCH64
2264 DECLARE_LEAF_CLASS(AsmAarch64BarrierOperand);
2265 IS_SERIALIZABLE(AsmAarch64BarrierOperand);
2267 #ifdef DOCUMENTATION
2273 DECLARE_OTHERS(AsmAarch64BarrierOperand);
2274 #if defined(SgAsmAarch64BarrierOperand_OTHERS) || defined(DOCUMENTATION)
2275 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
2277 friend class boost::serialization::access;
2280 void serialize(S &s,
const unsigned ) {
2282 s & BOOST_SERIALIZATION_NVP(operation_);
2287 Rose::BinaryAnalysis::Aarch64BarrierOperation operation_;
2291 explicit SgAsmAarch64BarrierOperand(Rose::BinaryAnalysis::Aarch64BarrierOperation operation)
2292 : operation_(operation) {}
2297 Rose::BinaryAnalysis::Aarch64BarrierOperation operation()
const {
2300 void operation(Rose::BinaryAnalysis::Aarch64BarrierOperation op) {
2304 #endif // SgAsmAarch64BarrierOperand_OTHERS
2306 #ifdef DOCUMENTATION
2313 NEW_NONTERMINAL_MACRO(AsmUnaryExpression,
2314 AsmUnaryPlus | AsmUnaryMinus | AsmUnaryRrx | AsmUnaryTruncate | AsmUnarySignedExtend
2315 | AsmUnaryUnsignedExtend,
2316 "AsmUnaryExpression",
"AsmUnaryExpressionTag",
false);
2317 AsmUnaryExpression.setCppCondition(
"!defined(DOCUMENTATION)");
2318 IS_SERIALIZABLE(AsmUnaryExpression);
2320 #ifdef DOCUMENTATION
2326 #ifdef DOCUMENTATION
2334 AsmUnaryExpression.setDataPrototype(
"SgAsmExpression*",
"operand",
"= NULL",
2335 CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE);
2338 DECLARE_OTHERS(AsmUnaryExpression);
2339 #if defined(SgAsmUnaryExpression_OTHERS) || defined(DOCUMENTATION)
2340 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
2342 friend class boost::serialization::access;
2345 void serialize(S &s,
const unsigned ) {
2347 s & BOOST_SERIALIZATION_NVP(p_operand);
2350 #endif // SgAsmUnaryExpression_OTHERS
2352 #ifdef DOCUMENTATION
2358 DECLARE_LEAF_CLASS(AsmDirectRegisterExpression);
2359 IS_SERIALIZABLE(AsmDirectRegisterExpression);
2361 #ifdef DOCUMENTATION
2367 DECLARE_OTHERS(AsmDirectRegisterExpression);
2368 #if defined(SgAsmDirectRegisterExpression_OTHERS) || defined(DOCUMENTATION)
2369 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
2371 friend class boost::serialization::access;
2374 void serialize(S &s,
const unsigned ) {
2382 #endif // SgAsmDirectRegisterExpression_OTHERS
2384 #ifdef DOCUMENTATION
2390 DECLARE_LEAF_CLASS(AsmIndirectRegisterExpression);
2391 IS_SERIALIZABLE(AsmIndirectRegisterExpression);
2393 #ifdef DOCUMENTATION
2414 #ifdef DOCUMENTATION
2424 AsmIndirectRegisterExpression.setDataPrototype(
"Rose::BinaryAnalysis::RegisterDescriptor",
"stride",
"",
2425 CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
2428 #ifdef DOCUMENTATION
2438 AsmIndirectRegisterExpression.setDataPrototype(
"Rose::BinaryAnalysis::RegisterDescriptor",
"offset",
"",
2439 CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
2442 #ifdef DOCUMENTATION
2452 AsmIndirectRegisterExpression.setDataPrototype(
"size_t",
"index",
"",
2453 CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
2456 #ifdef DOCUMENTATION
2466 AsmIndirectRegisterExpression.setDataPrototype(
"size_t",
"modulus",
"",
2467 CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
2470 DECLARE_OTHERS(AsmIndirectRegisterExpression);
2471 #if defined(SgAsmIndirectRegisterExpression_OTHERS) || defined(DOCUMENTATION)
2472 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
2474 friend class boost::serialization::access;
2477 void serialize(S &s,
const unsigned ) {
2479 s & BOOST_SERIALIZATION_NVP(p_stride);
2480 s & BOOST_SERIALIZATION_NVP(p_offset);
2481 s & BOOST_SERIALIZATION_NVP(p_index);
2482 s & BOOST_SERIALIZATION_NVP(p_modulus);
2489 : p_index(0), p_modulus(0) {}
2490 #endif // SgAsmIndirectRegisterExpression_OTHERS
2492 #ifdef DOCUMENTATION
2498 NEW_NONTERMINAL_MACRO(AsmRegisterReferenceExpression, AsmDirectRegisterExpression|AsmIndirectRegisterExpression,
2499 "AsmRegisterReferenceExpression",
"AsmRegisterReferenceExpressionTag",
false);
2500 AsmRegisterReferenceExpression.setCppCondition(
"!defined(DOCUMENTATION)");
2501 IS_SERIALIZABLE(AsmRegisterReferenceExpression);
2503 #ifdef DOCUMENTATION
2509 #ifdef DOCUMENTATION
2517 AsmRegisterReferenceExpression.setDataPrototype(
"Rose::BinaryAnalysis::RegisterDescriptor",
"descriptor",
"",
2518 CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
2521 #ifdef DOCUMENTATION
2531 AsmRegisterReferenceExpression.setDataPrototype(
"int",
"adjustment",
"=0",
2532 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL,
2536 DECLARE_OTHERS(AsmRegisterReferenceExpression);
2537 #if defined(SgAsmRegisterReferenceExpression_OTHERS) || defined(DOCUMENTATION)
2538 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
2540 friend class boost::serialization::access;
2543 void serialize(S &s,
const unsigned ) {
2545 s & BOOST_SERIALIZATION_NVP(p_descriptor);
2546 s & BOOST_SERIALIZATION_NVP(p_adjustment);
2553 : p_adjustment(0) {}
2554 #endif // SgAsmRegisterReferenceExpression_OTHERS
2556 #ifdef DOCUMENTATION
2562 DECLARE_LEAF_CLASS(AsmRegisterNames);
2563 IS_SERIALIZABLE(AsmRegisterNames);
2565 #ifdef DOCUMENTATION
2571 #ifdef DOCUMENTATION
2578 const SgAsmRegisterReferenceExpressionPtrList&
get_registers()
const;
2579 void set_registers(
const SgAsmRegisterReferenceExpressionPtrList&);
2582 AsmRegisterNames.setDataPrototype(
"SgAsmRegisterReferenceExpressionPtrList",
"registers",
"",
2583 NO_CONSTRUCTOR_PARAMETER, BUILD_LIST_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE);
2586 #ifdef DOCUMENTATION
2597 AsmRegisterNames.setDataPrototype(
"unsigned",
"mask",
"=0",
2598 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
2601 DECLARE_OTHERS(AsmRegisterNames);
2602 #if defined(SgAsmRegisterNames_OTHERS) || defined(DOCUMENTATION)
2603 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
2605 friend class boost::serialization::access;
2608 void serialize(S &s,
const unsigned ) {
2610 s & BOOST_SERIALIZATION_NVP(p_registers);
2611 s & BOOST_SERIALIZATION_NVP(p_mask);
2614 #endif // SgAsmRegisterNames_OTHERS
2616 #ifdef DOCUMENTATION
2622 DECLARE_LEAF_CLASS(AsmIntegerValueExpression);
2623 IS_SERIALIZABLE(AsmIntegerValueExpression);
2625 #ifdef DOCUMENTATION
2645 #ifdef DOCUMENTATION
2660 AsmIntegerValueExpression.setDataPrototype(
"SgNode*",
"baseNode",
"=NULL",
2661 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
2664 DECLARE_OTHERS(AsmIntegerValueExpression);
2665 #if defined(SgAsmIntegerValueExpression_OTHERS) || defined(DOCUMENTATION)
2666 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
2668 friend class boost::serialization::access;
2671 void serialize(S &s,
const unsigned ) {
2673 s & BOOST_SERIALIZATION_NVP(p_baseNode);
2713 std::string
get_label(
bool quiet=
false)
const;
2759 #endif // SgAsmIntegerValueExpression_OTHERS
2761 #ifdef DOCUMENTATION
2767 DECLARE_LEAF_CLASS(AsmFloatValueExpression);
2768 IS_SERIALIZABLE(AsmFloatValueExpression);
2770 #ifdef DOCUMENTATION
2779 AsmFloatValueExpression.setAutomaticGenerationOfConstructor(
false);
2781 DECLARE_OTHERS(AsmFloatValueExpression);
2782 #if defined(SgAsmFloatValueExpression_OTHERS) || defined(DOCUMENTATION)
2789 mutable double p_nativeValue;
2790 mutable bool p_nativeValueIsValid;
2792 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
2794 friend class boost::serialization::access;
2797 void serialize(S &s,
const unsigned ) {
2799 s & BOOST_SERIALIZATION_NVP(p_nativeValue);
2800 s & BOOST_SERIALIZATION_NVP(p_nativeValueIsValid);
2842 #endif // SgAsmFloatValueExpression_OTHERS
2844 #ifdef DOCUMENTATION
2849 #ifdef ROSE_ENABLE_ASM_AARCH32
2850 DECLARE_LEAF_CLASS(AsmAarch32Coprocessor);
2851 IS_SERIALIZABLE(AsmAarch32Coprocessor);
2853 #ifdef DOCUMENTATION
2859 DECLARE_OTHERS(AsmAarch32Coprocessor);
2860 #if defined(SgAsmAarch32Coprocessor_OTHERS) || defined(DOCUMENTATION)
2861 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
2863 friend class boost::serialization::access;
2866 void serialize(S & s,
const unsigned ) {
2868 s & BOOST_SERIALIZATION_NVP(coprocessor_);
2876 explicit SgAsmAarch32Coprocessor(
int coprocessor)
2877 : coprocessor_(coprocessor) {}
2882 int coprocessor()
const {
return coprocessor_; }
2883 void coprocessor(
int n) { coprocessor_ = n; }
2885 #endif // SgAsmAarch32Coprocessor_OTHERS
2887 #ifdef DOCUMENTATION
2893 DECLARE_LEAF_CLASS(AsmByteOrder);
2894 IS_SERIALIZABLE(AsmByteOrder);
2896 #ifdef DOCUMENTATION
2902 DECLARE_OTHERS(AsmByteOrder);
2903 #if defined(SgAsmByteOrder_OTHERS) || defined(DOCUMENTATION)
2904 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
2906 friend class boost::serialization::access;
2909 void serialize(S & s,
const unsigned ) {
2911 s & BOOST_SERIALIZATION_NVP(byteOrder_);
2916 ByteOrder::Endianness byteOrder_;
2920 : byteOrder_(byteOrder) {}
2925 ByteOrder::Endianness
byteOrder()
const {
return byteOrder_; }
2926 void byteOrder(ByteOrder::Endianness sex) { byteOrder_ = sex; }
2928 #endif // SgAsmByteOrder_OTHERS
2930 #ifdef DOCUMENTATION
2936 NEW_NONTERMINAL_MACRO(AsmConstantExpression,
2937 AsmIntegerValueExpression | AsmFloatValueExpression,
2938 "AsmConstantExpression",
"AsmConstantExpressionTag",
false);
2939 AsmConstantExpression.setCppCondition(
"!defined(DOCUMENTATION)");
2940 IS_SERIALIZABLE(AsmConstantExpression);
2942 DECLARE_HEADERS(AsmConstantExpression);
2943 #if defined(SgAsmConstantExpression_HEADERS) || defined(DOCUMENTATION)
2944 #include <Sawyer/BitVector.h>
2945 #endif // SgAsmConstantExpression_HEADERS
2947 #ifdef DOCUMENTATION
2956 #ifndef DOCUMENTATION
2958 AsmConstantExpression.setDataPrototype(
"Sawyer::Container::BitVector",
"bitVector",
"",
2959 NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
2962 DECLARE_OTHERS(AsmConstantExpression);
2963 #if defined(SgAsmConstantExpression_OTHERS) || defined(DOCUMENTATION)
2964 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
2966 friend class boost::serialization::access;
2969 void serialize(S &s,
const unsigned ) {
2971 s & BOOST_SERIALIZATION_NVP(p_bitVector);
2985 #endif // SgAsmConstantExpression_OTHERS
2987 #ifdef DOCUMENTATION
2993 NEW_NONTERMINAL_MACRO(AsmValueExpression,
2994 AsmConstantExpression,
2995 "AsmValueExpression",
"AsmValueExpressionTag",
false);
2996 AsmValueExpression.setCppCondition(
"!defined(DOCUMENTATION)");
2997 IS_SERIALIZABLE(AsmValueExpression);
2999 #ifdef DOCUMENTATION
3011 #ifdef DOCUMENTATION
3023 AsmValueExpression.setDataPrototype(
"SgAsmValueExpression*",
"unfolded_expression_tree",
"= NULL",
3024 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE);
3027 #ifdef DOCUMENTATION
3040 AsmValueExpression.setDataPrototype(
"unsigned short",
"bit_offset",
"= 0",
3041 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
3044 #ifdef DOCUMENTATION
3055 AsmValueExpression.setDataPrototype(
"unsigned short",
"bit_size",
"= 0",
3056 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
3059 #ifdef DOCUMENTATION
3070 AsmValueExpression.setDataPrototype(
"SgSymbol*",
"symbol",
"= NULL",
3071 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
3074 DECLARE_OTHERS(AsmValueExpression);
3075 #if defined(SgAsmValueExpression_OTHERS) || defined(DOCUMENTATION)
3076 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
3078 friend class boost::serialization::access;
3081 void serialize(S &s,
const unsigned ) {
3083 s & BOOST_SERIALIZATION_NVP(p_unfolded_expression_tree);
3084 s & BOOST_SERIALIZATION_NVP(p_bit_offset);
3085 s & BOOST_SERIALIZATION_NVP(p_bit_size);
3087 ASSERT_require2(p_symbol == NULL,
"not implemented yet");
3089 s & BOOST_SERIALIZATION_NVP(p_symbol);
3093 #endif // SgAsmValueExpression_OTHERS
3095 #ifdef DOCUMENTATION
3101 DECLARE_LEAF_CLASS(AsmMemoryReferenceExpression);
3102 IS_SERIALIZABLE(AsmMemoryReferenceExpression);
3104 #ifdef DOCUMENTATION
3110 #ifdef DOCUMENTATION
3122 AsmMemoryReferenceExpression.setDataPrototype(
"SgAsmExpression*",
"address",
"= NULL",
3123 CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE);
3126 #ifdef DOCUMENTATION
3138 AsmMemoryReferenceExpression.setDataPrototype(
"SgAsmExpression*",
"segment",
"= NULL",
3139 CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE);
3142 DECLARE_OTHERS(AsmMemoryReferenceExpression);
3143 #if defined(SgAsmMemoryReferenceExpression_OTHERS) || defined(DOCUMENTATION)
3144 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
3146 friend class boost::serialization::access;
3149 void serialize(S &s,
const unsigned ) {
3151 s & BOOST_SERIALIZATION_NVP(p_address);
3152 s & BOOST_SERIALIZATION_NVP(p_segment);
3155 #endif // SgAsmMemoryReferenceExpression_OTHERS
3157 #ifdef DOCUMENTATION
3163 DECLARE_LEAF_CLASS(AsmControlFlagsExpression);
3164 IS_SERIALIZABLE(AsmControlFlagsExpression);
3166 #ifdef DOCUMENTATION
3172 #ifndef DOCUMENTATION
3173 AsmControlFlagsExpression.setDataPrototype(
"unsigned long",
"bit_flags",
"= 0",
3174 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
3177 DECLARE_OTHERS(AsmControlFlagsExpression);
3178 #if defined(SgAsmControlFlagsExpression_OTHERS) || defined(DOCUMENTATION)
3179 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
3181 friend class boost::serialization::access;
3184 void serialize(S &s,
const unsigned ) {
3186 s & BOOST_SERIALIZATION_NVP(p_bit_flags);
3189 #endif // SgAsmControlFlagsExpression_OTHERS
3191 #ifdef DOCUMENTATION
3197 DECLARE_LEAF_CLASS(AsmCommonSubExpression);
3198 IS_SERIALIZABLE(AsmCommonSubExpression);
3200 #ifdef DOCUMENTATION
3206 #ifndef DOCUMENTATION
3207 AsmCommonSubExpression.setDataPrototype(
"SgAsmExpression*",
"subexpression",
"= 0",
3208 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE);
3211 DECLARE_OTHERS(AsmCommonSubExpression);
3212 #if defined(SgAsmCommonSubExpression_OTHERS) || defined(DOCUMENTATION)
3213 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
3215 friend class boost::serialization::access;
3218 void serialize(S &s,
const unsigned ) {
3220 s & BOOST_SERIALIZATION_NVP(p_subexpression);
3223 #endif // SgAsmCommonSubExpression_OTHERS
3225 #ifdef DOCUMENTATION
3231 DECLARE_LEAF_CLASS(AsmRiscOperation);
3232 IS_SERIALIZABLE(AsmRiscOperation);
3234 #ifdef DOCUMENTATION
3247 #ifdef DOCUMENTATION
3258 AsmRiscOperation.setDataPrototype(
"SgAsmRiscOperation::RiscOperator",
"riscOperator",
"= SgAsmRiscOperation::OP_NONE",
3259 CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
3262 #ifdef DOCUMENTATION
3273 AsmRiscOperation.setDataPrototype(
"SgAsmExprListExp*",
"operands",
"= NULL",
3274 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE);
3277 DECLARE_OTHERS(AsmRiscOperation);
3278 #if defined(SgAsmRiscOperation_OTHERS) || defined(DOCUMENTATION)
3290 OP_filterCallTarget,
3291 OP_filterReturnTarget,
3292 OP_filterIndirectJumpTarget,
3302 OP_leastSignificantSetBit,
3303 OP_mostSignificantSetBit,
3308 OP_shiftRightArithmetic,
3313 OP_isUnsignedLessThan,
3314 OP_isUnsignedLessThanOrEqual,
3315 OP_isUnsignedGreaterThan,
3316 OP_isUnsignedGreaterThanOrEqual,
3317 OP_isSignedLessThan,
3318 OP_isSignedLessThanOrEqual,
3319 OP_isSignedGreaterThan,
3320 OP_isSignedGreaterThanOrEqual,
3332 OP_unsignedMultiply,
3343 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
3345 friend class boost::serialization::access;
3348 void serialize(S &s,
const unsigned ) {
3350 s & BOOST_SERIALIZATION_NVP(p_riscOperator);
3351 s & BOOST_SERIALIZATION_NVP(p_operands);
3354 #endif // SgAsmRiscOperation_OTHERS
3356 #ifdef DOCUMENTATION
3362 DECLARE_LEAF_CLASS(AsmExprListExp);
3363 IS_SERIALIZABLE(AsmExprListExp);
3365 #ifdef DOCUMENTATION
3371 #ifdef DOCUMENTATION
3382 AsmExprListExp.setDataPrototype(
"SgAsmExpressionPtrList",
"expressions",
"",
3383 NO_CONSTRUCTOR_PARAMETER, BUILD_LIST_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE);
3386 DECLARE_OTHERS(AsmExprListExp);
3387 #if defined(SgAsmExprListExp_OTHERS) || defined(DOCUMENTATION)
3388 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
3390 friend class boost::serialization::access;
3393 void serialize(S &s,
const unsigned ) {
3395 s & BOOST_SERIALIZATION_NVP(p_expressions);
3398 #endif // SgAsmExprListExp_OTHERS
3400 #ifdef DOCUMENTATION
3406 NEW_NONTERMINAL_MACRO(AsmExpression,
3407 AsmValueExpression | AsmBinaryExpression | AsmUnaryExpression |
3408 AsmMemoryReferenceExpression | AsmRegisterReferenceExpression | AsmControlFlagsExpression |
3409 AsmCommonSubExpression | AsmExprListExp | AsmRegisterNames |
3411 #ifdef ROSE_ENABLE_ASM_AARCH64
3412 | AsmAarch64AtOperand | AsmAarch64PrefetchOperand | AsmAarch64SysMoveOperand
3413 | AsmAarch64CImmediateOperand | AsmAarch64BarrierOperand
3415 #ifdef ROSE_ENABLE_ASM_AARCH32
3416 | AsmAarch32Coprocessor
3419 "AsmExpression",
"AsmExpressionTag",
false);
3420 AsmExpression.setCppCondition(
"!defined(DOCUMENTATION)");
3421 IS_SERIALIZABLE(AsmExpression);
3423 #ifdef DOCUMENTATION
3429 #ifdef DOCUMENTATION
3439 AsmExpression.setDataPrototype(
"SgAsmType*",
"type",
"= NULL",
3440 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
3443 #ifdef DOCUMENTATION
3453 AsmExpression.setDataPrototype(
"std::string",
"comment",
"= \"\"",
3454 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
3457 DECLARE_OTHERS(AsmExpression);
3458 #if defined(SgAsmExpression_OTHERS) || defined(DOCUMENTATION)
3459 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
3461 friend class boost::serialization::access;
3464 void serialize(S &s,
const unsigned ) {
3465 s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(
SgAsmNode);
3466 s & BOOST_SERIALIZATION_NVP(p_type);
3467 s & BOOST_SERIALIZATION_NVP(p_comment);
3489 #endif // SgAsmExpression_OTHERS
3491 #ifdef DOCUMENTATION
3511 DECLARE_LEAF_CLASS(AsmIntegerType);
3512 IS_SERIALIZABLE(AsmIntegerType);
3514 #ifdef DOCUMENTATION
3520 #ifndef DOCUMENTATION
3522 AsmIntegerType.setDataPrototype(
"bool",
"isSigned",
"=false",
3523 NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
3526 DECLARE_OTHERS(AsmIntegerType);
3527 #if defined(SgAsmIntegerType_OTHERS) || defined(DOCUMENTATION)
3528 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
3530 friend class boost::serialization::access;
3533 void serialize(S &s,
const unsigned ) {
3535 s & BOOST_SERIALIZATION_NVP(p_isSigned);
3551 virtual void check()
const $ROSE_OVERRIDE;
3552 virtual std::string
toString()
const $ROSE_OVERRIDE;
3553 #endif // SgAsmIntegerType_OTHERS
3555 #ifdef DOCUMENTATION
3561 DECLARE_LEAF_CLASS(AsmFloatType);
3562 IS_SERIALIZABLE(AsmFloatType);
3564 DECLARE_HEADERS(AsmFloatType);
3565 #if defined(SgAsmFloatType_HEADERS) || defined(DOCUMENTATION)
3566 #include <Sawyer/BitVector.h>
3567 #include <BitFlags.h>
3568 #endif // SgAsmFloatType_HEADERS
3570 #ifdef DOCUMENTATION
3576 #ifndef DOCUMENTATION
3578 AsmFloatType.setDataPrototype(
"size_t",
"significandOffset",
"=(size_t)(-1)",
3579 NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
3580 AsmFloatType.setDataPrototype(
"size_t",
"significandNBits",
"=(size_t)(-1)",
3581 NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
3582 AsmFloatType.setDataPrototype(
"size_t",
"signBitOffset",
"=(size_t)(-1)",
3583 NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
3584 AsmFloatType.setDataPrototype(
"size_t",
"exponentOffset",
"=(size_t)(-1)",
3585 NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
3586 AsmFloatType.setDataPrototype(
"size_t",
"exponentNBits",
"=(size_t)(-1)",
3587 NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
3588 AsmFloatType.setDataPrototype(
"uint64_t",
"exponentBias",
"=0",
3589 NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
3590 AsmFloatType.setDataPrototype(
"unsigned",
"flags",
"=0",
3591 NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
3594 DECLARE_OTHERS(AsmFloatType);
3595 #if defined(SgAsmFloatType_OTHERS) || defined(DOCUMENTATION)
3596 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
3598 friend class boost::serialization::access;
3601 void serialize(S &s,
const unsigned ) {
3603 s & BOOST_SERIALIZATION_NVP(p_significandOffset);
3604 s & BOOST_SERIALIZATION_NVP(p_significandNBits);
3605 s & BOOST_SERIALIZATION_NVP(p_signBitOffset);
3606 s & BOOST_SERIALIZATION_NVP(p_exponentOffset);
3607 s & BOOST_SERIALIZATION_NVP(p_exponentNBits);
3608 s & BOOST_SERIALIZATION_NVP(p_exponentBias);
3609 s & BOOST_SERIALIZATION_NVP(p_flags);
3644 Flags
flags()
const;
3671 virtual void check() const $ROSE_OVERRIDE;
3672 virtual
std::
string toString() const $ROSE_OVERRIDE;
3673 #endif // SgAsmFloatType_OTHERS
3675 #ifdef DOCUMENTATION
3681 NEW_NONTERMINAL_MACRO(AsmScalarType,
3682 AsmIntegerType | AsmFloatType,
3683 "AsmScalarType",
"AsmScalarTypeTag",
false);
3684 AsmScalarType.setCppCondition(
"!defined(DOCUMENTATION)");
3685 IS_SERIALIZABLE(AsmScalarType);
3687 #ifdef DOCUMENTATION
3693 #ifndef DOCUMENTATION
3695 AsmScalarType.setDataPrototype(
"ByteOrder::Endianness",
"minorOrder",
"= ByteOrder::ORDER_UNSPECIFIED",
3696 NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
3697 AsmScalarType.setDataPrototype(
"ByteOrder::Endianness",
"majorOrder",
"= ByteOrder::ORDER_UNSPECIFIED",
3698 NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
3699 AsmScalarType.setDataPrototype(
"size_t",
"majorNBytes",
"=0",
3700 NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
3701 AsmScalarType.setDataPrototype(
"size_t",
"nBits",
"=0",
3702 NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
3705 DECLARE_OTHERS(AsmScalarType);
3706 #if defined(SgAsmScalarType_OTHERS) || defined(DOCUMENTATION)
3707 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
3709 friend class boost::serialization::access;
3712 void serialize(S &s,
const unsigned ) {
3713 s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(
SgAsmType);
3714 s & BOOST_SERIALIZATION_NVP(p_minorOrder);
3715 s & BOOST_SERIALIZATION_NVP(p_majorOrder);
3716 s & BOOST_SERIALIZATION_NVP(p_majorNBytes);
3717 s & BOOST_SERIALIZATION_NVP(p_nBits);
3730 virtual size_t get_nBits()
const $ROSE_OVERRIDE;
3733 ByteOrder::Endianness get_minorOrder()
const;
3736 ByteOrder::Endianness get_majorOrder()
const;
3739 size_t get_majorNBytes()
const;
3742 virtual void check()
const $ROSE_OVERRIDE;
3743 virtual std::string
toString()
const $ROSE_OVERRIDE;
3744 #endif // SgAsmScalarType_OTHERS
3746 #ifdef DOCUMENTATION
3752 DECLARE_LEAF_CLASS(AsmVectorType);
3753 IS_SERIALIZABLE(AsmVectorType);
3755 #ifdef DOCUMENTATION
3761 #ifndef DOCUMENTATION
3763 AsmVectorType.setDataPrototype(
"size_t",
"nElmts",
"=0",
3764 NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
3765 AsmVectorType.setDataPrototype(
"SgAsmType*",
"elmtType",
"=NULL",
3766 NO_CONSTRUCTOR_PARAMETER, NO_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
3769 DECLARE_OTHERS(AsmVectorType);
3770 #if defined(SgAsmVectorType_OTHERS) || defined(DOCUMENTATION)
3771 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
3773 friend class boost::serialization::access;
3776 void serialize(S &s,
const unsigned ) {
3777 s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(
SgAsmType);
3778 s & BOOST_SERIALIZATION_NVP(p_nElmts);
3779 s & BOOST_SERIALIZATION_NVP(p_elmtType);
3794 virtual void check()
const $ROSE_OVERRIDE;
3795 virtual std::string
toString()
const $ROSE_OVERRIDE;
3796 virtual size_t get_nBits()
const $ROSE_OVERRIDE;
3797 #endif // SgAsmVectorType_OTHERS
3799 #ifdef DOCUMENTATION
3805 NEW_NONTERMINAL_MACRO(AsmType, AsmScalarType | AsmVectorType,
"AsmType",
"AsmTypeTag",
false);
3806 AsmType.setCppCondition(
"!defined(DOCUMENTATION)");
3807 IS_SERIALIZABLE(AsmType);
3809 #ifdef DOCUMENTATION
3815 DECLARE_OTHERS(AsmType);
3816 #if defined(SgAsmType_OTHERS) || defined(DOCUMENTATION)
3820 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
3822 friend class boost::serialization::access;
3825 void serialize(S &s,
const unsigned ) {
3826 s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(
SgAsmNode);
3838 virtual void check()
const;
3864 template<
class Type>
3866 ASSERT_not_null(toInsert);
3867 std::string key = toInsert->toString();
3868 Type *retval =
dynamic_cast<Type*
>(p_typeRegistry.
insertMaybe(key, toInsert));
3869 ASSERT_not_null(retval);
3870 if (retval!=toInsert)
3874 #endif // SgAsmType_OTHERS
3876 #ifdef DOCUMENTATION
3890 DECLARE_LEAF_CLASS(AsmFunction);
3891 IS_SERIALIZABLE(AsmFunction);
3893 #ifdef DOCUMENTATION
3913 #ifdef DOCUMENTATION
3919 const std::string&
get_name()
const;
3923 AsmFunction.setDataPrototype(
"std::string",
"name",
"= \"\"",
3924 CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
3927 #ifdef DOCUMENTATION
3938 AsmFunction.setDataPrototype(
"unsigned",
"reason",
"= SgAsmFunction::FUNC_NONE",
3939 CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
3942 #ifdef DOCUMENTATION
3954 AsmFunction.setDataPrototype(
"std::string",
"reasonComment",
"",
3955 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
3958 #ifdef DOCUMENTATION
3968 AsmFunction.setDataPrototype(
"SgAsmFunction::function_kind_enum",
"function_kind",
"= SgAsmFunction::e_unknown",
3969 CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
3972 #ifdef DOCUMENTATION
3980 AsmFunction.setDataPrototype(
"SgAsmFunction::MayReturn",
"may_return",
"= SgAsmFunction::RET_UNKNOWN",
3981 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
3984 #ifdef DOCUMENTATION
3994 AsmFunction.setDataPrototype(
"std::string",
"name_md5",
"= \"\"",
3995 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
3998 #ifdef DOCUMENTATION
4008 AsmFunction.setDataPrototype(
"SgAsmStatementPtrList",
"statementList",
"",
4009 NO_CONSTRUCTOR_PARAMETER, BUILD_LIST_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE);
4012 #ifdef DOCUMENTATION
4015 AsmFunction.setDataPrototype(
"SgAsmStatementPtrList",
"dest",
"",
4016 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
4019 #ifdef DOCUMENTATION
4030 AsmFunction.setDataPrototype(
"rose_addr_t",
"entry_va",
"= 0",
4031 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
4034 #ifdef DOCUMENTATION
4045 AsmFunction.setDataPrototype(
"SgSymbolTable*",
"symbol_table",
"= NULL",
4046 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, DEF_DELETE, NO_COPY_DATA);
4049 #ifdef DOCUMENTATION
4052 AsmFunction.setDataPrototype(
"size_t",
"cached_vertex",
"= (size_t)(-1)",
4053 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
4056 #ifdef DOCUMENTATION
4070 AsmFunction.setDataPrototype(
"int64_t",
"stackDelta",
"= SgAsmInstruction::INVALID_STACK_DELTA",
4071 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
4074 #ifdef DOCUMENTATION
4087 AsmFunction.setDataPrototype(
"std::string",
"callingConvention",
"",
4088 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
4091 DECLARE_OTHERS(AsmFunction);
4092 #if defined(SgAsmFunction_OTHERS) || defined(DOCUMENTATION)
4094 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
4096 friend class boost::serialization::access;
4099 void serialize(S &s,
const unsigned ) {
4101 s & BOOST_SERIALIZATION_NVP(p_name);
4102 s & BOOST_SERIALIZATION_NVP(p_reason);
4103 s & BOOST_SERIALIZATION_NVP(p_reasonComment);
4104 s & BOOST_SERIALIZATION_NVP(p_function_kind);
4105 s & BOOST_SERIALIZATION_NVP(p_may_return);
4106 s & BOOST_SERIALIZATION_NVP(p_name_md5);
4107 s & BOOST_SERIALIZATION_NVP(p_statementList);
4108 s & BOOST_SERIALIZATION_NVP(p_dest);
4109 s & BOOST_SERIALIZATION_NVP(p_entry_va);
4111 s & BOOST_SERIALIZATION_NVP(p_cached_vertex);
4112 s & BOOST_SERIALIZATION_NVP(p_stackDelta);
4113 s & BOOST_SERIALIZATION_NVP(p_callingConvention);
4232 static std::string
reason_key(
const std::string &prefix=
"");
4240 static std::string
reason_str(
bool pad,
unsigned reason);
4246 virtual bool operator()(
SgNode*) = 0;
4307 #endif // SgAsmFunction_OTHERS
4310 #ifdef DOCUMENTATION
4317 DECLARE_LEAF_CLASS(AsmBlock);
4318 IS_SERIALIZABLE(AsmBlock);
4320 #ifdef DOCUMENTATION
4345 #if 0 // [Robb P Matzke 2017-02-13]: not used anymore? Not serialized.
4347 AsmBlock.setDataPrototype(
"rose_addr_t",
"next_block_true_address",
"= 0",
4348 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
4351 #if 0 // [Robb P Matzke 2017-02-13]: not used anymore? Not serialized.
4352 AsmBlock.setDataPrototype(
"rose_addr_t",
"next_block_false_address",
"= 0",
4353 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
4356 #ifdef DOCUMENTATION
4362 rose_addr_t
get_id()
const;
4363 void set_id(rose_addr_t);
4366 AsmBlock.setDataPrototype(
"rose_addr_t",
"id",
"= 0",
4367 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
4370 #ifdef DOCUMENTATION
4380 AsmBlock.setDataPrototype(
"unsigned",
"reason",
"= SgAsmBlock::BLK_NONE",
4381 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
4384 #ifdef DOCUMENTATION
4399 AsmBlock.setDataPrototype(
"SgAsmStatementPtrList",
"statementList",
"",
4400 NO_CONSTRUCTOR_PARAMETER, BUILD_LIST_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE);
4403 #ifdef DOCUMENTATION
4419 AsmBlock.setDataPrototype(
"SgAsmIntegerValuePtrList",
"successors",
"",
4420 NO_CONSTRUCTOR_PARAMETER, BUILD_LIST_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
4423 #ifdef DOCUMENTATION
4438 AsmBlock.setDataPrototype(
"bool",
"successors_complete",
"= false",
4439 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
4442 #ifdef DOCUMENTATION
4456 AsmBlock.setDataPrototype(
"SgAsmBlock*",
"immediate_dominator",
"=NULL",
4457 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
4460 #ifdef DOCUMENTATION
4473 AsmBlock.setDataPrototype(
"size_t",
"cached_vertex",
"= (size_t)(-1)",
4474 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
4477 #ifdef DOCUMENTATION
4488 AsmBlock.setDataPrototype(
"double",
"code_likelihood",
"= 0.0",
4489 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
4492 #ifdef DOCUMENTATION
4505 AsmBlock.setDataPrototype(
"int64_t",
"stackDeltaOut",
"= SgAsmInstruction::INVALID_STACK_DELTA",
4506 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
4509 DECLARE_OTHERS(AsmBlock);
4510 #if defined(SgAsmBlock_OTHERS) || defined(DOCUMENTATION)
4511 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
4513 friend class boost::serialization::access;
4516 void serialize(S &s,
const unsigned ) {
4518 s & BOOST_SERIALIZATION_NVP(p_reason);
4519 s & BOOST_SERIALIZATION_NVP(p_statementList);
4520 s & BOOST_SERIALIZATION_NVP(p_successors);
4521 s & BOOST_SERIALIZATION_NVP(p_successors_complete);
4522 s & BOOST_SERIALIZATION_NVP(p_immediate_dominator);
4523 s & BOOST_SERIALIZATION_NVP(p_cached_vertex);
4524 s & BOOST_SERIALIZATION_NVP(p_code_likelihood);
4525 s & BOOST_SERIALIZATION_NVP(p_stackDeltaOut);
4616 static std::string
reason_key(
const std::string &prefix=
"");
4628 static std::string
reason_str(
bool pad,
unsigned reason);
4629 #endif // SgAsmBlock_OTHERS
4631 #ifdef DOCUMENTATION
4638 DECLARE_LEAF_CLASS(AsmStaticData);
4639 IS_SERIALIZABLE(AsmStaticData);
4641 #ifdef DOCUMENTATION
4653 #ifdef DOCUMENTATION
4664 AsmStaticData.setDataPrototype(
"SgUnsignedCharList",
"raw_bytes",
"",
4665 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
4668 DECLARE_OTHERS(AsmStaticData);
4669 #if defined(SgAsmStaticData_OTHERS) || defined(DOCUMENTATION)
4670 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
4672 friend class boost::serialization::access;
4675 void serialize(S &s,
const unsigned ) {
4677 s & BOOST_SERIALIZATION_NVP(p_raw_bytes);
4686 #endif // SgAsmStaticData_OTHERS
4688 #ifdef DOCUMENTATION
4695 DECLARE_LEAF_CLASS(AsmSynthesizedDataStructureDeclaration);
4696 IS_SERIALIZABLE(AsmSynthesizedDataStructureDeclaration);
4698 #ifdef DOCUMENTATION
4713 DECLARE_OTHERS(AsmSynthesizedDataStructureDeclaration);
4714 #if defined(SgAsmSynthesizedDataStructureDeclaration_OTHERS) || defined(DOCUMENTATION)
4715 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
4717 friend class boost::serialization::access;
4720 void serialize(S & s,
const unsigned ) {
4725 SgAsmSynthesizedDeclarationPtrList p_declarationList;
4730 p_declarationList.push_back(declaration);
4732 #endif // SgAsmSynthesizedDataStructureDeclaration_OTHERS
4734 #ifdef DOCUMENTATION
4741 DECLARE_LEAF_CLASS(AsmSynthesizedFieldDeclaration);
4742 IS_SERIALIZABLE(AsmSynthesizedFieldDeclaration);
4744 #ifdef DOCUMENTATION
4750 #ifdef DOCUMENTATION
4754 const std::string&
get_name()
const;
4758 AsmSynthesizedFieldDeclaration.setDataPrototype(
"std::string",
"name",
"= \"\"",
4759 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL,
4763 #ifdef DOCUMENTATION
4773 AsmSynthesizedFieldDeclaration.setDataPrototype(
"uint64_t",
"offset",
"= 0",
4774 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL,
4778 DECLARE_OTHERS(AsmSynthesizedFieldDeclaration);
4779 #if defined(SgAsmSynthesizedFieldDeclaration_OTHERS) || defined(DOCUMENTATION)
4780 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
4782 friend class boost::serialization::access;
4785 void serialize(S &s,
const unsigned ) {
4789 #endif // SgAsmSynthesizedFieldDeclaration_OTHERS
4791 #ifdef DOCUMENTATION
4798 NEW_NONTERMINAL_MACRO(AsmSynthesizedDeclaration,
4799 AsmSynthesizedDataStructureDeclaration | AsmFunction | AsmSynthesizedFieldDeclaration,
4800 "AsmSynthesizedDeclaration",
"AsmSynthesizedDeclarationTag",
false );
4801 AsmSynthesizedFieldDeclaration.setCppCondition(
"!defined(DOCUMENTATION)");
4802 IS_SERIALIZABLE(AsmSynthesizedDeclaration);
4804 #ifdef DOCUMENTATION
4815 DECLARE_OTHERS(AsmSynthesizedDeclaration);
4816 #if defined(SgAsmSynthesizedDeclaration_OTHERS) || defined(DOCUMENTATION)
4817 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
4819 friend class boost::serialization::access;
4822 void serialize(S &s,
const unsigned ) {
4826 #endif // SgAsmSynthesizedDeclaration_OTHERS
4828 #ifdef DOCUMENTATION
4835 NEW_NONTERMINAL_MACRO(AsmStatement,
4836 AsmSynthesizedDeclaration | AsmBlock | AsmInstruction | AsmStaticData,
4837 "AsmStatement",
"AsmStatementTag",
false);
4838 AsmStatement.setCppCondition(
"!defined(DOCUMENTATION)");
4839 IS_SERIALIZABLE(AsmStatement);
4841 #ifdef DOCUMENTATION
4850 #ifdef DOCUMENTATION
4860 AsmStatement.setDataPrototype(
"rose_addr_t",
"address",
"= 0",
4861 CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
4865 #ifdef DOCUMENTATION
4873 AsmStatement.setDataPrototype(
"std::string",
"comment",
"= \"\"",
4874 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE, COPY_DATA);
4877 DECLARE_OTHERS(AsmStatement);
4878 #if defined(SgAsmStatement_OTHERS) || defined(DOCUMENTATION)
4879 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
4881 friend class boost::serialization::access;
4884 void serialize(S &s,
const unsigned ) {
4885 s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(
SgNode);
4886 s & BOOST_SERIALIZATION_NVP(p_address);
4887 s & BOOST_SERIALIZATION_NVP(p_comment);
4890 #endif // SgAsmStatement_OTHERS
4892 #ifdef DOCUMENTATION
4910 DECLARE_LEAF_CLASS(AsmInterpretationList);
4911 IS_SERIALIZABLE(AsmInterpretationList);
4913 #ifdef DOCUMENTATION
4919 #ifdef DOCUMENTATION
4930 AsmInterpretationList.setDataPrototype(
"SgAsmInterpretationPtrList",
"interpretations",
"",
4931 NO_CONSTRUCTOR_PARAMETER, BUILD_LIST_ACCESS_FUNCTIONS, DEF_TRAVERSAL,
4935 DECLARE_OTHERS(AsmInterpretationList);
4936 #if defined(SgAsmInterpretationList_OTHERS) || defined(DOCUMENTATION)
4937 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
4939 friend class boost::serialization::access;
4942 void serialize(S &s,
const unsigned ) {
4943 s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(
SgAsmNode);
4944 s & BOOST_SERIALIZATION_NVP(p_interpretations);
4947 #endif // SgAsmInterpretationList_OTHERS
4949 #ifdef DOCUMENTATION
4955 DECLARE_LEAF_CLASS(AsmInterpretation);
4956 IS_SERIALIZABLE(AsmInterpretation);
4958 DECLARE_HEADERS(AsmInterpretation);
4959 #if defined(SgAsmInterpretation_HEADERS) || defined(DOCUMENTATION)
4960 #include <MemoryMap.h>
4962 #endif // SgAsmInterpretation_HEADERS
4964 #ifdef DOCUMENTATION
4975 #ifdef DOCUMENTATION
4978 AsmInterpretation.setAutomaticGenerationOfConstructor(
false);
4981 #ifdef DOCUMENTATION
4994 AsmInterpretation.setDataPrototype(
"SgAsmGenericHeaderList*",
"headers",
"= NULL",
4995 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
4998 #ifdef DOCUMENTATION
5008 AsmInterpretation.setDataPrototype(
"SgAsmBlock*",
"global_block",
"= NULL",
5009 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE);
5012 DECLARE_OTHERS(AsmInterpretation);
5013 #if defined(SgAsmInterpretation_OTHERS) || defined(DOCUMENTATION)
5017 bool coverageComputed;
5018 mutable InstructionMap instruction_map;
5022 double percentageCoverage;
5024 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
5026 friend class boost::serialization::access;
5029 void serialize(S &s,
const unsigned ) {
5030 s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(
SgAsmNode);
5031 s & BOOST_SERIALIZATION_NVP(p_headers);
5032 s & BOOST_SERIALIZATION_NVP(p_global_block);
5033 s & BOOST_SERIALIZATION_NVP(p_map);
5034 s & BOOST_SERIALIZATION_NVP(p_registers);
5035 s & BOOST_SERIALIZATION_NVP(coverageComputed);
5036 s & BOOST_SERIALIZATION_NVP(instruction_map);
5037 s & BOOST_SERIALIZATION_NVP(percentageCoverage);
5044 : p_registers(NULL), coverageComputed(false), percentageCoverage(0.0), p_headers(NULL), p_global_block(NULL) {
5052 SgAsmGenericFilePtrList
get_files()
const;
5107 #endif // SgAsmInterpretation_OTHERS
5109 #ifdef DOCUMENTATION
5123 DECLARE_LEAF_CLASS(AsmElfFileHeader);
5124 IS_SERIALIZABLE(AsmElfFileHeader);
5126 #ifdef DOCUMENTATION
5139 #ifdef DOCUMENTATION
5149 AsmElfFileHeader.setDataPrototype(
"unsigned char",
"e_ident_file_class",
"= 0",
5150 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
5153 #ifdef DOCUMENTATION
5163 AsmElfFileHeader.setDataPrototype(
"unsigned char",
"e_ident_data_encoding",
"= 0",
5164 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
5167 #ifdef DOCUMENTATION
5177 AsmElfFileHeader.setDataPrototype(
"unsigned char",
"e_ident_file_version",
"= 0",
5178 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
5181 #ifdef DOCUMENTATION
5191 AsmElfFileHeader.setDataPrototype(
"SgUnsignedCharList",
"e_ident_padding",
"",
5192 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
5195 #ifdef DOCUMENTATION
5205 AsmElfFileHeader.setDataPrototype(
"unsigned long",
"e_type",
"= 0",
5206 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
5209 #ifdef DOCUMENTATION
5219 AsmElfFileHeader.setDataPrototype(
"unsigned long",
"e_machine",
"= 0",
5220 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
5223 #ifdef DOCUMENTATION
5233 AsmElfFileHeader.setDataPrototype(
"unsigned long",
"e_flags",
"= 0",
5234 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
5237 #ifdef DOCUMENTATION
5247 AsmElfFileHeader.setDataPrototype(
"unsigned long",
"e_ehsize",
"= 0",
5248 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
5251 #ifdef DOCUMENTATION
5261 AsmElfFileHeader.setDataPrototype(
"unsigned long",
"phextrasz",
"= 0",
5262 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
5265 #ifdef DOCUMENTATION
5275 AsmElfFileHeader.setDataPrototype(
"unsigned long",
"e_phnum",
"= 0",
5276 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
5279 #ifdef DOCUMENTATION
5289 AsmElfFileHeader.setDataPrototype(
"unsigned long",
"shextrasz",
"= 0",
5290 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
5293 #ifdef DOCUMENTATION
5303 AsmElfFileHeader.setDataPrototype(
"unsigned long",
"e_shnum",
"= 0",
5304 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
5307 #ifdef DOCUMENTATION
5317 AsmElfFileHeader.setDataPrototype(
"unsigned long",
"e_shstrndx",
"= 0",
5318 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
5321 #ifdef DOCUMENTATION
5333 AsmElfFileHeader.setDataPrototype(
"SgAsmElfSectionTable*",
"section_table",
"= NULL",
5334 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
5337 #ifdef DOCUMENTATION
5348 AsmElfFileHeader.setDataPrototype(
"SgAsmElfSegmentTable*",
"segment_table",
"= NULL",
5349 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
5352 DECLARE_OTHERS(AsmElfFileHeader);
5353 #if defined(SgAsmElfFileHeader_OTHERS) || defined(DOCUMENTATION)
5355 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
5357 friend class boost::serialization::access;
5360 void serialize(S &s,
const unsigned ) {
5362 s & BOOST_SERIALIZATION_NVP(p_e_ident_file_class);
5363 s & BOOST_SERIALIZATION_NVP(p_e_ident_data_encoding);
5364 s & BOOST_SERIALIZATION_NVP(p_e_ident_file_version);
5365 s & BOOST_SERIALIZATION_NVP(p_e_ident_padding);
5366 s & BOOST_SERIALIZATION_NVP(p_e_type);
5367 s & BOOST_SERIALIZATION_NVP(p_e_machine);
5368 s & BOOST_SERIALIZATION_NVP(p_e_flags);
5369 s & BOOST_SERIALIZATION_NVP(p_e_ehsize);
5370 s & BOOST_SERIALIZATION_NVP(p_phextrasz);
5371 s & BOOST_SERIALIZATION_NVP(p_e_phnum);
5372 s & BOOST_SERIALIZATION_NVP(p_shextrasz);
5373 s & BOOST_SERIALIZATION_NVP(p_e_shnum);
5374 s & BOOST_SERIALIZATION_NVP(p_e_shstrndx);
5375 s & BOOST_SERIALIZATION_NVP(p_section_table);
5376 s & BOOST_SERIALIZATION_NVP(p_segment_table);
5429 #if !defined(SWIG) && !defined(_MSC_VER)
5430 __attribute__((packed))
5435 unsigned char e_ident_magic[4];
5436 unsigned char e_ident_file_class;
5437 unsigned char e_ident_data_encoding;
5438 unsigned char e_ident_file_version;
5439 unsigned char e_ident_padding[9];
5448 uint16_t e_phentsize;
5450 uint16_t e_shentsize;
5452 uint16_t e_shstrndx;
5454 #if !defined(SWIG) && !defined(_MSC_VER)
5455 __attribute__((packed))
5470 :
SgAsmGenericHeader(f) , p_e_ident_file_class(0), p_e_ident_file_version(1), p_e_type(0),
5471 p_e_machine(0), p_e_flags(0), p_e_ehsize(0), p_phextrasz(0), p_e_phnum(0), p_shextrasz(0),
5472 p_e_shnum(0), p_e_shstrndx(0), p_section_table(NULL), p_segment_table(NULL) {
5500 virtual
void unparse(
std::ostream&) const $ROSE_OVERRIDE;
5503 virtual
void dump(FILE*, const
char *prefix, ssize_t idx) const $ROSE_OVERRIDE;
5509 SgAsmGenericSectionPtrList get_sectab_sections();
5512 SgAsmGenericSectionPtrList get_segtab_sections();
5515 virtual const
char *format_name() const $ROSE_OVERRIDE;
5521 #endif // SgAsmElfFileHeader_OTHERS
5523 #ifdef DOCUMENTATION
5537 DECLARE_LEAF_CLASS(AsmElfSectionTable);
5538 IS_SERIALIZABLE(AsmElfSectionTable);
5540 #ifdef DOCUMENTATION
5550 DECLARE_OTHERS(AsmElfSectionTable);
5551 #if defined(SgAsmElfSectionTable_OTHERS) || defined(DOCUMENTATION)
5552 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
5554 friend class boost::serialization::access;
5557 void serialize(S &s,
const unsigned ) {
5591 rose_addr_t calculate_sizes(
size_t *entsize,
size_t *required,
size_t *optional,
size_t *entcount) const;
5594 virtual
bool reallocate() $ROSE_OVERRIDE;
5597 virtual
void unparse(
std::ostream&) const $ROSE_OVERRIDE;
5600 virtual
void dump(FILE*, const
char *prefix, ssize_t idx) const $ROSE_OVERRIDE;
5604 #endif // SgAsmElfSectionTable_OTHERS
5606 #ifdef DOCUMENTATION
5613 DECLARE_LEAF_CLASS(AsmElfSectionTableEntry);
5614 IS_SERIALIZABLE(AsmElfSectionTableEntry);
5616 #ifdef DOCUMENTATION
5622 #ifdef DOCUMENTATION
5632 AsmElfSectionTableEntry.setDataPrototype(
"unsigned",
"sh_name",
"= 0",
5633 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
5636 #ifdef DOCUMENTATION
5646 AsmElfSectionTableEntry.setDataPrototype(
"SgAsmElfSectionTableEntry::SectionType",
"sh_type",
"= SHT_PROGBITS",
5647 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
5650 #ifdef DOCUMENTATION
5660 AsmElfSectionTableEntry.setDataPrototype(
"unsigned long",
"sh_link",
"= 0",
5661 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
5664 #ifdef DOCUMENTATION
5674 AsmElfSectionTableEntry.setDataPrototype(
"unsigned long",
"sh_info",
"= 0",
5675 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
5678 #ifdef DOCUMENTATION
5688 AsmElfSectionTableEntry.setDataPrototype(
"uint64_t",
"sh_flags",
"= 0",
5689 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
5692 #ifdef DOCUMENTATION
5702 AsmElfSectionTableEntry.setDataPrototype(
"rose_addr_t",
"sh_addr",
"= 0",
5703 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
5706 #ifdef DOCUMENTATION
5716 AsmElfSectionTableEntry.setDataPrototype(
"rose_addr_t",
"sh_offset",
"= 0",
5717 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
5720 #ifdef DOCUMENTATION
5730 AsmElfSectionTableEntry.setDataPrototype(
"rose_addr_t",
"sh_size",
"= 0",
5731 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
5734 #ifdef DOCUMENTATION
5744 AsmElfSectionTableEntry.setDataPrototype(
"rose_addr_t",
"sh_addralign",
"= 0",
5745 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
5748 #ifdef DOCUMENTATION
5758 AsmElfSectionTableEntry.setDataPrototype(
"rose_addr_t",
"sh_entsize",
"= 0",
5759 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
5762 #ifdef DOCUMENTATION
5768 const SgUnsignedCharList&
get_extra()
const;
5769 void set_extra(
const SgUnsignedCharLit&);
5772 AsmElfSectionTableEntry.setDataPrototype(
"SgUnsignedCharList",
"extra",
"",
5773 NO_CONSTRUCTOR_PARAMETER, BUILD_LIST_ACCESS_FUNCTIONS, NO_TRAVERSAL,
5777 DECLARE_OTHERS(AsmElfSectionTableEntry);
5778 #if defined(SgAsmElfSectionTableEntry_OTHERS) || defined(DOCUMENTATION)
5779 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
5781 friend class boost::serialization::access;
5784 void serialize(S &s,
const unsigned ) {
5786 s & BOOST_SERIALIZATION_NVP(p_sh_name);
5787 s & BOOST_SERIALIZATION_NVP(p_sh_type);
5788 s & BOOST_SERIALIZATION_NVP(p_sh_link);
5789 s & BOOST_SERIALIZATION_NVP(p_sh_info);
5790 s & BOOST_SERIALIZATION_NVP(p_sh_flags);
5791 s & BOOST_SERIALIZATION_NVP(p_sh_addr);
5792 s & BOOST_SERIALIZATION_NVP(p_sh_offset);
5793 s & BOOST_SERIALIZATION_NVP(p_sh_size);
5794 s & BOOST_SERIALIZATION_NVP(p_sh_addralign);
5795 s & BOOST_SERIALIZATION_NVP(p_sh_entsize);
5796 s & BOOST_SERIALIZATION_NVP(p_extra);
5822 SHT_LOPROC = 0x70000000,
5823 SHT_HIPROC = 0x7fffffff,
5824 SHT_LOUSER = 0x80000000,
5825 SHT_HIUSER = 0xffffffff
5863 uint32_t sh_addralign;
5864 uint32_t sh_entsize;
5866 #if !defined(SWIG) && !defined(_MSC_VER)
5867 __attribute__((packed))
5880 uint64_t sh_addralign;
5881 uint64_t sh_entsize;
5883 #if !defined(SWIG) && !defined(_MSC_VER)
5884 __attribute__((packed))
5902 void *
encode(ByteOrder::Endianness sex,
5904 void *
encode(ByteOrder::Endianness sex,
5912 virtual void dump(FILE*,
const char *prefix, ssize_t idx)
const;
5921 #endif // SgAsmElfSectionTableEntry_OTHERS
5923 #ifdef DOCUMENTATION
5937 DECLARE_LEAF_CLASS(AsmElfSegmentTable);
5938 IS_SERIALIZABLE(AsmElfSegmentTable);
5940 #ifdef DOCUMENTATION
5951 DECLARE_OTHERS(AsmElfSegmentTable);
5952 #if defined(SgAsmElfSegmentTable_OTHERS) || defined(DOCUMENTATION)
5953 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
5955 friend class boost::serialization::access;
5958 void serialize(S &s,
const unsigned ) {
5994 rose_addr_t calculate_sizes(
size_t *entsize,
size_t *required,
size_t *optional,
size_t *entcount) const;
5997 virtual
bool reallocate() $ROSE_OVERRIDE;
6000 virtual
void unparse(
std::ostream&) const $ROSE_OVERRIDE;
6003 virtual
void dump(FILE*, const
char *prefix, ssize_t idx) const $ROSE_OVERRIDE;
6007 #endif // SgAsmElfSegmentTable_OTHERS
6009 #ifdef DOCUMENTATION
6015 DECLARE_LEAF_CLASS(AsmElfSegmentTableEntryList);
6016 IS_SERIALIZABLE(AsmElfSegmentTableEntryList);
6018 #ifdef DOCUMENTATION
6023 #ifdef DOCUMENTATION
6030 const SgAsmElfSegmentTableEntryPtrList&
get_entries();
6031 void set_entries(
const SgAsmElfSegmentTableEntryPtrList&);
6034 AsmElfSegmentTableEntryList.setDataPrototype(
"SgAsmElfSegmentTableEntryPtrList",
"entries",
"",
6035 NO_CONSTRUCTOR_PARAMETER, BUILD_LIST_ACCESS_FUNCTIONS, DEF_TRAVERSAL,
6039 DECLARE_OTHERS(AsmElfSegmentTableEntryList);
6040 #if defined(SgAsmElfSegmentTableEntryList_OTHERS) || defined(DOCUMENTATION)
6041 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
6043 friend class boost::serialization::access;
6046 void serialize(S &s,
const unsigned ) {
6050 #endif // SgAsmElfSegmentTableEntryList_OTHERS
6052 #ifdef DOCUMENTATION
6059 DECLARE_LEAF_CLASS(AsmElfSegmentTableEntry);
6060 IS_SERIALIZABLE(AsmElfSegmentTableEntry);
6062 #ifdef DOCUMENTATION
6068 #ifdef DOCUMENTATION
6078 AsmElfSegmentTableEntry.setDataPrototype(
"size_t",
"index",
"= 0",
6079 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
6082 #ifdef DOCUMENTATION
6090 AsmElfSegmentTableEntry.setDataPrototype(
"SgAsmElfSegmentTableEntry::SegmentType",
"type",
6091 "= SgAsmElfSegmentTableEntry::PT_LOAD",
6092 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
6095 #ifdef DOCUMENTATION
6103 AsmElfSegmentTableEntry.setDataPrototype(
"SgAsmElfSegmentTableEntry::SegmentFlags",
"flags",
6104 "= SgAsmElfSegmentTableEntry::PF_NONE",
6105 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
6108 #ifdef DOCUMENTATION
6118 AsmElfSegmentTableEntry.setDataPrototype(
"rose_addr_t",
"offset",
"= 0",
6119 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
6122 #ifdef DOCUMENTATION
6133 AsmElfSegmentTableEntry.setDataPrototype(
"rose_addr_t",
"vaddr",
"= 0",
6134 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
6137 #ifdef DOCUMENTATION
6147 AsmElfSegmentTableEntry.setDataPrototype(
"rose_addr_t",
"paddr",
"= 0",
6148 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
6151 #ifdef DOCUMENTATION
6161 AsmElfSegmentTableEntry.setDataPrototype(
"rose_addr_t",
"filesz",
"= 0",
6162 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
6165 #ifdef DOCUMENTATION
6175 AsmElfSegmentTableEntry.setDataPrototype(
"rose_addr_t",
"memsz",
"= 0",
6176 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
6179 #ifdef DOCUMENTATION
6189 AsmElfSegmentTableEntry.setDataPrototype(
"rose_addr_t",
"align",
"= 0",
6190 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
6193 #ifdef DOCUMENTATION
6199 const SgUnsignedCharList&
get_extra()
const;
6200 void set_extra(
const SgUnsignedCharList&);
6203 AsmElfSegmentTableEntry.setDataPrototype(
"SgUnsignedCharList",
"extra",
"",
6204 NO_CONSTRUCTOR_PARAMETER, BUILD_LIST_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
6207 DECLARE_OTHERS(AsmElfSegmentTableEntry);
6208 #if defined(SgAsmElfSegmentTableEntry_OTHERS) || defined(DOCUMENTATION)
6209 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
6211 friend class boost::serialization::access;
6214 void serialize(S &s,
const unsigned ) {
6216 s & BOOST_SERIALIZATION_NVP(p_index);
6217 s & BOOST_SERIALIZATION_NVP(p_type);
6218 s & BOOST_SERIALIZATION_NVP(p_flags);
6219 s & BOOST_SERIALIZATION_NVP(p_offset);
6220 s & BOOST_SERIALIZATION_NVP(p_vaddr);
6221 s & BOOST_SERIALIZATION_NVP(p_paddr);
6222 s & BOOST_SERIALIZATION_NVP(p_filesz);
6223 s & BOOST_SERIALIZATION_NVP(p_memsz);
6224 s & BOOST_SERIALIZATION_NVP(p_align);
6225 s & BOOST_SERIALIZATION_NVP(p_extra);
6243 PT_HIOS = 0x6fffffff,
6245 PT_HIPROC = 0x7fffffff,
6289 #if !defined(SWIG) && !defined(_MSC_VER)
6290 __attribute__((packed))
6304 #if !defined(SWIG) && !defined(_MSC_VER)
6305 __attribute__((packed))
6331 virtual void dump(FILE*,
const char *prefix, ssize_t idx)
const;
6342 #endif // SgAsmElfSegmentTableEntry_OTHERS
6344 #ifdef DOCUMENTATION
6358 DECLARE_LEAF_CLASS(AsmElfSymbolSection);
6359 IS_SERIALIZABLE(AsmElfSymbolSection);
6361 #ifdef DOCUMENTATION
6367 #ifdef DOCUMENTATION
6375 AsmElfSymbolSection.setDataPrototype(
"bool",
"is_dynamic",
"= false",
6376 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
6379 #ifdef DOCUMENTATION
6390 AsmElfSymbolSection.setDataPrototype(
"SgAsmElfSymbolList*",
"symbols",
"= NULL",
6391 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE);
6394 DECLARE_OTHERS(AsmElfSymbolSection);
6395 #if defined(SgAsmElfSymbolSection_OTHERS) || defined(DOCUMENTATION)
6396 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
6398 friend class boost::serialization::access;
6401 void serialize(S &s,
const unsigned ) {
6403 s & BOOST_SERIALIZATION_NVP(p_is_dynamic);
6404 s & BOOST_SERIALIZATION_NVP(p_symbols);
6430 virtual
void finish_parsing() $ROSE_OVERRIDE;
6439 virtual rose_addr_t calculate_sizes(
size_t *total,
size_t *required,
size_t *optional,
size_t *nentries) const $ROSE_OVERRIDE;
6444 virtual
bool reallocate() $ROSE_OVERRIDE;
6447 virtual
void unparse(
std::ostream&) const $ROSE_OVERRIDE;
6450 virtual
void dump(FILE*, const
char *prefix, ssize_t idx) const $ROSE_OVERRIDE;
6454 #endif // SgAsmElfSymbolSection_OTHERS
6456 #ifdef DOCUMENTATION
6462 DECLARE_LEAF_CLASS(AsmElfSymbolList);
6463 IS_SERIALIZABLE(AsmElfSymbolList);
6465 #ifdef DOCUMENTATION
6470 #ifdef DOCUMENTATION
6481 AsmElfSymbolList.setDataPrototype(
"SgAsmElfSymbolPtrList",
"symbols",
"",
6482 NO_CONSTRUCTOR_PARAMETER, BUILD_LIST_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE);
6485 DECLARE_OTHERS(AsmElfSymbolList);
6486 #if defined(SgAsmElfSymbolList_OTHERS) || defined(DOCUMENTATION)
6487 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
6489 friend class boost::serialization::access;
6492 void serialize(S &s,
const unsigned ) {
6494 s & BOOST_SERIALIZATION_NVP(p_symbols);
6497 #endif // SgAsmElfSymbolList_OTHERS
6499 #ifdef DOCUMENTATION
6505 DECLARE_LEAF_CLASS(AsmElfSymbol);
6506 IS_SERIALIZABLE(AsmElfSymbol);
6508 #ifdef DOCUMENTATION
6517 #ifdef DOCUMENTATION
6527 AsmElfSymbol.setDataPrototype(
"unsigned char",
"st_info",
"= 0",
6528 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
6531 #ifdef DOCUMENTATION
6541 AsmElfSymbol.setDataPrototype(
"unsigned char",
"st_res1",
"= 0",
6542 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
6545 #ifdef DOCUMENTATION
6555 AsmElfSymbol.setDataPrototype(
"unsigned",
"st_shndx",
"= 0",
6556 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
6559 #ifdef DOCUMENTATION
6569 AsmElfSymbol.setDataPrototype(
"rose_addr_t",
"st_size",
"= 0",
6570 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
6573 #ifdef DOCUMENTATION
6579 const SgUnsignedCharList&
get_extra()
const;
6580 void set_extra(
const SgUnsignedCharList&);
6583 AsmElfSymbol.setDataPrototype(
"SgUnsignedCharList",
"extra",
"",
6584 NO_CONSTRUCTOR_PARAMETER, BUILD_LIST_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
6587 DECLARE_OTHERS(AsmElfSymbol);
6588 #if defined(SgAsmElfSymbol_OTHERS) || defined(DOCUMENTATION)
6589 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
6591 friend class boost::serialization::access;
6594 void serialize(S &s,
const unsigned ) {
6596 s & BOOST_SERIALIZATION_NVP(p_st_info);
6597 s & BOOST_SERIALIZATION_NVP(p_st_res1);
6598 s & BOOST_SERIALIZATION_NVP(p_st_shndx);
6599 s & BOOST_SERIALIZATION_NVP(p_st_size);
6600 s & BOOST_SERIALIZATION_NVP(p_extra);
6605 enum ElfSymBinding {
6635 #if !defined(SWIG) && !defined(_MSC_VER)
6636 __attribute__((packed))
6642 unsigned char st_info;
6643 unsigned char st_res1;
6648 #if !defined(SWIG) && !defined(_MSC_VER)
6649 __attribute__((packed))
6682 virtual void dump(FILE *f,
const char *prefix, ssize_t idx)
const $ROSE_OVERRIDE;
6693 static std::string
to_string(SgAsmElfSymbol::ElfSymBinding);
6700 void parse_common();
6701 #endif // SgAsmElfSymbol_OTHERS
6703 #ifdef DOCUMENTATION
6717 DECLARE_LEAF_CLASS(AsmElfSymverSection);
6718 IS_SERIALIZABLE(AsmElfSymverSection);
6720 #ifdef DOCUMENTATION
6729 #ifdef DOCUMENTATION
6740 AsmElfSymverSection.setDataPrototype(
"SgAsmElfSymverEntryList*",
"entries",
"= NULL",
6741 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE);
6744 DECLARE_OTHERS(AsmElfSymverSection);
6745 #if defined(SgAsmElfSymverSection_OTHERS) || defined(DOCUMENTATION)
6746 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
6748 friend class boost::serialization::access;
6751 void serialize(S &s,
const unsigned ) {
6753 s & BOOST_SERIALIZATION_NVP(p_entries);
6771 virtual rose_addr_t calculate_sizes(
size_t *total,
size_t *required,
size_t *optional,
size_t *nentries) const $ROSE_OVERRIDE;
6774 virtual
void unparse(
std::ostream&) const $ROSE_OVERRIDE;
6777 virtual
void dump(FILE*, const
char *prefix, ssize_t idx) const $ROSE_OVERRIDE;
6780 #endif // SgAsmElfSymverSection_OTHERS
6782 #ifdef DOCUMENTATION
6788 DECLARE_LEAF_CLASS(AsmElfSymverEntry);
6789 IS_SERIALIZABLE(AsmElfSymverEntry);
6791 #ifdef DOCUMENTATION
6797 #ifdef DOCUMENTATION
6807 AsmElfSymverEntry.setDataPrototype(
"size_t",
"value",
"= 0",
6808 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
6811 DECLARE_OTHERS(AsmElfSymverEntry);
6812 #if defined(SgAsmElfSymverEntry_OTHERS) || defined(DOCUMENTATION)
6813 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
6815 friend class boost::serialization::access;
6818 void serialize(S &s,
const unsigned ) {
6820 s & BOOST_SERIALIZATION_NVP(p_value);
6832 virtual void dump(FILE *f,
const char *prefix, ssize_t idx)
const;
6836 #endif // SgAsmElfSymverEntry_OTHERS
6838 #ifdef DOCUMENTATION
6845 DECLARE_LEAF_CLASS(AsmElfSymverEntryList);
6846 IS_SERIALIZABLE(AsmElfSymverEntryList);
6848 #ifdef DOCUMENTATION
6857 #ifdef DOCUMENTATION
6861 const SgAsmElfSymverEntryPtrList&
get_entries()
const;
6862 void set_entries(
const SgAsmElfSymverEntryPtrList&);
6865 AsmElfSymverEntryList.setDataPrototype(
"SgAsmElfSymverEntryPtrList",
"entries",
"",
6866 NO_CONSTRUCTOR_PARAMETER, BUILD_LIST_ACCESS_FUNCTIONS, DEF_TRAVERSAL,
6870 DECLARE_OTHERS(AsmElfSymverEntryList);
6871 #if defined(SgAsmElfSymverEntryList_OTHERS) || defined(DOCUMENTATION)
6872 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
6874 friend class boost::serialization::access;
6877 void serialize(S &s,
const unsigned ) {
6879 s & BOOST_SERIALIZATION_NVP(p_entries);
6882 #endif // SgAsmElfSymverEntryList_OTHERS
6884 #ifdef DOCUMENTATION
6890 DECLARE_LEAF_CLASS(AsmElfSymverDefinedSection);
6891 IS_SERIALIZABLE(AsmElfSymverDefinedSection);
6893 #ifdef DOCUMENTATION
6903 #ifdef DOCUMENTATION
6914 AsmElfSymverDefinedSection.setDataPrototype(
"SgAsmElfSymverDefinedEntryList*",
"entries",
"= NULL",
6915 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, DEF_TRAVERSAL,
6919 DECLARE_OTHERS(AsmElfSymverDefinedSection);
6920 #if defined(SgAsmElfSymverDefinedSection_OTHERS) || defined(DOCUMENTATION)
6921 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
6923 friend class boost::serialization::access;
6926 void serialize(S &s,
const unsigned ) {
6928 s & BOOST_SERIALIZATION_NVP(p_entries);
7011 virtual rose_addr_t calculate_sizes(
size_t *total,
size_t *required,
size_t *optional,
size_t *nentries) const $ROSE_OVERRIDE;
7016 virtual
void unparse(
std::ostream&) const $ROSE_OVERRIDE;
7019 virtual
void dump(FILE*, const
char *prefix, ssize_t idx) const $ROSE_OVERRIDE;
7023 #endif // SgAsmElfSymverDefinedSection_OTHERS
7025 #ifdef DOCUMENTATION
7031 DECLARE_LEAF_CLASS(AsmElfSymverDefinedEntryList);
7032 IS_SERIALIZABLE(AsmElfSymverDefinedEntryList);
7034 #ifdef DOCUMENTATION
7043 #ifdef DOCUMENTATION
7047 const SgAsmElfSymverDefinedEntryPtrList&
get_entries()
const;
7048 void set_entries(
const SgAsmElfSymverDefinedPtrList&);
7051 AsmElfSymverDefinedEntryList.setDataPrototype(
"SgAsmElfSymverDefinedEntryPtrList",
"entries",
"",
7052 NO_CONSTRUCTOR_PARAMETER, BUILD_LIST_ACCESS_FUNCTIONS, DEF_TRAVERSAL,
7056 DECLARE_OTHERS(AsmElfSymverDefinedEntryList);
7057 #if defined(SgAsmElfSymverDefinedEntryList_OTHERS) || defined(DOCUMENTATION)
7058 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
7060 friend class boost::serialization::access;
7063 void serialize(S &s,
const unsigned ) {
7065 s & BOOST_SERIALIZATION_NVP(p_entries);
7068 #endif // SgAsmElfSymverDefinedEntryList_OTHERS
7070 #ifdef DOCUMENTATION
7076 DECLARE_LEAF_CLASS(AsmElfSymverDefinedEntry);
7077 IS_SERIALIZABLE(AsmElfSymverDefinedEntry);
7079 #ifdef DOCUMENTATION
7085 #ifdef DOCUMENTATION
7095 AsmElfSymverDefinedEntry.setDataPrototype(
"size_t",
"version",
"= 0",
7096 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
7099 #ifdef DOCUMENTATION
7109 AsmElfSymverDefinedEntry.setDataPrototype(
"int",
"flags",
"= 0",
7110 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
7113 #ifdef DOCUMENTATION
7123 AsmElfSymverDefinedEntry.setDataPrototype(
"size_t",
"index",
"= 0",
7124 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
7127 #ifdef DOCUMENTATION
7137 AsmElfSymverDefinedEntry.setDataPrototype(
"uint32_t",
"hash",
"= 0",
7138 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
7141 #ifdef DOCUMENTATION
7152 AsmElfSymverDefinedEntry.setDataPrototype(
"SgAsmElfSymverDefinedAuxList*",
"entries",
"",
7153 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE);
7156 DECLARE_OTHERS(AsmElfSymverDefinedEntry);
7157 #if defined(SgAsmElfSymverDefinedEntry_OTHERS) || defined(DOCUMENTATION)
7158 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
7160 friend class boost::serialization::access;
7163 void serialize(S &s,
const unsigned ) {
7165 s & BOOST_SERIALIZATION_NVP(p_version);
7166 s & BOOST_SERIALIZATION_NVP(p_flags);
7167 s & BOOST_SERIALIZATION_NVP(p_index);
7168 s & BOOST_SERIALIZATION_NVP(p_hash);
7169 s & BOOST_SERIALIZATION_NVP(p_entries);
7187 #if !defined(SWIG) && !defined(_MSC_VER)
7188 __attribute__((packed))
7198 ctor(symver_defined);
7208 virtual void dump(FILE *f,
const char *prefix, ssize_t idx)
const;
7212 #endif // SgAsmElfSymverDefinedEntry_OTHERS
7214 #ifdef DOCUMENTATION
7220 DECLARE_LEAF_CLASS(AsmElfSymverDefinedAuxList);
7221 IS_SERIALIZABLE(AsmElfSymverDefinedAuxList);
7223 #ifdef DOCUMENTATION
7232 #ifdef DOCUMENTATION
7236 const SgAsmElfSymverDefinedAuxPtrList& get_entries()
const;
7237 void set_entries(
const SgAsmElfSymverDefinedAuxPtrList&);
7240 AsmElfSymverDefinedAuxList.setDataPrototype(
"SgAsmElfSymverDefinedAuxPtrList",
"entries",
"",
7241 NO_CONSTRUCTOR_PARAMETER, BUILD_LIST_ACCESS_FUNCTIONS, DEF_TRAVERSAL,
7245 DECLARE_OTHERS(AsmElfSymverDefinedAuxList);
7246 #if defined(SgAsmElfSymverDefinedAuxList_OTHERS) || defined(DOCUMENTATION)
7247 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
7249 friend class boost::serialization::access;
7252 void serialize(S &s,
const unsigned ) {
7254 s & BOOST_SERIALIZATION_NVP(p_entries);
7257 #endif // SgAsmElfSymverDefinedAuxList_OTHERS
7259 #ifdef DOCUMENTATION
7265 DECLARE_LEAF_CLASS(AsmElfSymverDefinedAux);
7266 IS_SERIALIZABLE(AsmElfSymverDefinedAux);
7268 #ifdef DOCUMENTATION
7273 #ifdef DOCUMENTATION
7281 AsmElfSymverDefinedAux.setDataPrototype(
"SgAsmGenericString*",
"name",
"= 0",
7282 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE);
7285 DECLARE_OTHERS(AsmElfSymverDefinedAux);
7286 #if defined(SgAsmElfSymverDefinedAux_OTHERS) || defined(DOCUMENTATION)
7287 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
7289 friend class boost::serialization::access;
7292 void serialize(S &s,
const unsigned ) {
7294 s & BOOST_SERIALIZATION_NVP(p_name);
7308 #if !defined(SWIG) && !defined(_MSC_VER)
7309 __attribute__((packed))
7323 ctor(symver_def_entry,symver_def_sec);
7327 void parse(ByteOrder::Endianness,
const SgAsmElfSymverDefinedAux::ElfSymverDefinedAux_disk*);
7330 void *
encode(ByteOrder::Endianness, SgAsmElfSymverDefinedAux::ElfSymverDefinedAux_disk*)
const;
7337 virtual void dump(FILE *f,
const char *prefix, ssize_t idx)
const;
7341 #endif // SgAsmElfSymverDefinedAux_OTHERS
7343 #ifdef DOCUMENTATION
7349 DECLARE_LEAF_CLASS(AsmElfSymverNeededSection);
7350 IS_SERIALIZABLE(AsmElfSymverNeededSection);
7352 #ifdef DOCUMENTATION
7362 #ifdef DOCUMENTATION
7373 AsmElfSymverNeededSection.setDataPrototype(
"SgAsmElfSymverNeededEntryList*",
"entries",
"= NULL",
7374 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE);
7377 DECLARE_OTHERS(AsmElfSymverNeededSection);
7378 #if defined(SgAsmElfSymverNeededSection_OTHERS) || defined(DOCUMENTATION)
7379 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
7381 friend class boost::serialization::access;
7384 void serialize(S &s,
const unsigned ) {
7386 s & BOOST_SERIALIZATION_NVP(p_entries);
7414 virtual rose_addr_t calculate_sizes(
size_t *total,
size_t *required,
size_t *optional,
size_t *nentries) const $ROSE_OVERRIDE;
7419 virtual
void unparse(
std::ostream&) const $ROSE_OVERRIDE;
7422 virtual
void dump(FILE*, const
char *prefix, ssize_t idx) const $ROSE_OVERRIDE;
7426 #endif // SgAsmElfSymverNeededSection_OTHERS
7428 #ifdef DOCUMENTATION
7434 DECLARE_LEAF_CLASS(AsmElfSymverNeededEntryList);
7435 IS_SERIALIZABLE(AsmElfSymverNeededEntryList);
7437 #ifdef DOCUMENTATION
7446 #ifdef DOCUMENTATION
7450 const SgAsmElfSymverNeededEntryPtrList& get_entries() void;
7451 void set_entries(
const SgAsmElfSymverNeededEntryPtrList&);
7454 AsmElfSymverNeededEntryList.setDataPrototype(
"SgAsmElfSymverNeededEntryPtrList",
"entries",
"",
7455 NO_CONSTRUCTOR_PARAMETER, BUILD_LIST_ACCESS_FUNCTIONS, DEF_TRAVERSAL,
7459 DECLARE_OTHERS(AsmElfSymverNeededEntryList);
7460 #if defined(SgAsmElfSymverNeededEntryList_OTHERS) || defined(DOCUMENTATION)
7461 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
7463 friend class boost::serialization::access;
7466 void serialize(S &s,
const unsigned ) {
7468 s & BOOST_SERIALIZATION_NVP(p_entries);
7471 #endif // SgAsmElfSymverNeededEntryList_OTHERS
7473 #ifdef DOCUMENTATION
7479 DECLARE_LEAF_CLASS(AsmElfSymverNeededEntry);
7480 IS_SERIALIZABLE(AsmElfSymverNeededEntry);
7482 #ifdef DOCUMENTATION
7488 #ifdef DOCUMENTATION
7498 AsmElfSymverNeededEntry.setDataPrototype(
"size_t",
"version",
"= 0",
7499 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
7502 #ifdef DOCUMENTATION
7510 AsmElfSymverNeededEntry.setDataPrototype(
"SgAsmGenericString*",
"file_name",
"= 0",
7511 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE);
7514 #ifdef DOCUMENTATION
7525 AsmElfSymverNeededEntry.setDataPrototype(
"SgAsmElfSymverNeededAuxList*",
"entries",
"",
7526 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE);
7529 DECLARE_OTHERS(AsmElfSymverNeededEntry);
7530 #if defined(SgAsmElfSymverNeededEntry_OTHERS) || defined(DOCUMENTATION)
7531 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
7533 friend class boost::serialization::access;
7536 void serialize(S &s,
const unsigned ) {
7538 s & BOOST_SERIALIZATION_NVP(p_version);
7539 s & BOOST_SERIALIZATION_NVP(p_file_name);
7540 s & BOOST_SERIALIZATION_NVP(p_entries);
7557 #if !defined(SWIG) && !defined(_MSC_VER)
7558 __attribute__((packed))
7568 : p_file_name(NULL) {
7569 ctor(symver_needed);
7579 virtual void dump(FILE *f,
const char *prefix, ssize_t idx)
const;
7583 #endif // SgAsmElfSymverNeededEntry_OTHERS
7585 #ifdef DOCUMENTATION
7591 DECLARE_LEAF_CLASS(AsmElfSymverNeededAuxList);
7592 IS_SERIALIZABLE(AsmElfSymverNeededAuxList);
7594 #ifdef DOCUMENTATION
7603 #ifdef DOCUMENTATION
7607 const SgAsmElfSymverNeededAuxPtrList&
get_entries()
const;
7608 void set_entries(
const SgAsmElfSymverNeededAuxPtrList&);
7611 AsmElfSymverNeededAuxList.setDataPrototype(
"SgAsmElfSymverNeededAuxPtrList",
"entries",
"",
7612 NO_CONSTRUCTOR_PARAMETER, BUILD_LIST_ACCESS_FUNCTIONS, DEF_TRAVERSAL,
7616 DECLARE_OTHERS(AsmElfSymverNeededAuxList);
7617 #if defined(SgAsmElfSymverNeededAuxList_OTHERS) || defined(DOCUMENTATION)
7618 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
7620 friend class boost::serialization::access;
7623 void serialize(S &s,
const unsigned ) {
7625 s & BOOST_SERIALIZATION_NVP(p_entries);
7628 #endif // SgAsmElfSymverNeededAuxList_OTHERS
7630 #ifdef DOCUMENTATION
7636 DECLARE_LEAF_CLASS(AsmElfSymverNeededAux);
7637 IS_SERIALIZABLE(AsmElfSymverNeededAux);
7639 #ifdef DOCUMENTATION
7645 #ifdef DOCUMENTATION
7655 AsmElfSymverNeededAux.setDataPrototype(
"uint32_t",
"hash",
"= 0",
7656 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
7659 #ifdef DOCUMENTATION
7669 AsmElfSymverNeededAux.setDataPrototype(
"int",
"flags",
"= 0",
7670 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
7673 #ifdef DOCUMENTATION
7683 AsmElfSymverNeededAux.setDataPrototype(
"size_t",
"other",
"= 0",
7684 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
7687 #ifdef DOCUMENTATION
7695 AsmElfSymverNeededAux.setDataPrototype(
"SgAsmGenericString*",
"name",
"= 0",
7696 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE);
7699 DECLARE_OTHERS(AsmElfSymverNeededAux);
7700 #if defined(SgAsmElfSymverNeededAux_OTHERS) || defined(DOCUMENTATION)
7701 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
7703 friend class boost::serialization::access;
7706 void serialize(S &s,
const unsigned ) {
7708 s & BOOST_SERIALIZATION_NVP(p_hash);
7709 s & BOOST_SERIALIZATION_NVP(p_flags);
7710 s & BOOST_SERIALIZATION_NVP(p_other);
7711 s & BOOST_SERIALIZATION_NVP(p_name);
7728 #if !defined(SWIG) && !defined(_MSC_VER)
7729 __attribute__((packed))
7743 ctor(symver_needed_entry,symver_needed_sec);
7757 virtual void dump(FILE *f,
const char *prefix, ssize_t idx)
const;
7761 #endif // SgAsmElfSymverNeededAux_OTHERS
7763 #ifdef DOCUMENTATION
7778 DECLARE_LEAF_CLASS(AsmElfRelocSection);
7779 IS_SERIALIZABLE(AsmElfRelocSection);
7781 #ifdef DOCUMENTATION
7787 #ifdef DOCUMENTATION
7795 AsmElfRelocSection.setDataPrototype(
"bool",
"uses_addend",
"= true",
7796 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
7799 #ifdef DOCUMENTATION
7807 AsmElfRelocSection.setDataPrototype(
"SgAsmElfSection*",
"target_section",
"= NULL",
7808 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
7811 #ifdef DOCUMENTATION
7821 AsmElfRelocSection.setDataPrototype(
"SgAsmElfRelocEntryList*",
"entries",
"= NULL",
7822 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE);
7825 DECLARE_OTHERS(AsmElfRelocSection);
7826 #if defined(SgAsmElfRelocSection_OTHERS) || defined(DOCUMENTATION)
7827 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
7829 friend class boost::serialization::access;
7832 void serialize(S &s,
const unsigned ) {
7834 s & BOOST_SERIALIZATION_NVP(p_uses_addend);
7835 s & BOOST_SERIALIZATION_NVP(p_target_section);
7836 s & BOOST_SERIALIZATION_NVP(p_entries);
7843 ctor(symsec,targetsec);
7851 virtual rose_addr_t
calculate_sizes(
size_t *total,
size_t *required,
size_t *optional,
size_t *entcount)
const $ROSE_OVERRIDE;
7854 virtual bool reallocate() $ROSE_OVERRIDE;
7857 virtual void unparse(std::ostream&)
const $ROSE_OVERRIDE;
7860 virtual void dump(FILE*,
const char *prefix, ssize_t idx)
const $ROSE_OVERRIDE;
7864 #endif // SgAsmElfRelocSection_OTHERS
7866 #ifdef DOCUMENTATION
7872 DECLARE_LEAF_CLASS(AsmElfRelocEntryList);
7873 IS_SERIALIZABLE(AsmElfRelocEntryList);
7875 #ifdef DOCUMENTATION
7884 #ifdef DOCUMENTATION
7888 const SgAsmElfRelocEntryPtrList&
get_entries()
const;
7889 void set_entries(
const SgAsmElfRelocEntryPtrList&);
7892 AsmElfRelocEntryList.setDataPrototype(
"SgAsmElfRelocEntryPtrList",
"entries",
"",
7893 NO_CONSTRUCTOR_PARAMETER, BUILD_LIST_ACCESS_FUNCTIONS, DEF_TRAVERSAL,
7897 DECLARE_OTHERS(AsmElfRelocEntryList);
7898 #if defined(SgAsmElfRelocEntryList_OTHERS) || defined(DOCUMENTATION)
7899 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
7901 friend class boost::serialization::access;
7904 void serialize(S &s,
const unsigned ) {
7906 s & BOOST_SERIALIZATION_NVP(p_entries);
7909 #endif // SgAsmElfRelocEntryList_OTHERS
7911 #ifdef DOCUMENTATION
7917 DECLARE_LEAF_CLASS(AsmElfRelocEntry);
7918 IS_SERIALIZABLE(AsmElfRelocEntry);
7920 #ifdef DOCUMENTATION
7926 #ifdef DOCUMENTATION
7936 AsmElfRelocEntry.setDataPrototype(
"rose_addr_t",
"r_offset",
"= 0",
7937 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
7940 #ifdef DOCUMENTATION
7950 AsmElfRelocEntry.setDataPrototype(
"rose_addr_t",
"r_addend",
"= 0",
7951 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
7954 #ifdef DOCUMENTATION
7960 unsigned long get_sym()
const;
7964 AsmElfRelocEntry.setDataPrototype(
"unsigned long",
"sym",
"= 0",
7965 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
7968 #ifdef DOCUMENTATION
7978 AsmElfRelocEntry.setDataPrototype(
"SgAsmElfRelocEntry::RelocType",
"type",
"= R_386_NONE",
7979 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
7982 #ifdef DOCUMENTATION
7986 const SgUnsignedCharList&
get_extra()
const;
7987 void set_extra(
const SgUnsignedCharList&);
7990 AsmElfRelocEntry.setDataPrototype(
"SgUnsignedCharList",
"extra",
"",
7991 NO_CONSTRUCTOR_PARAMETER, BUILD_LIST_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
7994 DECLARE_OTHERS(AsmElfRelocEntry);
7995 #if defined(SgAsmElfRelocEntry_OTHERS) || defined(DOCUMENTATION)
7996 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
7998 friend class boost::serialization::access;
8001 void serialize(S &s,
const unsigned ) {
8003 s & BOOST_SERIALIZATION_NVP(p_r_offset);
8004 s & BOOST_SERIALIZATION_NVP(p_r_addend);
8005 s & BOOST_SERIALIZATION_NVP(p_sym);
8006 s & BOOST_SERIALIZATION_NVP(p_type);
8007 s & BOOST_SERIALIZATION_NVP(p_extra);
8088 #if !defined(SWIG) && !defined(_MSC_VER)
8089 __attribute__((packed))
8098 #if !defined(SWIG) && !defined(_MSC_VER)
8099 __attribute__((packed))
8107 #if !defined(SWIG) && !defined(_MSC_VER)
8108 __attribute__((packed))
8116 #if !defined(SWIG) && !defined(_MSC_VER)
8117 __attribute__((packed))
8127 : p_r_offset(0), p_r_addend(0), p_sym(0), p_type(
R_386_NONE) {
8153 virtual void dump(FILE *f,
const char *prefix, ssize_t idx)
const {
8154 dump(f, prefix, idx, NULL);
8163 #endif // SgAsmElfRelocEntry_OTHERS
8165 #ifdef DOCUMENTATION
8179 DECLARE_LEAF_CLASS(AsmElfDynamicSection);
8180 IS_SERIALIZABLE(AsmElfDynamicSection);
8182 #ifdef DOCUMENTATION
8188 #ifdef DOCUMENTATION
8199 AsmElfDynamicSection.setDataPrototype(
"SgAsmElfDynamicEntryList*",
"entries",
"= NULL",
8200 NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, DEF_TRAVERSAL, NO_DELETE);
8203 DECLARE_OTHERS(AsmElfDynamicSection);
8204 #if defined(SgAsmElfDynamicSection_OTHERS) || defined(DOCUMENTATION)
8205 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
8207 friend class boost::serialization::access;
8210 void serialize(S &s,
const unsigned ) {
8212 s & BOOST_SERIALIZATION_NVP(p_entries);
8227 virtual
void finish_parsing() $ROSE_OVERRIDE;
8231 virtual rose_addr_t calculate_sizes(
size_t *total,
size_t *required,
size_t *optional,
size_t *entcount) const $ROSE_OVERRIDE;
8234 virtual
bool reallocate() $ROSE_OVERRIDE;
8237 virtual
void unparse(
std::ostream&) const $ROSE_OVERRIDE;
8240 virtual
void dump(FILE*, const
char *prefix, ssize_t idx) const $ROSE_OVERRIDE;