|
|
reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced
|
Derived Classes
tools/lldb/include/lldb/Symbol/PostfixExpression.h 51 class BinaryOpNode : public Node {
79 class InitialValueNode: public Node {
89 class IntegerNode : public Node {
105 class RegisterNode : public Node {
119 class SymbolNode : public Node {
132 class UnaryOpNode : public Node {
References
include/llvm/Support/Casting.h 34 using SimpleType = From; // The real type this represents...
37 static SimpleType &getSimplifiedValue(From &Val) { return Val; }
41 using NonConstSimpleType = typename simplify_type<From>::SimpleType;
47 static RetType getSimplifiedValue(const From& Val) {
57 static inline bool doit(const From &Val) {
76 static inline bool doit(const From &Val) {
77 return isa_impl<To, From>::doit(Val);
104 static inline bool doit(const From *Val) {
106 return isa_impl<To, From>::doit(*Val);
141 template <class X, class Y> LLVM_NODISCARD inline bool isa(const Y &Val) {
142 return isa_impl_wrap<X, const Y,
143 typename simplify_type<const Y>::SimpleType>::doit(Val);
204 using ret_type = typename cast_retty_impl<To,FromTy>::ret_type;
210 To, From, typename simplify_type<From>::SimpleType>::ret_type;
210 To, From, typename simplify_type<From>::SimpleType>::ret_type;
227 static typename cast_retty<To, FromTy>::ret_type doit(const FromTy &Val) {
227 static typename cast_retty<To, FromTy>::ret_type doit(const FromTy &Val) {
228 typename cast_retty<To, FromTy>::ret_type Res2
236 std::is_same<X, typename simplify_type<X>::SimpleType>::value;
236 std::is_same<X, typename simplify_type<X>::SimpleType>::value;
256 inline typename cast_retty<X, Y>::ret_type cast(Y &Val) {
256 inline typename cast_retty<X, Y>::ret_type cast(Y &Val) {
258 return cast_convert_val<X, Y,
259 typename simplify_type<Y>::SimpleType>::doit(Val);
263 inline typename cast_retty<X, Y *>::ret_type cast(Y *Val) {
263 inline typename cast_retty<X, Y *>::ret_type cast(Y *Val) {
265 return cast_convert_val<X, Y*,
266 typename simplify_type<Y*>::SimpleType>::doit(Val);
342 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type dyn_cast(Y *Val) {
342 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type dyn_cast(Y *Val) {
include/llvm/Support/type_traits.h 55 struct add_const_past_pointer { using type = const T; };
tools/lldb/include/lldb/Symbol/PostfixExpression.h 51 class BinaryOpNode : public Node {
59 BinaryOpNode(OpType op_type, Node &left, Node &right)
59 BinaryOpNode(OpType op_type, Node &left, Node &right)
64 const Node *Left() const { return m_left; }
65 Node *&Left() { return m_left; }
67 const Node *Right() const { return m_right; }
68 Node *&Right() { return m_right; }
70 static bool classof(const Node *node) { return node->GetKind() == BinaryOp; }
74 Node *m_left;
75 Node *m_right;
79 class InitialValueNode: public Node {
83 static bool classof(const Node *node) {
89 class IntegerNode : public Node {
95 static bool classof(const Node *node) { return node->GetKind() == Integer; }
105 class RegisterNode : public Node {
111 static bool classof(const Node *node) { return node->GetKind() == Register; }
119 class SymbolNode : public Node {
125 static bool classof(const Node *node) { return node->GetKind() == Symbol; }
132 class UnaryOpNode : public Node {
138 UnaryOpNode(OpType op_type, Node &operand)
143 const Node *Operand() const { return m_operand; }
144 Node *&Operand() { return m_operand; }
146 static bool classof(const Node *node) { return node->GetKind() == UnaryOp; }
150 Node *m_operand;
167 virtual ResultT Visit(BinaryOpNode &binary, Node *&ref) = 0;
168 virtual ResultT Visit(InitialValueNode &val, Node *&ref) = 0;
169 virtual ResultT Visit(IntegerNode &integer, Node *&) = 0;
170 virtual ResultT Visit(RegisterNode ®, Node *&) = 0;
171 virtual ResultT Visit(SymbolNode &symbol, Node *&ref) = 0;
172 virtual ResultT Visit(UnaryOpNode &unary, Node *&ref) = 0;
176 ResultT Dispatch(Node *&node) {
178 case Node::BinaryOp:
180 case Node::InitialValue:
182 case Node::Integer:
184 case Node::Register:
186 case Node::Symbol:
188 case Node::UnaryOp:
203 bool ResolveSymbols(Node *&node,
204 llvm::function_ref<Node *(SymbolNode &symbol)> replacer);
207 inline T *MakeNode(llvm::BumpPtrAllocator &alloc, Args &&... args) {
215 Node *ParseOneExpression(llvm::StringRef expr, llvm::BumpPtrAllocator &alloc);
217 std::vector<std::pair<llvm::StringRef, Node *>>
225 void ToDWARF(Node &node, Stream &stream);
tools/lldb/source/Plugins/SymbolFile/Breakpad/SymbolFileBreakpad.cpp 422 llvm::ArrayRef<uint8_t> SymbolFileBreakpad::SaveAsDWARF(postfix::Node &node) {
441 postfix::Node *rhs = postfix::ParseOneExpression(rule->second, node_alloc);
564 std::vector<std::pair<llvm::StringRef, postfix::Node *>> program =
tools/lldb/source/Plugins/SymbolFile/Breakpad/SymbolFileBreakpad.h 204 llvm::ArrayRef<uint8_t> SaveAsDWARF(postfix::Node &node);
tools/lldb/source/Plugins/SymbolFile/NativePDB/PdbFPOProgramToDWARFExpression.cpp 54 static Node *ResolveFPOProgram(llvm::StringRef program,
58 std::vector<std::pair<llvm::StringRef, Node *>> parsed =
95 Node *target_program =
tools/lldb/source/Symbol/PostfixExpression.cpp 44 Node *postfix::ParseOneExpression(llvm::StringRef expr,
46 llvm::SmallVector<Node *, 4> stack;
55 Node *right = stack.pop_back_val();
56 Node *left = stack.pop_back_val();
66 Node *operand = stack.pop_back_val();
87 std::vector<std::pair<llvm::StringRef, Node *>>
95 std::vector<std::pair<llvm::StringRef, Node *>> result;
99 Node *rhs = ParseOneExpression(expr, alloc);
110 SymbolResolver(llvm::function_ref<Node *(SymbolNode &symbol)> replacer)
116 bool Visit(BinaryOpNode &binary, Node *&) override {
120 bool Visit(InitialValueNode &, Node *&) override { return true; }
121 bool Visit(IntegerNode &, Node *&) override { return true; }
122 bool Visit(RegisterNode &, Node *&) override { return true; }
124 bool Visit(SymbolNode &symbol, Node *&ref) override {
125 if (Node *replacement = m_replacer(symbol)) {
134 bool Visit(UnaryOpNode &unary, Node *&) override {
138 llvm::function_ref<Node *(SymbolNode &symbol)> m_replacer;
148 void Visit(BinaryOpNode &binary, Node *&) override;
150 void Visit(InitialValueNode &val, Node *&) override;
152 void Visit(IntegerNode &integer, Node *&) override {
158 void Visit(RegisterNode ®, Node *&) override;
160 void Visit(SymbolNode &symbol, Node *&) override {
164 void Visit(UnaryOpNode &unary, Node *&) override;
179 void DWARFCodegen::Visit(BinaryOpNode &binary, Node *&) {
206 void DWARFCodegen::Visit(InitialValueNode &, Node *&) {
215 void DWARFCodegen::Visit(RegisterNode ®, Node *&) {
229 void DWARFCodegen::Visit(UnaryOpNode &unary, Node *&) {
241 Node *&node, llvm::function_ref<Node *(SymbolNode &)> replacer) {
241 Node *&node, llvm::function_ref<Node *(SymbolNode &)> replacer) {
245 void postfix::ToDWARF(Node &node, Stream &stream) {
246 Node *ptr = &node;
tools/lldb/unittests/Symbol/PostfixExpressionTest.cpp 43 std::string Visit(BinaryOpNode &binary, Node *&) override {
48 std::string Visit(InitialValueNode &, Node *&) override { return "InitialValue"; }
50 std::string Visit(IntegerNode &integer, Node *&) override {
54 std::string Visit(RegisterNode ®, Node *&) override {
58 std::string Visit(SymbolNode &symbol, Node *&) override {
62 std::string Visit(UnaryOpNode &unary, Node *&) override {
68 static std::string Print(Node *node) {
109 std::vector<std::pair<llvm::StringRef, Node *>> parsed =
134 Node *ast = ParseOneExpression(expr, alloc);
usr/include/c++/7.4.0/bits/move.h 72 constexpr _Tp&&
83 constexpr _Tp&&
usr/include/c++/7.4.0/type_traits 381 : public __is_pointer_helper<typename remove_cv<_Tp>::type>::type
1554 { typedef _Tp type; };
1558 { typedef _Tp type; };
1563 { typedef _Tp type; };
1574 remove_const<typename remove_volatile<_Tp>::type>::type type;
1633 { typedef _Tp type; };
1983 { typedef _Up type; };