reference, declarationdefinition
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 &reg, 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 &reg, 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 &reg, 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 &reg, 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; };