23 #define WITH_BINARY_ANALYSIS 0
40 void unused(
const T&) {}
51 template <
class T1,
class T2>
57 template <
class T1,
class T2>
60 typedef const T2 type;
66 #define SG_UNEXPECTED_NODE(X) (sg::unexpected_node(X, __FILE__, __LINE__))
69 void report_error(std::string desc)
71 throw std::logic_error(desc);
75 void report_error_if(
bool iserror, std::string desc)
83 template <
class T,
class E>
98 void unexpected_node(
const SgNode& n,
const char* file = 0,
size_t ln = 0)
100 sg::unused(n), sg::unused(file), sg::unused(ln);
102 std::string msg =
"unexpected node-type: ";
105 msg = msg +
typeid(n).name();
109 const std::string at(
" at ");
110 const std::string sep(
" : ");
111 const std::string num(conv<std::string>(ln));
113 msg = msg + at + file + sep + num;
116 std::cerr << msg << std::endl;
125 template <
class _ReturnType>
128 typedef _ReturnType ReturnType;
140 operator ReturnType()
const {
return res; }
151 template <
class SageNode>
153 SageNode& assume_sage_type(
SgNode& n)
155 return static_cast<SageNode&
>(n);
160 template <
class SageNode>
162 const SageNode& assume_sage_type(
const SgNode& n)
164 return static_cast<const SageNode&
>(n);
167 #define GEN_VISIT(X) \
168 void visit(X * n) { rv.handle(*n); }
170 template <
class RoseVisitor>
541 #if WITH_BINARY_ANALYSIS
571 GEN_VISIT(SgAsmCommonSubExpression)
606 GEN_VISIT(SgAsmGenericStrtab)
644 GEN_VISIT(SgAsmElfEHFrameEntryFDList)
651 GEN_VISIT(SgAsmElfSymverDefinedAux)
844 template <
class RoseVisitor>
847 _dispatch(
const RoseVisitor& rv,
SgNode* n)
918 template <
class RoseVisitor>
921 dispatch(
const RoseVisitor& rv,
SgNode* n)
923 return _dispatch(rv, n);
927 template <
class RoseVisitor>
930 dispatch(
const RoseVisitor& rv,
const SgNode* n)
932 return _dispatch(rv, const_cast<SgNode*>(n));
935 template <
class SageNode>
938 void handle(SageNode&) {}
948 template <
class AncestorNode,
class QualSgNode>
952 typedef std::pair<AncestorNode*, QualSgNode*> Pair;
957 : Base(), res(NULL, NULL)
964 void handle(QualSgNode& n) { res.second = n.get_parent(); }
965 void handle(AncestorNode& n) { res.first = &n; }
967 operator Pair()
const {
return res; }
972 template <
class AncestorNode,
class QualSgNode>
973 AncestorNode* _ancestor(QualSgNode& n)
977 typename AncestorFinder::Pair res(NULL, n.get_parent());
979 while (res.second != NULL)
981 res = (
typename AncestorFinder::Pair) sg::dispatch(AncestorFinder(), res.second);
998 template <
class AncestorNode>
999 AncestorNode* ancestor(
SgNode* n)
1001 if (n == NULL)
return NULL;
1003 return _ancestor<AncestorNode>(*n);
1007 template <
class AncestorNode>
1008 const AncestorNode* ancestor(
const SgNode* n)
1010 if (n == NULL)
return NULL;
1012 return _ancestor<const AncestorNode>(*n);
1016 template <
class AncestorNode>
1017 AncestorNode& ancestor(
SgNode& n)
1019 AncestorNode* res = _ancestor<AncestorNode>(n);
1026 template <
class AncestorNode>
1027 const AncestorNode& ancestor(
const SgNode& n)
1029 const AncestorNode* res = _ancestor<const AncestorNode>(n);
1036 template <
class SageNode>
1037 struct TypeRecoveryHandler
1039 typedef typename ConstLike<SageNode, SgNode>::type SgBaseNode;
1043 TypeRecoveryHandler()
1044 : res(NULL), loc(NULL), loc_ln(0)
1047 TypeRecoveryHandler(
const char* f,
size_t ln)
1048 : res(NULL), loc(f), loc_ln(ln)
1051 void handle(SgBaseNode& n) { unexpected_node(n, loc, loc_ln); }
1052 void handle(SageNode& n) { res = &n; }
1054 operator SageNode* () {
return res; }
1060 #define SG_ASSERT_TYPE(SAGENODE, N) (sg::assert_sage_type<SAGENODE>(N, __FILE__, __LINE__))
1069 template <
class SageNode>
1070 SageNode* assert_sage_type(
SgNode* n,
const char* f = 0,
size_t ln = 0)
1072 return sg::dispatch(TypeRecoveryHandler<SageNode>(f, ln), n);
1076 template <
class SageNode>
1077 const SageNode* assert_sage_type(
const SgNode* n,
const char* f = 0,
size_t ln = 0)
1079 return sg::dispatch(TypeRecoveryHandler<const SageNode>(f, ln), n);
1097 void swap_parent(
void*,
void*) {}
1106 template <
class SageNode,
class SageChild>
1107 void swap_child(SageNode& lhs, SageNode& rhs, SageChild* (SageNode::*getter) ()
const,
void (SageNode::*setter) (SageChild*))
1109 SageChild* lhs_child = (lhs.*getter)();
1110 SageChild* rhs_child = (rhs.*getter)();
1111 ROSE_ASSERT(lhs_child && rhs_child);
1113 (lhs.*setter)(rhs_child);
1114 (rhs.*setter)(lhs_child);
1116 swap_parent(lhs_child, rhs_child);
1122 template <
class SageNode>
1125 typedef void (*TransformHandlerFn)(SageNode*);
1133 void handle(SageNode& n) { fn(&n); }
1135 TransformHandlerFn fn;
1140 template <
class SageNode>
1143 createTraversalFunction(
void (* fn)(SageNode*))
1153 template <
class GVisitor>
1164 gvisitor = sg::dispatch(gvisitor, n);
1168 GVisitor visitor() {
return gvisitor; }
1184 forAllNodes(F fn,
SgNode* root, AstSimpleProcessing::Order order = postorder)
1188 TraversalClass<F> tt(fn);
1191 tt.traverse(root, order);
1192 return tt.visitor();
1195 template <
class SageNode>
1198 forAllNodes(
void (*fn)(SageNode*),
SgNode* root, AstSimpleProcessing::Order order = postorder)
1200 forAllNodes(createTransformExecutor(fn), root, order);
1203 #if !defined(NDEBUG)
1205 std::string nodeType(
const SgNode& n)
1207 return typeid(n).name();
1211 std::string nodeType(
const SgNode* n)
1213 if (n == NULL)
return "<null>";
1215 return nodeType(*n);
1219 template <
class GVisitor>
1225 : gvisitor(gv), parent(p), cnt(0)
1228 void operator()(
SgNode* n)
1232 #if !defined(NDEBUG)
1235 std::cerr <<
"succ(" << nodeType(parent) <<
", " << cnt <<
") is null" << std::endl;
1240 if (n != NULL) gvisitor = sg::dispatch(gvisitor, n);
1243 operator GVisitor() {
return gvisitor; }
1252 template <
class GVisitor>
1255 dispatchHelper(GVisitor gv,
SgNode* parent = NULL)
1262 template <
class GVisitor>
1264 GVisitor traverseChildren(GVisitor gv,
SgNode& n)
1268 return std::for_each(successors.begin(), successors.end(), dispatchHelper(gv, &n));
1272 template <
class GVisitor>
1274 GVisitor traverseChildren(GVisitor gv,
SgNode* n)
1276 return traverseChildren(gv, sg::deref(n));
This class represents modifiers for SgDeclaration (declaration statements).
List of pointers to file sections.
This class represents the notion of an initializer for a variable declaration or expression in a func...
This class represents the concept of a scope in C++ (e.g. global scope, fuction scope, etc.).
The GNU symbol version definitions.
This class represents the concept of a C++ template instantiation directive.
This class represents the concept of an instantiation of member function template or a member functio...
This class represents the concept of a class declaration statement. It includes the concept of an ins...
This class represents the concept of a declaration list.
This class represents a boolean value (expression value).
One entry of the ELF symbol version needed table.
This class represents a OLD concept of the structure require for qualified names when they were in th...
String associated with a binary file.
Expression that adds two operands.
This class represents the concept of an instantiated class template.
This class represents the notion of an value (expression value).
List of dynamic linking section entries.
This class represents the concept of a C or C++ goto statement.
Contiguous region of a file.
This class represents the concept of a C or C++ statement which contains a expression.
Expression that performs a post-increment operation.
Expression representing a (no-op) unary plus operation.
This class represents the notion of a binary operator. It is derived from a SgExpression because oper...
Expression that performs a right rotate.
Auxiliary info for needed symbol version.
Base class for all binary analysis IR nodes.
This class represents a source file for a project (which may contian many source files and or directo...
List of entries for the ELF symbol version definition table.
This class represents the variable declaration or variable initialization withn a for loop...
One entry of an ELF relocation table.
This class represents the concept of a C++ sequence of catch statements.
This class represents the notion of a unary operator. It is derived from a SgExpression because opera...
This class represents the GNU extension "statement expression" (thus is non-standard C and C++)...
Class for traversing the AST.
This class represents the C++ throw expression (handled as a unary operator).
Expression that performs a post-decrement operation.
This class represents the rhs of a variable declaration which includes an optional assignment (e...
Portable Executable Import Section.
This class represents the concept of a C++ using directive.
List of binary interpretations.
Base class for machine instructions.
This class represents the concept of a do-while statement.
This class represents a Fortran pointer assignment. It is not some weird compound assignment operator...
This class represents the concept of a class name within the compiler.
This class represents the location of the code associated with the IR node in the original source cod...
This class represents the concept of an enum declaration.
Base class for scalar types.
List of expression nodes.
This class represents the "this" operator (can be applied to any member data).
Expression that performs an arithmetic, sign-bit preserving right shift.
void set_parent(SgNode *parent)
All nodes in the AST contain a reference to a parent node.
This class represents a string type used for SgStringVal IR node.
Expression that performs a logical, sign-bit non-preserving right shift.
This class represents the concept of a C style extern "C" declaration. But such information (linkage)...
This class represents the notion of a declared variable.
Strings stored in an ELF or PE container.
This class represents the concept of a member function declaration statement.
Expression that returns the remainder when dividing the first operand by the second.
This class represents the concept of a C and C++ case option (used within a switch statement)...
This class represents the concept of a function declaration statement.
Node to hold a list of symbol node pointers.
Base class for ELF file sections.
This class represents the concept of a C Assembler statement (untested).
This class represents the concept of a scope in C++ (e.g. global scope, fuction scope, etc.).
Base class for PE sections.
This class represents the concept of a C and C++ expression list.
This class represents the "sizeof()" operator (applied to any type).
Expression that divides the first operand by the second.
Hods a list of symbol version aux entries.
COFF symbol string table.
This class represents the concept of a C++ namespace alias declaration statement. ...
This class is not used in ROSE, but is intended to represent a list of SgModifierTypes (similar to th...
This class represents the base class of a numbr of IR nodes that don't otherwise fit into the existin...
Entry in an ELF symbol version table.
This class represents a directory within a projects file structure of files and directories.
This class represents the notion of an value (expression value).
ELF error handling frame entry frame description entry.
This class represents the concept of a C trinary conditional expression (e.g. "test ...
Represents an ELF relocation section.
One import directory per library.
void visit(SgNode *n)
this method is called at every traversed node.
GNU symbol version requirements table.
List of ELF relocation entries.
This class represents the notion of a break statement (typically used in a switch statment)...
List of AST file node pointers.
This class represents the concept of a name within the compiler.
ELF section containing dynamic linking information.
executes a functor for a specific node type
List of ELF EH frame CI entries.
Represents an ELF EH frame section.
One entry of an ELF notes table.
ELF string table section.
This class represents the concept of a class definition in C++.
This class represents strings within the IR nodes.
Reference to memory locations.
projects the constness of T1 on T2
This class represents the concept of a contructor initializer list (used in constructor (member funct...
Expression represting negation.
List of pointers to other AST nodes.
Expression representing a machine register.
Base class for integer values.
This class represents the concept of a namespace name within the compiler.
This class represents the notion of a typedef declaration.
ELF file section containing symbols.
This class represents the notion of an value (expression value).
This class represents the base class for all IR nodes within Sage III.
List of operands for an instruction.
This class represents the concept of a catch within a try-catch construct used in C++ exception handl...
Base class for dynamically linked library information.
This class represents the notion of an value (expression value).
This class represents the concept of a variable name within the compiler (a shared container for the ...
This class represents the concept of an instantiation of function template.
Expression that performs a pre-decrement operation.
Expression that performs a pre-increment operation.
This class represents the "&" operator (applied to any lvalue).
A single imported object.
Represents one PowerPC machine instruction.
One entry from an ELF symbol version definition table.
Represents a single ELF symbol.
This class represents the base class of a number of IR nodes define modifiers within the C++ grammar...
This class represents the concept of a block (not a basic block from control flow analysis)...
This class represents the concept of a C++ namespace declaration.
Base class for strings related to binary specimens.
This class represents the concept of a namespace definition.
This class represents the concept of a for loop.
Base class for unary expressions.
Represents one Intel x86 machine instruction.
This class represents the concept of a C++ using declaration.
This class represents a C99 complex type.
Base class for statement-like subclasses.
This class represents a type for all functions.
This class represents the concept of a namespace definition.
This class represents the numeric negation of a value. Not to be confused with SgSubtractOp.
This class represents the concept of a C Assembler statement (untested).
Represents one entry of a segment table.
This class represents the concept of a C or C++ default case within a switch statement.
Base class for expressions.
This class represents a default type used for some IR nodes (see below).
This class represents the concept of an "if" construct.
virtual std::vector< SgNode * > get_traversalSuccessorContainer()
container of pointers to AST successor nodes used in the traversal overridden in every class by gener...
This class represents the concept of a template declaration.
Expression that performs a logical left shift operation.
List of pointers to other nodes.
Expression that multiplies two operands.
This class represents template argument within the use of a template to build an instantiation.
This class represents the variable refernece in expressions.
Represents one ARM machine instruction.
Node to hold list of ELF note entries.
This class represents the concept of a do-while statement.
This class represents a OLD concept of the structure require for qualified names when they were in th...
List of entries from a symbol version table.
List of SgAsmPERVASizePair AST nodes.
Base class for binary types.
This class represents the definition (initialization) of a variable.
This class represents the concept of a class definition in C++.
This class represents the concept of a C++ call to the delete operator.
virtual void accept(ROSE_VisitorPattern &visitor)
support for the classic visitor pattern done in GoF
helper class for _ancestor
Registers accessed indirectly.
This class represents the concept of a C++ call to the new operator.
This class represents the concept of a C or C++ continue statement.
This class represents an object used to initialize the unparsing.
This class represents the member function being called and must be assembled in the SgFunctionCall wi...
This class represents modifiers specific to storage.
This class represents the symbol tables used in both SgScopeStatement and the SgFunctionTypeSymbolTab...
Expression that subtracts the second operand from the first.
SgNode * get_parent() const
Access function for parent node.
This class represents the function being called and must be assembled in the SgFunctionCall with the ...
This class represents the concept of try statement within the try-catch support for exception handlin...
This class represents the concept of a C Assembler statement.
This class represents the concept of a name and a type. It may be renamed in the future to SgTypeSymb...
This class represents a list of associated typedefs for the SgType IR nodes which reference this list...
One entry from the dynamic linking table.
This class represents a source project, with a list of SgFile objects and global information about th...
This class represents the function type table (stores all function types so that they can be shared i...
This class represents a C99 complex type.
This class represents the concept of a C or C++ variable declaration.
This class represents the notion of an initializer for a variable declaration or expression in a func...
The ELF symbol version table.
Represents one entry in an ELF section table.
Represents an ELF segment table.
Strings stored in an ELF or PE container.
Represents an ELF section table.
A list of imported items.
Represents an interpretation of a binary container.
This class represents the concept of a C or C++ label statement.
List of symbol version needed entries.
This class is part of the older CC++ concept. It is not a part of C or C++ (this IR node is not used ...
This class represents the concept of a C++ function call (which is an expression).
Base class for binary files.
Base class for binary expressions.
Base class for vector types.
This class was part of CC++ support from a long time ago.
List of symbol version aux entries.
This class represents the concept of a declaration statement.
This class represents the concept of a switch.
This class represents the concept of a C++ expression built from a class name.
A list of PE Import Directories.
ELF error handling frame entry, common information entry.
